Java获取派生类泛型真实类型

import java.lang.reflect.ParameterizedType;
import java.lang.reflect.Type;
import java.util.LinkedList;

public class TestActualClass {
    private static class D1 {}
    private static class D2 {}
    private static class D3 {}


    private static class B1<T> {}
    private static class B2<T> extends B1<T> {}
    private static class B3<T> extends B1<D1> {}
    private static class B4 extends B2<D2> {}
    private static class B5 extends B3<D3> {}

    private static Class<?> getFirstActualType(Class<?> genericSuperClass, Class<?> finalClass) {
        if (genericSuperClass.getTypeParameters().length == 0)
            return null;

        if (!genericSuperClass.isAssignableFrom(finalClass))
            return null;

        LinkedList<Class<?>> stack = new LinkedList<>();

        while (finalClass != genericSuperClass) {
            stack.add(finalClass);
            finalClass = finalClass.getSuperclass();
        }

        while (!stack.isEmpty()) {
            Class<?> aClass = stack.pollLast();
            Type type = aClass.getGenericSuperclass();
            if (!(type instanceof ParameterizedType)) {
                continue;
            }

            Type[] actualTypes = ((ParameterizedType) type).getActualTypeArguments();
            if (actualTypes == null || actualTypes.length == 0)
                return null;

            Type actualType = actualTypes[0];
            if (actualType instanceof Class)
                return (Class<?>)actualType;
        }

        return null;
    }

    public static void main(String[] args) {
        //B1类的类型没有确定 输出null
        System.out.println(getFirstActualType(B1.class, B2.class));

        //B3虽然还是泛型， 但B1类已确定是D1  输出 D1
        System.out.println(getFirstActualType(B1.class, B3.class));

        //输出 D2
        System.out.println(getFirstActualType(B1.class, B4.class));

        //输出 D1
        System.out.println(getFirstActualType(B1.class, B5.class));
    }
}