10

我有一个带有泛型返回类型的方法的接口，并且在运行时有一些类的实例间接实现了该接口。现在我想使用反射找出每个实现的实际返回类型。

（我的想法是使用这种机制来定义一个使用接口的策略，并在运行时从一组策略实现中找到一个匹配的策略（特定的返回类型），而不必引入暴露类型的冗余辅助方法）。

更具体地说，让我们考虑以下场景：

private interface DAO <I extends Serializable, E> {

    public E getById (I id);
}

private abstract class AbstractDAO <T> implements DAO<Integer, T> {

    @Override
    public T getById (Integer id) {
        // dummy implementation, just for this example
        return null;
    }
}

private class PersonDAO extends AbstractDAO<Person> {
}

private class PersonDAOExtension extends PersonDAO {
}

在运行时，我想为给定的类 ( ) 找出PersonDAOExtension.class方法返回的类型getById(..)（预期为：Person.class）。

使用反射，我可以找出Type从这个方法返回的泛型。在这种情况下，它是 a TypeVariable（但也可以是 a Class，如果层次结构中的任何类将指定协变返回类型）：

Method method = PersonDAOExtension.class.getMethod("getById", Integer.class);
Type genericReturnType = method.getGenericReturnType();
if (genericReturnType instanceof TypeVariable<?>) {
    TypeVariable<?> typeVariable = (TypeVariable<?>) genericReturnType;
    typeVariable.getName(); //results in "T"
}

我假设解析实际类型意味着递归到超类和接口，并为任何参数化类型转换原始( parameterizedType.getRawType()) 和实际( parameterizedType.getActualTypeArguments()) 类型参数，直到找到所需的类型名称。

以前有没有人这样做过，也许准备好一些代码片段可以帮助我实现这一目标？提前谢谢了 ：）

提示：我能够在运行时使用反射提取以下信息，因此保留了原始和实际类型信息：

private abstract interface DAO<I, E>
private abstract class AbstractDAO<T> extends Object implements DAO<Integer, T> [raw type:DAO<I, E>]
private class PersonDAO extends AbstractDAO<Person> [raw type:AbstractDAO<T>]
private class PersonDAOExtension extends PersonDAO
4

3 回答 3

11

我终于找到了一个解决方案，递归到超类和接口，用传递的类型参数替换类型变量，直到到达所需的基类：

 /**
 * Resolves the actual generic type arguments for a base class, as viewed from a subclass or implementation.
 * 
 * @param <T> base type
 * @param offspring class or interface subclassing or extending the base type
 * @param base base class
 * @param actualArgs the actual type arguments passed to the offspring class
 * @return actual generic type arguments, must match the type parameters of the offspring class. If omitted, the
 * type parameters will be used instead.
 */
public static <T> Type[] resolveActualTypeArgs (Class<? extends T> offspring, Class<T> base, Type... actualArgs) {

    assert offspring != null;
    assert base != null;
    assert actualArgs.length == 0 || actualArgs.length == offspring.getTypeParameters().length;

    //  If actual types are omitted, the type parameters will be used instead.
    if (actualArgs.length == 0) {
        actualArgs = offspring.getTypeParameters();
    }
    // map type parameters into the actual types
    Map<String, Type> typeVariables = new HashMap<String, Type>();
    for (int i = 0; i < actualArgs.length; i++) {
        TypeVariable<?> typeVariable = (TypeVariable<?>) offspring.getTypeParameters()[i];
        typeVariables.put(typeVariable.getName(), actualArgs[i]);
    }

    // Find direct ancestors (superclass, interfaces)
    List<Type> ancestors = new LinkedList<Type>();
    if (offspring.getGenericSuperclass() != null) {
        ancestors.add(offspring.getGenericSuperclass());
    }
    for (Type t : offspring.getGenericInterfaces()) {
        ancestors.add(t);
    }

    // Recurse into ancestors (superclass, interfaces)
    for (Type type : ancestors) {
        if (type instanceof Class<?>) {
            // ancestor is non-parameterized. Recurse only if it matches the base class.
            Class<?> ancestorClass = (Class<?>) type;
            if (base.isAssignableFrom(ancestorClass)) {
                Type[] result = resolveActualTypeArgs((Class<? extends T>) ancestorClass, base);
                if (result != null) {
                    return result;
                }
            }
        }
        if (type instanceof ParameterizedType) {
            // ancestor is parameterized. Recurse only if the raw type matches the base class.
            ParameterizedType parameterizedType = (ParameterizedType) type;
            Type rawType = parameterizedType.getRawType();
            if (rawType instanceof Class<?>) {
                Class<?> rawTypeClass = (Class<?>) rawType;
                if (base.isAssignableFrom(rawTypeClass)) {

                    // loop through all type arguments and replace type variables with the actually known types
                    List<Type> resolvedTypes = new LinkedList<Type>();
                    for (Type t : parameterizedType.getActualTypeArguments()) {
                        if (t instanceof TypeVariable<?>) {
                            Type resolvedType = typeVariables.get(((TypeVariable<?>) t).getName());
                            resolvedTypes.add(resolvedType != null ? resolvedType : t);
                        } else {
                            resolvedTypes.add(t);
                        }
                    }

                    Type[] result = resolveActualTypeArgs((Class<? extends T>) rawTypeClass, base, resolvedTypes.toArray(new Type[] {}));
                    if (result != null) {
                        return result;
                    }
                }
            }
        }
    }

    // we have a result if we reached the base class.
    return offspring.equals(base) ? actualArgs : null;
}

奇迹般有效：

resolveActualTypeArgs(PersonDAOExtension.class, DAO.class)

结果Integer，Person

resolveActualTypeArgs(AbstractDAO.class, DAO.class)

结果Integer，T

resolveActualTypeArgs(LinkedList.class, Iterable.class, String.class)

结果是String

我现在可以使用它来找出一组给定的 DAO 实现中的哪些可以读取 Persons：

List<DAO<?, ?>> knownDAOs = ...

for (DAO<?, ?> daoImpl : knownDAOs) {
    Type[] types = resolveActualTypeArgs(daoImpl.getClass(), DAO.class);
    boolean canReadPerson = types[1] instanceof Class<?> && Person.class.isAssignableFrom((Class<?>) types[1]);
}

无论我通过 a new PersonDAOExtension()， anew PersonDAO()还是 a ，这都有效new AbstractDAO<Person>{}。

于 2013-06-25T15:51:05.373 回答
11

我能够使用 Google Guava 的TypeToken类在一行中确定方法的通用返回类型：

TypeToken.of(PersonDAOExtension.class)
        .resolveType(PersonDAOExtension.class.getMethod("getById", Integer.class).getGenericReturnType())
        .getRawType()

或者，如果您想获取类的泛型类型（正如您在接受的答案中所做的那样），而不是方法的返回类型，您可以执行以下操作：

TypeToken.of(PersonDAOExtension.class)
        .resolveType(AbstractDAO.class.getTypeParameters()[0])
        .getRawType()

这两种解决方案都Person.class按预期返回。

从您对已接受答案的评论来看，您似乎只想知道给定的 DAO 是否可以接受Person对象。这也可以通过 API 实现：

(new TypeToken<DAO<?, Person>>() {})
        .isSupertypeOf(TypeToken.of(PersonDAOExtension.class))

在 Guava GitHub wiki 上有一个关于这个和其他 Guava 反射实用程序功能的体面解释。

于 2014-06-29T08:25:42.090 回答
0

我之前也遇到过类似的问题。在我的解决方案中，抽象类有一个名为

static void register(Class<? extends DAO> clazz, ? extends DAO daoInstance).

在抽象类中，我有一个Map存储对实例的引用。我使用了单例，但如果您有多个实例，您可以使用多图。使用这种技术，您可以摆脱反射，您将拥有Set您注册的所有实现及其类。

如果您需要更多信息，也可以注册一些 pojo 类：

public class DaoData{

    private Class<? extends DAO> daoClass;
    private Class<?> someArbitraryTypeClass;
    // ...
}

static void register(DaoData daoData, ? extends DAO daoInstance)

我知道这不是最好的解决方案，但它很简单并且可以完成工作。

于 2013-06-25T12:43:34.250 回答