跨进程架构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);
}