Java获得范型类型class

Java很多框架或库中都会提供具有范型的回调接口或抽象类。当我们在使用时，代码类似于：

MyClient.getInstance().handleEvent(new MyCallback<SomeEntity>() {            @Override            public void onSuccess(SomeEntity entity) {                System.out.println("Entity is: " + s);            }            @Override            public void onFailure(String errorMsg) {                System.out.println(errorMsg);            }        });

在匿名的回调类中，传入了范型类型，回调的接口中直接给出了相应类型的入参实例。
那么这样的功能是如何实现的呢？
实际是java的范型机制中，并没有把所有的范型信息擦除，通过一些反射相关的API，可以将父类的范型参数获取到。

首先假定我们的Callback是抽象类方式提供的：

public abstract class MyAbstractCallback<ENTITY> {    abstract void onSuccess(ENTITY entity);    abstract void onFailure(String errorMsg);}

在这里引入了范型，当我们实现这个抽象类，就是本文最开始的形式。虽然我们的onSuccess入参类型已经是相应类型实例了，
但我们的“库”在回调onSuccess函数时，并没有相应的实例。因此我们需要获取到“ENTITY”对应类的class对象，并使用反射的方法生成实例，回调给上层。
那么handleEvent的内部应该是这样的：

public <ENTITY> void handleEvent(MyCallback<ENTITY> callback) {        Object obj = Class.forName(ENTITY.class.getName()).newInstance();        ENTITY result = (ENTITY) obj;        callback.onSuccess(result);    }

很显然这样的写法是无法编译通过的，因为我们无法通过范型类型ENTITY直接获取到它的class，在编译期java已经将范型擦除。
但由于callback对象必然是抽象类的一个实现子类，因此我们虽然不能直接获取到callback实现类中的范型信息，但可以获取到父类中的范型参数来达到同样的效果，这个信息是不会被擦除的。
java的反射中提供了getGenericSuperclass()方法可以实现这个需求。

public <ENTITY> void handleEvent(MyAbstractCallback<ENTITY> callback) {        // 单继承，父类只有一个        Type superclass = callback.getClass().getGenericSuperclass();        // 如果实现类没有范型信息，直接返回        if (!(superclass instanceof ParameterizedTypeImpl)) {            return;        }        try {            // 找到声明的具体类型            ParameterizedType parameterized = (ParameterizedType) superclass;            Type actualType = parameterized.getActualTypeArguments()[0];            Object obj = Class.forName(actualType.getTypeName()).newInstance();            ENTITY result = (ENTITY) obj;            onSuccessB(callback, result);        } catch (Exception e) {            e.printStackTrace();            onFailureB(callback, e.getLocalizedMessage());        }    }

整个流程可以归纳为：
1.通过getGenericSuperclass()方法获取到带有范型参数的父类信息，为Type的实例。
2.如果这个实例包含范型参数，那么获取到的是ParameterizedTypeImpl实例。
3.将这个Type类型实例向下强转为ParameterizedType类型，通过getActualTypeArguments方法获取到实际的类型信息（这个方法返回的是数组，因为我们定义的抽象类仅有一个范型参数，因此数组第一个元素就是我们实现时传入的类型）。
4.获取到类型后就可以通过反射方法生成实例，调用回调方法返回。

对于接口类型的回调也同样适用，与获取父类范型参数类似，java提供了getGenericInterfaces方法，返回所有实现的接口。
如果接口是带有范型参数的，那么它同样是ParameterizedTypeImpl的实例。代码逻辑稍有增加，主要是因为一个类可以实现多个接口，需要在getGenericInterfaces返回的数组里先找到相应的接口类型。

public <ENTITY> void handleEvent(MyCallback<ENTITY> callback) {        Type[] interfaces = callback.getClass().getGenericInterfaces();        Type target = null;        // 实际的对象可能实现了多个接口，需要从其中找到MyCallback        for (int i = 0; i < interfaces.length; i++) {            // 范型接口在数组中是ParameterizedTypeImpl类型            if (interfaces[i] instanceof ParameterizedTypeImpl) {                ParameterizedTypeImpl impl = (ParameterizedTypeImpl) interfaces[i];                if (impl.getRawType().getName().equals(MyCallback.class.getName())) {                    // target就是实现了MyCallback的范型接口                    target = interfaces[i];                }            }        }        if (target != null) {            try {                // 找到声明的具体类型                ParameterizedType parameterized = (ParameterizedType) target;                Type actualType = parameterized.getActualTypeArguments()[0];                Object obj = Class.forName(actualType.getTypeName()).newInstance();                ENTITY result = (ENTITY) obj;                onSuccess(callback, result);            } catch (Exception e) {                e.printStackTrace();                onFailure(callback, e.getLocalizedMessage());            }        }    }

找到接口类型后适用同样的方法拿到具体类型并反射生成实例。
将这两个方法封装到一个类中：

public class MyClient {    private static MyClient singleInstance = new MyClient();    public static MyClient getInstance() {        return singleInstance;    }    /**     * 处理接口类型的回调函数     * @param callback     * @param <ENTITY>     */    public <ENTITY> void handleEvent(MyCallback<ENTITY> callback) {        Type[] interfaces = callback.getClass().getGenericInterfaces();        Type target = null;        // 实际的对象可能实现了多个接口，需要从其中找到MyCallback        for (int i = 0; i < interfaces.length; i++) {            // 范型接口在数组中是ParameterizedTypeImpl类型            if (interfaces[i] instanceof ParameterizedTypeImpl) {                ParameterizedTypeImpl impl = (ParameterizedTypeImpl) interfaces[i];                if (impl.getRawType().getName().equals(MyCallback.class.getName())) {                    // target就是实现了MyCallback的范型接口                    target = interfaces[i];                }            }        }        if (target != null) {            try {                // 找到声明的具体类型                ParameterizedType parameterized = (ParameterizedType) target;                Type actualType = parameterized.getActualTypeArguments()[0];                Object obj = Class.forName(actualType.getTypeName()).newInstance();                ENTITY result = (ENTITY) obj;                onSuccess(callback, result);            } catch (Exception e) {                e.printStackTrace();                onFailure(callback, e.getLocalizedMessage());            }        }    }    private <ENTITY> void onSuccess(MyCallback<ENTITY> callback, ENTITY entity) {        System.out.println("log success");        callback.onSuccess(entity);    }    private <ENTITY> void onFailure(MyCallback<ENTITY> callback, String msg) {        System.out.println("log failure");        callback.onFailure(msg);    }    // --------------------------------------------    /**     * 处理类形式的回调函数     * @param callback     * @param <ENTITY>     */    public <ENTITY> void handleEvent(MyAbstractCallback<ENTITY> callback) {        // 单继承，父类只有一个        Type superclass = callback.getClass().getGenericSuperclass();        // 如果实现类没有范型信息，直接返回        if (!(superclass instanceof ParameterizedTypeImpl)) {            return;        }        try {            // 找到声明的具体类型            ParameterizedType parameterized = (ParameterizedType) superclass;            Type actualType = parameterized.getActualTypeArguments()[0];            Object obj = Class.forName(actualType.getTypeName()).newInstance();            ENTITY result = (ENTITY) obj;            onSuccessB(callback, result);        } catch (Exception e) {            e.printStackTrace();            onFailureB(callback, e.getLocalizedMessage());        }    }    private <ENTITY> void onSuccessB(MyAbstractCallback<ENTITY> callback, ENTITY entity) {        System.out.println("log success");        callback.onSuccess(entity);    }    private <ENTITY> void onFailureB(MyAbstractCallback<ENTITY> callback, String msg) {        System.out.println("log failure");        callback.onFailure(msg);    }}

接下来可以写一些测试代码，可以通过修改构造函数参数数量，触发反射生成实例报错走onFailure的逻辑。这里由于反射仅生成了实例没有设置参数，所有的打印都是空值：

public class TestMain {    public String name;    // 打开用来测试newInstance报错走onFailure    /*public TestMain(String name) {        this.name = name;    }*/    public String getName() {        return name;    }    public void setName(String name) {        this.name = name;    }    public void printTestMainName() {        System.out.println("Name of TestMain is: " + this.name);    }    public static void main(String[] args) {        MyClient.getInstance().handleEvent(new MyTestCallback());        MyClient.getInstance().handleEvent(new MyCallback<String>() {            @Override            public void onSuccess(String s) {                System.out.println("String is: " + s);            }            @Override            public void onFailure(String errorMsg) {                System.out.println(errorMsg);            }        });        MyClient.getInstance().handleEvent(new AnotherCallback());        MyClient.getInstance().handleEvent(new MyAbstractCallback<String>() {            @Override            void onSuccess(String s) {                System.out.println("String is: " + s);            }            @Override            void onFailure(String errorMsg) {                System.out.println(errorMsg);            }        });    }}

前两个方法是接口实现类的调用，后两个方法是抽象类的实现类调用。同时第一个测试方法传入的是事先定义好的实现类，第二次传入了匿名实现类。

接口与抽象类的定义：

public interface MyCallback<ENTITY> {    void onSuccess(ENTITY entity);    void onFailure(String errorMsg);}public abstract class MyAbstractCallback<ENTITY> {    abstract void onSuccess(ENTITY entity);    abstract void onFailure(String errorMsg);}

接口实现类与抽象类的实现类(这里主要测试了实现多个接口时的处理逻辑)：

public class MyTestCallback implements MyCallback<TestMain>, FooInterface {    @Override    public void foo() {    }    @Override    public void onSuccess(TestMain o) {        o.printTestMainName();    }    @Override    public void onFailure(String errorMsg) {        System.out.println(errorMsg);    }}public class AnotherCallback extends MyAbstractCallback<TestMain> {    @Override    void onSuccess(TestMain testMain) {        testMain.printTestMainName();    }    @Override    void onFailure(String errorMsg) {        System.out.println(errorMsg);    }}