泛型Java-获取泛型的泛型类型

Question

如何获取这个类的类型？对于上下文，我使用ModelMapper，我需要类类型T从S转换为T。

@Component
public class A<T, S> {
    
    private Class<T> tType;
    private Class<S> sType;
    
    @SuppressWarnings("unchecked")
    public A() {
        this.tType = (Class<T>) // some method to take the type
        this.sType = (Class<S>) // some method to take the type
    }   

    public T toModel(S regras) {
        return modelMapper.map(regras, tType); 
    }

背景：

public class B{

    @Autowired 
    private A<SomeClassX, SomeClassY> var;
    
    // Some code

我已经尝试了N种方法，其中我放置了“//一些方法来获取类型”，但没有任何效果。例如：

    @SuppressWarnings("unchecked")
    public A() {
        this.tType = (Class<T>) getGenericClassType(0);
        this.sType = (Class<S>) getGenericClassType(1);
    }   

    private Type getGenericClassType(int index) {
        Type type = getClass().getGenericSuperclass(); 
        while(!(type instanceof ParameterizedType)) { 
            if (type == null) { 
                return null; 
            }
            
            if (type instanceof ParameterizedType) {
                type = ((Class<?>) ((ParameterizedType) type).getRawType()).getGenericSuperclass();
            } else {
                type = ((Class<?>) type).getGenericSuperclass();
            } 
        }
        
        return ((ParameterizedType) type).getActualTypeArguments()[index];
    }

或

    @SuppressWarnings("unchecked")
    public A() {
        this.tType = (Class<T>) GenericTypeResolver.resolveTypeArguments(getClass(), GenericConverter.class)[0];
        this.sType = (Class<S>) GenericTypeResolver.resolveTypeArguments(getClass(), GenericConverter.class)[1];
    }   

Answer 1

你不能。泛型是编译器想象出来的：编译器使用泛型生成错误和注入类型转换，然后将其全部删除。它不在类文件中，因此在运行时不可用，因此，“我的t实际上是什么”的概念是不可能的。

有一些变通方法：

当然，您可以将一个j.l.Class实例传递给构造函数。您的代码片段使用了“A”和“B”这两个名称，这非常不幸，因为单大写通常用于类型vars，所以我将把它们命名为mycopa和MyCombB。

像这样的东西：

public class MyCompA<S, T> {
  private final Class<S> sourceType;
  private final Class<T> targetType;

  public MyCompA(Class<S> sourceType, Class<T> targetType) {
    this.sourceType = sourceType;
    this.targetType = targetType;
  }

  public T toModel(S regras) {
      return modelMapper.map(regras, targetType); 
  }
}

尽管如此，听起来您实际上并不需要任何源类型，所以您最好不要使用它。

这种策略有两个问题：

• 有一些东西是泛型无法表示的，一个j.l.Class实例可以表示这些东西。具体来说，原语：int，原语有一个表示它的j.l.Class实例；您可以使用表达式int.class获得它int是无效的泛型（至少还没有，可能在将来的java版本中）：Class

一种方法是STT。它们看起来很时髦。制作它们：

TypeToken<List<String>> = new TypeToken<>() {};

注意这里奇怪的尾随符。这将创建一个匿名类，而类确实携带泛型信息，这些信息在编译后仍然存在，因此可以通过反射访问进行查询。运行时系统对它没有任何作用——就JVM而言，它是注释（JVM不知道泛型是什么，也不把它们用于任何事情。它位于类文件中，仅用于javac，但我们可以通过反射来读取它，就是这样）。

public abstract class TypeToken<T> {
  public Type getType() {
    Type t = getClass().getGenericSuperclass();
    if (!(t instanceof ParameterizedType pt)) throw new IllegalStateException("Incorrect use of TypeToken: " + t);
    
    Type[] typeArgs = pt.getActualTypeArguments();
    if (typeArgs.length == 1) return typeArgs;
    throw new IllegalStateException("Incorrect use of TypeToken: " + t);
}

我已经向您展示了如何创建这些实例。如果您愿意，您可以在构造函数中包含对getType（）的调用（您可能想要缓存返回值；它不能更改并且反射可能有点昂贵），因为这样您将在创建无效类型标记时获得异常（例如：new TypeToken() {}-这是原始用法，当然在这里不起作用，重点是捕获中的内容

显然，您的ModelMapper.map方法需要Class类型的值