深入挖掘Spring系列 -- Spring里面常用的反射实例化技巧

getSuperType()：获取直接父类型
getInterfaces()：获取接口类型
getGeneric(int...)：获取类型携带的泛型类型
resolve()：Type对象到Class对象的转换
         另外，ResolvableType的构造方法全部为私有的，我们不能直接new，只能使用其提供的静态方法进行类型获取：
forField(Field)：获取指定字段的类型
forMethodParameter(Method, int)：获取指定方法的指定形参的类型
forMethodReturnType(Method)：获取指定方法的返回值的类型
forClass(Class)：直接封装指定的类型
复制代码

package com.sise.test;
import org.junit.Assert;
import org.junit.Test;
import org.springframework.core.MethodParameter;
import org.springframework.core.ResolvableType;
import java.lang.reflect.Field;
import java.lang.reflect.Method;
import java.lang.reflect.Type;
import java.util.ArrayList;
import java.util.List;
/**
 * @author hao_lin
 * @data 2018/10/8 10:46
 */
public class ResolvableTypeTest {
    static class ExtendsList extends ArrayList<CharSequence> {
        public String field1;
        public List<String> stringList(int id) {
            List<String> list = new ArrayList<>();
            list.add(id + "iii");
            return list;
        }
        public void handlePassword(HeadVO<User, Accout> param) {
        }
    }
    /**
     * 如何防止某个参数为空，进行反射实例化的做法
     *
     * @throws NoSuchMethodException
     * @throws IllegalAccessException
     * @throws InstantiationException
     */
    @Test
    public void handleParameter() throws NoSuchMethodException, IllegalAccessException, InstantiationException {
        Method method = ExtendsList.class.getMethod("handlePassword", HeadVO.class);
        //获取到相应方法的第一个参数
        ResolvableType resolvableType = ResolvableType.forMethodParameter(method, 0);
        //获取到相应方法的第一个参数的泛型类型的第二个参数类型
        Class<?> bodyClass = resolvableType.getGeneric(1).resolve();
        Accout accout = (Accout) bodyClass.newInstance();
        System.out.println(accout.toString());
    }
    /**
     * 获取类名
     */
    @Test
    public void forClass() {
        ResolvableType type = ResolvableType.forClass(ExtendsList.class);
        Assert.assertTrue(type.getType().equals((Type) ExtendsList.class));
    }
    /**
     * 获取字段的名称
     */
    @Test
    public void forField() throws NoSuchFieldException {
        //公开方法才有权限获取
        Field[] fields = ExtendsList.class.getFields();
        for (Field field : fields) {
            System.out.println(field.getName());
        }
        //公开方法才有权限获取
        Field field = ExtendsList.class.getField("field1");
        //获取到相应字段是属于String类型
        ResolvableType type = ResolvableType.forField(field);
        Assert.assertTrue(type.getType().equals(field.getGenericType()));
    }
    /**
     * 获取一个方法的参数类型
     *
     * @throws NoSuchMethodException
     */
    @Test
    public void forMethodParameter() throws NoSuchMethodException {
        Method method = ExtendsList.class.getMethod("stringList", int.class);
        MethodParameter methodParameter = MethodParameter.forMethodOrConstructor(method, 0);
        ResolvableType type = ResolvableType.forMethodParameter(methodParameter);
        Assert.assertTrue(type.getType().equals(method.getGenericParameterTypes()[0]));
    }
    /**
     * 获取方法的返回类型
     *
     * @throws NoSuchMethodException
     */
    @Test
    public void forMethodReturnType() throws NoSuchMethodException {
        Method method = ExtendsList.class.getMethod("stringList", int.class);
        ResolvableType type = ResolvableType.forMethodReturnType(method);
        System.out.println(type.getType());
        MethodParameter methodParameter = MethodParameter.forMethodOrConstructor(method, 0);
        ResolvableType type1 = ResolvableType.forMethodParameter(methodParameter);
        System.out.println(type1.getType());
    }
    /**
     * 获取自身的一个类型
     */
    @Test
    public void forClassTest() {
        ResolvableType type = ResolvableType.forClass(ExtendsList.class);
        System.out.println(type.getType());
        System.out.println(type.getRawClass());
        Assert.assertTrue(type.getType().equals(ExtendsList.class));
        Assert.assertTrue(type.getRawClass().equals(ExtendsList.class));
    }
    /**
     * 获取该类的父类类型
     */
    @Test
    public void getSuperTypeTest() {
        ResolvableType type = ResolvableType.forType(ExtendsList.class);
        ResolvableType superType = type.getSuperType();
        System.out.println(superType.getType());
        System.out.println(superType.getRawClass());
        System.out.println(superType.getGeneric().getType());
    }
    /**
     * 可以将ExtendsList以as的方式转换一下,向上取接口或父类
     */
    @Test
    public void asTest() {
        ResolvableType type = ResolvableType.forType(ExtendsList.class);
        ResolvableType listType = type.as(ArrayList.class);
        System.out.println(listType.getType());
        System.out.println(listType.getRawClass());
        //获取到继承的父类的泛型类型
        System.out.println(listType.getGeneric().getType());
    }
}
复制代码