Android进程间通信方式Messenger的简单记录

前言

简单记录一下Messenger的使用，方便自己查阅。

正文

什么是Messenger

Messenger是基于消息Message的传递的一种轻量级IPC进程间通信方式，本质上是对Binder的封装。

通过Messenger可以让我们可以简单地在进程间直接使用Handler进行Message传递，跨进程是通过Binder（AIDL实现），而消息发送是通过Handler#sendMessage方法，而处理则是Handler#handleMessage处理的；当然除了Handler之外还可以是自定义的相关的某些IBinder接口，简而言之，Messenger的跨进程能力是由构造时关联的对象提供的。

Messenger是以串行的方式来处理消息，如果有大量消息发送到服务端，也只能一个一个的处理，那么如果高并发的请求用AIDL更合适一些。

Messenger的使用

Server端进程：

我们需要在服务端进程中创建一个Service来监听客户端的连接请求，同时创建Handler并通过Handler创建Messenger对象。最后在Service的onBind中返回Messenger中的Binder。

public class MessengerService extends Service {

    private Messenger mMessenger;
    private final int MSG_ONE = 0x1001;
    private final int MSG_TWO = 0x1002;

    @Nullable
    @Override
    public IBinder onBind(Intent intent) {
        // 返回iBinder
        return mMessenger.getBinder();
    }

    @Override
    public void onCreate() {
        super.onCreate();
        //创建Messenger
        mMessenger = new Messenger(mServerHandler);
    }


    @Override
    public void onDestroy() {
        super.onDestroy();
        //移除消息，这个忽略
        mServerHandler.removeCallbacksAndMessages(null);
    }

    @SuppressWarnings("HandlerLeak")
    private final Handler mServerHandler = new Handler() {
        @Override
        public void handleMessage(@NonNull Message msg) {
            super.handleMessage(msg);
            if (msg.what == MSG_ONE) {
                // 可以处理Client传过来的Message
                //略...
                // 跟Client通信，
                try {
                    //双向通行，获取Client的Messenger
                    Messenger clientMessenger = msg.replyTo;
                    if (null != clientMessenger) {
                        Message message = Message.obtain();
                        message.what = MSG_TWO;
                        message.obj = "Hello  : "; //内容
                        clientMessenger.send(message);
                    }
                } catch (RemoteException e) {
                    e.printStackTrace();
                }
            }
        }
    };
}

AndroidManifest.xml的配置

<service
    android:name=".service.MessengerService"
    android:enabled="true"
    android:exported="true">
    <intent-filter>
        <action android:name="com.biumall.messenger.service.MessengerService" />
        <category android:name="android.intent.category.DEFAULT" />
    </intent-filter>
</service>

Client端进程：

客户端只需要创建用于绑定服务端的Service，并通过服务端返回的Ibinder创建Messenger，此时就可以通过这个Messenger向服务端发送消息了。

public class MainActivity extends AppCompatActivity {

    private final String TAG = MessengerApp.TAG + MainActivity.class.getSimpleName();
    private final int MSG_ONE = 0x1001;
    // Client和Server的Messenger
    private Messenger mServiceMessenger = null, mClientMessenger = null;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        Log.d(TAG, "onCreate: ");
        initData();
    }

    @Override
    protected void onDestroy() {
        super.onDestroy();
        mClientHandler.removeCallbacksAndMessages(null);
        unbindService(serviceConnection);
        Log.d(TAG, "onDestroy: ");
    }

    @SuppressWarnings("HandlerLeak")
    private final Handler mClientHandler = new Handler() {
        @Override
        public void handleMessage(@NonNull Message msg) {
            super.handleMessage(msg);
            // 可以处理Server传过来的Message
        }
    };


    private void initData() {
        // 创建Client的Messenger
        mClientMessenger = new Messenger(mClientHandler);
        bindService();
    }

    /**
     * 绑定Server
     */
    private void bindService() {
        Intent intent = new Intent();
        intent.setClassName("com.biumall.messenger", "com.biumall.messenger.service.MessengerService");
        bindService(intent, serviceConnection, Context.BIND_AUTO_CREATE);
    }

    private final ServiceConnection serviceConnection = new ServiceConnection() {
        @Override
        public void onServiceConnected(ComponentName componentName, IBinder iBinder) {
            // 获取Server端Messenger
            mServiceMessenger = new Messenger(iBinder);
            // 死亡监听，如果死了重新绑定
            try {
                mServiceMessenger.getBinder().linkToDeath(new IBinder.DeathRecipient() {
                    @Override
                    public void binderDied() {
                        mServiceMessenger = null;
                        bindService();
                    }
                }, 0);
            } catch (RemoteException e) {
                e.printStackTrace();
            }

            //向服务端通信，并把mClientMessenger传给服务端
            try {
                Message message = Message.obtain();
                message.obj = "Hi  : ";
                message.replyTo = mClientMessenger; // 把服务端的Messenger附上，方便双向通信
                message.what = MSG_ONE;
                mServiceMessenger.send(message);
            } catch (RemoteException e) {
                e.printStackTrace();
            }
        }

        @Override
        public void onServiceDisconnected(ComponentName componentName) {
            mServiceMessenger = null;
        }
    };
}

如果要双向通信，需要把Client的Messenger通过message.replyTo 传给Server端，这样就可以双向通信了。

上面代码都有实现。

参考文章

1. 《Android Messenger进程间双向通信详解》
2. 《Android中Messenger的简单使用》
3. 《Android进程间通信之Messenger的使用和理解》
4. 《【Android学习笔记】Android进程间通信方式Messenger》
5. 《Android IPC之Messenger 》