Java 获取泛型类型

不太完美的泛型

大家在使用泛型开发的时候，有很多时候会遇到这样的需求—— 获取泛型具体的类。
比如现在有Service<T>，要想得到泛型T的类型，正常情况下，我们第一个想法就是通过T.class获得，但得到的是那刺眼的下划红色波浪线。
那么如何才能拿到泛型的类型？想要得到泛型的类型需要满足哪些条件呢？

获取到泛型类型的条件

1. 必须具有真实类型的存在
2. 泛型的类型是明确的

第一个很好理解，如果连要获取的类都不存在，即未定义，那自然是获取不到的；
第二个条件，举个例子，假设存在User，那么List<User>就是明确的，List<T>是不明确的。

满足上面两点，就可以获取泛型的类型了。

获取泛型类型

首先看下java.lang.Class.java中与泛型相关的方法有哪些：

与泛型相关的方法
其中getGenericInfo()和getGenericSignature0()都是私有方法，那么我们暂时就只能尝试从getGenericInterfaces()和getGenericSuperclass()这两个方法入手了。

查看源码上的注释，大致作用如下：

• getGenericInterfaces: 返回此类直接实现的所有接口的类型。接口的实现类通过该方法，可以获取所实现的接口的泛型类型，比如：接口Service<T>，实现类UserServiceImpl<User>，能够得到Service<User>
• getGenericSuperclass: 返回此类所表示的实体的直接超类的类型。一个类的子类通过该方法，可以获取超类的泛型类型，比如：SuperClass<T>，子类Main<User>，能够得到SuperClass<User>

可以看出都跟继承类/实现接口有关，因为在类或接口定义的类型参数（泛型）其实是不确定的，只有子类继承或接口实现才能确定类型参数的具体类型。比如：接口Service<T>，类型参数T是不确定的，说白了其实就是个占位符，而实现类UserServiceImpl<User>才能确定类型参数T是User。

为了更好理解，先来看一段代码：

package xxx.xxx.xxx;

import java.lang.reflect.ParameterizedType;
import java.lang.reflect.Type;

abstract class SuperClass<T> {
}

class Main extends SuperClass<User> {

    public static void main(String[] args) {
        // 获取 Main 的超类 SuperClass 的签名(携带泛型). 这里为: xxx.xxx.xxx.SuperClass<xxx.xxx.xxx.User>
        Type genericSuperclass = Main.class.getGenericSuperclass();
        // 强转成 参数化类型 实体.
        ParameterizedType parameterizedType = (ParameterizedType) genericSuperclass;
        System.out.println(parameterizedType);

        // 获取超类的泛型类型数组. 即SuperClass<User>的<>中的内容, 因为泛型可以有多个, 所以用数组表示
        Type[] actualTypeArguments = parameterizedType.getActualTypeArguments();
        Type genericType = actualTypeArguments[0];
        Class<User> clazz = (Class<User>) genericType;
        System.out.println(clazz);
    }

}

class User {
}

打印结果：

xxx.xxx.xxx.SuperClass<xxx.xxx.xxx.User>
class xxx.xxx.xxx.User

上面的代码，是通过继承方式，明确类型，然后获取泛型类。
总体思路是这样的：先定义一个类SuperClass<T>，其中T为类型参数，即泛型，这个时候要想获取T的类型，显然是不可能的，因为本来就是一个通用类型；但是通过继承该类，并确定了泛型的类型，那么我们就能通过getGenericSuperclass()获取到泛型的类型。

其实，上面的代码只是为了方便测试才这么写的，也比较容易理解，一般实战的写法是这样的：

abstract class SuperClass<T> {

    public Class<T> getGenericClass() {
        ParameterizedType parameterizedType = (ParameterizedType) getClass().getGenericSuperclass();
        return (Class<T>) parameterizedType.getActualTypeArguments()[0];
    }

}

class Main extends SuperClass<User> {

    public static void main(String[] args) {
        System.out.println(new Main().getGenericClass());
    }

}

class User {
}

不出意外的话，会打印如下结果：

class xxx.xxx.xxx.User

需要注意的是，SuperClass<T>是一个抽象类，因为getGenericClass()方法是为它的子类服务的，SuperClass<T>本身的实例对象如果调用该方法，将会直接报错或返回错误的结果，所以干脆定义成抽象类，避免被实例化。另外，为了防止方法被覆写，可以使用private访问修饰符或者定义为 final 方法。

当然多级继承也是适用的，比如：

// 这里省略 SuperClass 和 User 的定义

class Main<T> extends SuperClass<T> {
}

class MultiInheritance extends Main<User> {
    public static void main(String[] args) {
        System.out.println(new MultiInheritance().getGenericClass());
    }
}

通过上面的代码，基本可以了解通过getGenericSuperClass()获取泛型类型的大概思路和原理，而getGenericInterfaces()的获取思路也是大同小异。直接上实例代码：

package xxx.xxx.xxx;

import java.lang.reflect.ParameterizedType;
import java.lang.reflect.Type;

interface ServiceA<T> {
}

interface ServiceB<T> {
}

class ServiceImpl implements ServiceA<EntityA>, ServiceB<EntityB> {

    public static void main(String[] args) {
        Type[] genericInterfaces = ServiceImpl.class.getGenericInterfaces();
        if (genericInterfaces.getClass().isAssignableFrom(ParameterizedType[].class)) {
            for (Type genericInterface : genericInterfaces) {
                ParameterizedType parameterizedType = (ParameterizedType) genericInterface;
                Type[] actualTypeArguments = parameterizedType.getActualTypeArguments();
                Type type = actualTypeArguments[0];
                if (type instanceof Class) {
                    Class<?> clazz = (Class<?>) type;
                    System.out.println(clazz);
                }
            }
        }
    }

}

class EntityA {
}

class EntityB {
}

控制台打印结果如下：

class xxx.xxx.xxx.EntityA
class xxx.xxx.xxx.EntityB

扩展

很多情况下，Class被用来当作参数，我们其实可以将带泛型的类作为参数传入，我们一般为了方便，很少去特定定义一个类，因此，我们可以借助匿名内部类的便利来达到这一目的。
首先看一段代码：

package xxx.xxx.xxx;

import java.lang.reflect.ParameterizedType;

abstract class SuperClass<T> {

    public Class<T> getGenericClass() {
        ParameterizedType parameterizedType = (ParameterizedType) getClass().getGenericSuperclass();
        return (Class<T>) parameterizedType.getActualTypeArguments()[0];
    }

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

}

其中SuperClass<User>(){}就是一个匿名内部类。当然上面只是为了展示匿名内部类，真正的应用可以参考fastjson的TypeRefrence。