Messenger
Messenger就是基于Message的进程间通信,也就是我们可以向在线程间利用Handler.send(Message)一样，所以用起来是非常简单的。
Messenger的使用
Service服务端
首先，我们写一个服务端Service：
public class MyService extends Service {
public final static String TAG = "MyService";
public final static int SERVICEID = 0x0001;
private Messenger messenger = new Messenger(new Handler() {
@Override
public void handleMessage(Message msg) {
super.handleMessage(msg);
if (msg.arg1 == SERVICEID) {
//接受从客户端传来的消息
Log.d(TAG, "客服端传来的消息===>>>>>>");
String str = (String) msg.getData().get("content");
Log.d(TAG, str);
//发送数据给客户端
Message msgTo = Message.obtain();
msgTo.arg1 = 0X0002;
Bundle bundle = new Bundle();
bundle.putString("content", "我是从服务器来的字符串");
msgTo.setData(bundle);
try {
//注意，这里把数据从服务器发出了
msg.replyTo.send(msgTo);
} catch (RemoteException e) {
e.printStackTrace();
}
}
}
});
@Override
public void onCreate() {
super.onCreate();
Log.i(TAG, "onCreat");
}
@Override
public IBinder onBind(Intent intent) {
return messenger.getBinder();
}
}
看看我们的Service服务端，可谓是真的很简单，我们首先创建了一个Messenger，在Messenger的构造函数中传入了一个Handler对象。然后在onBind方法中返回了一个messenger.getBinder()。
我们注意到在Handler中我们接受到消息后又给客户端发送了一条消息msg.replyTo(msgTo)。Messnger是可以相互发送消息的。当然，这也就要求在客户端和服务端都有自己的Messnger。
最后，我们要么就直接安装运行Service，要么就注册Service的时候加上Process属性，因为我们要测试的是跨进程通信了。
public class MainActivity extends AppCompatActivity {
public final static int ACTIVITYID = 0X0002;
//客户端的Messnger
private Messenger aMessenger = new Messenger(new Handler() {
@Override
public void handleMessage(Message msg) {
super.handleMessage(msg);
if (msg.arg1 == ACTIVITYID) {
//客户端接受服务端传来的消息
Log.d(TAG, "服务端传来了消息=====>>>>>>>");
String str = (String) msg.getData().get("content");
Log.d(TAG, str);
}
}
});
//服务端传来的Messenger
Messenger sMessenger;
ServiceConnection serviceConnection = new ServiceConnection() {
@Override
public void onServiceConnected(ComponentName name, IBinder service) {
sMessenger = new Messenger(service);
Message message = Message.obtain();
message.arg1 = 0x0001;
//注意这里，把`Activity`的`Messenger`赋值给了`message`中，当然可能你已经发现这个就是`Service`中我们调用的`msg.replyTo`了。
message.replyTo = aMessenger;
Bundle bundle = new Bundle();
bundle.putString("content", "我就是Activity传过来的字符串");
message.setData(bundle);
try {
//消息从客户端发出
sMessenger.send(message);
} catch (RemoteException e) {
e.printStackTrace();
}
}
@Override
public void onServiceDisconnected(ComponentName name) {
Log.e(TAG, "连接Service失败");
}
};
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_main);
startAndBindService();
}
private void startAndBindService() {
Intent service = new Intent(MainActivity.this, MyService.class);
startService(service);
bindService(service, serviceConnection, Context.BIND_AUTO_CREATE);
}
}
在这里我们把serviceConnection成功返回的IBinder转换成的是Messnger，接着就调用而messenger.send(message);,就这样，我们的消息就发送出了，和同一线程里面的消息发送几乎一样，只是这里的handmessage(Message message)是在不同的进程。
当然，为了接受从服务端发来的消息，我们在Activity中定义了一个Messenger,并且在客户端发给服务端的消息（Message）中把客户端的Messenger给赋值进Message中。
就这样，最简单的Messenger就完成了。
这种情况在我们的项目中也是经常可见的，例如，你下载一个很大的东西时，就直接开一个进程去下，下载完成后再将文件路径给发送给客户端......当然，这个demo中我们什么都没有去处理就直接返回了，在服务端是会有逻辑的，这里就没有过多的演示了。
Messenger的理解
首先，我们还是从Service中看起,还记得我们在Service中new了一个Messenger并且传入了一个Handler吧，然后在onBind()方法中就返回了一个messenger.getBinder()：
public IBinder getBinder() {
return mTarget.asBinder();
}
一看，里面返回的就是mTarget.asBinder(),然后我们就找找mTarget：
public Messenger(Handler target) {
mTarget = target.getIMessenger();
}
结果在Messenger的构造函数中发现了target.getIMessenger(),继续，我们看看Handler中的这个方法：
final IMessenger getIMessenger() {
synchronized (mQueue) {
if (mMessenger != null) {
return mMessenger;
}
mMessenger = new MessengerImpl();
return mMessenger;
}
}
private final class MessengerImpl extends IMessenger.Stub {
public void send(Message msg) {
msg.sendingUid = Binder.getCallingUid();
Handler.this.sendMessage(msg);
}
}
由源码我们发现MessengerImpl就是Hnadler的一个内部类，然后继承于IMessenger.Stub。看到这里，或许就已经发现了，这和aidl中生成的类不是一样的吗？的确，这里就是实现的一个aidl文件。在这个类中，实现了以一个send方法，这个方法中调用了Handler.sendMessage()方法，这也就是为什么，我们的消息来得时候会出现在handlerMessage()中。这里，我们在理一下，客户端在调用send方法的时候，由于在不同的进程，传送的数据先回被序列化，然后进行跨进程传送，最后到了服务端进行解析，对应调用send方法执行。
不知道是否还记得，我们在用aidl通信的时候，我们在Service中首先要生成一个XXXX.Stub的实现类，然后再在onBind()中返回一个XXXX.Stub的引用。
现在我们在回首看一下，我们在Service中返回的mTarget.asBinder()其实就是MessengerImpl,当然asBinder()返回的就是自己本身。
当然，还有个问题我们得注意，就是服务端给客户端发送的消息。从demo中我们知道，我们在Serivice中使用msg.replyTo.send(msgTo);进行向客户端发送消息。而msg的replyTo这个属性在客户端中就是由客户端生成的Messenger。其实这里也是好理解的，首先，我们这里的跨进程主要就是通过Binder的，即我们在客户端和服务端传递Binder来进行通信。而这里的Messnger也就是一个包装了的Binder。
aidl实现双向通信
看了Messenger的实现方式，我们想一下用aidl来实现客户端与服务端的双向通信也是很容易的。
1.我们在服务端aidl定义一个方法，接受一个Binder。
2.在客户端中我们也通过aidl生成一个Binder,然后当我们通过ServicConnection获取到服务端的Binder后，再调用接受Bindler的那个方法，并把客户端中生成的Binder给传进去。
3.服务端相应客户端请求的方法时，在调用客户端Binder发送消息即可。
作者：MathiasLuo
链接：https://www.jianshu.com/p/af8991c83fcb
来源：简书
著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。
网友评论