Messenger轻量级IPC方案

概述

什么是messenger

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

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

如下图所示

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

优势

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

通信实例

Service端

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客户端

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();
    }

清单文件中,设置

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

运行应用,看一下log,

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可以支持大量的数据类型。


互相通信

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

服务端修改

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;
        }
    }
}

客户端修改

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) {

    }
};

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

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。
也欢迎大家关注我的简书CSDNgithub主页

推荐阅读更多精彩内容

  • 上篇文章介绍了IPC机制的基本概念以及简单使用,文章链接:Android 关于IPC机制的理解(一) 这篇文章主要...
    老实任阅读 175评论 0 1
  • 1. 使用Bundle 由于Bundle实现了Parcelable接口,所以在四大组件中的三大组件(Activit...
    lemonCode阅读 287评论 0 1
  • 1. activiy的生命周期和启动模式 ActivityA到ActivityB的跳转生命周期的顺序是什么呢?Ac...
    super_shanks阅读 469评论 0 1
  • 懂了龙应台的目送 不是因为想要逃课才不想回学校,而是只是想跟爸妈多吃一顿饭。可是我天生就是一个很奇怪的人。我乐于跟...
    一定是酱阅读 35评论 0 0
  • 下雨了,没带伞的人很多,原来淋湿的不止我一个,只是别人都找到了避雨的地方,我却还站在雨里
    尚好佳阅读 11评论 0 0