本文内容基于《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发送处理消息，一次只处理一个请求，所以不需要考虑线程同步的问题。
本人技术有限，欢迎指正，谢谢！
