Android上最简单的IPC方案——Messenger

每个系统都会有相应的 IPC 机制以方便开发者来进行进程间通讯，那么首先我们来梳理一下 Android 中的 IPC 机制有哪些：

1. 组件间使用 Intent 传递数据；
2. 文件共享；
3. Messenger；
4. AIDL；
5. ContentProvider；
6. Socket；

这6种方式各有各的优缺点和适用场景，在开发过程中最合适当前需求的才是最好的。至于它们各自适用场景此处就不详述了。今天主要来讲一讲这几种机制中，功能强大但是使用起来却非常简单的 Messenger。

Messenger

Messenger 即信使的意思， 看起来它就与 Message 对象有关，因为这个对象就是用来在不同进程中传递 Message 对象的。

Messenger 是一种轻量级的 IPC 方案，它的底层实现是 AIDL。 因为它对 AIDL 做了封装，所以使用起来非常简单，就类似于我们绑定一个 Service 一样。同时，由于它一次处理一个请求，所以在服务端我们不用考虑线程同步的问题，因为在服务端中不存在并发执行的情况。

下面我们就一步一步来实现一个 Messenger 的例子，先从客户端发送消息到服务端开始，然后再逐步完成其双向通讯的功能。

Messenger 实现

要实现一个 Messenger 的双向通信的例子，那么肯定就需要实现服务端和客户端这两个部分。 我们先把实现 Messenger 的几个步骤列出来，再来代码演示：

• 服务端进程

  1. 创建一个 Service 来处理客户端的连接请求；
  2. 创建一个 Handler 并通过它来创建一个 Messenger 对象；
  3. 在 Service 的 onBind 函数中返回这个 Messenger 对象底层的 Binder ；

• 客户端进程

  1. 绑定服务端的Service；
  2. 绑定成功后用服务端返回的 IBinder 对象创建一个 Messenger；
  3. 通过这个 Messenger 向服务端发送消息，消息类型为 Message 对象；
  4. 创建一个 Handler 并创建一个新的 Messenger 对象；
  5. 将这个新的 Messenger 对象通过 Message 的 replyTo 参数传递给服务端，服务端就可以通过这个 replyTo 参数回应客户端了；

客户端发送信息到服务端

首先是服务端，我们需要实现一个典型的 Service 。在这个 Service 中，创建一个 MessengerHandler 对象用来接收客户端的消息，并创建了一个与该Handler 相关联的 Messenger，在 onBind 方法中返回它里面的 Binder 对象 ：

public class MessengerService extends Service {

    private static class MessengerHandler extends Handler {
        @Override
        public void handleMessage(Message msg) {
            switch (msg.what) {
                case 10086:
                    Log.i("swifter", "服务端收到消息："+msg.getData().getString("msg"));
                    break;
            }
        }
    }

    //此Messenger将客户端发送的消息传递给 MessengerHandler
    private Messenger messenger = new Messenger(new MessengerHandler());

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

为了能够让该 Service 能够在独立的线程中，我们制定其 process ：

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

然后看看客户端的实现，基本就是一个 Activity 绑定 Service 的标准写法：

public class MainActivity extends Activity {

    private Messenger messenger;

    private ServiceConnection serviceConnection = new ServiceConnection() {
        @Override
        public void onServiceConnected(ComponentName name, IBinder service) {
            messenger = new Messenger(service);
            //创建完成Messenger后就可以通过Messenger 来发送 Message 了
            Message message = Message.obtain();
            message.what = 10086;
            Bundle bundle = new Bundle();
            bundle.putString("msg", "this is message from client.");
            message.setData(bundle);

            try {    //通过信使发送信息
                messenger.send(message);
            } catch (RemoteException e) {
                e.printStackTrace();
            }
        }

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

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);

        //绑定服务
        Intent intent = new Intent(this, MessengerService.class);
        bindService(intent, serviceConnection, Context.BIND_AUTO_CREATE);
    }

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

运行能看到log输出：

I/swifter: 服务端收到消息：this is message from client.

在 Messenger 中进行数据传递必须将数据放入 Message 中，而 Messenger 和 Message 都实现了 Parcelable 接口，因此可以跨进程传输。简单来说， Message 中所支持的数据类型就是 Messenger 所支持的传输类型。但是作为规范，还是使用 Bundle 来进行要传输的数据的封装是最好的。

服务端回应客户端

上面的例子演示了如何在服务端接受到客户端发送的消息，为了进行双向通讯，下面就演示服务端如何回应客户端。

首先是服务端，需要更改的地方不多，只是在收到消息之后回复一条消息：

private static class MessengerHandler extends Handler {
    @Override
    public void handleMessage(Message msg) {
        switch (msg.what) {
            case 10086:
                Log.i("swifter", "服务端收到消息："+msg.getData().getString("msg"));

                Messenger replyMessenger = msg.replyTo;
                Message replyMessage = Message.obtain();
                Bundle bundle = new Bundle();
                bundle.putString("reply", "服务端已经收到消息");
                replyMessage.what = 10010;
                replyMessage.setData(bundle);
                try {
                    replyMessenger.send(replyMessage);
                } catch (RemoteException e) {
                    e.printStackTrace();
                }
                break;
        }
    }
}

在客户端上，为了接受服务端的信息，客户端也需要实现一个 Messenger :

private static class MessengerHandler extends Handler {
    @Override
    public void handleMessage(Message msg) {
        switch (msg.what) {
            case 10010:
                Log.i("swifter", "客户端收到消息："+msg.getData().getString("reply"));
                break;
        }
    }
}

private Messenger replyMessenger = new Messenger(new MessengerHandler());

除此之外，我们还需要将这个replyMessenger设置到要发送的 Message 的 replyTo 参数中去，这样服务器才能拿到这个参数并回应信息。

message.replyTo = replyMessenger;

运行程序能看到log如下：

I/swifter: 服务端收到消息：this is message from client.
I/swifter: 客户端收到消息：服务端已经收到消息

至此，使用 Messenger 进行客户端与服务端之间的双向通信还是蛮容易的，相比 AIDL， 这个方案相当的便捷。因为使用的是串行方式处理信息，所以 Messenger 比较适用于第并发的一对多的通信。不同的场景下还是需要找到最合适的方案。还是那句话，每个方案都是针对不同的业务场景而设计的，总之，找到合适的就是最好的。