Question

我能够使下面的通用方法工作的唯一方法是传递看似多余的TypeLiteral<Set<T>>参数。我认为应该可以在给定其他参数的情况下以编程方式构造此参数，但无法弄清楚如何。

protected <T> Key<Set<T>> bindMultibinder(
 TypeLiteral<Set<T>> superClassSet, TypeLiteral<T> superClass) {
   final Key<Set<T>> multibinderKey = Key.get(superClassSet, randomAnnotation);
   return multibinderKey;
}

客户端代码如下：

bindMultibinder(new TypeLiteral<Set<A<B>>>(){}, new TypeLiteral<A<B>>(){});

A和B是接口。

如果我尝试以下操作（删除TypeLiteral<Set<T>> superClassSet参数），则会出现java.util.Set<T> cannot be used as a key; It is not fully specified.运行时错误。

protected <T> Key<Set<T>> bindMultibinder(TypeLiteral<T> superClass) {
   final Key<Set<T>> multibinderKey = Key.get(
    new TypeLiteral<Set<T>>() {}, randomAnnotation);
   return multibinderKey;
}

Answer 1

如果您已经知道答案的大部分内容，请原谅我：在您的级别上很难做出假设。

问题的原因是类型擦除，正如您所知道的那样。为了摆脱类型擦除，Guice使用了具体祖先的技巧，如下所示：

class Trick<T> {
    T t;
}

public class GenericTest {
    public static void main(String[] args) {
        Trick<Set<String>> trick = new Trick<Set<String>>() {
        };

        // Prints "class org.acm.afilippov.GenericTest$1"
        System.out.println(trick.getClass());
        // Prints "org.acm.afilippov.Trick<java.util.Set<java.lang.String>>"
        System.out.println(trick.getClass().getGenericSuperclass());
    }
}

要点是，当您创建一个扩展通用超类并显式指定类型参数的类时，通常需要编写metods which accept that very specific type, and these methods' signatures cannot be erased。在这种情况下，我们在FAQ中讨论没有问题，但编译器保存了类型信息：无论如何，类的用户需要知道确切的类型才能使用这些方法。

现在你的版本没有从TypeLiteral<Set<YourSpecificType>>继承的具体类，它只有TypeLiteral<Set<T>> - 这就是它失败的地方。

改变我的小例子，那就是：

public class GenericTest {
    public static void main(String[] args) {
        tryMe(String.class);
    }

    private static <T> void tryMe(Class<T> clazz) {
        Trick<Set<T>> trick = new Trick<Set<T>>() {
        };

        // Prints "class org.acm.afilippov.GenericTest$1"
        System.out.println(trick.getClass());
        // Prints "org.acm.afilippov.Trick<java.util.Set<T>>"
        System.out.println(trick.getClass().getGenericSuperclass());
    }
}

正如您所看到的，我们的GenericTest$1不再具体了：它仍然有一个类型参数，其具体值（此处为String）在编译期间丢失。

你当然可以避免这种情况，但为了做到这一点，你需要创建一个带有用于继承的特定类型参数的类，这样Guice就能够解决这些问题。。稍等一下，我会试着想出一个例子。

更新：结果证明是非常长的。所以这里有一个更新版本：

public class GenericTest {
    public static void main(String[] args) throws Exception {
        tryMe(String.class);
    }

    private static <T> void tryMe(Class<T> clazz) throws IllegalAccessException, InstantiationException {
        Class c = loadClass("org.acm.afilippov.ASMTrick", generateClass(clazz));

        Trick<Set<T>> trick = (Trick<Set<T>>) c.newInstance();

        // Prints "class org.acm.afilippov.ASMTrick"
        System.out.println(trick.getClass());
        // Prints "org.acm.afilippov.Trick<java.util.Set<java.lang.String>>"
        System.out.println(trick.getClass().getGenericSuperclass());
    }

    private static byte[] generateClass(Class<?> element) {
        ClassWriter cw = new ClassWriter(0);
        MethodVisitor mv;

        cw.visit(V1_6, ACC_FINAL + ACC_SUPER, "org/acm/afilippov/ASMTrick",
                "Lorg/acm/afilippov/Trick<Ljava/util/Set<L" + element.getName().replaceAll("\\.", "/") + ";>;>;",
                "org/acm/afilippov/Trick", null);

        {
            mv = cw.visitMethod(0, "<init>", "()V", null, null);
            mv.visitCode();
            mv.visitVarInsn(ALOAD, 0);
            mv.visitMethodInsn(INVOKESPECIAL, "org/acm/afilippov/Trick", "<init>", "()V");
            mv.visitInsn(RETURN);
            mv.visitMaxs(1, 1);
            mv.visitEnd();
        }
        cw.visitEnd();

        return cw.toByteArray();
    }

    private static Class loadClass(String className, byte[] b) {
        //override classDefine (as it is protected) and define the class.
        Class clazz = null;
        try {
            ClassLoader loader = ClassLoader.getSystemClassLoader();
            Class cls = Class.forName("java.lang.ClassLoader");
            java.lang.reflect.Method method =
                    cls.getDeclaredMethod("defineClass", new Class[]{String.class, byte[].class, int.class, int.class});

            // protected method invocaton
            method.setAccessible(true);
            try {
                Object[] args = new Object[]{className, b, new Integer(0), new Integer(b.length)};
                clazz = (Class) method.invoke(loader, args);
            } finally {
                method.setAccessible(false);
            }
        } catch (Exception e) {
            e.printStackTrace();
            System.exit(1);
        }
        return clazz;
    }
}

如您所见，现在保留了类型信息。我相信这种方法没有被使用，因为即使对于这个草案来说也太痛苦了。

Answer 2

完全指定表示所有类型参数的值都是已知的。使用Guice公共API似乎无法从TypeLiteral<Set<T>>构建完全指定的TypeLiteral<T>。具体来说，TypeLiteral只有两个构造函数。第一个是：

/**
 * Constructs a new type literal. Derives represented class from type
 * parameter.
 *
 * <p>Clients create an empty anonymous subclass. Doing so embeds the type
 * parameter in the anonymous class's type hierarchy so we can reconstitute it
 * at runtime despite erasure.
 */
@SuppressWarnings("unchecked")
protected TypeLiteral() {
  this.type = getSuperclassTypeParameter(getClass());
  this.rawType = (Class<? super T>) MoreTypes.getRawType(type);
  this.hashCode = type.hashCode();
}

此构造函数尝试从TypeLiteral的运行时类中推导出类型参数的值。仅当运行时类确定类型参数时，才会生成完全指定的类型。但是，因为泛型类的所有实例共享相同的运行时类（即new HashSet<String>().getClass() == new HashSet<Integer>().getClass()，所以仅当TypeLiteral的非泛型子类是实例化。也就是说，我们不能为T的不同值重用相同的类声明，但必须为每个T定义一个新类。这非常麻烦，正如alf的答案所示。

这使我们得到了另一个构造函数，它更有用，但不是公共API的一部分：

/**
 * Unsafe. Constructs a type literal manually.
 */
@SuppressWarnings("unchecked")
TypeLiteral(Type type) {
  this.type = canonicalize(checkNotNull(type, "type"));
  this.rawType = (Class<? super T>) MoreTypes.getRawType(this.type);
  this.hashCode = this.type.hashCode();
}

我们可以使用这个构造函数如下：

package com.google.inject;

import java.util.Set;

import com.google.inject.internal.MoreTypes;

public class Types {
    public static <T> TypeLiteral<Set<T>> setOf(TypeLiteral<T> lit) {
        return new TypeLiteral<Set<T>>(new MoreTypes.ParameterizedTypeImpl(null, Set.class, lit.getType())); 
    }
}

测试用例：

public static void main(String[] args) {
    System.out.println(setOf(new TypeLiteral<String>() {}));
}

在一个完美的世界中，Guice将提供一个公共API来实现这一目标......

Generics Hell：我可以构建一个TypeLiteral <set <t>＆gt;使用泛型？</set <t>

2 个答案: