[Android]你不知道的Android进程化(5)--进程通信Messenger框架

大家好，我系苍王。
以下是我这个系列的相关文章，有兴趣可以参考一下，可以给个喜欢或者关注我的文章。

[Android]如何做一个崩溃率少于千分之三噶应用app--章节列表

Android组件化架构热卖中

组件化群1已经满员，进来的可以加群2 763094035

上一节，介绍了使用AIDL的进程通信框架。
这一节给大家介绍Messenger的通信框架，而Messenger其意思是“信使”的意思
使用Messenger的优势在于
1.实际传递的是Message，可以复用信息池
2.支持信息回调
3.不需要编写aidl

Messenger通信原理图

Messenger继承了Parcelable接口，可以作为序列化对象用于传输。
这里可以传入Handler，Handler里面有包含IMessenger对象

     /**     * Create a new Messenger pointing to the given Handler.  Any Message     * objects sent through this Messenger will appear in the Handler as if     * {@link Handler#sendMessage(Message) Handler.sendMessage(Message)} had     * been called directly.     *      * @param target The Handler that will receive sent messages.     */    public Messenger(Handler target) {        mTarget = target.getIMessenger();    }

或者传入IBinder对象，Stub当中存在IMessenger对象

    /**     * Create a Messenger from a raw IBinder, which had previously been     * retrieved with {@link #getBinder}.     *      * @param target The IBinder this Messenger should communicate with.     */    public Messenger(IBinder target) {        mTarget = IMessenger.Stub.asInterface(target);    }

实际上Handler中IMessager实现对象是MessengerImpl

    final IMessenger getIMessenger() {        synchronized (mQueue) {            if (mMessenger != null) {                return mMessenger;            }            mMessenger = new MessengerImpl();            return mMessenger;        }    }

这里IMessenger是调用Handler的send方法来发送消息的。

    private final class MessengerImpl extends IMessenger.Stub {        public void send(Message msg) {            msg.sendingUid = Binder.getCallingUid();            Handler.this.sendMessage(msg);        }    }

每个Message当中也包含了一个replyTo的变量用户回调

    /**     * Optional Messenger where replies to this message can be sent.  The     * semantics of exactly how this is used are up to the sender and     * receiver.     */    public Messenger replyTo;

就这几个步骤Messenger独立的实现了Parcelable和使用aidl的通信方式

接下来我们介绍一下Modular框架是用Messenger通信设计。
不同于上一节介绍的ModularArchitecture的aidl中通信是1对1的通信，Modular提供的通信框架是通过1对多的发送方式来传递的。

以下是Messenger的注册流程图

Messenger注册流程图

1.每个模块初始化时启动一个消息队列来监听消息。

    @Override    public void init() {        mBaseModule = this;        //启动线程接收消息        mWorkThread = new WorkThread();        mWorkThread.start();        //注册跳转路由        OkBus.getInstance().register(Constants.ROUTER_OPEN_URL, new Event() {            @Override            public void call(Message msg) {                String url = (String) msg.obj;               //实际跳转使用的Router                              Router.openLocalUrl(BaseAppModuleApp.getBaseApplication(), url);            }        }, Bus.UI); //线程参数    }    public class WorkThread extends Thread {        Handler mHandler;        public Messenger clientHandler;        @Override        public void run() {            Looper.prepare();            //每个module都有接收消息处理ClientHandler            mHandler = new ClientHandler();            clientHandler = new Messenger(mHandler);            if(resultRef!=null){                try {                    resultRef.set(clientHandler);                } catch (Exception e) {                    e.printStackTrace();                } finally {                    //使用CountDownLatch唤醒机制保证线程安全                    latch.countDown();                }            }            Looper.loop();        }        public void quit() {            mHandler.getLooper().quit();        }    }

2.绑定MessengerService作为进程间管理，并且绑定每个模块的ServiceConnection

/**     * 连接服务器     */    public void connectService() {        Intent intent = new Intent(MessengerService.class.getCanonicalName());// 5.0+ need explicit intent        intent.setPackage(Constants.SERVICE_PACKAGE_NAME); // the package name of Remote Service        //绑定MessengerService作为进程间管理，并且绑定每个模块的ServiceConnection        boolean mIsBound = bindService(intent, mBaseModule.mConnection, BIND_AUTO_CREATE);        LogUtils.i(Constants.TAG + " connectService", " ServiceConnection-->bindService  mIsBound: " + mIsBound);    }

3.启动MessengerService，启动消息循环

 @Override    public void onCreate() {        super.onCreate();        LogUtils.i(Constants.TAG + " essengerService", "MessengerService -->onCreate");        mWorkThread = new WorkThread();        mWorkThread.start();    }    public class WorkThread extends Thread {        public ServiceHandler mHandler;        @Override        public void run() {            Looper.prepare();            LogUtils.i(Constants.TAG + " essengerService", "MessengerService -->new ServiceHandler");            //通过ServiceHandler来处理收到的消息            mHandler = new ServiceHandler();            Messenger mMessenger = new Messenger(mHandler);          //  OkBus.getInstance().mServiceMessenger = mMessenger;            try {                resultRef.set(mMessenger);            } catch (Exception e) {                e.printStackTrace();            } finally {                latch.countDown();            }            Looper.loop();        }        public void quit() {            mHandler.getLooper().quit();        }    }    @Nullable    @Override    public IBinder onBind(Intent intent) {        try {            latch.await(10, TimeUnit.SECONDS); //最多等待10秒        } catch (Exception e) { //等待中断            e.printStackTrace();        }        Messenger mMessenger = resultRef.get();        return mMessenger.getBinder();    }

4.初始化OkBus并发送消息注册

    public void initModule(BaseModule mBaseModule, Messenger mServiceMessenger, int mModuleId, Messenger mClientMessenger) {        this.mServiceMessenger = mServiceMessenger;        this.mModuleId = mModuleId;        this.mBaseModule = mBaseModule;        isModule.set(true);        mBaseModule.isConnected.set(true);        //线程池获取信息        Message msg = Message.obtain();        Bundle data = new Bundle();        data.putInt(Constants.REGISTER_ID, mModuleId);//注册模块信息        msg.setData(data);        msg.replyTo = mClientMessenger;   //将处理消息的Messenger绑定到消息上带到服务端        try {            //发送到MessengerService中处理            mServiceMessenger.send(msg);        } catch (Exception e) {            e.printStackTrace();        }    }

5.ServiceHandler中维护一个对Service Messenger到多个Client Messenger的关系

    @Override    public void handleMessage(Message msg) {        super.handleMessage(msg);        try {            Bundle bundle = msg.getData();            int registerId = bundle.getInt(Constants.REGISTER_ID, -1);            if (registerId > 0) {//注册模块类型的消息                LogUtils.logOnUI(Constants.TAG, "handleMessage: msg = [收到注册模块类型的消息]: registerId: " + Integer.toHexString(registerId));                //每个模块对应的ClientHandler                Messenger client = msg.replyTo;                 mClientMessengers.put(registerId, client);//存储Client端接受处理消息的Messenger来发送Message到Client                Message data = Message.obtain();                Bundle mBundle = new Bundle();                mBundle.putInt(Constants.REGISTER_RES, Constants.REGISTER_SEC);    //通知Client模块注册成功                data.setData(mBundle);                try {                    client.send(data);  //回调注册状态给模块                } catch (Exception e) {                    e.printStackTrace();                }            }

6.介绍的模块注册结果

public class ClientHandler extends Handler {    @Override    public void handleMessage(Message msg) {        ……        int resCode = bundle.getInt(Constants.REGISTER_RES, -1);        if (resCode < 0) {//收到普通消息        ……        } else {//收到模块注册结果消息            boolean isRegisterSec = resCode == Constants.REGISTER_SEC;            if (isRegisterSec) {                LogUtils.logOnUI(Constants.TAG, "handleMessage() : reply = [注册成功]");            }        }    }}

7.其绑定完毕之后，将module信息注册到OkBus，之后会使用afterConneted()来初始化想要接收的消息

public ServiceConnection mConnection = new ServiceConnection() {        @Override        public void onServiceConnected(ComponentName name, IBinder service) {            LogUtils.logOnUI(Constants.TAG, "ServiceConnection-->onServiceConnected 已自动唤醒服务器");            Messenger mServiceMessenger = new Messenger(service);            OkBus.getInstance().initModule(mBaseModule, mServiceMessenger, getModuleId(), mWorkThread.clientHandler);            afterConnected();        }

8.通过ServiceBus来注册其他module会跨module调用过来的消息。

@Override    public void afterConnected() {        ServiceBus.getInstance().registerService(Constants.SERVICE_A_UID, msg -> {            LogUtils.logOnUI(Constants.TAG, "afterConnected  a 进程收到[服务请求]消息:ServiceMessage-->hello:  " + Integer.toHexString(Math.abs(msg.what)));            return "10086";        });    }

9.服务注册后，可以看到其会通过onEvent返回回调的msg对象(CallBack接口)

    /**     * 注册服务     *     * @param serviceId 服务id     * @param callback  服务调用的回调     * @param        服务返回的数据范型     */    public  void registerService(final int serviceId, final CallBack callback) {        LogUtils.logOnUI(Constants.TAG, "注册服务  " + Integer.toHexString(Math.abs(serviceId)));        okBus.unRegister(serviceId);//服务提供者只能有一个        okBus.register(serviceId, msg -> {            //TODO 优化到子线程            okBus.onEvent(serviceId - 1, callback.onCall(msg));        });    }

到这里就介绍完初始化和注册流程了。

接下来介绍一下消息发送的架构，注意一下的模块服务规则

    //==================模块间的服务定义============//    /**     * 服务定义规则：     * 1、服务的请求ID必须是负值(正值表示事件)     * 2、服务的请求ID必须是奇数，偶数表示该服务的返回事件，     * 即：   requestID－1 ＝ returnID     * 例如  -0xa001表示服务请求  -0xa002表示-0xa001的服务返回     */    public static final int SERVICE_A_UID = -0xa001;        /**         * 异步调用远端服务         */        findViewById(R.id.bt_1).setOnClickListener(v -> {        //异步调用，           ServiceBus.getInstance().fetchService(Constants.SERVICE_A_UID, msg -> {                LogUtils.logOnUI(Constants.TAG, "b 进程收到[异步服务返回]消息:  获取到的UID-->" + msg.obj);                Toast.makeText(BModuleActivity.this,                        "b 进程收到[异步服务返回]消息:  获取到的UID-->" + msg.obj,                        Toast.LENGTH_SHORT).show();            });        });

具体步骤
1.对ID的请求限制
2.module连接的判断，没有连接就尝试连接
3.唤醒目标进程
4.注册回调
5.通知目标模块

跨模块通信

    /**     * 异步调用服务     *     * @param serviceId 服务id     * @param callback  回调     */    public void fetchService(final int serviceId, final Event callback) {        if (serviceId > 0 || serviceId % 2 == 0) {            assert false : "请求ID必须是负奇值!";            return;        }        if (okBus.isModule() && !okBus.isModuleConnected()) {            LogUtils.logOnUI(Constants.TAG, "请求失败，服务已经断开链接，尝试重新打开服务，进行请求");            BaseAppModuleApp.getBaseApplication().connectService();            return;        }        //自动唤醒目标进程        if (okBus.isModule()) {            String module_name = Integer.toHexString(Math.abs(serviceId)).substring(0, 1);            noticeModule(module_name, serviceId, null);        }        //1、先注册回调        okBus.register(serviceId - 1, msg -> {            callback.call(msg);            okBus.unRegister(serviceId - 1);//服务是单次调用，触发后即取消注册        });        //2、通知目标模块        okBus.onEvent(serviceId);    }

唤醒目标进程

    /**     * 唤醒目标进程     *     * @param module_name 模块名     * @param serviceId   服务ID     * @param url         要打开的url     */    public void noticeModule(String module_name, int serviceId, String url) {        Intent ait = new Intent(NoticeService.class.getCanonicalName());// 5.0+ need explicit intent        //唤醒目标进程的服务Action名        ait.setPackage(Constants.MODULE_PACKAGE_PRE + module_name);   //唤醒目标进程的包名        //绑定包名        BaseAppModuleApp.getBaseApplication().bindService(ait, new ServiceConnection() {            @Override            public void onServiceConnected(ComponentName name, IBinder service) {                if (service != null) {                    LogUtils.logOnUI(Constants.TAG, "已经自动唤醒" + module_name);                    Messenger moduleNameMessenger = new Messenger(service);                    Message _msg = Message.obtain();                    Bundle _data = new Bundle();                    _data.putBoolean(Constants.NOTICE_MSG, true);                    _msg.setData(_data);                    _msg.replyTo = okBus.mServiceMessenger;//把服务器的信使给目标组件的信使，让他俩自己联系，这里仅仅是通知                    try {                        moduleNameMessenger.send(_msg);                    } catch (Exception e) {                        e.printStackTrace();                    }                    try {                        Thread.sleep(200);//给服务器和目标组件500ms联系的时间                    } catch (Exception e) {                        e.printStackTrace();                    }                } else {                    LogUtils.logOnUI(Constants.TAG, module_name + "进程,本来就是醒的");                }                if (serviceId < 0) {  //唤醒成功，继续发送异步请求，通知目标模块                    okBus.onEvent(serviceId);                }                if (!TextUtils.isEmpty(url)) {  //目标url不为空，继续打开目标                    OkBus.getInstance().onEvent(Constants.ROUTER_OPEN_URL, url);                }            }            @Override            public void onServiceDisconnected(ComponentName name) {                LogUtils.logOnUI(Constants.TAG, "自动唤醒目标进程失败 module_name:" + module_name);            }        }, BIND_AUTO_CREATE);    }

启动模块，并传递绑定对象

    /**     * 收到唤醒通知之后，初始化模块，并自动去服务器注册     *     * @param intent     * @return     */    @Nullable    @Override    public IBinder onBind(Intent intent) {        LogUtils.logOnUI(Constants.TAG, getPackageName() + " 收到唤醒通知");        //获取模块的module        BaseModule mBaseModule = BaseAppModuleApp.getBaseApplication().mBaseModule;        if (!mBaseModule.isConnected.get()) {            LogUtils.logOnUI(Constants.TAG, getPackageName() + " 我被唤醒啦");            //初始化module，启动module的ClientHandler(Messenger)            mBaseModule.init(latch, resultRef);            mBaseModule.afterConnected();            try {                //超时限制                latch.await(2000, TimeUnit.SECONDS);            } catch (Exception e) { //等待中断                e.printStackTrace();            }        }        //返回ClientHandler的Binder对象        return mBaseModule.mWorkThread.clientHandler.getBinder();    }

发送消息，其最终是通过ServiceBus转发到每个模块OkBus，然后Binder传递的Messenger关联来完成信息传递。

/**     * @param tag  发送消息的事件ID     * @param data 发送消息的数据     * @return     */    public OkBus onEvent(int tag, Object data) {        //发送时间，所以tag小于0        String hex = Integer.toHexString(Math.abs(tag));        LogUtils.i("Message OkBus", "onEvent  " + (tag > 0 ? "[普通]" : "[服务]") + "  tag: " + hex);        //1、本地先处理非服务消息        if (tag >= 0) onLocalEvent(tag, data);        //2、如果是组建化，向服务器发消息        if (isModule.get()) {            //保证发送时服务启动            if (!isModuleConnected()) {                LogUtils.i("Message OkBus", "发消息失败，服务已经断开链接，尝试重新打开服务，进行发消息");                BaseAppModuleApp.getBaseApplication().connectService();                return this;            }           //数据为空，即为事件            if (data == null || data instanceof Serializable) {                Message newMsg = new Message();                if (data != null) {                    Bundle bundle = new Bundle();                    bundle.putSerializable(Constants.MESSAGE_DATA, (Serializable) data);                    newMsg.setData(bundle);                }                newMsg.arg1 = mModuleId;                newMsg.what = tag;                try {                    //发送信息到目标Service                    mServiceMessenger.send(newMsg);                } catch (Exception e) {                    e.printStackTrace();                }            } else {                assert false : "跨进程时，你传递的对象没有序列化！";            }        } else if (tag < 0) {//非组件化时本地处理服务消息            onLocalEvent(tag, data);        }        return this;    }

使用Messenger通信框架设计就介绍到这里。
1.Modular框架，模块内传输使用了OkBus的路由传输，而在跨模块则使用Messenger的方式来完成
2.Messenger实际是一个封装好的IBinder对象
3.Modular通过合理设置跨模块的传输的协议逻辑来完成信息传输

更多相关文章

随机推荐