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

版权声明:本文为博主原创文章,未经博主允许不得转载。 https://blog.csdn.net/Lee_Swifter/article/details/78239614

每个系统都会有相应的 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 比较适用于第并发的一对多的通信。不同的场景下还是需要找到最合适的方案。还是那句话,每个方案都是针对不同的业务场景而设计的,总之,找到合适的就是最好的。

69fa3f23-c8c6-41b4-a00f-e29bdc6106b1.jpg

阅读更多
换一批

没有更多推荐了,返回首页