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);
}
}
3259
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
