跨进程架构HermesEventBus原理分析到手写实现<三>
发送请求到服务端:
继续接着上一次https://www.cnblogs.com/webor2006/p/12196171.html的代码继续来编写,上一次在SecondAcitity中完成了远程服务的连接了:
接下来则应该是发送消息给主进程,然后在MainActivity中进行消息的接收处理了,我们知道在主进程中我们注册了一个UserManager单例对象:
那如果我们在SecondActivity改变这个单例对象的值:
很明显在MainActivity的主进程中再获取的话是收不到在子进程更改的数据变化的:
因为这俩是不在一个进程了,那接下来就以这个为例子,如果能实现跨进程的情况下也能达到相互数据及时感知,那其实也就实现了Hermes框架的效果了,当然要实现肯定得借助于AIDL了,不过这里还得借助于动态代理来达成,之前咱们在分析Hermes的原理时也看到了动态代理隐藏其中, 下面则来开始实现,稍麻烦一点,坚持:
为了能够清楚的知道咱们要实现它的具体步骤,跟着图来:
也就是客户端要通过aidl来告诉服务端需要给客户端返回服务端的UserManager单例对象,好,下面实现一下,先修改一下布局:
具体来实现一下,由于目前在子进程无法拿到父进程的UserManager对象实例,所以这里需要定义一个接口来将这个类中的行为抽象出来:
而这个接口对应的是哪个类这里用注解标注一下,以便到时反射时进行动态代理时好知道最终要代理的对象的类名:
然后让UserManager实现这个接口:
刚才不是说最终要用到动态代理技术么,最终对象的生成则就是采用动态代理来实现的,所以我们看到Hermes框架也是这么搞的,瞅一下:
而它也是实现了一个接口:
接口中则都是抽象的行为:
此时咱们获取对像的代码就可以这样写的:
接下来则集中精力来实现这个方法,实现了跨进程发消息的问题就基本就解决了:
而通过aidl发送的方法是Request,它里面只有一个String属性:
所以,咱们应该对所有的参数信息进行对象封装一下,最终再转换成一个Json串并生成咱们的Request对象,所以接下来新建一个JavaBean:
好,接下来具体实现一下:
public class MyHermes { private static final MyHermes ourInstance = new MyHermes(); private static final Gson GSON = new Gson(); private Context context; private MyTypeCenter typeCenter; private ServiceConnectionManager serviceConnectionManager; public static MyHermes getDefault() { return ourInstance; } private MyHermes() { typeCenter = MyTypeCenter.getInstance(); serviceConnectionManager = ServiceConnectionManager.getInstance(); } public void init(Context context) { context = context.getApplicationContext(); } public void register(Class<?> clazz) { typeCenter.register(clazz); } public void connectApp(Context context, Class<? extends HermesService> service) { connectApp(context, null, service); } public void connectApp(Context context, String packageName, Class<? extends HermesService> service) { init(context); serviceConnectionManager.bind(context.getApplicationContext(), packageName, service); } //获取另一个进程的对象 public <T> T getInstance(Class<T> clazz, Object... parameters) { Response responce = sendRequest(HermesService.class, clazz, null, parameters); return null; } private <T> Response sendRequest(Class<HermesService> hermesServiceClass , Class<T> clazz, Method method, Object[] parameters) { RequestBean requestBean = new RequestBean(); String className = null; if (clazz.getAnnotation(ClassId.class) == null) { //有注解 requestBean.setClassName(clazz.getName()); requestBean.setResultClassName(clazz.getName()); } else { //木有注解时返回类型的全类名 requestBean.setClassName(clazz.getAnnotation(ClassId.class).value()); requestBean.setResultClassName(clazz.getAnnotation(ClassId.class).value()); } if (method != null) { //方法名 统一传 方法名+参数名 getInstance(java.lang.String) requestBean.setMethodName(TypeUtils.getMethodId(method)); } RequestParameter[] requestParameters = null; if (parameters != null && parameters.length > 0) { requestParameters = new RequestParameter[parameters.length]; for (int i = 0; i < parameters.length; i++) { Object parameter = parameters[i]; String parameterClassName = parameter.getClass().getName(); String parameterValue = GSON.toJson(parameter); RequestParameter requestParameter = new RequestParameter(parameterClassName, parameterValue); requestParameters[i] = requestParameter; } } if (requestParameters != null) { requestBean.setRequestParameter(requestParameters); } return null; } }
好,接下来则将上面的这个封装bean利用gson转换成json串,最后再生成咱们要发送的Request对象,再通过aidl进行发送,这里在发送Request其实是有两种类型的,所以咱们定义两个常量值,并给Request增加一个类型字段:
public class Request implements Parcelable { private String data; //请求对象的类型 private int type; public String getData() { return data; } public void setData(String data) { this.data = data; } public int getType() { return type; } public void setType(int type) { this.type = type; } protected Request(Parcel in) { data = in.readString(); type = in.readInt(); } public Request(String data, int type) { this.data = data; this.type = type; } @Override public void writeToParcel(Parcel dest, int flags) { dest.writeString(data); dest.writeInt(type); } @Override public int describeContents() { return 0; } public static final Creator<Request> CREATOR = new Creator<Request>() { @Override public Request createFromParcel(Parcel in) { return new Request(in); } @Override public Request[] newArray(int size) { return new Request[size]; } }; }
其aidl的发送则转由ServiceConnectionManager负责了,所以接下来实现一下发送逻辑:
此时就通过AIDL将请求发送到了Service了,目前咱们的Service还木有实现:
所以接下来咱们来处理它。
服务端消息处理:
接下来则到这一步了:
这里则需要根据不同的requesttype来生成不同的response,这里需要用到策略模式了,其实Hermes框架也是类似,瞅一下:
其中对于第个Receiver进行了一些抽象:
所以咱们也校仿一下,先建立一个抽象的Response生成对象:
public abstract class ResponceMake { //UserManage 的Class protected Class<?> reslutClass; // getInstance() 参数数组 protected Object[] mParameters; Gson GSON = new Gson(); protected MyTypeCenter typeCenter = MyTypeCenter.getInstance(); public Response makeResponce(Request request) { RequestBean requestBean = GSON.fromJson(request.getData(), RequestBean.class); reslutClass = typeCenter.getClassType(requestBean.getResultClassName()); //参数还原 RequestParameter[] requestParameters = requestBean.getRequestParameter(); if (requestParameters != null && requestParameters.length > 0) { mParameters = new Object[requestParameters.length]; for (int i = 0; i < requestParameters.length; i++) { RequestParameter requestParameter = requestParameters[i]; Class<?> clazz = typeCenter.getClassType(requestParameter.getParameterClassName()); mParameters[i] = GSON.fromJson(requestParameter.getParameterValue(), clazz); } } else { mParameters = new Object[0]; } setMethod(requestBean); Object resultObject = invokeMethod(); //TODO 需要转换成Response return null; } protected abstract Object invokeMethod(); protected abstract void setMethod(RequestBean requestBean); }
然后咱们来处理具体的子类,目前先来处理单例UserManager的获取:
其中先来实现setMethod(),也就是根据方法的参数信息最终来生成一个Method对象,如下:
其中method就是调用UserManager中的getInstance()方法:
比如好理解,直接贴出代码了,接着再来实现invokeMethod():
好,此时再回到抽象ResponseMake类,再处理Response结果转换的逻辑:
此时就又需要借助于一个封装的bean类进行转换,如下:
其中Respnse需要再增加一个构造,直接对里面的data赋值:
最后咱们在Service中来使用一下:
好,再回到主流程来,目前Response已经从服务端拿到之后,则需要根据Response通过动态代理来调用对象中的具体方法了,也就是流程来到了这:
对应代码为:
这里则就是需要产生一个代理对象了,具体代码如下:
接下来就是来实现这个InvocationHandler的代码了,先来从调用角度来看一下,当我们获得了UserManager的代理对象之后,则会如此调用了:
而每个方法的调用很显然都得有一个AIDL的过程,也就是要通知到服务端来进行调用,那既然每个方法都需要有这么一个过程,那用动态代理的拦截机制不正好么,所以接睛来咱们在拦截处进行方法的远程调用:
上面发送代码基本跟之前获取getInstance的差不多,可以对其进行封装一下,这里就不追求优质代码了, 重点是理解背后的原理。
好,此时已经将setStudent()的方法请求发送到了服务端了,接着服务端需要对其进行处理,回到主服务的代码:
跟之前的类似使用策略模式,先建议一个子类,然后再使用之则可:
其中TypeCenter中需要增加一个getMethod()方法:
其中可以看到都是从之前我们主进程进行注册时的缓存中拿的方法,所以性能也是比较好的。
好,准备了这个Response之后下面则来使用一下:
至此!!!关于得到UserManager单例对象以及调用它里面的setStudent()方法的整个底层的aidl逻辑都写法了,说实话,真的好麻烦呀~~还是挺佩服饿了么开源的工程师,那写了这么多代码到底好不好使呢?下面来应用一下:
好,编译运行,在SecondActivity获取UserManager单例时报错了,错误信息如下:
呃,好吧,粗心了,确实不是接口:
咱们修复一下:
好,再次运行:
嗯,完美的实现了我们想要的跨进程的功能,当然目前代码不是太完善,但是木有关系,实现了核心的功能对于这些完善都是可以自己再弄的,再说如果商用也不可以是真的用手写的框架,一般都会用三方成熟的开源组件,但是从学习的角度只有这样才能让自己学到东东,最后在返回app时还有个崩溃: