Spring 是如何解析泛型 - ResolvalbeType

Spring 系列目录(https://www.cnblogs.com/binarylei/p/10198698.html)

Java Type 泛型系列文章：

1. Java - Type 介绍
2. Java - Type 的获取方式
3. Spring - ResolvableType

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 类型：

• ParameterizedType getRawType 对应的 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;

}

参考：

1. 《Spring ResolvableType 更好的处理泛型》：https://blog.csdn.net/u012881904/article/details/80813294

---

每天用心记录一点点。内容也许不重要，但习惯很重要！

最新文章

1. 利用JS制作简便计算器
2. 基于 Node.js 平台的web开发框架-----express
3. restore和recover的区别(转)
4. Logstash+kibana+ ElasticSearch+redis
5. 如何做到 jQuery-free？
6. phpMyAdmin安装设置
7. 提升Delphi编程效率必须使用的快捷键(Delphi2007版本)
8. 学校oj平台上不去
9. Chapter 1:Introduction
10. selenium 相关api操作
11. Nodejs.调用Linux命令
12. Linux 中磁盘阵列RAID10损坏以及修复
13. python之路--MySQl单表查询
14. 删除office拥有多个都需要激活的授权信息
15. mongo官方企业版安装及数据库授权使用
16. 建立标准编码规则（二）-DiagnosticAnalyzer 增加诊断分析代码
17. easyUI拖动购物车案例
18. 【做题】agc008f - Black Radius——计数&讨论&思维
19. OSGI企业应用开发（六）细说Blueprint & Gemini Blueprint（一）
20. linux 如何正确的关闭mongodb

热门文章

1. C++字符串和向量
2. ssh架构之hibernate(四)二级缓存
3. 使用idea+gradle建立SSM项目
4. java正则验证
5. c# 用户页面
6. WINDOW 2008多人访问设置
7. Java Arrays
8. app和wap手机网站的区别在哪里
9. POJ-3126.PrimePath(欧拉筛素数打表 + BFS)
10. Max Points on a Line （HASH TABLE