Messenger可以翻译为信使，信使是什么呢？信使是奉派担任使命或传达消息、递送书信的人。而在进程间通信中可以通过它可以在不同进程中传递Message对象。通过查看Messenger的构造方法可以看到Messenger的底层是AIDL。

public Messenger(Handler target) {
    mTarget = target.getIMessenger();
}
public Messenger(IBinder target) {
    mTarget = IMessenger.Stub.asInterface(target);
}

Messenger的使用可分为以下几个步骤，分为服务端和客户端：

1. 服务端进程
   首先，需要在服务端创建一个Service来处理客户端的连接请求，同时创建一个Handler（这个Handler用来处理客户端传递过来的Message），并通过这个Handler来创建一个Messenger对象，然后在Service的onBind()方法中返回这个Messenger对象底层的Binder即可。
2. 客户端进程
   客户端进程中，首先要绑定服务端的Service，绑定成功后通过传回的IBinder对象来创建Messenger对象，然后通过这个Messenger对象来发送Message到服务端。如果需要服务端能够回应客户端，那么还需要创建一个Handler并创建一个新的Messenger，并把这个Messenger对象通过Message的replyTo参数传递给服务器，服务器通过这个replyTo参数就可以回应客户端。

下面来看一个简单的例子。
首先是服务端的代码，在MessengerHandle的handleMessage中收到客户端传来的数据，将其打印到Log，然后replyTo获得的Messenger发送消息回应客户端：

public class MessengerService extends Service {
    private static final String TAG = "MessengerService";

    //通过Handler来创建Messenger对象
    private final Messenger mMessenger = new Messenger(new MessengerHandler());

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

    //创建一个Handler来处理客户端传来的Message
    private static class MessengerHandler extends Handler {
        @Override
        public void handleMessage(@NonNull Message msg) {
            switch (msg.what) {
                case MSG_FROM_CLIENT:
                    Log.i(TAG, "receive msg from Client: " + msg.getData().getString("msg"));
                    // 回复消息给客户端
                    // 如果客户端没有设置msg.replyTo，那么这里的msg.replyTo为空，就会报NullPointException
                    Messenger replyMsg = msg.replyTo;
                    Message message = Message.obtain(null, MSG_FROM_CLIENT);
                    Bundle bundle = new Bundle();
                    bundle.putString("reply", "Server receive.");
                    message.setData(bundle);
                    try {
                        replyMsg.send(message);
                    } catch (RemoteException e) {
                        e.printStackTrace();
                    }
                    break;
                default:
                    super.handleMessage(msg);
            }
        }
    }
}

然后是客户端的实现，客户端需要创建一个处理服务器回复的Handler，并使用这个Handler创建一个接收服务端回应的Messenger，然后将这个Messenger通过Message的replyTo参数传递给服务端：

public class MessengerActivity extends AppCompatActivity {
    private static final String TAG = "MessengerActivity";

    //发送消息给服务端的Messenger
    private Messenger mMessenger;

    //接收服务端回复的消息的Messenger
    private Messenger mGetReplyMessenger = new Messenger(new MessengerHandler());

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_messenger);
        Intent intent = new Intent(this, MessengerService.class);
        bindService(intent, mConnection, Context.BIND_AUTO_CREATE);
    }

    @Override
    protected void onDestroy() {
        unbindService(mConnection);
        super.onDestroy();
    }

    // 处理服务器回复的消息
    private static class MessengerHandler extends Handler {
        @Override
        public void handleMessage(@NonNull Message msg) {
            switch (msg.what) {
                case MSG_FROM_CLIENT:
                    Log.d(TAG, "receive msg from Service: " + msg.getData().getString("reply"));
                    break;
                default:
                    super.handleMessage(msg);
            }
        }
    }

    private ServiceConnection mConnection = new ServiceConnection() {
        @Override
        public void onServiceConnected(ComponentName name, IBinder service) {
            mMessenger = new Messenger(service);

            Message msg = Message.obtain(null, MSG_FROM_CLIENT);
            Bundle data = new Bundle();
            data.putString("msg", "this is client message");
            msg.setData(data);
            // 想要获得服务器端回复的数据，
            // 必须设置回复的Messenger，否则服务器端的msg.replyTo为空。
            msg.replyTo = mGetReplyMessenger;
            try {
                mMessenger.send(msg);
            } catch (RemoteException e) {
                e.printStackTrace();
            }
        }

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

接下来运行代码，看看日志输出是否和我们预想的一样。

2019-12-19 13:03:41.152 10990-10990/? I/MessengerService: receive msg from Client: this is client message
2019-12-19 13:03:41.153 10967-10967/com.demo.ipc D/MessengerActivity: receive msg from Service: Server receive.

很明显和我们预想的一样，下面是Messenger的工作原理图。

Messenger.png

参考书籍《Android开发艺术探索》