1、Messenger 简介
说到Android进程间通信，大家肯定能想到的是编写aidl文件，然后通过aapt生成的类方便的完成服务端，以及客户端代码的编写。如果你对这个过程不熟悉，可以查看Android aidl Binder框架浅析；
当然今天要说的通信方式肯定不是通过编写aidl文件的方式，那么有请今天的主角：Messenger。ok，这是什么样的一个类呢？我们看下注释
This allows for the implementation of message-based communication across processes
允许实现基于消息的进程间通信方式。
平时一说进程间通讯，大家都会想到AIDL，其实messenger和AIDL作用一样，都可以进行进程间通讯。它是基于消息的进程间通信，就像子线程和UI线程发送消息那样，是不是很简单，还不用去写AIDL文件，是不是有点小爽。哈哈。
此外，还支持记录客户端对象的Messenger，然后可以实现一对多的通信；甚至作为一个转接处，任意两个进程都能通过服务端进行通信。
与 AIDL 比较：
当您需要执行 IPC 时，为您的接口使用 Messenger 要比使用 AIDL 实现更加简单，因为 Messenger 会将所有服务调用排入队列，而纯粹的 AIDL 接口会同时向服务发送多个请求，服务随后必须应对多线程处理。
对于大多数应用，服务不需要执行多线程处理，因此使用 Messenger 可让服务一次处理一个调用。如果您的服务必须执行多线程处理，则应使用 AIDL 来定义接口。
2、通信实例
1）Service端
代码
package com.ryg.chapter_2.messenger;
import android.app.Service;
import android.content.Intent;
import android.os.*;
import android.util.Log;
import com.ryg.chapter_2.utils.MyConstants;
/**
* FileName:
* Author: nanzong
* Date: 2019-06-20 17:23
* Description:
* History:
*/
public class MessengerService extends Service {
private static final String TAG = "MessengerActivity";
private static class MessengerHandler extends Handler {
@Override
public void handleMessage(Message msg) {
switch (msg.what) {
case MyConstants.MSG_FROM_CLIENT:
Log.d(TAG, "receive msg from Client:" + msg.getData().getString("mymsg"));
Messenger msgfromClient = msg.replyTo;
Message relpyMessage = Message.obtain(null, MyConstants.MSG_FROM_SERVICE);
Bundle bundle = new Bundle();
bundle.putString("reply", " 嗯 ， 你的消息我已经收到，稍后会回复你！");
relpyMessage.setData(bundle);
try {
msgfromClient.send(relpyMessage);
} catch (RemoteException e) {
e.printStackTrace();
}
break;
default:
super.handleMessage(msg);
}
}
}
private final Messenger mMessenger = new Messenger(new MessengerHandler());
@Override
public IBinder onBind(Intent intent) {
return mMessenger.getBinder();
}
}
服务端就是一个Service,只需要去声明一个Messernger (Handler handler)对象，然后onBind方法中返回一个mMessenger.getBinder();
然后等客户端将消息发送到Handler中的handleMessage，根据msg.what去判断什么操作，最终将结果通过msgfromClient.replyTo.send(relpyMessage);返回
注册文件
别忘了注册service
2）客户端
Activity
package com.ryg.chapter_2.messenger;
import android.annotation.SuppressLint;
import android.app.Activity;
import android.content.ComponentName;
import android.content.Context;
import android.content.Intent;
import android.content.ServiceConnection;
import android.os.*;
import android.util.Log;
import com.ryg.chapter_2.R;
import com.ryg.chapter_2.utils.MyConstants;
public class MessengerActivity extends Activity {
private static final String TAG = "MessengerActivity";
private Messenger mServerMessenger;
@SuppressLint("HandlerLeak")
private Messenger mClientMessenger = new Messenger(new Handler() {
@Override
public void handleMessage(Message msg) {
switch (msg.what) {
case MyConstants.MSG_FROM_SERVICE:
Log.d(TAG, "receive msg from Service:" + msg.getData().getString("reply"));
break;
default:
super.handleMessage(msg);
}
}
});
private ServiceConnection mConnection = new ServiceConnection() {
//Activity 与 Service连接成功使回调该方法
@Override
public void onServiceConnected(ComponentName className, IBinder service) {
mServerMessenger = new Messenger(service);
Log.d(TAG, "bind service");
Message msg = Message.obtain(null, MyConstants.MSG_FROM_CLIENT);
Bundle data = new Bundle();
data.putString("mymsg", "hello, this is client.");
msg.setData(data);
msg.replyTo = mClientMessenger; //指定回信人是客户端定义的
try {
mServerMessenger.send(msg);
} catch (RemoteException e) {
e.printStackTrace();
}
}
//Activity 与 Service 断开连接 回调该方法
@Override
public void onServiceDisconnected(ComponentName name) {
mServerMessenger = null;
}
};
@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();
}
}
首先bindService,然后再onServiceConnected中拿到回调的service( Binder)对象，通过 mServerMessenger = new Messenger(service);然后就可以使用mServerMessenger.send(msg);发送给服务端了
mServerMessenger = new Messenger(service);
Log.d(TAG, "bind service");
Message msg = Message.obtain(null, MyConstants.MSG_FROM_CLIENT);
Bundle data = new Bundle();
data.putString("mymsg", "hello, this is client.");
msg.setData(data);
msg.replyTo = mClientMessenger; //指定回信人是客户端定义的
try {
往服务端发送消息
mServerMessenger.send(msg);
} catch (RemoteException e) {
e.printStackTrace();
}
那么服务端会收到消息，处理完成会将结果返回，传到client的mMessenger中的Handler的handleMessage方法中给对应地方进行处理
3) 运行结果
2019-06-28 08:56:57.480 21990-21990/com.ryg.chapter_2 D/MessengerActivity: bind service
2019-06-28 08:56:59.482 22039-22039/com.ryg.chapter_2:remote D/MessengerActivity: receive msg from Client:hello, this is client.
2019-06-28 08:56:59.482 21990-21990/com.ryg.chapter_2 D/MessengerActivity: receive msg from Service: 嗯 ， 你的消息我已经收到，稍后会回复你！
通过代码可以看到服务端往客户端传递数据是通过msg.replyTo这个对象的，那么服务端完全可以做到，使用一个List甚至Map去存储所有绑定客户端的msg.replyTo对象，然后想给谁发消息都可以。
3、源码分析
Messenger 有两个构造函数
- 以Handler 为参数
- 以IBinder 为参数
//服务端构建对象
public Messenger(Handler target) {
mTarget = target.getIMessenger();
}
//客户端构建对象
public Messenger(IBinder target) {
mTarget = IMessenger.Stub.asInterface(target); //和前面的 AIDL 很相似吧
}
1）客户端向服务端通信
服务端
服务端的onBind是这么写的：
@Override
public IBinder onBind(Intent intent) {
return mMessenger.getBinder();
}
那么点进去：
/**
* Retrieve the IBinder that this Messenger is using to communicate with
* its associated Handler.
*
* @return Returns the IBinder backing this Messenger.
*/
public IBinder getBinder() {
return mTarget.asBinder();
}
可以看到返回的是mTarget.asBinder();
我们前边构建Messenger对象的代码 new Messenger(new Handler())；
mTarget就是这么来的
public Messenger(Handler target) {
mTarget = 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);
}
}
mTarget是一个MessengerImpl对象，那么asBinder实际上是返回this，也就是MessengerImpl对象；
这是一个内部类，继承IMessenger.Stub，然后实现了一个send方法，该方法就是将接收到的消息通过Handler.this.sendMessage(msg);发送到handleMessage方法。
看到这，大家有没有想到什么，难道不觉得extends IMessenger.Stub这种写法异常的熟悉么？
我们传统写aidl文件，aapt给我们生成什么，生成IXXX.Stub类，然后我们服务端继承IXXX.Stub实现接口中的方法。
这里依赖了一个aidl生成的类
/Users/nanzong/Library/Android/sdk/sources/android-28/android/os/IMessenger.aidl
package android.os;
import android.os.Message;
/** @hide */
oneway interface IMessenger {
void send(in Message msg);
}
Messenger就是依赖了该aidl文件生成的类，继承了该类的IMessenger.Stub类，实现了send方法，send方法中参数会通过客户端传递过来，最终发送给Handler进行处理。
客户端
客户端首先通过onServiceConnected拿到sevice（Ibinder）对象，这里没什么特殊的，我们平时的写法也是这样的，只不过我们平时会这么写：
IMessenger.Stub.asInterface(service)拿到接口对象进行调用；
我们代码中是
mService = new Messenger(service);
public Messenger(IBinder target) {
mTarget = IMessenger.Stub.asInterface(target);
}
和我们平时aidl写法没有任何区别，通过编写aidl文件，服务端onBind利用Stub编写接口实现返回；客户端利用回调得到IBinder对象，使用IMessager.Stub.asInterface(target)拿到接口实例进行调用；
2）服务端与客户端通信
那么，客户端与服务端通信的确没什么特殊的地方，我们完全也可以编写个类似的aidl文件实现；那么服务端是如何与客户端通信的呢？
还记得，客户端send方法发送的是一个Message，这个Message.replyTo指向的是一个mMessenger，我们在Activity中初始化的。
那么将消息发送到服务端，肯定是通过序列化与反序列化拿到Message对象，我们看下Message的反序列化的代码：
# Message
private void readFromParcel(Parcel source) {
what = source.readInt();
arg1 = source.readInt();
arg2 = source.readInt();
if (source.readInt() != 0) {
obj = source.readParcelable(getClass().getClassLoader());
}
when = source.readLong();
data = source.readBundle();
replyTo = Messenger.readMessengerOrNullFromParcel(source);
sendingUid = source.readInt();
}
主要看replyTo，调用的Messenger.readMessengerOrNullFromParcel
public static Messenger readMessengerOrNullFromParcel(Parcel in) {
IBinder b = in.readStrongBinder();
return b != null ? new Messenger(b) : null;
}
public static void writeMessengerOrNullToParcel(Messenger messenger, Parcel out) {
out.writeStrongBinder(messenger != null ? messenger.mTarget.asBinder() : null);
}
通过上面的writeMessengerOrNullToParcel可以看到，它将客户端的messenger.mTarget.asBinder()对象进行了恢复，客户端的message.mTarget.asBinder()是什么？
客户端也是通过Handler创建的Messenger，于是asBinder返回的是：
public Messenger(Handler target) {
mTarget = target.getIMessenger();
}
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);
}
}
public IBinder getBinder() {
return mTarget.asBinder();
}
那么asBinder，实际上就是MessengerImpl extends IMessenger.Stub中的asBinder了。
#IMessenger.Stub
@Override
public android.os.IBinder asBinder(){
return this;
}
那么其实返回的就是MessengerImpl对象自己。到这里可以看到message.mTarget.asBinder()其实返回的是客户端的MessengerImpl对象。
msgfromClient.replyTo.send(msgToClient);
public void send(Message message) throws RemoteException {
mTarget.send(message);
}
这个mTarget实际上就是对客户端的MessengerImpl对象的封装，那么send(message)（屏蔽了transact/onTransact的细节），这个message最终肯定传到客户端的handler的handleMessage方法中。
总结下：
客户端与服务端通信，利用的aidl文件，没什么特殊的
服务端与客户端通信，主要是在传输的消息上做了处理，让Messager.replyTo指向的客户端的Messenger,而Messenger又持有客户端的一个Binder对象（MessengerImpl）。服务端正是利用这个Binder对象做的与客户端的通信。