Android 进程间通信(四) - Messenger 以及源码分析

在上几篇文章中，我们已经学习了Binder 这种通信模式，这章中，我们来学习 Messenger；

Messenger可以翻译为信使，它可以在不同进程间传递 Message 对象。Messenger 是一种轻量的 IPC 防范，它的底层实现是 AIDL，后面我们会分析它的源码；

Messenger 一次只能处理一个请求，因此并不适合高并发的问题，也不用考虑线程同步的问题，因为服务端中不存在并发执行的情形。

一. 实现Messenger通信

从上面可以知道，可以传递 Message，一些简单的数据，我们就可以通过这种方式去实现了。下面我们一起来实现它。
今天的效果是，客户端发送两个数字，服务端返回两数之和：

1.1. 服务端

在服务端中，我们可以直接 new 一个 Messenger ，传递一个 Handler，如下：

public class MessengerService extends Service {
    private static final String TAG = "MessageService";
    public MessengerService() {
    }

    Messenger mMessenger = new Messenger(new Handler(Looper.getMainLooper()){
        @Override
        public void handleMessage(@NonNull Message msg) {
            super.handleMessage(msg);
        }
    });

    @Override
    public IBinder onBind(Intent intent) {
        return mMessenger.getBinder();
    }
}

可以看到，Messenger 的构造方法中，传递了一个 Handler，当接收到客户端的 Message 消息时，会在 handleMessage() 方法中处理，并通过 mMessenger.getBinder() 返回 binder 对象。

接着，需要通过 Message 拿到两个数字，并返回相加的结果，如下：

        @Override
        public void handleMessage(@NonNull Message msg) {
            super.handleMessage(msg);
            try {
                int num = msg.arg1 + msg.arg2;
                Message message = Message.obtain();
                message.what = 2;
                message.arg1 = num;
                //通过客户端的 Messenger 来把数据发送回去
                msg.replyTo.send(message);
            } catch (RemoteException e) {
                e.printStackTrace();
            }
        }

需要注意的是，数据在返回的时候，需要通过 msg.replyTo 去发送，它的对象为 Messenger 。
这样，服务端就写好了。

1.2. 客户端

接着，我们新建一个moudle，通过包名加类名的方式去 bind 这个服务。如下：

Intent intent = new Intent();
//绑定 服务
intent.setClassName("com.example.ipcdemo","com.example.ipcdemo.service.MessengerService");
mRemoteService = new RemoteService();
bindService(intent,mRemoteService, Service.BIND_AUTO_CREATE);

在连接的时候，创建 Messenger ：

    class RemoteService implements ServiceConnection {

        @Override
        public void onServiceConnected(ComponentName name, IBinder service) {
            mBinder = new Messenger(service);
            mSb.append("连接上服务端").append("\n");
            mTextView.setText(mSb.toString());
        }

        @Override
        public void onServiceDisconnected(ComponentName name) {
            mBinder = null;
        }
    }

这样，我们就拿到了服务端mBinder的实例了，然后通过点击事件，把数据发送过去：

    public void testBtn(View view) {
        Message msg = Message.obtain();
        msg.arg1 = (int) (Math.random() * 100+1);
        msg.arg2 = (int) (Math.random() * 100+1);
        mTextView.setText(mSb.toString());
        //传递 client 的 messenger ，实现服务端与客户端通信
        msg.replyTo = mMessenger;
        if (mBinder != null) {
            try {
                mBinder.send(msg);
            } catch (RemoteException e) {
                e.printStackTrace();
            }
        }
    }

同时，也要注意，把要接受服务端信息的 Messenger 绑定到 msg.replyTo 中。客户端的 Messenger 如下：

    Messenger mMessenger = new Messenger(new Handler(Looper.getMainLooper()){
        @Override
        public void handleMessage(@NonNull Message msg) {
            super.handleMessage(msg);
            mSb.append(msg.arg1).append("\n");
            mTextView.setText(mSb.toString());
        }
    });

这样，我们就实现所有功能了。效果如下面的 gif 。

使用 Messenger 的优缺点如下：

优点	缺点	使用场景
功能一般，支持一对多穿行通信，支持实时通信	不能很好的处理高并发情形，不支持RPC，数据通过Message传输，因此只能传输Bundle支持的数据类型,比如 msg.setData()	低并发的一对多及即时通信，无RPC需求，或者无需要返回结果的RPC需求

二. 源码分析

上面说到，Messenger 是基于 AIDL 的，怎么得出来的呢？它的构造方法传递要求传入的 Handler，进入到里面看一下：

    public Messenger(Handler target) {
        mTarget = target.getIMessenger();
    }

然后，去到 Handler ，找到 getIMessage() 方法：

可以看到，mMessenger 的实现类为 MessengerImpl ，而它继承自 IMessenger.Stub ；看到这里有没有很熟悉？ 没错，跟我们的 AIDL 的实现类一样，通过源码也知道，IMessenger 确实是个 AIDL 接口：

package android.os;

import android.os.Message;

/** @hide */
oneway interface IMessenger {
    void send(in Message msg);
}

在它的 send 方法中，把数据又通过 Handler 的 sendMessage 方法，发送给自身，从而当有数据来的时候，就会调用它的 handleMessage(）方法。

而在客户端的绑定数据中，也验证了这个问题，比如：

去到构造方法中，可以看到：

通过 asInterface 拿到binder。

这样，我们就了解清楚了。