有了上一篇《Android的进阶学习(四)--AIDL的使用与理解》的知识后，现在我们看Messenger就会更加容易了。所以，如果你还没有看《Android的进阶学习(四)--AIDL的使用与理解》，推荐看后再看这篇。
Messenger
Messenger就是基于Message的进程间通信,也就是我们可以向在线程间利用Handler.send(Message)一样，所以用起来是非常简单的。
由上篇文章，我们知道我们可以编写aidl文件来进行进程间的通讯，而现在，我们用Messnger就不需要显式使用aidl文件了，为什么说不是显式呢？看完你就懂了。
Messenger的使用
明白一个类的原理前，首先就因该学会使用，毕竟我们的最终目的是搞明白原理，让我们能够更好的使用。
这里我们还是选择一个远程的Service和Activity之间的通信吧。
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`属性，因为我们要测试的是跨进程通信了。
######Activity客户端
我们的`Activity`也是相当简单的，所以还是先上代码:
public class MainActivity extends AppCompatActivity {
public final static String TAG = "MainActivity";
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运行结果
客户端：
服务端：
可见，当我们的服务端接收到消息后，就向客户端发出了一条消息。这种情况在我们的项目中也是经常可见的，例如，你下载一个很大的东西时，就直接开一个进程去下，让后下载完成后再将文件路径给发送给客户端......当然，这个demo中我们什么都没有去处理就直接返回了，在服务端是会有逻辑的，这里就没有过多的演示了。
Messenger的理解
知其所以然，我们就接着看看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);
}
}
在getIMessenger()中就简单的判断一下mMessenger是否存，不存在的话就new一个返回，存在的话就直接返回，还是很简单的。接着我们就看看这个MessengerImpl到底是个什么东西？
由源码我们发现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。
图画得很简单，但是也足以说明问题了。这里我们有两个进程，一个进程A，一个进程B,其中每个进程中我们都生成了一个相应的进程。接着就该注意一下了，当我们从A到B发送消息时，我们使用的是MessengerB.send(Message),B到A的时候是MessengerA.send(Message),这时候你可能就纳闷了，为什么不是用相应的发送？进程A中的MessengerB又是怎样来的？
联系上面的demo这就很说明问题了，我们假设进程A是客户端，B是服务端。那么进程A（Activity）中通过ServiceConnection就得到了进程B（Service）中Messenger中包装的Binder,在自己包装一下，就是MessengerB了。这也和上一篇中的在客户端调用aidl文件接口方法联系起来。
然后，我们需要知道的就是进程B（Service）中是怎样有进程A（Activity）的MessengerA的了？其实我想你已经明白了，就是在进程A给进程B发送的Message中，我们把MessengerA给传了过去。回想上面的代码，我们在客户端进行的message.replyTo = aMessenger;和在服务端进行的msg.replyTo.send(msgTo);就是把MessengerA给进行写入和读取。现在是不是有一种大彻大悟的感觉？如果没有，那就慢慢再理一下吧！
aidl实现双向通信
看了Messenger的实现方式，我们想一下用aidl来实现客户端与服务端的双向通信也是很容易的,那就在上一篇文章的基础上理一下思路吧。
1.我们在服务端aidl定义一个方法，接受一个Binder。
2.在客户端中我们也通过aidl生成一个Binder,然后当我们通过ServicConnection获取到服务端的Binder后，再调用接受Bindler的那个方法，并把客户端中生成的Binder给传进去。
3.服务端相应客户端请求的方法时，在调用客户端Binder发送消息即可。
基本思路就是这样，当然肯定没有谷歌的Messenger完美，但是可以加强我们对aidl和Messenger的理解了。
总结
搞什么嘛，最后还不就是aidl，就是封装了一下而已。这也就是文章开头所说的不显式使用aidl。
最后
还有，这些是我参考《Android开发艺术探索》的，对，就是任大大的。
