Apkcore

Messenger轻量级IPC方案

发表于

概述

什么是messenger

Messenger可以翻译为信使，通过它可以在不同的进程中传递Messenger对象，在Message中放入我们要传递的数据，可以轻松实现数据的跨进程传递。Messenger是一种轻量级的IPC方案，底层实现了AIDL。

什么是基于消息的进程间通信

如下图所示

可以看到，我们可以在客户端发送一个Message给服务端，服务端在handler中会接收到客户端的消息，然后进行对应的处理，处理完成后，再奖结果等数据封装成Message，发送给客户端，客户端的handler中会接收到处理的结果。

优势

  • 基于Message，这个熟悉
  • 支持回调的方式，也就是服务端处理完成长任务可以和客户端交互
  • 不需要编写AIDL文件
    此外还支持，记录客户端的Messenger，然后可以实现一对多的通信；甚至作为一个转接处，做生意两个进程都能通过服务端进行通信。

    通信实例

    Service端

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    public class MessengerService extends Service {
        private static final String TAG = "MessengerService";
        private static class MessengerHandler extends Handler {
            @Override
            public void handleMessage(Message msg) {
                switch (msg.what) {
                    case 9527:
                        Log.d(TAG, "receive msg from Client: " + msg.getData().getString("msg"));
                        break;
                    default:
                        super.handleMessage(msg);
                        break;
                }
            }
        }
        private final Messenger mMessenger = new Messenger(new MessengerHandler());
        @Nullable
        @Override
        public IBinder onBind(Intent intent) {
            return mMessenger.getBinder();
        }
    }

Activity客户端

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
public class MessengerActivity extends AppCompatActivity {
    private static final String TAG = "MessengerActivity";
    private Messenger mService;
    private ServiceConnection mServiceConnection= new ServiceConnection() {
        @Override
        public void onServiceConnected(ComponentName name, IBinder service) {
            mService = new Messenger(service);
            Message msg = Message.obtain(null,9527);
            Bundle bundle = new Bundle();
            bundle.putString("msg","hello, man,this is Client!");
            msg.setData(bundle);
            try {
                mService.send(msg);
            } catch (RemoteException e) {
                e.printStackTrace();
            }
        }
        @Override
        public void onServiceDisconnected(ComponentName name) {
        }
    };
    @Override
    protected void onCreate(@Nullable Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_messenger);
        Intent intent = new Intent(this, MessengerService.class);
        bindService(intent,mServiceConnection,BIND_AUTO_CREATE);
    }
    @Override
    protected void onDestroy() {
        unbindService(mServiceConnection);
        super.onDestroy();
    }

清单文件中，设置

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

运行应用，看一下log，

1
04-03 15:34:42.408 16418-16418/? D/MessengerService: receive msg from Client: hello, man,this is Client!

通过上面的例子可以看出，在Messenger中进行数据传递必须将数据放入Message中，而Messenger和Message都实现了Parclabe接口，因此可以跨进程传输。简单来说，Message来传输，Message中能使用的载体只有what,agri,arg2,Bundle以及replyTo(这个很重要，过下要讲到)。在Message中另一个字段object在Android2.2以及，object字段不支持跨进程传输，不过2.2以后，也仅仅提供了实现了Parclabe接口的对象进行传输。

所幸我们还有Bundle，Bundel可以支持大量的数据类型。

互相通信

上面的例子实现了服务端接收到客户端的消息，但是我们有时候还需要回应。

服务端修改

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
private static class MessengerHandler extends Handler {
    @Override
    public void handleMessage(Message msg) {
        switch (msg.what) {
            case 9527:
                Log.d(TAG, "receive msg from Client: " + msg.getData().getString("msg"));
                Messenger client = msg.replyTo;
                Message replyMessage = Message.obtain(null,9528);
                Bundle bundle = new Bundle();
                bundle.putString("reply","hi!this is Service!");
                replyMessage.setData(bundle);
                try {
                    client.send(replyMessage);
                } catch (RemoteException e) {
                    e.printStackTrace();
                }
                break;
            default:
                super.handleMessage(msg);
                break;
        }
    }
}

客户端修改

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
private Messenger mReplyMessenger = new Messenger(new MessengerHandler());
private static  class MessengerHandler extends Handler{
    @Override
    public void handleMessage(Message msg) {
        switch (msg.what){
            case 9528:
                Log.d(TAG, "handleMessage: "+msg.getData().getString("reply"));
                break;
            default:
        super.handleMessage(msg);
                break;
        }
    }
}
private Messenger mService;
private ServiceConnection mServiceConnection= new ServiceConnection() {
    @Override
    public void onServiceConnected(ComponentName name, IBinder service) {
        mService = new Messenger(service);
        Message msg = Message.obtain(null,9527);
        Bundle bundle = new Bundle();
        bundle.putString("msg","hello, man,this is Client!");
        msg.setData(bundle);
        //一定要加这句
        msg.replyTo = mReplyMessenger;
        try {
            mService.send(msg);
        } catch (RemoteException e) {
            e.printStackTrace();
        }
    }
    @Override
    public void onServiceDisconnected(ComponentName name) {
    }
};

可以通过日志看到相互通信成功

1
2
3
04-03 15:54:44.839 2733-2733/com.apkcore.aidltest:remote D/MessengerService: receive msg from Client: hello, man,this is Client!
04-03 15:54:44.872 2698-2698/com.apkcore.aidltest D/MessengerActivity: handleMessage: hi!this is Service!

缺点

Messenger是以串行的方式处理客户端发来的ii他呵呵，如果有大量的消息同时发送到服务端，服务端仍然只能一个一个的处理，如果有大量的并发请求，那么用Messenger就不太合适。同时Messenger的作用主要是传递消息，很多时候我们可以需要跨进程调用服务端的方法，这种情况下用Messenger就无法做到，这个时候我们就要使用AIDL。
也欢迎大家关注我的简书、CSDN和github主页