Android IPC之Messenger

Messenger 翻译为信使，通过Messenger可以实现在不同进程间传递Message对象。
Messenger是以串行的方式来处理消息，如果有大量消息发送到服务端，也只能一个一个的处理，那么如果高并发的请求用AIDL更合适一些。
另外AIDL是Messenger的底层实现，Messenger本质上也是AIDL，，只不过系统为我们做了封装方便我们调用而已。

接下来看Messenger的构造方法:
第一个构造方法需要传递一个Handler，从Handler的getIMessenger中得到Messenger。
第二个构造方法需要传递一个IBinder，并通过IMessenger.Stub.asInterface(target);得到Messenger。

/**
     * 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();
    }

/**
     * 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);
    }

接下来看一下Messenger的使用，实现一个Messenger通常需要一个服务端进程和客户端进程。

服务端进程：
我们需要在服务端进程中创建一个Service来监听客户端的连接请求，同时创建Handler并通过Handler创建Messenger对象。最后在Service的onBind中返回Messenger中的Binder。

客户端进程：
客户端只需要创建用于绑定服务端的Service，并通过服务端返回的Ibinder创建Messenger，此时就可以通过这个Messenger向服务端发送消息了。接下来看代码。

服务端：

public class MessengerService extends Service {
    private static final String TAG = "MessengerService";
    //创建Handler 处理消息
    private static class MessengerHandler extends Handler{
        @Override
        public void handleMessage(@NonNull Message msg) {
            switch (msg.what){
                case 100:
                    //收到消息
                    Log.i(TAG,msg.getData().getString("msg"));
                    break;
                default:
                    super.handleMessage(msg);
            }
        }
    }

    //通过MessengerHandler创建Messenger
    private final Messenger mMessenger = new Messenger(new MessengerHandler());

    @Override
    public IBinder onBind(Intent intent) {
        //返回Messenger中的IBinder
        return mMessenger.getBinder();
    }
}

客户端：

    private Messenger messenger;

    private ServiceConnection mConnection = new ServiceConnection() {
        @Override
        public void onServiceConnected(ComponentName componentName, IBinder iBinder) {
            //通过服务端返回的IBinder创建Messenger
            messenger = new Messenger(iBinder);
            //创建Message
            Message msg = Message.obtain(null,100);
            Bundle data = new Bundle();
            data.putString("msg","我是一条消息");
            msg.setData(data);
            try {
                //发送Message
                messenger.send(msg);
            } catch (RemoteException e) {
                e.printStackTrace();
            }
        }

        @Override
        public void onServiceDisconnected(ComponentName componentName) {
        }
    };

最后绑定服务：

        Intent intent = new Intent(this, MessengerService.class);
        bindService(intent,mConnection, Context.BIND_AUTO_CREATE);

这时候客户端与服务端绑定时，服务端就可以收到客户端发送的消息了。

这时候有小伙伴就会问到了，如果想实现双向通信呢？服务端向客户端发送消息怎么实现呢？

其实很简单，首先客户端中如果想要接收服务端的消息，那么客户端也要和服务端一样 创建Messenger和Handler，并在客户端发送消息的时候加入如下代码。目的就是将客户端的Messenger发送给服务端。

Message.replyTo = Messenger; //客户端中的Messenger

最后服务端中通过Message.replyTo方法就可以得到客户端的Messenger，这样就可以通过这个Messenger向客户端发送消息啦。

是不是很简单，赶快去试试把！