Messenger可以翻译为信使，通过它可以在不同进程中传递Message对象，在Message 中放入我们需要传递的数据，就可以轻松实现数据的进程间传递了。Messenger是一种轻量级的IPC方案，它的底层实现是AIDL。Messenger的使用方法很简单，它对AIDL做了封装，使得我们可以更简单的进行进程间通信。同时，由于它一次处理一个请求，因此在服务端我们不用考虑。
1 服务端进程
首先我们需要在服务端创建一个Service来处理客户端的连接请求，同时创建一个Handler来通过它来创建一个Messenger对象，然后在Service的onBind中返回这个Messenger对象底层的Binder即可。
2 客户端进程
在客户端进程中，首先要绑定服务端的Service，绑定成功后用服务端返回的IBinder对象创建一个Messenger,通过这个Messenger就可以向服务端发送消息了，发消息类型为Message对象。如果需要服务端能够回应客户端，就和服务端一样，我们还需要创建一个Handler并创建一个新的Messenger，并把这个Messenger对象通过Message的replyTo参数传递给服务端，服务端通过这个replyTo参数就可以回应客户端。
public class MessengerService extends Service {
private static final String TAG = "MessengerService";
private static class MessengerHandler extends Handler{
@Override
public void handleMessage(Message msg) {
super.handleMessage(msg);
switch (msg.what){
case MyConstants.MES_FROM_CLIENT:
Log.d("zhouzhuo","receive msg from Client："+msg.getData().getString("msg"));
Messenger client = msg.replyTo;
Message replyMessage = Message.obtain(null,MyConstants.MES_FROM_SERVICE);
Bundle bundle = new Bundle();
bundle.putString("reply","恩，你的消息已经收到，稍后回复你");
replyMessage.setData(bundle);
try {
client.send(replyMessage);
} catch (RemoteException e) {
e.printStackTrace();
}
break;
}
}
}
private final Messenger messenger = new Messenger(new MessengerHandler());
@Nullable
@Override
public IBinder onBind(Intent intent) {
Log.d("zhouzhuo","==Binder===");
return messenger.getBinder();
}
@Override
public int onStartCommand(Intent intent, int flags, int startId) {
return super.onStartCommand(intent, flags, startId);
}
客户端的实现,首先需要绑定远程进程的MessengerService,绑定成功后，根据服务端返回的binder对象创建Messenger对象并使用此对象向服务端发送消息。代码如下:
public class MessengerActivity extends Activity {
private static final String TAG = "MessengerActivity";
private Messenger mSerVie;
//handler 将会接收这个消息
private Messenger mGetReplyMessenger = new Messenger(new MessengerHandler());
private static class MessengerHandler extends Handler{
@Override
public void handleMessage(Message msg) {
super.handleMessage(msg);
switch (msg.what){
case MyConstants.MES_FROM_SERVICE:
Log.i("zhouzhuo", "receive msg from Service:" + msg.getData().getString("reply"));
break;
}
}
}
private ServiceConnection mConnection = new ServiceConnection() {
@Override
public void onServiceConnected(ComponentName name, IBinder service) {
mSerVie = new Messenger(service);
Log.d("zhouzhuo","bind service");
Message msg = Message.obtain(null,MyConstants.MES_FROM_CLIENT);
Bundle data = new Bundle();
data.putString("msg","hello,this is client");
msg.setData(data);
//将消息
msg.replyTo = mGetReplyMessenger;
try {
mSerVie.send(msg);
} catch (RemoteException e) {
e.printStackTrace();
}
}
@Override
public void onServiceDisconnected(ComponentName name) {
}
};
@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() {
unbindService(mConnection);
super.onDestroy();
}
}
在Messenger中进行数据传递必须将数据放入Message中，而Messenger和Message都实现了Parcelable接口，因此可以进行跨进程传输。简单来说，Message中所支持的数据类型就是Messenger所支持的传输类型。实际上，通过Messenger来传输Message，Message中能使用的载体只有what,arg1,arg2,Bundle以及replyTo.Message中的另一个字段object在同一进程中是很实用的，但是在进程间通信的时候，在Android 2.2 以前的object字段不支持跨进程传输，即使2.2以后，也仅仅是系统提供的实现了Parcelable接口的对象才能通过他来传输，非系统的Parcelable对象无法通过obj字段来传输，这也导致object的实用性大大降低，所幸我们还有Bundle,Bundle中可以支持大量的数据类型。
3 代码运行后的结果
ne D/zhouzhuo: ==Binder===
01-02 13:59:33.175 439-439/com.zhouzhuo.messengerone D/mali_winsys: new_window_surface returns 0x3000
01-02 13:59:33.195 439-439/com.zhouzhuo.messengerone D/zhouzhuo: bind service
01-02 13:59:33.210 439-439/com.zhouzhuo.messengerone D/zhouzhuo: receive msg from Client：hello,this is client
01-02 13:59:33.210 439-439/com.zhouzhuo.messengerone I/zhouzhuo: receive msg from Service:恩，你的消息已经收到，稍后回复你
01-02 13:59:46.725 439-445/com.zhouzhuo.messengerone I/jdwp: Ignoring second debugger -- accepting and dropping
4 项目地址
