Android IPC之Messager用法示例

Messager可以翻译为信使，顾名思义，通过它可以在不同进程中传递Message对象，在Message中放入我们需要传递的数据，就可以轻松地实现数据的进程间穿传递了。Messager是一种轻量级的IPC方式，它的底层实现是AIDL。这个大家可以下去看一下Messager的构造方法就知道了。

Messager的使用方法很简单，它对AIDL做了封装，使得我们可以更简便的进行进程间通信。同时，由于它一次处理一个请求，因此在服务器中不存在并发的情形。实现一个Messager有如下几个步骤，分为服务端和客户端。

1，服务端进程

首先，我们需要在服务端创建一个Service来处理客户端的连接请求，同时创建一个Handler并通过它来创建一个Messager对象，然后在Service的onBinder中返回这个Messager对象底层的Binder即可。

代码如下：

package com.example.lenovo.textmyaidl;

import android.app.Service;
import android.content.Intent;
import android.os.Bundle;
import android.os.Handler;
import android.os.IBinder;
import android.os.Message;
import android.os.Messenger;
import android.os.RemoteException;
import android.util.Log;

/**
* MessaerHandler用来处理客户端发来的消息，并从消息中取出客户端发来的文本消息。而
* messenger是一个Messager对象，它和MessaerHandler相关联，并在onBind方法中返回它里面的Binder
* 对象，可以看出这里的messager的作用就是将客户端发送的消息传递给MessaerHandler处理。
* Created by lenovo on 2016/4/24.
*/
public class MessengerService extends Service {

private  static  final String TAG = "MessengerService";

private static class  MessaerHandler extends Handler{
@Override
public void handleMessage(Message msg) {
switch (msg.what){
case MyContants.MSG_FROM_CLIENT:
Log.e(TAG,"receive msg from client:"+msg.getData().getString("msg"));
Messenger client = msg.replyTo;
Message replyMessage = Message.obtain(null,MyContants.MSG_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 MessaerHandler());
@Override
public IBinder onBind(Intent intent) {
return messenger.getBinder();
}
}

然后，注册service，让其运行在单独的进程中：

<service android:name=".MessengerService"
android:process=":remote"></service>

2，客户端进程

代码如下：

package com.example.lenovo.textmyaidl;

import android.app.Activity;
import android.content.ComponentName;
import android.content.Context;
import android.content.Intent;
import android.content.ServiceConnection;
import android.os.Bundle;
import android.os.Handler;
import android.os.IBinder;
import android.os.Message;
import android.os.Messenger;
import android.os.RemoteException;
import android.util.Log;

public class MainActivity extends Activity {

private static final String TAG = "MainActivity";

private  Messenger mGetMessage = new Messenger(new MessengerHandler());
private Messenger mService;

private  static class  MessengerHandler extends Handler{
@Override
public void handleMessage(Message msg) {

switch (msg.what){
case MyContants.MSG_FROM_SERVICE:
Log.e(TAG,"recive msg from Service:"+msg.getData().getString("reply"));
}
}
}

private ServiceConnection connection = new ServiceConnection() {
@Override
public void onServiceConnected(ComponentName name, IBinder service) {
mService = new Messenger(service);
Message msg = Message.obtain(null,MyContants.MSG_FROM_CLIENT);
Bundle data = new Bundle();
data.putString("msg","hello,this is client");
msg.replyTo = mGetMessage;
msg.setData(data);
try {
mService.send(msg);
} catch (RemoteException e) {
e.printStackTrace();
}
}

@Override
public void onServiceDisconnected(ComponentName name) {

}
};

protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_main);

Intent intent = new Intent(this,MessengerService.class);
bindService(intent,connection, Context.BIND_AUTO_CREATE);
}

@Override
protected void onDestroy() {
unbindService(connection);
super.onDestroy();
}
}

运行结果：

04-24 11:31:38.632 12385-12385/com.example.lenovo.textmyaidl:remote E/MessengerService:
receive msg from client:
hello,this is client
04-24 11:31:39.060 12363-12363/com.example.lenovo.textmyaidl E/MainActivity: recive msg from Service:
嗯，你的消息我收到了，稍后回复你！

通过上面的例子可以看出来。在Messenger中进行数据传递必须将数据封装到Messenge中。Messenger和Messenge都实现了Parcelable接口，因此可以跨进程传输。简单的来说就是Messenge中所支持的数据类型就是Messenger所支持的传输类型。Messenge的另一个字段object在同一个进程中是很实用的，但是在跨进程中却是由有很大的限制的，只支持系统提供的实现了Parcelable接口的对象的传输，非系统的（自定义的）对象是无法跨进程用object字段来传输的。