朝花夕拾跨进程通信,你只知道AIDL,就OUT了

Posted 宋者为王

tags:

篇首语:本文由小常识网(cha138.com)小编为大家整理,主要介绍了朝花夕拾跨进程通信,你只知道AIDL,就OUT了相关的知识,希望对你有一定的参考价值。

前言

      转载请声明,转自【https://www.cnblogs.com/andy-songwei/p/11774836.html】,谢谢!

      提起跨进程通信,大多数人首先会想到AIDL。我们知道,用AIDL来实现跨进程通信,需要在客户端和服务端都添加上aidl文件,并在服务端的Service中实现aidl对应的接口。如果还需要服务端给客户端发送信息,还需要再添加回调相关的aidl文件,以及使用RemoteCallbackList来辅助实现该功能。在我的另外一篇文章【朝花夕拾】Android性能篇之(七)Android跨进程通信篇中,就专门介绍过AIDL来实现客户端和服务端互相通信的方式,不清楚的可以看看这篇文章的介绍。本文将介绍一下另外一种更简单的方式——Messenger,来实现客户端和服务端跨进程互相通信。

       本文的主要内容如下:

 

 

一、Messenger简介

       Messenger翻译为信使,顾名思义,就是用于传递信息的,通过它可以在不同进程中传递Message对象。在Message中放入我们需要传递的信息,然后通过Messenger将Message传递给对方,就可以轻轻松松实现跨进程数据传递。实际上Messenger是一种轻量级的IPC(跨进程通信)方式,它的底层仍然是实现的AIDL。它是一种基于消息的进程通信,就像子线程和UI线程发送消息那样,Demo中服务端和客户端使用的Handler,正好说明了这一点。

 

二、Messenger使用代码示例

       话不多说,咱们这里看看一个完整的Demo,来直观感受一下Messenger的使用。本Demo演示的功能很简单,客户端发送消息给服务端,服务端收到消息后再发送消息给客户端作为响应。

  1、服务端代码实现

 1 public class MessengerService extends Service {
 2     private static final String TAG = "Messenger-Demo";
 3     private static final int MSG_CLIENT = 0x001;
 4     private static final int MSG_SERVER = 0X002;
 5     private static final String KEY_CLIENT = "key_client";
 6     private static final String KEY_SERVER = "key_server";
 7 
 8     private final Messenger mMessenger = new Messenger(new MessageHandler());
 9 
10     @Nullable
11     @Override
12     public IBinder onBind(Intent intent) {
13         return mMessenger.getBinder();
14     }
15 
16     private static class MessageHandler extends Handler {
17         @Override
18         public void handleMessage(Message msg) {
19             switch (msg.what) {
20                 case MSG_CLIENT:
21                     Log.d(TAG, "receive msg from Client:" + msg.getData().getString(KEY_CLIENT));
22                     Messenger messenger = msg.replyTo;
23                     Message serverMsg = Message.obtain();
24                     serverMsg.what = MSG_SERVER;
25                     Bundle bundle = new Bundle();
26                     bundle.putString(KEY_SERVER, "Hello Client! I am fine, thank you");
27                     serverMsg.setData(bundle);
28                     try {
29                         messenger.send(serverMsg);
30                     } catch (RemoteException e) {
31                         e.printStackTrace();
32                     }
33                     break;
34                 default:
35                     super.handleMessage(msg);
36             }
37         }
38     }
39 }

       对应清单文件中的注册

1 <service
2     android:name=".MessengerService "
3     android:exported="true"/>

这里需要注意的是第三行,该Service需要提供给其它应用调用,需要将该属性值设置为true。

  2、客户端代码实现

 1 public class MessengerClientActivity extends AppCompatActivity {
 2 
 3     private static final String TAG = "Messenger-Demo";
 4     private static final int MSG_CLIENT = 0x001;
 5     private static final int MSG_SERVER = 0X002;
 6     private static final String KEY_CLIENT = "key_client";
 7     private static final String KEY_SERVER = "key_server";
 8     private static final String SERVER_PKGNAME = "com.example.messageserver";
 9     private static final String SERVICE_PATH = "com.example.messageserver.MessengerService";
10     private Messenger mRemoteMessenger;
11     private Messenger mLocalMessenger = new Messenger(new MessengerClientHandler());
12 
13     @Override
14     protected void onCreate(Bundle savedInstanceState) {
15         super.onCreate(savedInstanceState);
16         setContentView(R.layout.activity_main);
17         Log.d(TAG,"onCreate");
18         bindService();
19     }
20 
21     private void bindService() {
22         Intent intent = new Intent();
23         ComponentName componentName = new ComponentName(SERVER_PKGNAME, SERVICE_PATH);
24         intent.setComponent(componentName);
25         bindService(intent, mServiceConnection, Context.BIND_AUTO_CREATE);
26     }
27 
28     private static class MessengerClientHandler extends Handler {
29         @Override
30         public void handleMessage(Message msg) {
31             switch (msg.what) {
32                 case MSG_SERVER:
33                     Log.d(TAG, "receive msg from Server:" + msg.getData().getString(KEY_SERVER));
34                     break;
35                 default:
36                     break;
37             }
38             super.handleMessage(msg);
39         }
40     }
41 
42     private ServiceConnection mServiceConnection = new ServiceConnection() {
43         @Override
44         public void onServiceConnected(ComponentName name, IBinder service) {
45             mRemoteMessenger = new Messenger(service);
46             Message clientMsg = Message.obtain();
47             clientMsg.what = MSG_CLIENT;
48             Bundle bundle = new Bundle();
49             bundle.putString(KEY_CLIENT, "Hello,Server! How are you ?");
50             clientMsg.setData(bundle);
51             clientMsg.replyTo = mLocalMessenger;
52             try {
53                 mRemoteMessenger.send(clientMsg);
54             } catch (RemoteException e) {
55                 e.printStackTrace();
56             }
57         }
58 
59         @Override
60         public void onServiceDisconnected(ComponentName name) {
61 
62         }
63     };
64 
65     @Override
66     protected void onDestroy() {
67         super.onDestroy();
68         unbindService(mServiceConnection);
69     }
70 }

  3、运行

       运行时先启动服务端,再启动客户端,可以看到如下log信息:

1 15185-15185/com.example.messageserver D/Messenger-Demo: receive msg from Client:Hello,Server! How are you ?
2 14269-14269/com.example.messageclient D/Messenger-Demo: receive msg from Server:Hello Client! I am fine, thank you

 这样客户端和服务端就完成了一次互相通信。从代码上来看,就能感受到,相比于直接使用AIDL方式,Messenger简洁方便了很多。

 

三、Messenger的使用步骤流程图

       通过前面的Demo直观感受了Messenger的使用,其交互流程大致为以下六步:

 

 

       对照Demo和上图,应该能够轻松理解Messenger的交互流程了。这里需要注意的是,实际上给Server端的Handler发送消息的Messenger,是结合服务端返回的IBinder实例来生成的服务端远程代理;给客户端Handler发送消息的Messenger也是第4步中发送给服务端的客户端本地Messenger, 可以理解为是自己的Messenger给自己的Handler在发送消息。

 

四、Messenger和AIDL的联系与区别

       前面我们说过Messager的底层还是实现的AIDL,这是它们的联系。它们的区别是:

    (1)Messenger使用起来比AIDL简洁方便。

    (2)AIDL的客户端接口会同时向服务端发送多个请求,服务端需要应用多线程处理。而Messenger会将所有请求排入队列(Handler对应的MessageQueue),让服务器一次处理一个调用,不用处理多线程问题。大多数情况下,服务端不需要执行多线程处理此时选择Messenger方式更合适,而如果客户端的请求要求服务端执行多线程处理,就应该使用AIDL来实现,选择哪一种,还是需要根据实际情况来选择。

 

五、Messenger源码分析

       到这里,就讲完了Messenger的基本使用方法,以及基本知识,但我们仍然需要分析源码来更深入理解Messenger,不能仅停留在应用的层面。下面我们大致按照按照第4点中的“客户端和服务端交互流程图”中的步骤,来分析一下源码。

 

  1、Server端Messenger的创建以及onBinder回调方法返回值流程分析

       当Client端通过bindService和Server端bind时,会回调用MessengerService中的onBind方法,并返回一个IBinder对象。

1 //============MessengerService.java===========
2 private final Messenger mMessenger = new Messenger(new MessageHandler());
3 public IBinder onBind(Intent intent) {
4     return mMessenger.getBinder();
5 }

第4行的mMessenger变量,它在第2行中创建,我们跟进到源码中看一下它的构造方法:

 1 //=============Messenger.java============
 2 private final IMessenger mTarget;
 3 /**
 4  * Create a new Messenger pointing to the given Handler.  Any Message
 5  * objects sent through this Messenger will appear in the Handler as if
 6  * {@link Handler#sendMessage(Message) Handler.sendMessage(Message)} had
 7  * been called directly.
 8  * 
 9  * @param target The Handler that will receive sent messages.
10  */
11 public Messenger(Handler target) {
12     mTarget = target.getIMessenger();
13 }
14 
15 //==============Handler.java===========
16 final IMessenger getIMessenger() {
17     synchronized (mQueue) {
18         if (mMessenger != null) {
19             return mMessenger;
20         }
21         mMessenger = new MessengerImpl();
22         return mMessenger;
23     }
24 }
25 ......
26 private final class MessengerImpl extends IMessenger.Stub {
27     public void send(Message msg) {
28         msg.sendingUid = Binder.getCallingUid();
29         Handler.this.sendMessage(msg);
30     }
31 }

        第3~10行的注释对理解Messenger很有用,这里简单翻译一下:创建一个新的指向给定Handler(也就是MessengerService类中的自定义的MessengerHandler)的Messenger。当Handler.sendMessage(Message)被直接调用时,任何通过该Messenger发送的Message对象都会出现在这个Handler(即MessengerHandler)中。参数是Handler 类型的targe,它将接收发送来的message。

       通过上面的源码跟踪,可以发现,这里创建的Messenger,即mMessenger变量,实际上就是MessengerImpl对象。它继承自IMessenger.Stub,看到这里,我们就能够很容易联想到AIDL了,通过AIDL的方式,Service端回调的onBind方法,返回的自定义Binder就是就是这样写的。如果有编译过AIDL项目,跟进Stub后可以看到如下内容:

1 public static abstract class Stub extends android.os.Binder implements xxx
2 //============Binder.java============
3 public class Binder implements IBinder {...}

Stub继承自android.os.Binder,可见MessengerImpl实际上也是一个Binder对象,而Binder是IBinder的实现类。现在我们就搞清楚了在创建Messenger对象时所创建的mTarget,实际上就是一个Binder。(这里讲到的AIDL相关的内容,可以参照文章开头处提到的文章,里面有讲到AIDL编译后生成的内容)。

       再看mMessenger调用的getBinder()方法。

 1 //=============MessengerService.java=========
 2 
 3 public IBinder onBind(Intent intent) {
 4     return mMessenger.getBinder();
 5 }
 6 
 7 //============Messenger.java=============
 8 /**
 9  * Retrieve the IBinder that this Messenger is using to communicate with
10  * its associated Handler.
11  * 
12  * @return Returns the IBinder backing this Messenger.
13  */
14 public IBinder getBinder() {
15     return mTarget.asBinder();
16 }

 第7~13行注释有说明:该方法用于获取IBinder,当前Messenger(即mMessenger)正在用这个IBinder和与自己关联的Handler进行通信。这里仍然需要借助aidl生成的java接口文件中的内容(下面这个Stub在前面提到过)来理解:

1 public static abstract class Stub extends android.os.Binder implements xxx {
2       ......
3       @Override
4         public android.os.IBinder asBinder() {
5             return this;
6         }
7       ......
8 }

通过前面的分析,我们已经知道了继承链:MessengerImpl extends IMessenger.Stub extends android.os.Binder implements IBinder。而mTarget是MessengerImpl的实例,我们可以得知,mTarget.asBinder()返回的就是MessengerImpl对象(这里不太确定这个结论是否正确,但返回的是Stub对象是显而易见的)。这里再次对比AIDL实现方式中onBind方法的返回形式,其常见写法是:return new MyBinder(),这里的MyBinder extends Stub,这样一对比,就和AIDL不谋而合了。

        到这里,就分析完了Server端创建Messenger,以及回调onBinder方法的返回值源码流程。

 

  2、Client端远程Messenger的创建

        MessengerClientActivity类的第45行,bindService成功后,会创建一个用于和Server端发送消息的远程Messenger:

//======================MessengerClientActivity.java==================
1
public void onServiceConnected(ComponentName name, IBinder service) { 2 mRemoteMessenger = new Messenger(service); 3 ...... 4 }

这里我们又看到了另外一种创建Messenger的方式,我们看看源码:

//=====================Messenger.java=================
1
/** 2 * Create a Messenger from a raw IBinder, which had previously been 3 * retrieved with {@link #getBinder}. 4 * 5 * @param target The IBinder this Messenger should communicate with. 6 */ 7 public Messenger(IBinder target) { 8 mTarget = IMessenger.Stub.asInterface(target); 9 }

我们仍然先翻译一下注释:从一个原始的IBinder创建一个Messenger,该IBinder之前通过getBinder方法来获取得到。参数为IBinder类型,当前Messenger应该和这个IBinder进行通信。当我们看到第8行的时候,是不是又仿佛看到了AIDL中客户端创建服务端代理类呢?

       结合上述代码的分析,已经很明确地验证了第二节中说的,Messenger的底层仍然是AIDL!

 

  3、Client端向Server端发送消息

        在MessengerClientActivity类的第53行,也就是下面的第7行,就是远程Messenger向服务端发送消息。

//===============MessengerClientActivity.java=============
1
@Override 2 public void onServiceConnected(ComponentName name, IBinder service) { 3 mRemoteMessenger = new Messenger(service); 4 Message clientMsg = Message.obtain(); 5 ...... 6 try { 7 mRemoteMessenger.send(clientMsg); 8 } catch (RemoteException e) { 9 e.printStackTrace(); 10 } 11 }

我们查看send的源码:

 1 //============Messenger.java===========
 2 /**
 3  * Send a Message to this Messenger\'s Handler.
 4  * 
 5  * @param message The Message to send.  Usually retrieved through
 6  * {@link Message#obtain() Message.obtain()}.
 7  * 
 8  * @throws RemoteException Throws DeadObjectException if the target
 9  * Handler no longer exists.
10  */
11 public void send(Message message) throws RemoteException {
12     mTarget.send(message);
13 }
14 
15 //=============Handler.java============
16 private final class MessengerImpl extends IMessenger.Stub {
17     public void send(Message msg) {
18         msg.sendingUid = Binder.getCallingUid();
19         Handler.this.sendMessage(msg);
20     }
21 }

我们仍然先简单看看注释:发送Message给该Messenger的Handler(该Messenger来自于Server端,所以这里的Handler也就是Server端自定义那个Handler)。第1点中讲过,mTarget就是MessengerImpl的实例,所以第12行就是执行的第17行。第19行我们再熟悉不过了,Handler发送Message,所以我们这里就很明确了,远程Messenger的send方法,实际上就是通过Handler来发送数据的。

 

  4、Server端向Client端发送消息

       实现Server端向Client端发送数据,关键代码如下:

 1 //=======  MessengerClientActivity========
 2 private Messenger mLocalMessenger = new Messenger(new MessengerClientHandler());
 3 @Override
 4 public void onServiceConnected(ComponentName name, IBinder service) {
 5     mRemoteMessenger = new Messenger(service);
 6     Message clientMsg = Message.obtain();
 7     ......
 8     clientMsg.replyTo = mLocalMessenger;
 9     ......
10     try {
11         mRemoteMessenger.send(clientMsg);
12     } catch (RemoteException e) {
13         e.printStackTrace();
14     }
15 }
16 
17 //==========AidlService========
18 Messenger messenger = msg.replyTo;
19 Message serverMsg = Message.obtain();
20 ......
21 try {
22     messenger.send(serverMsg);
23 } catch (RemoteException e) {
24     e.printStackTrace();
25 }

这里关键中的关键是第8行,和第18行。客户端需要将本地Messenger发送给Server端,也就是第8行,其源码如下:

1 //==========Message.java===========
2 public Messenger replyTo;

这里的replyTo是一个Messenger类型的,第8行就将本地Messenger装进Message中,发送到Server端了。在Server端就会接收该Messenger,如第18行中所示。这样,Server端就拿到了Client端的本地Messenger对象,然后就可以通过这个Messenger给Client端发送消息了,接收者为Client端本地Messenger关联的Handler,这样就实现了服务端向客户端发送消息。

       到这里,Messenger通信流程的源码分析就结束了。简单来说,Messenger原理就是封装了AIDL,以及使用Handler来发送消息。

 

结语

       由于笔者水平有限,文章中如果有描述不准确或者不妥当的地方,还请读者不吝赐教,非常感谢!

以上是关于朝花夕拾跨进程通信,你只知道AIDL,就OUT了的主要内容,如果未能解决你的问题,请参考以下文章

Android跨进程通信AIDL和messenger详解

Android跨进程通信AIDL和messenger详解

Android 跨进程通信-从源码分析AIDL跨进程通信实现

使用AIDL跨进程通信

Android跨进程通信AIDL服务

朝花夕拾一篇文章搞懂Android跨进程通信