Messenger通信原理以及实现

Messenger是什么？

Messenger是以串行的方式处理客户端请求，如果大量请求同时发送到服务端，Messenger就不合适。

Messenger的工作原理

传输字段

Messenger和Message都实现Parcelable接口，因此可以跨进程传输。通过Messenger传输Message，Message中使用的载体只有what，arg1，arg2，Bundle以及replyTo。另一个object字段不支持跨进程传输。

实现Messenger

服务端进程

在服务端创建一个Srevice处理客户端连接请求，同时创建一个Handler并通过它创建Messenger对象，在Service的OnBinder返回这个Messenger对象的Binder。

客户端进程

绑定服务端Service，绑定成功后用服务端返回IBinder对象创建一个Messenger，通过这个Messenger就可以向服务端发送消息。

如果需要服务端回应客户端，创建一个Handler并创建一个新的Messenger，把这个Messenger对象通过Message的replyTo参数传递给服务端。

如何在服务端接收客户端中发送的消息

服务端代码示例如下：

public class MessengerService extends Service{
    
    private static final String TAG = "MessengerService";
    
    // Service接收处理来自客户端的消息
    private static class MessengerHandler extends Handler{
        
        @Override
        public void handleMessage(Message msg){
            switch(msg.what){
                case MyConstants.MSG_FROM_CLIENT:
                    Log.i(TAG, "receive msg from Clinet:" + msg.getData());
                    break;
                default:
                    super.handleMessage(msg);
            }
        }
    }
    
    private final Messenger mMessenger = new Messenger(new MessengerHandler());
    
    @Override
    public IBinder onBinder(Intent intent){
        return mMessenger.getBinder()；
    }
}

客户端实现的代码如下：

public class MessengerActivity extends Activity{
    
    private static final String TAG = "MessengerActivity";
    
    private Messenger mService;
    
    private ServiceConnection mConn = new ServiceConnection(){
        
        public void onServiceConnected(ComponentName className, IBinder service){
            mService = new Messenger(service);
            Message msg = Message.obtain(null, MyConstants.MSG_FROM_CLIENT);
            Bundle data = new Bundle();
            data.putString("msg", "hello ,this is client");
            msg.setData(data);
            try{
                mService.send(msg);
            }
            catch (RemoteException e){
                e.printStackTrace();
            }
        }
        
        public void onServiceDisconnected(ComponentName className){}
    };
    
    @Override
    protected void onCreate(Bundle savedInstanceState){
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_messenger);
        Intent intent = new Intent(this, MessengerService.class);
        bindService(intent, mConnection, Context.BIND_AUTO_CREATE);
        
    }
    
    @Override
    protected void onDestroy(){
        unbinderService(mConnection);
        super.onDestroy();
    }
}

如何在客户端接收服务端发送的消息

服务端只需修改MessengerHandler，当收到消息后立即回复客户端，以下是示例代码：

服务端的代码如下：

private static class MessengerHandler extends Handler{
    @Override
    public void handleMessage(Message msg){
        switch(msg.what){
            case MyConstants.MSG_FROM_CLINET:
                Log.i(TAG, "receive msg from client:" + msg.getData().getString("msg"));
                Messenger client = msg.replyTo;
                Message replyMessage = Message.obtain(null, MyConstants.MSG_FROM_SERVICE);
                Bundle bundle = new Bundle();
                bundle.putString("reply", "your messge has been received,I will reply you later");
                replyMessage.setData(bundle);
                try{
                    client.send(relpyMessage);
                }catch (RemoteException e){
                    e.printStackTrace();
                }
                break;
            default:
                super.handleMessage(msg);
        }
    }
}

客户端代码的修改，客户端需要准备一个接收消息的Messenger和Handler，如下：

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

private static class MessengerHandler extends Handler{
    @Override
    public void handleMessage(Message msg){
        switch(msg.what){
            case MyConstants.MSG_FROM_SERVICE:
                Log.i(TAG, "receive msg from Service:" + msg.getData().getString("reply"));
                break;
            default:
                super.handleMessage(msg);
        }
    }
}

Messenger通信示例代码

服务端的实现

public class MyService extends Service {

    public final static String TAG = MyService.class.getSimpleName();

    private Messenger mMessenger = new Messenger(new MyServiceHandler());

    public MyService() {
    }

    @Override
    public IBinder onBind(Intent intent) {
        // TODO: Return the communication channel to the service.
        return mMessenger.getBinder();
    }

    private class MyServiceHandler extends Handler {
        @Override
        public void handleMessage(Message msg) {
            switch (msg.what) {
                case MsgConstants.MSG_FROM_CLIENT:
                    // 服务端处理客户端发送的消息
                    Bundle data = msg.getData();
                    String msgContent = data.getString("msg");
                    Log.d(TAG, "service received msg" + " <" + msgContent + ">");

                    // 回复客户端
                    Messenger client = msg.replyTo;
                    Bundle replyData = new Bundle();
                    replyData.putString("reply",
                            "\n" + "service ACK msg - " + msgContent
                                    + "\n" + "service send msg - 韩国将疫情预警上调到最高级别");
                    Message replyMsg = Message.obtain();
                    replyMsg.what = MsgConstants.MSG_FROM_SERVICE;
                    replyMsg.setData(replyData);
                    try {
                        client.send(replyMsg);
                        Log.d(TAG, "service reply client");
                    } catch (RemoteException e) {
                        e.printStackTrace();
                    }
                    break;
                default:
                    super.handleMessage(msg);
                    break;
            }
        }
    }
}

客户端的实现

public class MsgActivity extends AppCompatActivity {

    public final static String TAG = MsgActivity.class.getSimpleName();

    private Intent intent = null;
    private Messenger mClient = null;
    private Messenger mMessenger = new Messenger(new MsgHandler());

    private ServiceConnection mConnection = new ServiceConnection() {
        @Override
        public void onServiceConnected(ComponentName componentName, IBinder iBinder) {
            mClient = new Messenger(iBinder);
            sendMsgToService();
        }

        @Override
        public void onServiceDisconnected(ComponentName componentName) {

        }
    };

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

    private void initService() {
        intent = new Intent(this, MyService.class);
        bindService(intent, mConnection, Context.BIND_AUTO_CREATE);
    }

    private void sendMsgToService() {
        final Message msg = Message.obtain();
        msg.what = MsgConstants.MSG_FROM_CLIENT;
        Bundle data = new Bundle();
        data.putString("msg", "client send msg - 今天终于开始正式上班");
        msg.setData(data);

        // 设置服务端回复的Messenger
        msg.replyTo = mMessenger;

        // 客户端给服务端发送信息
        new Thread(new Runnable() {
            @Override
            public void run() {
                try {
                    mClient.send(msg);
                } catch (RemoteException e) {
                    e.printStackTrace();
                }
            }
        }).start();
        Log.d(TAG, "client send msg to service");
    }

    private class MsgHandler extends Handler {
        @Override
        public void handleMessage(Message msg) {
            switch (msg.what) {
                case MsgConstants.MSG_FROM_SERVICE:
                    Bundle data = msg.getData();
                    String msgContent = data.getString("reply");
                    Log.d(TAG, "client received msg" + msgContent);
                    break;
                default:
                    super.handleMessage(msg);
                    break;
            }
        }
    }
}