android message 传递对象,Android基于Message的进程间通信之Messenger使用及解析

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);返回

注册文件

 

android:name=".messenger.MessengerService"

android:process=":remote" >

别忘了注册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对象做的与客户端的通信。