模仿jackson的TypeFactory去动态解析一个java类

MyTypeFactory的constructType方法

public class MyJavaType {

    private Class<?> rawClass;
    private MyJavaType superClass;

    private MyJavaType[] superInterfaces;

    public MyJavaType getSuperClass() {
        return superClass;
    }

    public MyJavaType[] getSuperInterfaces() {
        return superInterfaces;
    }

    public MyJavaType() {
    }

    public MyJavaType(Class<?> rawClass) {
        this.rawClass = rawClass;
    }

    public MyJavaType(Class<?> rawClass, MyJavaType superClass, MyJavaType[] superInterfaces) {
        this.rawClass = rawClass;
        this.superClass = superClass;
        this.superInterfaces = superInterfaces;
    }


    public static void main(String[] args) {
        MyTypeFactory myTypeFactory = MyTypeFactory.defaultInstance();

        MyJavaType myJavaType = myTypeFactory.constructType(DefaultListableBeanFactory.class);

        System.out.println(myJavaType);


    }

    @Override
    public String toString() {

        StringBuilder builder = new StringBuilder();

        MyJavaType type = this;

        if(type.superClass!=null){

            type = type.superClass;

            builder.append(type);
        }

        return "MyJavaType{" +
                "rawClass=" + rawClass +
                ", superClass=" + superClass +
                '}';
    }
}

```
import java.lang.reflect.Type;
```
public class MyTypeFactory {

    protected final static MyTypeFactory instance = new MyTypeFactory();

    public static MyTypeFactory defaultInstance() { return instance; }

    protected final static MyJavaType CORE_TYPE_OBJECT = new MyJavaType(Object.class);

    private final static MyJavaType[] NO_TYPES = new MyJavaType[0];

    protected MyJavaType fromAny(Type srcType){

        MyJavaType resultType;

        resultType = fromClass((Class<?>) srcType);

        return resultType;
    }

    protected MyJavaType fromClass(Class<?> rawType){

        MyJavaType result;

        if(rawType== Object.class){
            result = CORE_TYPE_OBJECT;

            return result;
        }
        MyJavaType superClass;

        MyJavaType[] superInterfaces;

        if (rawType.isInterface()) {
            superClass = null;
            superInterfaces = resolveSuperInterfaces( rawType);
        } else {
            superClass = resolveSuperClass(rawType);
            superInterfaces = resolveSuperInterfaces(rawType);
        }

        result = new MyJavaType(rawType,superClass,superInterfaces);

        return result;

    }

    protected MyJavaType[] resolveSuperInterfaces(Class<?> rawType) {
        Type[] types = rawType.getGenericInterfaces();
        if (types == null || types.length == 0) {
            return NO_TYPES;
        }
        int len = types.length;
        MyJavaType[] resolved = new MyJavaType[len];
        for (int i = 0; i < len; ++i) {
            Type type = types[i];
            resolved[i] = fromAny(type);
        }
        return resolved;
    }

    protected MyJavaType resolveSuperClass(Class<?> rawType)
    {
        Type parent = rawType.getGenericSuperclass();
        if (parent == null) {
            return null;
        }
        return fromAny(parent);
    }

    public MyJavaType constructType(Type type){
        return fromAny(type);
    }
}