不太完美的泛型
大家在使用泛型开发的时候，有很多时候会遇到这样的需求—— 获取泛型具体的类。
比如现在有Service<T>，要想得到泛型T的类型，正常情况下，我们第一个想法就是通过T.class获得，但得到的是那刺眼的下划红色波浪线。
那么如何才能拿到泛型的类型？想要得到泛型的类型需要满足哪些条件呢？
获取到泛型类型的条件
- 必须具有真实类型的存在
- 泛型的类型是明确的
第一个很好理解，如果连要获取的类都不存在，即未定义，那自然是获取不到的；
第二个条件，举个例子，假设存在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。
网友评论