Android 进程间通信：Messenger

1.概述

项目中常用到的进程间通信更多是用AIDL，在前阵子复习的时候才了解还有 Messenger 这种方法。既然要学习就记录下，以后要用的时候才能快速的掌握。

Messenger 是一种轻量级的IPC方案，它的底层实现是AIDL，可以在不同进程中传递 Message 对象，它一次只处理一个请求，在服务端不需要考虑线程同步的问题，服务端不存在并发执行的情况。

2. Messenger的构造方法

Public constructors
`Messenger(Handler target)` Create a new Messenger pointing to the given Handler.
`Messenger(IBinder target)` Create a Messenger from a raw IBinder, which had previously been retrieved with `getBinder()`.

Public constructors

Messenger(Handler target)

Create a new Messenger pointing to the given Handler.

Messenger(IBinder target)

Create a Messenger from a raw IBinder, which had previously been retrieved with getBinder().

3. Messenger 使用

3.1 客户端步骤：

3.1.1 创建一个handler对象，并实现 handleMessage() 方法，用户接收客户端的消息。

3.1.2 创建Messenger ，封装handler。

3.1.3 用Messenger的 getBinder() 方法获取一个IBinder对象，通过 onBind 返回给客户端。

服务端的Service：

package cn.zzw.messenger.server;import android.app.Service;
import android.content.Intent;
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 MessengerService extends Service {private static final String TAG = "MessengerService";private MessengerHandler mHandler = new MessengerHandler();private Messenger mMessenger = new Messenger(mHandler);private static final int MSG_SUM = 10086;private class MessengerHandler extends Handler {@Overridepublic void handleMessage(Message msg) {if(msg.what==MSG_SUM){Log.e(TAG,"handleMessage");try {int arg1 = msg.arg1;int arg2=msg.arg2;Message msgToClient=Message.obtain(msg);msgToClient.arg1=arg1+arg2;msg.replyTo.send(msgToClient);} catch (RemoteException e) {}}}}@Overridepublic IBinder onBind(Intent intent) {return mMessenger.getBinder();}@Overridepublic void onDestroy() {super.onDestroy();mHandler.removeCallbacksAndMessages(null);}
}

3.2 客户端步骤：

3.2.1 在 Activity 中绑定服务。

3.2.2 创建ServiceConnection并在其中使用 IBinder 将 Messenger实例化

3.2.3 使用Messenger向服务端发送消息

客户端主要代码：

package cn.zzw.messenger.client;import androidx.appcompat.app.AppCompatActivity;import android.content.ComponentName;
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;
import android.view.View;
import android.widget.Button;
import android.widget.TextView;
import android.widget.Toast;public class MainActivity extends AppCompatActivity {private static final String TAG = "MessengerClient";private TextView mTv;private Messenger mService;private static final int MSG_SUM = 10086;private MessengerHandler mHandler = new MessengerHandler();private Messenger mMessenger = new Messenger(mHandler);private class MessengerHandler extends Handler {@Overridepublic void handleMessage(Message msg) {if(msg.what==MSG_SUM){Log.e(TAG,"handleMessage");int arg1 = msg.arg1;Log.e(TAG,"handleMessage:"+arg1);Toast.makeText(MainActivity.this,"The Result is "+arg1,Toast.LENGTH_SHORT).show();}}}private ServiceConnection conn=new ServiceConnection() {@Overridepublic void onServiceConnected(ComponentName componentName, IBinder iBinder) {//获取服务端关联的Messenger对象mService = new Messenger(iBinder);Log.e(TAG,"onServiceConnected");}@Overridepublic void onServiceDisconnected(ComponentName componentName) {Log.e(TAG,"onServiceDisconnected");mService=null;}};@Overrideprotected void onCreate(Bundle savedInstanceState) {super.onCreate(savedInstanceState);setContentView(R.layout.activity_main);bindToServserService();mTv = findViewById(R.id.mTv);findViewById(R.id.mBtn_cal).setOnClickListener(new View.OnClickListener() {@Overridepublic void onClick(View view) {Message msg = Message.obtain(null, MSG_SUM, 10, 500);msg.replyTo = mMessenger;if(null!=mService){//往服务端发送消息try {Log.e(TAG,"mService.send");mService.send(msg);} catch (RemoteException e) {e.printStackTrace();}}}});}/** 绑定服务端的Service*/private void bindToServserService() {Intent intent=new Intent();intent.setPackage("cn.zzw.messenger.server");intent.setAction("CN.ZZW.MESSENGER.SERVER");bindService(intent,conn,BIND_AUTO_CREATE);}@Overrideprotected void onDestroy() {super.onDestroy();unbindService(conn);mHandler.removeCallbacksAndMessages(null);}
}

4. 运行结果

client端的log：

E/MessengerClient: mService.send
E/MessengerClient: mService.sendhandleMessagehandleMessage:510
E/MessengerClient: handleMessagehandleMessage:510

Server端的log：

E/MessengerService: handleMessage
E/MessengerService: handleMessage
E/MessengerService: handleMessage
E/MessengerService: handleMessage
E/MessengerService: handleMessage

5.原理

先看下 Messenger 的源码，代码行数非常少：

http://androidxref.com/9.0.0_r3/xref/frameworks/base/core/java/android/os/Messenger.java

/** Copyright (C) 2006 The Android Open Source Project** Licensed under the Apache License, Version 2.0 (the "License");* you may not use this file except in compliance with the License.* You may obtain a copy of the License at**      http://www.apache.org/licenses/LICENSE-2.0** Unless required by applicable law or agreed to in writing, software* distributed under the License is distributed on an "AS IS" BASIS,* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.* See the License for the specific language governing permissions and* limitations under the License.*/package android.os;/*** Reference to a Handler, which others can use to send messages to it.* This allows for the implementation of message-based communication across* processes, by creating a Messenger pointing to a Handler in one process,* and handing that Messenger to another process.** <p>Note: the implementation underneath is just a simple wrapper around* a {@link Binder} that is used to perform the communication.  This means* semantically you should treat it as such: this class does not impact process* lifecycle management (you must be using some higher-level component to tell* the system that your process needs to continue running), the connection will* break if your process goes away for any reason, etc.</p>*/
public final class Messenger implements Parcelable {private final IMessenger mTarget;/*** Create a new Messenger pointing to the given Handler.  Any Message* objects sent through this Messenger will appear in the Handler as if* {@link Handler#sendMessage(Message) Handler.sendMessage(Message)} had* been called directly.* * @param target The Handler that will receive sent messages.*/public Messenger(Handler target) {mTarget = target.getIMessenger();}/*** Send a Message to this Messenger's Handler.* * @param message The Message to send.  Usually retrieved through* {@link Message#obtain() Message.obtain()}.* * @throws RemoteException Throws DeadObjectException if the target* Handler no longer exists.*/public void send(Message message) throws RemoteException {mTarget.send(message);}/*** 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();}/*** Comparison operator on two Messenger objects, such that true* is returned then they both point to the same Handler.*/public boolean equals(Object otherObj) {if (otherObj == null) {return false;}try {return mTarget.asBinder().equals(((Messenger)otherObj).mTarget.asBinder());} catch (ClassCastException e) {}return false;}public int hashCode() {return mTarget.asBinder().hashCode();}public int describeContents() {return 0;}public void writeToParcel(Parcel out, int flags) {out.writeStrongBinder(mTarget.asBinder());}public static final Parcelable.Creator<Messenger> CREATOR= new Parcelable.Creator<Messenger>() {public Messenger createFromParcel(Parcel in) {IBinder target = in.readStrongBinder();return target != null ? new Messenger(target) : null;}public Messenger[] newArray(int size) {return new Messenger[size];}};/*** Convenience function for writing either a Messenger or null pointer to* a Parcel.  You must use this with {@link #readMessengerOrNullFromParcel}* for later reading it.* * @param messenger The Messenger to write, or null.* @param out Where to write the Messenger.*/public static void writeMessengerOrNullToParcel(Messenger messenger,Parcel out) {out.writeStrongBinder(messenger != null ? messenger.mTarget.asBinder(): null);}/*** Convenience function for reading either a Messenger or null pointer from* a Parcel.  You must have previously written the Messenger with* {@link #writeMessengerOrNullToParcel}.* * @param in The Parcel containing the written Messenger.* * @return Returns the Messenger read from the Parcel, or null if null had* been written.*/public static Messenger readMessengerOrNullFromParcel(Parcel in) {IBinder b = in.readStrongBinder();return b != null ? new Messenger(b) : null;}/*** Create a Messenger from a raw IBinder, which had previously been* retrieved with {@link #getBinder}.* * @param target The IBinder this Messenger should communicate with.*/public Messenger(IBinder target) {mTarget = IMessenger.Stub.asInterface(target);}
}

这时候我们在回头看两个构造方法：

 1. public Messenger(Handler target) {mTarget = target.getIMessenger();}2. public Messenger(IBinder target) {mTarget = IMessenger.Stub.asInterface(target);}

两个构造方法内部都是初始化对象 mTarget：

private final IMessenger mTarget;

再看看 IMessenger，是一个AIDL文件：

http://androidxref.com/9.0.0_r3/xref/frameworks/base/core/java/android/os/IMessenger.aidl

/* //device/java/android/android/app/IActivityPendingResult.aidl
**
** Copyright 2007, The Android Open Source Project
**
** Licensed under the Apache License, Version 2.0 (the "License");
** you may not use this file except in compliance with the License.
** You may obtain a copy of the License at
**
**     http://www.apache.org/licenses/LICENSE-2.0
**
** Unless required by applicable law or agreed to in writing, software
** distributed under the License is distributed on an "AS IS" BASIS,
** WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
** See the License for the specific language governing permissions and
** limitations under the License.
*/package android.os;import android.os.Message;/** @hide */
oneway interface IMessenger {void send(in Message msg);
}

在看看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);}}

从以上代码，可以看出Messenger又跟Binder联系起来了。最终还是AIDL文件来完成的，只不过Messenger进行了深度的封装AIDL，使用起来更简单。

最后，附上文中的示例代码：https://download.csdn.net/download/zzw0221/11260381

参考：

https://blog.csdn.net/hzw2017/article/details/81090319

https://www.jianshu.com/p/48e212d1fde4