Messenger可以译为信使，可以在不同进程间传递Message对象。将我们需要传递的数据放入Message对象中，就可以通过Messenger在不同的进程间进行传递。
Messenger是一种轻量级的IPC通信方式，它底层实现也是AIDL。
下面我们先看看如果通过Messenger在不同的进程间传递数据。

客户端向服务端发送数据

服务端

第一、自定义Service
第二、创建Handler对象，用于接收客户端发送的数据
第三、通过Handler创建Messenger对象
第四、通过Messenger对象获取Binder对象，onBinder方法返回获得的Binder对象

客户端

第一、绑定服务
第二、创建ServiceConnection对象，并实现里面的方法
第三、在onServiceConnected方法中通过IBinder方法创建Messenger对象
第四、创建Message对象，并将要传递的数据放入Message对象中
第五、Messenger对象调用send方法将Message对象发送给服务端

客户端和服务端互发消息

在上面步骤的基础上，我们做些改动就可以实现客户端和服务端互发消息。
在客户端也向服务端那样创建一个Handler对象和一个Messenger对象
在客户端发送消息的时候通过message的replyTo将客户端的Messenger传递给服务端
在服务端接收消息的时候通过Message的replyTo获取到客户端的Mesenger对象
通过客户端的Messenger向客户端发送消息

客户端和服务端互动消息的示例

注册

   <activity android:name=".ipc_demo3.ClientActivity" />

        <service
            android:name=".ipc_demo3.MessengerService"
            android:process="com.messenger.remote" />

服务端

public class MessengerService extends Service {
    public static final int SERVICE_MESSENGER_WHAT = 121;

    //第一步创建一个Handler对象
    private static class ServiceHandler extends Handler {
        @Override
        public void handleMessage(Message msg) {
            super.handleMessage(msg);
            switch (msg.what) {
                case SERVICE_MESSENGER_WHAT:
                    //服务端接收到客户端发送的数据
                    Bundle data = msg.getData();
                    if (data != null) {
                        String clientData = data.getString("clientData");
                        Log.e("Messenger通信", clientData);
                    }
                    //服务端回复客户端
                    Messenger clientMessenger = msg.replyTo;
                    Message clientMessage = Message.obtain(null, ClientActivity.CLIENT_MESSENGER_WHAT);
                    Bundle bundle = new Bundle();
                    bundle.putString("ServiceData", "服务端回复客户端的数据");
                    clientMessage.setData(bundle);
                    try {
                        clientMessenger.send(clientMessage);
                    } catch (RemoteException e) {
                        e.printStackTrace();
                    }
                    break;
                default:
                    break;
            }
        }
    }


    //第二步创建一个Messenger对象
    private final Messenger serviceMessenger = new Messenger(new ServiceHandler());

    @Nullable
    @Override
    public IBinder onBind(Intent intent) {
        //第三步 返回Messenger的binder对象
        return serviceMessenger.getBinder();
    }
}

客户端

public class ClientActivity extends Activity {
    public static final int CLIENT_MESSENGER_WHAT = 122;

    @Override
    protected void onCreate(@Nullable Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.shared_file_data_layout);
        TextView dealData = (TextView) findViewById(R.id.deal_data_tv);
        String titleStr = "客户端";
        dealData.setText(titleStr);

        sendDataToService();
    }

    /**
     * 创建一个客户端的Handler，用于接收服务端发送的数据
     */
    private static class ClientHandler extends Handler {
        @Override
        public void handleMessage(Message msg) {
            super.handleMessage(msg);
            switch (msg.what) {
                case CLIENT_MESSENGER_WHAT:
                    Bundle data = msg.getData();
                    if (data != null) {
                        String serviceData = data.getString("ServiceData");
                        Log.e("Messenger通信", serviceData);
                    }
                    break;
                default:
                    break;
            }
        }
    }

    /**
     * 创建一个客户端的Messenger对象
     */
    private Messenger clientMessenger = new Messenger(new ClientHandler());


    private ServiceConnection serviceConnection = new ServiceConnection() {
        @Override
        public void onServiceConnected(ComponentName name, IBinder service) {
            //通过Service创建一个Messenger
            Messenger messengerService = new Messenger(service);
            //创建一个Message对象
            Message message = Message.obtain(null, MessengerService.SERVICE_MESSENGER_WHAT);
            Bundle bundle = new Bundle();
            bundle.putString("clientData", "客户端给服务端发送的消息");
            message.setData(bundle);

            //客户端的Messenger对象通过message对象的replyTo传递给服务端
            message.replyTo = clientMessenger;
            try {
                //通过Messenger将message对象发送给Service
                messengerService.send(message);
            } catch (RemoteException e) {
                e.printStackTrace();
            }
        }

        @Override
        public void onServiceDisconnected(ComponentName name) {

        }
    };

    private void sendDataToService() {
        Intent service = new Intent(this, MessengerService.class);
        bindService(service, serviceConnection, Context.BIND_AUTO_CREATE);
    }

    @Override
    protected void onDestroy() {
        if (serviceConnection != null) {
            unbindService(serviceConnection);
        }
        super.onDestroy();
    }
}