Android IPC机制－Messenger的使用

本文内容基于《Android开发艺术探索》，强烈推荐，值得一看。

Messenger是一种轻量级的IPC解决方案，通过它可以在不同进程之间传递Message对象，从而实现进程间通信，首先我们来看一下它部分源码：

public Messenger(Handler target) {
    mTarget = target.getIMessenger();
}

public Messenger(IBinder target) {
    mTarget = IMessenger.Stub.asInterface(target);
}

public void send(Message message) throws RemoteException {  
    mTarget.send(message);
}  
  
public IBinder getBinder() {  
    return mTarget.asBinder();  
}

从IMessenger或是Stub.asInterface可以看出来Messenger多进程通信，底层实现还是AIDL，IMessenger.aidl的实现如下

package android.os;

import android.os.Message;

/** @hide */
oneway interface IMessenger {
    void send(in Message msg);
}

接下来我们看一下如何使用Messenger实现多进程通信

• 服务端

public class MessengerService extends Service {

    private static final String TAG = MessengerService.class.getSimpleName();

    private Messenger mMessenger = new Messenger(new Handler() {

        @Override
        public void handleMessage(Message msg) {
            switch (msg.what) {
                case 1:
                    Log.e(TAG, "receive msg from Client:" + msg.getData().getString("msg"));
                    Messenger client = msg.replyTo;
                    Message relpyMessage = Message.obtain(null, 0);
                    Bundle bundle = new Bundle();
                    bundle.putString("reply", "嗯，你的消息我已经收到，稍后会回复你。");
                    relpyMessage.setData(bundle);
                    try {
                        client.send(relpyMessage);
                    } catch (RemoteException e) {
                        e.printStackTrace();
                    }
                    break;
                default:
                    super.handleMessage(msg);
            }
        }

    });

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

• 客户端

public class MainActivity extends AppCompatActivity {

    private static final String TAG = MainActivity.class.getSimpleName();
    private Messenger messenger;

    private Messenger replyMessager = new Messenger(new Handler(){
        @Override
        public void handleMessage(Message msg) {
            switch (msg.what){
                case 0:
                    Log.e(TAG, "receive msg from Server:" + msg.getData().getString("reply"));
                    break;
                default:
                    break;
            }
        }
    });

    private ServiceConnection connection = new ServiceConnection() {
        @Override
        public void onServiceConnected(ComponentName name, IBinder service) {
            messenger = new Messenger(service);
            Message m = Message.obtain(null, 1);
            Bundle b = new Bundle();
            b.putString("msg", "我是客户端,我找你");
            m.setData(b);
            m.replyTo = replyMessager;
            try {
                messenger.send(m);
            } 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);  //这边我是在同一个应用中指定MessengerService的android:process属性实现多线程所以用的是显示调用，不同应用要通过隐式调用
        bindService(intent, connection, BIND_AUTO_CREATE);
    }
}

服务端我们主要的操作有：

• 创建了一个Service来处理客户端的请求;
• 通过创建的Handler对象来创建Messenger对象，用Handler中的MessengerImpl对象为Messenger的mTarget赋值;
• 在onBind方法中返回Messenger中的IBinder对象(即mTarget.asBinder())，客户的可以用来创建Messenger对象向服务端发送消息
• 从客户的传来的Message对象中获取客户端的Messenger对象，通过Messenger#send(Message msg)发送消息给客户的。

客户端我们的主要操作有：

• 绑定服务，用服务端返回的IBinder对象初始化Messenger对象，用来向服务端发送消息；
• 通过创建的Handler对象来创建自己的Messenger对象，用Handler中的MessengerImpl对象为Messenger的mTarget赋值;
• 创建消息把自己的Messenger对象赋值给Message.replyTo，服务端接收消息后从Message对象中取出客户端的Messenger对象向客户端发送消息

从最上面Messenger的部分源码我们可以知道，Messenger#send(Message msg)发送消息是调用了IMessenger#send(in Message msg)，从Handler中的相关源码(如下)可以看出Messenger发送消息本质上还是用Handler发送的。

final IMessenger getIMessenger() {  
    synchronized (mQueue) {  
        if (mMessenger != null) {  
            return mMessenger;  
        }  
        mMessenger = new MessengerImpl();
        return mMessenger;  
    }  
}  
  
private final class MessengerImpl extends IMessenger.Stub { //AIDL，实现IMessenger.Stub  
    public void send(Message msg) {  
        Handler.this.sendMessage(msg);//由 Handler来发送消息  
    }  
}

我理解的Messenger多进程通信，希望大家指正

服务端通过客户端绑定服务时，把服务端Hanlder中的MessengerImpl对象(继承自IMessenger.Stub，IMessenger.Stub继承自android.os.Binder并实现IMessenger接口，它持有Handler对象的引用)返回给客户端，客户绑定服务时用服务端返回的MessengerImpl对象创建用于向服务端发送消息的Messenger对象，最终客户端通过该Messenger对象中MessengerImpl对象持有的服务端的Handler对象的引用发送消息给服务端，消息中带有客户端自己的Messenger对象引用，服务端通过调用客户端Messenger对象的引用继而调用客户端中的Handler对象回复消息，从而实现进程间通信。
注：Messenger通信本质上也就是Hanlder发送处理消息，一次只处理一个请求，所以不需要考虑线程同步的问题。

本人技术有限，欢迎指正，谢谢！