Java获取类或接口上的泛型类型T方法

前言

实际开发中，泛型使用到处可见。有时候定义接口时，经常使用泛型，而不是指定具体对象，使用泛型的好处很多，特别是代码复用方面。要获取类或接口上的泛型类型Class<?>，然后对这个类型进行数据处理，至于怎么处理,还要看实际的应用场景。本篇讲述如何获取类或接口的泛型类型（参数化类型ParameterizedType）。

实例

1.定义泛型接口

public interface Response<T> {
    void onSuccess(T data);
}

2.定义泛型类

public static class BaseResponse<T> {
 }

3.定义测试类和测试方法
测试类

public static class SubResponse extends BaseResponse<Person> {

}

public static class Person {
    public String name;
}

测试方法

private static void test(SubResponse subResponse) {
        Class<?> clz = getClassT(subResponse, 0);
        System.out.println(clz.getSimpleName());
    }

    private static void test(Response a) {
        Class<?> clz = getInterfaceT(a, 0);
        System.out.println(clz.getSimpleName());
    }

4.调用

test(new Response<Person>() {
    @Override
    public void onSuccess(Person data) {

    }
});

test(new Response<List<Person>>() {
    @Override
    public void onSuccess(List<Person> data) {

    }
});
test(new SubResponse());

5.输出结果
上面输出都是

Person

这个clz 就是person的Class,有了这个Class，可以做你想做的事情,比如：根据Class实例化对象、或者结合Class把json字符串和xml字符串转化成具体的bean，然后再返回调用处。

获取类或接口上的泛型类型T完整代码

/**
     * 获取接口上的泛型T
     *
     * @param o     接口
     * @param index 泛型索引
     */
    public static Class<?> getInterfaceT(Object o, int index) {
        Type[] types = o.getClass().getGenericInterfaces();
        ParameterizedType parameterizedType = (ParameterizedType) types[index];
        Type type = parameterizedType.getActualTypeArguments()[index];
        return checkType(type, index);

    }


    /**
     * 获取类上的泛型T
     *
     * @param o     接口
     * @param index 泛型索引
     */
    public static Class<?> getClassT(Object o, int index) {
        Type type = o.getClass().getGenericSuperclass();
        if (type instanceof ParameterizedType) {
            ParameterizedType parameterizedType = (ParameterizedType) type;
            Type actType = parameterizedType.getActualTypeArguments()[index];
            return checkType(actType, index);
        } else {
            String className = type == null ? "null" : type.getClass().getName();
           throw new IllegalArgumentException("Expected a Class, ParameterizedType"
                    + ", but <" + type + "> is of type " + className);
        }
    }

    private static Class<?> checkType(Type type, int index) {
        if (type instanceof Class<?>) {
            return (Class<?>) type;
        } else if (type instanceof ParameterizedType) {
            ParameterizedType pt = (ParameterizedType) type;
            Type t = pt.getActualTypeArguments()[index];
            return checkType(t, index);
        } else {
            String className = type == null ? "null" : type.getClass().getName();
           throw new IllegalArgumentException("Expected a Class, ParameterizedType"
                    + ", but <" + type + "> is of type " + className);
        }
    }

小结

本篇讲述了如何获取类或接口上的泛型类型，实际要灵活使用。上面的Type是Java语言中所有类型的公共父接口。Type有四个子类——ParameterizedType、 TypeVariable、GenericArrayType、WildcardType。在Gson等框架中有出现，有空的话，大家可以研究一下用法。

如果一个类没有继承其他任何类，类似 class Person<T>{T data；}，对于这样的类是否有办法获取到类上的泛型T呢？

答案是可以的，由于Java在运行时，泛型参数的类型会被擦除，导致获取到的泛型类型是Object类型，可以借助子类保存父类泛型信息，解决java运行时泛型类型被擦除的问题的。

在上面例子基础上改造一下getClassT，封装一个中间类MyTypeToken：如下

public  class MyTypeToken<T> {
private  Type type;
private  Type parameterizedType;
public MyTypeToken() {
    getClassT(this, 0);
}

/**
 * 获取类上的泛型T
 *
 * @param o     接口
 * @param index 泛型索引
 */
public  Class<?> getClassT(Object o, int index) {
    Type type = o.getClass().getGenericSuperclass();
    if (type instanceof ParameterizedType) {
        ParameterizedType parameterizedType = (ParameterizedType) type;
        Type actType = parameterizedType.getActualTypeArguments()[index];
        return checkType(actType, index);
    } else {
        String className = type == null ? "null" : type.getClass().getName();
        throw new IllegalArgumentException("Expected a Class, ParameterizedType"
                + ", but <" + type + "> is of type " + className);
    }
}

private  Class<?> checkType(Type type, int index) {
    if (type instanceof Class<?>) {
        this.type = type;
        return (Class<?>) type;
    } else if (type instanceof ParameterizedType) {
        ParameterizedType pt = (ParameterizedType) type;
        Type t = pt.getActualTypeArguments()[index];
        parameterizedType = pt;
        return checkType(t, index);
    } else {
        String className = type == null ? "null" : type.getClass().getName();
        throw new IllegalArgumentException("Expected a Class, ParameterizedType"
                + ", but <" + type + "> is of type " + className);
    }
}

public Type getType() {
    return type;
}

public Type getParameterizedType() {
    return parameterizedType;
}
}

测试

测试类：

Person：

    public class Person<T> {
    T data;

    @Override
    public String toString() {
        return "Person{" +
                "data=" + data +
                '}';
    }
}

Student：

 public class Student {
    String name;
    int age;

    @Override
    public String toString() {
        return "Student{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
}

运行：

	//注意大括号，匿名内部类实例化对象，继承了MyTypeToken
	MyTypeToken<Person<Student>> myTypeToken = new MyTypeToken<Person<Student>>() {
    };
    Type type = myTypeToken.getType();
    Type parameterizedType = myTypeToken.getParameterizedType();
    Class<?> classT = (Class<?>) type;
    System.out.println("parameterizedType:" + parameterizedType.getTypeName() + ",泛型T name:" + type.getTypeName()+",T:"+classT.getSimpleName());

输出：

parameterizedType:com.sjl.lib.bean.Person<com.sjl.lib.bean.Student>,泛型T name:com.sjl.lib.bean.Student,T:Student

由此可见，正确拿到了泛型T
在上面例子进一步扩展测试：

假如有这么json串"{\"data\":{\"name\":\"李四\",\"age\":88" + "}}"，需要转成Person<Student>，可以使用Google Gson库处理一下：

    String json = "{\"data\":{\"name\":\"李四\",\"age\":88" + "}}";
	//parameterizedType对应上面的 myTypeToken.getParameterizedType();
    Person<Student> person = new Gson().fromJson(json, parameterizedType);
    System.out.println("Person<Student> :" + person.toString());

输出：

Person<Student>:Person{data=Student{name='李四', age=88}}

小结：

通过上面，你会发现其实跟一开始的例子一样，也是利用子类会保存父类class的泛型参数信息的特点（可以通过javap class分析一下或者直接到在classes目录下找到生成的中间文件，拖到AS里面分析），即通过匿名内部类实现了泛型参数的传递。