Spring 是如何解析泛型 - ResolvalbeType
Spring 系列目录(https://www.cnblogs.com/binarylei/p/10198698.html)
Java Type 泛型系列文章：
Spring 中大量使用反射，需要获取泛型的具体类型，为此专门提供了一个工具类解析泛型 - ResolvalbeType。ResolvableType 是对 Class，Field，Method 获取 Type 的抽象。
一、ResolvalbeType 使用
interface Service<N, M> {
}
class ServiceImpl<A, B> implements Service<String, Integer> {
public ServiceImpl(List<List<String>> list, Map<Double, Map<Float, Integer>> map) {
}
}
(1) forClass
@Test
public void forClassTest() {
ResolvableType resolvableType = ResolvableType.forClass(ServiceImpl.class);
// getType 保存原始的 Type 类型
Assert.assertEquals(ServiceImpl.class, resolvableType.getType());
// resolve 将 Type 解析为 Class， 如果无法解析返回 null
Assert.assertEquals(ServiceImpl.class, resolvableType.resolve());
}
(2) forField
private Service<Double, Float> service;
private List<List<String>> list;
private Map<String, Map<String, Integer>> map;
private List<String>[] array;
@Test
public void forFieldTest() {
// 1. Service<Double, Float> service
Field filed = ReflectionUtils.findField(ResolveTypeTest.class, "service");
ResolvableType resolvableType = ResolvableType.forField(filed);
// getType() 保存原始的 Type 类型
Assert.assertEquals(filed.getGenericType(), resolvableType.getType());
// resolve() 对于 ParameterizedType 类型保存的是 <> 之前的类型，即 Service.class
Assert.assertEquals(((ParameterizedType) filed.getGenericType()).getRawType(), resolvableType.resolve());
Class<?> clazz = resolvableType.getGeneric(0).resolve();
Assert.assertEquals(Double.class, clazz);
// 2. List<List<String>> list
resolvableType = ResolvableType.forField(
ReflectionUtils.findField(ResolveTypeTest.class, "list"));
// 下面两种获取泛型的方式等价
clazz = resolvableType.getGeneric(0).getGeneric(0).resolve();
Assert.assertEquals(String.class, clazz);
clazz = resolvableType.getGeneric(0, 0).resolve();
Assert.assertEquals(String.class, clazz);
// 3. Map<String, Map<String, Integer>> map
resolvableType = ResolvableType.forField(
ReflectionUtils.findField(ResolveTypeTest.class, "map"));
clazz = resolvableType.getGeneric(1).getGeneric(1).resolve();
Assert.assertEquals(Integer.class, clazz);
// 4. List<String>[] array
resolvableType = ResolvableType.forField(
ReflectionUtils.findField(ResolveTypeTest.class, "array"));
Assert.assertTrue(resolvableType.isArray());
Assert.assertEquals(List.class, resolvableType.getComponentType().resolve());
Assert.assertEquals(String.class, resolvableType.getComponentType().getGeneric(0).resolve());
}
(3) forMethodParameter
forMethodParameter 还有很多变种：如 forConstructorParameter、forMethodReturnType
@Test
public void forMethodTest() {
// 1. 方法的返回值类型
ResolvableType returnType = ResolvableType.forMethodReturnType(
ReflectionUtils.findMethod(ServiceImpl.class, "method"));
Assert.assertEquals(Double.class, returnType.getGeneric(1, 0).resolve());
// 2. 构造器 ServiceImpl(List<List<String>> list, Map<Double, Map<Float, Integer>> map)
ResolvableType parameterType = ResolvableType.forConstructorParameter(
ClassUtils.getConstructorIfAvailable(ServiceImpl.class, List.class, Map.class), 0);
// List<List<String>> 的泛型第一层为 <List<String>>，第二层为 <String>
Assert.assertEquals(String.class, parameterType.getGeneric(0, 0).resolve());
parameterType = ResolvableType.forConstructorParameter(
ClassUtils.getConstructorIfAvailable(ServiceImpl.class, List.class, Map.class), 1);
Assert.assertEquals(Double.class, parameterType.getGeneric(0).resolve());
Assert.assertEquals(Float.class, parameterType.getGeneric(1, 0).resolve());
Assert.assertEquals(Integer.class, parameterType.getGeneric(1, 1).resolve());
}
(4) 其它常用方法
@Test
public void test() {
// HashMap<K,V> extends AbstractMap<K,V> implements Map<K,V>, Cloneable, Serializable
ResolvableType resolvableType = ResolvableType.forClass(HashMap.class);
// 1. getInterfaces 获取接口
Assert.assertEquals(Map.class, resolvableType.getInterfaces()[0].resolve());
// 2. getSuperType 获取父类
Assert.assertEquals(AbstractMap.class, resolvableType.getSuperType().resolve());
// 3. as 向上转型 Map<K,V>
ResolvableType mapResolvableType = resolvableType.as(Map.class);
Assert.assertEquals(Map.class, mapResolvableType.resolve());
// 4. getRawClass 当 type 是 ParameterizedType 时有效
Assert.assertEquals(Map.class, mapResolvableType.getRawClass());
Assert.assertEquals(HashMap.class.getGenericInterfaces()[0], mapResolvableType.getType());
// 5. getGeneric 获取泛型 class ServiceImpl<A, B> implements Service<String, Integer>
resolvableType = ResolvableType.forClass(ServiceImpl.class);
// 当 Type 无法找到具体的 class 类型时返回 null
Assert.assertEquals("A", resolvableType.getGeneric(0).getType().getTypeName());
Assert.assertEquals(null, resolvableType.getGeneric(0).resolve());
// 以下两种获取泛型的 Class 类型方式等价
Assert.assertEquals(String.class, resolvableType.as(Service.class).getGeneric(0).resolve());
Assert.assertEquals(String.class, resolvableType.as(Service.class).resolveGeneric(0));
// 5. getComponentType 获取数组泛型 List<String>[] array
resolvableType = ResolvableType.forField(
ReflectionUtils.findField(ResolveTypeTest.class, "array"));
Assert.assertEquals(List.class, resolvableType.getComponentType().resolve());
}
(5) 创建 ResolvableType
@Test
public void test() {
ResolvableType resolvableType1 = ResolvableType.forClassWithGenerics(List.class, String.class);
ResolvableType resolvableType2 = ResolvableType.forArrayComponent(resolvableType1);
resolvableType2.getComponentType().getGeneric(0).resolve();
// List<String>[] array
ResolvableType resolvableType3 = ResolvableType.forField(
ReflectionUtils.findField(ResolveTypeTest.class, "array"));
Assert.assertTrue(resolvableType3.isAssignableFrom(resolvableType2));
Assert.assertTrue(ResolvableType.forClass(Object.class).isAssignableFrom(
ResolvableType.forClass(String.class)));
}
通过使用也可以看出 ResolvableType 最主要的目的是解析传入的 Type 类型，并通过 resolve() 获取真实的 Class 类型。
二、ResolvalbeType 源码分析
(1) ResolvalbeType 重要属性
// 需要解析的 JDK Type 类型
private final Type type;
// 缓存解析后的 Class 类型
private Class<?> resolved;
// 缓存解析后父类、接口、泛型、数组泛型等
private volatile ResolvableType superType;
private volatile ResolvableType[] interfaces;
private volatile ResolvableType[] generics;
private final ResolvableType componentType;
另外还有两个工具类辅助解析用：
// 对 Type 进行封装
private final TypeProvider typeProvider;
// 对 TypeVariable 如何解析为 Class 的策略
private final VariableResolver variableResolver;
(2) forField
下面以 forField(Field field) 为例，看 ResolvalbeType 是如何解析泛型的。
public static ResolvableType forField(Field field) {
Assert.notNull(field, "Field must not be null");
return forType(null, new FieldTypeProvider(field), null);
}
static ResolvableType forType(Type type, TypeProvider typeProvider, VariableResolver variableResolver) {
if (type == null && typeProvider != null) {
type = SerializableTypeWrapper.forTypeProvider(typeProvider);
}
if (type == null) {
return NONE;
}
// 1. Class 不用解析，所以没必要不缓存
if (type instanceof Class) {
return new ResolvableType(type, typeProvider, variableResolver, (ResolvableType) null);
}
cache.purgeUnreferencedEntries();
// 2. 其余的 Type 类型需要解析，所以先缓存起来
// 2.1 这个构造器专为缓存使用，不会触发 resolveClass() 操作
ResolvableType resultType = new ResolvableType(type, typeProvider, variableResolver);
ResolvableType cachedType = cache.get(resultType);
if (cachedType == null) {
// 2.2 如果缓存中没有就需要解析了，这个构造器会触发 resolveClass() 操作
cachedType = new ResolvableType(type, typeProvider, variableResolver, resultType.hash);
cache.put(cachedType, cachedType);
}
resultType.resolved = cachedType.resolved;
return resultType;
}
解析 Type 对应的真实 Class 类型在 cachedType = new ResolvableType(type, typeProvider, variableResolver, resultType.hash) 这一步，会触发 resolveClass() 操作。
private ResolvableType(Type type, @Nullable TypeProvider typeProvider,
@Nullable VariableResolver variableResolver, @Nullable Integer hash) {
this.type = type;
this.typeProvider = typeProvider;
this.variableResolver = variableResolver;
this.componentType = null;
this.hash = hash;
this.resolved = resolveClass(); // 关键
}
(3) resolveClass
resolveClass() 方法先对两种简单的类型 Class 和 GenericArrayType 进行了解析，其余的 Type 类型则委托给了 resolveType() 方法解析。
private Class<?> resolveClass() {
if (this.type == EmptyType.INSTANCE) {
return null;
}
// 1. Class 类型
if (this.type instanceof Class) {
return (Class<?>) this.type;
}
// 2. GenericArrayType 泛型数组，成员变量的 Class 类型
if (this.type instanceof GenericArrayType) {
Class<?> resolvedComponent = getComponentType().resolve();
return (resolvedComponent != null ? Array.newInstance(resolvedComponent, 0).getClass() : null);
}
return resolveType().resolve();
}
对于 Class 和 GenericArrayType 两种 Type 类型：
Class解析后仍为该 Class 类型GenericArrayType该泛型数组成员变量的 Class 类型
(4) resolveType
剩余的 ParameterizedType、WildcardType、TypeVariable 三种类型继续解析。
ResolvableType resolveType() {
// 3. ParameterizedType 类型，getRawType 的 Class 类型
if (this.type instanceof ParameterizedType) {
return forType(((ParameterizedType) this.type).getRawType(), this.variableResolver);
}
// 4. WildcardType 类型，上界或下界的 Class 类型，如有多个只取第一个
if (this.type instanceof WildcardType) {
Type resolved = resolveBounds(((WildcardType) this.type).getUpperBounds());
if (resolved == null) {
resolved = resolveBounds(((WildcardType) this.type).getLowerBounds());
}
return forType(resolved, this.variableResolver);
}
// 5. TypeVariable 类型
if (this.type instanceof TypeVariable) {
TypeVariable<?> variable = (TypeVariable<?>) this.type;
// 5.1 使用 resolveVariable 解析 Try default variable resolution
if (this.variableResolver != null) {
ResolvableType resolved = this.variableResolver.resolveVariable(variable);
if (resolved != null) {
return resolved;
}
}
// 5.2 TypeVariable 默认取上界的 Class 类型，如有多个只取第一个
return forType(resolveBounds(variable.getBounds()), this.variableResolver);
}
return NONE;
}
resolveType对于 ParameterizedType、WildcardType、TypeVariable 三种 Type 类型：
ParameterizedTypegetRawType 对应的 Class 类型WildcardType上界或下界的 Class 类型，如有多个只取第一个TypeVariable默认取上界的 Class 类型，如有多个只取第一个，也可以是 variableResolver 解析，默认为 DefaultVariableResolver
(5) getGenerics
public ResolvableType[] getGenerics() {
if (this == NONE) {
return EMPTY_TYPES_ARRAY;
}
ResolvableType[] generics = this.generics;
if (generics == null) {
// 1. 获取 Class 类型的泛型
if (this.type instanceof Class) {
Type[] typeParams = ((Class<?>) this.type).getTypeParameters();
generics = new ResolvableType[typeParams.length];
for (int i = 0; i < generics.length; i++) {
generics[i] = ResolvableType.forType(typeParams[i], this);
}
// 2. 获取 ParameterizedType 类型的泛型
} else if (this.type instanceof ParameterizedType) {
Type[] actualTypeArguments = ((ParameterizedType) this.type).getActualTypeArguments();
generics = new ResolvableType[actualTypeArguments.length];
for (int i = 0; i < actualTypeArguments.length; i++) {
generics[i] = forType(actualTypeArguments[i], this.variableResolver);
}
// 3. WildcardType、TypeVariable 类型调用 resolveType() 重新解析
} else {
generics = resolveType().getGenerics();
}
this.generics = generics;
}
return generics;
}
参考：
- 《Spring ResolvableType 更好的处理泛型》：https://blog.csdn.net/u012881904/article/details/80813294
每天用心记录一点点。内容也许不重要，但习惯很重要！