前言
在上一篇文章【Android最最简单】AIDL进阶（双向通信）中，已经向大家介绍了AIDL的进阶用法，用于service和client的双向调用，基本上可以满足大家的日常开发需求，且建立一套基于aidl实现的跨进程调用框架对于一个新需求或者一个新立项的项目，也完全没有什么难度，操起键盘代码一撸到底就是。但是，如果对于一个维护了N手的项目，突然要把已经实现了的N多需求转成跨进程实现，那就懵逼了，N多方法都需要用aidl实现，N多传输的bean类都要实现Parceable序列化，三N系列，想想就头大！
img
只要思想不滑坡，办法总比困难多！
解题思路
解题思路-1.0
实现一个通用接口，所有传输数据转json字符串，在接收数据后在进行拆箱还原成bean类，好了，完美解决，喜大普奔！此文over！
img
如此处理，虽然也不是不行，但这样简单，操作如此复杂，还要这篇文章干嘛！
解题思路-2.0
进入正题，最容易想到的方法是纯AIDL实现，接口文件一一对应，所有方法都编写AIDL接口文件实现！使用系列上一篇【Android最最简单】AIDL进阶（双向通信）介绍内容即可轻松实现。
- 优点：简单易懂。
- 缺点：
- 改造成本：成本高，比较适合新项目，不适合老项目；
- 后续维护：aidl接口文件和aidl序列化对象文件多，不利于维护。
解题思路-3.0
既然aidl可以传输数据，那么可不可以传输要调用的接口类名、方法名以及参数，在接收到数据后根据这些数据找到对应的实现类，执行方法然后返回结果呢？这样对调用者来说无感知，对提供者来说成本最小，可以简单发散一下思维，想象一下发起一次网络请求，我们只需要知道对应的url和对应的参数就可以了。
答案当然是可以了，要不然废话这么多干啥。是时候祭出今天的大杀器了——动态代理&反射！
杀猪刀-实操
1.创建双向通信
基于系列上一篇文章【Android最最简单】AIDL进阶（双向通信）中向大家介绍的进阶方法创建双向通信AIDL接口文件。
interface IService {
IPCResponse sendRequest(in IPCRequest request);
void attach(in IClientBridge iClientBridge);
}
interface IClientBridge {
IPCResponse sendRequest(in IPCRequest request);
}
模仿网络请求创建一个存储请求参数的接口类（IPCRequest）以及一个承载返回结果的接口类（IPCResponse），只需指定实现parcelable，具体实现类后续实现。
parcelable IPCRequest;
parcelable IPCResponse;
2.缓存实现对象
将实现object按实现接口名缓存对应的class、根据class缓存所有Method，并将object本身缓存。
public class IPCCache {
/**
* 保存服务端处理客户端请求的interfaces对应Class映射和内部的方法
*/
private final Map<String, Class<?>> mClazzs = new HashMap<>();
private final Map<Class<?>, HashMap<String, Method>> mMethods = new HashMap<>();
/**
* 保存服务端处理客户端请求的实例
*/
private final Map<String, WeakReference<Object>> mInstance = new HashMap<>();
/**
* 缓存对象及其方法
*
* @param object
*/
public void register(Object object) {
Class<?> clazz = object.getClass();
Class<?>[] interfaces = clazz.getInterfaces();
for (Class<?> cls : interfaces) {
mClazzs.put(cls.getName(), clazz);
}
// 缓存Method
HashMap<String, Method> method = new HashMap<>();
Method[] methods = clazz.getMethods();
for (Method m : methods) {
method.put(m.getName(), m);
}
mMethods.put(clazz, method);
addObject(clazz.getName(), object);
}
public void unRegister(Object object) {
Class<?> clazz = object.getClass();
Class<?>[] interfaces = clazz.getInterfaces();
for (Class<?> cls : interfaces) {
mClazzs.remove(cls.getName());
}
mMethods.remove(clazz);
removeObject(clazz.getName());
}
public Class<?> getClass(String interfacesName) {
if (TextUtils.isEmpty(interfacesName)) {
return null;
}
return mClazzs.get(interfacesName);
}
public Method getMethod(Class<?> clazz, String methodName) {
HashMap<String, Method> methods = mMethods.get(clazz);
return methods == null ? null : methods.get(methodName);
}
private void addObject(String className, Object object) {
mInstance.put(className, new WeakReference<>(object));
}
private void removeObject(String className) {
mInstance.remove(className);
}
public Object getObject(String className) {
return mInstance.containsKey(className) ? mInstance.get(className).get() : null;
}
}
3.动态代理[以client为例]
通过动态代理，将方法名、参数等封装成IPCRequest发送到service。
public <T> T get(Class<T> inter) {
if (null == mIpcService) {
return null;
}
// 获取处理客户端请求的对象的Key，以此在服务端找出对应的处理者
return (T) Proxy.newProxyInstance(getClass().getClassLoader(),
new Class[]{inter},
new ClientInvocationHandler(inter.getName()));
}
public class ClientInvocationHandler implements InvocationHandler {
private Gson mGson;
private String interfacesName;
public ClientInvocationHandler(String interfacesName) {
this.interfacesName = interfacesName;
mGson = new Gson();
}
@Override
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
/*
当代理对象执行方法时，会走到这里
然后构造请求
转发给服务端
*/
IPCRequest ipcRequest = new IPCRequest();
ipcRequest.setInterfacesName(interfacesName);
ipcRequest.setMethodName(method.getName());
ipcRequest.setParameters(ParamsConvert.serializationParams(args));
IPCResponse ipcResponse = ClientManager.getInstance().sendRequest(ipcRequest);
if (ipcResponse != null && ipcResponse.isSuccess()) {
Class<?> returnType = method.getReturnType();
if (returnType != void.class && returnType != Void.class) {
return mGson.fromJson(ipcResponse.getResult(), returnType);
}
}
return null;
}
}
4.实现双向通信方法[以service端为例]
提供根据请求IPCRequest中携带的接口名、方法名以及参数，找到对应的实现类对象和Method，通过反射调用执行方法，并将结果返回。
@Override
public IPCResponse sendRequest(IPCRequest request) throws RemoteException {
try {
Class<?> aClass = ServiceManager.getInstance().getClass(request.getInterfacesName());
Object object = ServiceManager.getInstance().getObject(aClass.getName());
Method me = ServiceManager.getInstance().getMethod(aClass, request.getMethodName());
Object[] params = ParamsConvert.unSerializationParams(request.getParameters());
Object result = me.invoke(object, params);
String r = ParamsConvert.mGson.toJson(result);
return new IPCResponse(r, "执行方法成功", true);
} catch (Exception e) {
e.printStackTrace();
}
return null;
}
