本文主要介绍AsyncChannel的使用和内部原理。
一、AsyncChannel概述
AsyncChannel在Wifi的处理机制中被大量使用,但是可惜的是该工具是一个internal的方法,没有开放给第三方应用使用,但是该工具提供的思路很有用,可以被扩展到任意两个Handle间传输数据的通道。
那么AsyncChannel究竟是什么工具呢?他的内部机制又是怎么样呢?我们先来看一下AsyncChannel的官方描述:
- * <p>An asynchronous channel between two handlers.</p>
- * <p>The handlers maybe in the same process or in another process. There
- * are two protocol styles that can be used with an AysncChannel. The
- * first is a simple request/reply protocol where the server does
- * not need to know which client is issuing the request.</p>
- * <p>In a simple request/reply protocol the client/source sends requests to the
- * server/destination. And the server uses the replyToMessage methods.
- * In this usage model there is no need for the destination to
- * use the connect methods. The typical sequence of operations is:</p>
- * <p>A second usage model is where the server/destination needs to know
- * which client it's connected too. For example the server needs to
- * send unsolicited messages back to the client. Or the server keeps
- * different state for each client. In this model the server will also
- * use the connect methods. The typical sequence of operation is:</p>
* <p>An asynchronous channel between two handlers.</p>
* <p>The handlers maybe in the same process or in another process. There
* are two protocol styles that can be used with an AysncChannel. The
* first is a simple request/reply protocol where the server does
* not need to know which client is issuing the request.</p>
* <p>In a simple request/reply protocol the client/source sends requests to the
* server/destination. And the server uses the replyToMessage methods.
* In this usage model there is no need for the destination to
* use the connect methods. The typical sequence of operations is:</p>
* <p>A second usage model is where the server/destination needs to know
* which client it's connected too. For example the server needs to
* send unsolicited messages back to the client. Or the server keeps
* different state for each client. In this model the server will also
* use the connect methods. The typical sequence of operation is:</p>
以上是AsyncChannel文件头的描述,从这三段描述中我们可以大致知道AsyncChannel的作用、特点以及用法。
1.1、作用
AsyncChannel在两个Handler间搭建了通道,可以用于消息传输。
1.2、特点
从上面第一段英文描述可以知道AsyncChannel的两个特点:
1、AsyncChannel可以作为Handler之间的通道。2、这两个Handler可以处于同一个进程,也可以不再同一个进程。
1.3、两种工作模式
第二段和第三段英文分别描述了AsyncChannel的两种工作模式:
1、单项通道模式,在该模式下,客户端只能向服务端发起请求,服务端给出回应。2、双向通道模式,在该模式下,客户端和服务端同时连接上AsyncChannel,客户端可以向服务端发送请求,服务端也可以向客户端发送请求。
下面我们分别来介绍这两种模式的使用方法。
二、AsyncChannel通道使用方法
为了进行测试,我搭建了一个Demo程序用于测试相关功能,源码可以这里下载。由于AsyncChannel是internal的工具,因此该Demo必须要在ROM源码环境下编译并具备系统签名。
在这个Demo中,只有三个文件:MainActivity、AsyncChannelClient、AsyncChannelService、AsyncChannelServiceFull四个文件,其作用分别是:MainActivity
----负责界面搭建,里面包含:“初始化客户端和服务端并依次建立单向通道和双向通道”、“初始化客户端和服务端并直接建立双向通道”、“发送异步信息”、“发送同步信息”等四个按钮。
AsyncChannelClient
----作为客户端,向服务端发送请求。
AsyncChannelService
----作为服务端,接受客户端请求。
AsyncChannelServiceFull
----作为服务端,用于接受快速双向通道的请求。
下面来看AsyncChannel的具体使用。
2.1、单向通道建立方法
在这个Demo中,当点击“初始化客户端和服务端并依次建立单向通道和双向通道”后,就会先后启动服务端和客户端,当客户端的Server启动(onStartCommand)时,就会与服务端建立单项通道。
我们先来看点击动作的处理:- @MainActivity.java
- public void onClick(View view) {
- switch (view.getId()) {
- case R.id.start_service_btn: {
- // 启动客户端和服务端
- Intent intent = new Intent();
- intent.setComponent(new ComponentName(this, AsyncChannelService.class));
- startService(intent);
- Intent inte = new Intent();
- inte.setComponent(new ComponentName(this, AsyncChannelClient.class));
- //Action是"Normal"
- inte.setAction("Normal");
- startService(inte);
- break;
- }
- }
- }
@MainActivity.java
public void onClick(View view) {
switch (view.getId()) {
case R.id.start_service_btn: {
// 启动客户端和服务端
Intent intent = new Intent();
intent.setComponent(new ComponentName(this, AsyncChannelService.class));
startService(intent);
Intent inte = new Intent();
inte.setComponent(new ComponentName(this, AsyncChannelClient.class));
//Action是"Normal"
inte.setAction("Normal");
startService(inte);
break;
}
}
}
然后我们来看客户端的 初始化流程:
- @AsyncChannelClient.java
- public static AsyncChannel sClientAsyncChannel;
- public int onStartCommand(Intent intent, int flags, int startId) {
- //创建本地的Handler对象
- HandlerThread handlerThread = new HandlerThread("ClientThread");
- handlerThread.start();
- Handler clientHandler = new ClientHandler(handlerThread.getLooper());
- //创建客户端的AsyncChannel
- sClientAsyncChannel = new AsyncChannel();
- String act = intent.getAction();
- //我们发送的Action就是"Normal"
- if ("Normal".equals(act)) {
- // 建立单向通道,获取服务端的Messenger对象
- Messenger serviceMessenger = AsyncChannelService.getServiceMessenger();
- //发起连接请求
- sClientAsyncChannel.connect(this, clientHandler, serviceMessenger);
- } else if ("Fast".equals(act)) {
- }
- return super.onStartCommand(intent, flags, startId);
- }
@AsyncChannelClient.java
public static AsyncChannel sClientAsyncChannel;
public int onStartCommand(Intent intent, int flags, int startId) {
//创建本地的Handler对象
HandlerThread handlerThread = new HandlerThread("ClientThread");
handlerThread.start();
Handler clientHandler = new ClientHandler(handlerThread.getLooper());
//创建客户端的AsyncChannel
sClientAsyncChannel = new AsyncChannel();
String act = intent.getAction();
//我们发送的Action就是"Normal"
if ("Normal".equals(act)) {
// 建立单向通道,获取服务端的Messenger对象
Messenger serviceMessenger = AsyncChannelService.getServiceMessenger();
//发起连接请求
sClientAsyncChannel.connect(this, clientHandler, serviceMessenger);
} else if ("Fast".equals(act)) {
}
return super.onStartCommand(intent, flags, startId);
}
上面的过程中,通过客户端的getServiceMessenger()方法
拿到服务端的Messenger对象,其过程是:
- @AsyncChannelService.java
- public static Messenger getServiceMessenger() {
- //服务端需要用自己的Handler构建Messenger然后发送给客户端
- return new Messenger(mServiceHandler);
- }
@AsyncChannelService.java
public static Messenger getServiceMessenger() {
//服务端需要用自己的Handler构建Messenger然后发送给客户端
return new Messenger(mServiceHandler);
}
以上就是客户端所做的全部准备,以及发起创建通道的请求过程。从这个过程中我们看到,作为客户端,如果想要创建与服务端之间的AsyncChannel,需要做以下几个准备:
1、获取服务端的Messenger对象,该对象其实就是利用服务端的Handler构建的Messenger;
2、创建客户端自己的Handler对象;
3、创建AsyncChannel对象;
4、通过AsyncChannel对象,连接当前的Handler和服务端的Messenger,从而申请连接。
当客户端发送完connect()请求之后,客户端需要做的就是在Handler对象中等待Message消息:
- @AsyncChannelClient.java
- public void handleMessage(Message message) {
- switch (message.what) {
- case AsyncChannel.CMD_CHANNEL_HALF_CONNECTED: {
- if (msg.arg1 == AsyncChannel.STATUS_SUCCESSFUL) {
- Log.d(tag, "Service half connected");
- }
- break;
- }
- }
- }
@AsyncChannelClient.java
public void handleMessage(Message message) {
switch (message.what) {
case AsyncChannel.CMD_CHANNEL_HALF_CONNECTED: {
if (msg.arg1 == AsyncChannel.STATUS_SUCCESSFUL) {
Log.d(tag, "Service half connected");
}
break;
}
}
}
当客户端接收到AsyncChannel.CMD_CHANNEL_HALF_CONNECTED消息后,说明当前的单项通道建立成功。此时的客户端可以通过sAsyncChannel的sendMessage()方法向服务端发送消息了。
以上就是单项通道的建立过程,整个过程不需要服务端做任何操作。
2.2、双向通道建立方法
那么如果客户端想要创建双向通道,该如何操作呢?
首先,服务端本身需要初始化Handler,并且如果服务端准备提供双向通道,那么就需要创建自己的AsyncChannel对象。这些工作需要在客户端初始化时完成:- @AsyncChannelService.java
- public int onStartCommand(Intent intent, int flags, int startId) {
- //初始化Handler
- HandlerThread handlerThread = new HandlerThread("ServiceThread");
- handlerThread.start();
- mServiceHandler = new ServiceHandler(handlerThread.getLooper());
- //创建AsyncChannel对象
- sServiceAsyncChannel = new AsyncChannel();
- return super.onStartCommand(intent, flags, startId);
- }
@AsyncChannelService.java
public int onStartCommand(Intent intent, int flags, int startId) {
//初始化Handler
HandlerThread handlerThread = new HandlerThread("ServiceThread");
handlerThread.start();
mServiceHandler = new ServiceHandler(handlerThread.getLooper());
//创建AsyncChannel对象
sServiceAsyncChannel = new AsyncChannel();
return super.onStartCommand(intent, flags, startId);
}
其实
双向通道是在单项通道基础上完成的,当客户端与服务端的单项通道创建完成后,也就是
当客户端收到AsyncChannel.CMD_CHANNEL_HALF_CONNECTED之后,可以向AsyncChannel对象发送CMD_CHANNEL_FULL_CONNECTION消息申请建立双向通道。
也就是在刚才接收到的消息基础上,发送CMD_CHANNEL_FULL_CONNECTION请求即可:
- @AsyncChannelClient.java
- public void handleMessage(Message message) {
- switch (message.what) {
- case AsyncChannel.CMD_CHANNEL_HALF_CONNECTED:
- if (message.arg1 == AsyncChannel.STATUS_SUCCESSFUL) {
- //客户端单项通道建立完成,继续申请双向通道
- sClientAsyncChannel.sendMessage(AsyncChannel.CMD_CHANNEL_FULL_CONNECTION);
- }
- break;
- }
- }
@AsyncChannelClient.java
public void handleMessage(Message message) {
switch (message.what) {
case AsyncChannel.CMD_CHANNEL_HALF_CONNECTED:
if (message.arg1 == AsyncChannel.STATUS_SUCCESSFUL) {
//客户端单项通道建立完成,继续申请双向通道
sClientAsyncChannel.sendMessage(AsyncChannel.CMD_CHANNEL_FULL_CONNECTION);
}
break;
}
}
此时的服务端将会在Handler中接收到如下消息:
- @AsyncChannelService.java
- public void handleMessage(Message msg) {
- switch ((msg.what)) {
- case AsyncChannel.CMD_CHANNEL_FULL_CONNECTION: {
- //服务端接收到双向通道的建立请求
- //如果同意客户端建立,则需要服务端向AsyncChannel申请连接请求
- sServiceAsyncChannel.connect(AsyncChannelService.this, mServiceHandler, msg.replyTo);
- break;
- }
- }
- }
@AsyncChannelService.java
public void handleMessage(Message msg) {
switch ((msg.what)) {
case AsyncChannel.CMD_CHANNEL_FULL_CONNECTION: {
//服务端接收到双向通道的建立请求
//如果同意客户端建立,则需要服务端向AsyncChannel申请连接请求
sServiceAsyncChannel.connect(AsyncChannelService.this, mServiceHandler, msg.replyTo);
break;
}
}
}
从上面代码看到,当客户端发起双向通道建立请求时,服务端将会收到AysncChannel.CMD_CHANNEL_FULL_CONNECTION的请求,此时的服务端如果同意建立双向通道,则使用自己的AsyncChannel对象将自己的Handler与客户端的Handler连接起来。
至此,双向通道建立完成,此时不仅客户端可以通过自己的AsyncChannel对象向服务端发送请求,服务端也可以通过自己的AsyncChannel对象向客户端发送请求。
以上就是双向通道的建立过程。
2.3、更有效的双向通道建立方法
上一节中介绍了双向通道的建立方法,其实这是一种“笨方法”,为什么这么说呢?我们来看一下要创建双向通道需要经过哪些步骤:
1、客户端发起connect()请求,申请建立单向通道;2、客户端接收到CMD_CHANNEL_HALF_CONNECTED,然后继续向AsyncChannel申请双向通道;
3、服务端接收到CMD_CHANNEL_FULL_CONNECTION申请,向AsyncChannel发送连接请求;
这就需要三个步骤才可以完成双向通道建立,并且最重要的是, 客户端始终不知道服务端是否真正连接上了AsyncChannel(如果客户端想知道结果,还需要服务端再次发送一次确认消息)。
那么有没有一种方法,在客户端创建通道时就指定要创建双向通道呢?
这就用上 fullyConnectSync()方法。通过该方法,客户端只需要一次就可以申请到双向通道,并且可以知道通道是否建立成功。
下面来看代码实现,当点击界面上“初始化客户端与服务端并快速建立双向通道”按钮后,将会触发客户端双向通道的申请:
- @MainActivity.java
- public void onClick(View view) {
- switch (view.getId()) {
- case R.id.start_service_fast_connect_btn: {
- Intent intent = new Intent();
- intent.setComponent(new ComponentName(this, AsyncChannelServiceFull.class));
- startService(intent);
- Intent inte = new Intent();
- inte.setComponent(new ComponentName(this, AsyncChannelClient.class));
- inte.setAction("Fast");
- startService(inte);
- break;
- }
- }
- }
@MainActivity.java
public void onClick(View view) {
switch (view.getId()) {
case R.id.start_service_fast_connect_btn: {
Intent intent = new Intent();
intent.setComponent(new ComponentName(this, AsyncChannelServiceFull.class));
startService(intent);
Intent inte = new Intent();
inte.setComponent(new ComponentName(this, AsyncChannelClient.class));
inte.setAction("Fast");
startService(inte);
break;
}
}
}
此时将会先后启动AsyncChannelServiceFull和AsyncChannelClient服务,并且发送的Action为“Fast”。
我们先来看AsyncChannelServiceFull服务的初始化流程:
- @AsyncChannelServiceFull.java
- public int onStartCommand(Intent intent, int flags, int startId) {
- //初始化Handler对象
- HandlerThread handlerThread = new HandlerThread("ServiceThread");
- handlerThread.start();
- mServiceHandler = new ServiceHandler(handlerThread.getLooper());
- //创建AsyncChannel对象
- sServiceAsyncChannel = new AsyncChannel();
- return super.onStartCommand(intent, flags, startId);
- }
@AsyncChannelServiceFull.java
public int onStartCommand(Intent intent, int flags, int startId) {
//初始化Handler对象
HandlerThread handlerThread = new HandlerThread("ServiceThread");
handlerThread.start();
mServiceHandler = new ServiceHandler(handlerThread.getLooper());
//创建AsyncChannel对象
sServiceAsyncChannel = new AsyncChannel();
return super.onStartCommand(intent, flags, startId);
}
然后来看AsyncChannelClient的操作:
- @AsyncChannelClient.java
- public int onStartCommand(Intent intent, int flags, int startId) {
- //初始化Handler对象
- HandlerThread handlerThread = new HandlerThread("ClientThread");
- handlerThread.start();
- Handler clientHandler = new ClientHandler(handlerThread.getLooper());
- //创建AsyncChannel对象
- sClientAsyncChannel = new AsyncChannel();
- String act = intent.getAction();
- if ("Normal".equals(act)) {
- } else if ("Fast".equals(act)) {//此时的Action是"Fast"
- // 要求直接双向通道
- Handler serviceHandler = AsyncChannelServiceFull.getServiceHandler();
- int result = sClientAsyncChannel.fullyConnectSync(this, clientHandler, serviceHandler);
- if (AsyncChannel.STATUS_SUCCESSFUL == result) {
- Log.d(tag, "client full connected");
- }
- }
- return super.onStartCommand(intent, flags, startId);
- }
@AsyncChannelClient.java
public int onStartCommand(Intent intent, int flags, int startId) {
//初始化Handler对象
HandlerThread handlerThread = new HandlerThread("ClientThread");
handlerThread.start();
Handler clientHandler = new ClientHandler(handlerThread.getLooper());
//创建AsyncChannel对象
sClientAsyncChannel = new AsyncChannel();
String act = intent.getAction();
if ("Normal".equals(act)) {
} else if ("Fast".equals(act)) {//此时的Action是"Fast"
// 要求直接双向通道
Handler serviceHandler = AsyncChannelServiceFull.getServiceHandler();
int result = sClientAsyncChannel.fullyConnectSync(this, clientHandler, serviceHandler);
if (AsyncChannel.STATUS_SUCCESSFUL == result) {
Log.d(tag, "client full connected");
}
}
return super.onStartCommand(intent, flags, startId);
}
这与单项通道的建立操作几乎完全一样,唯一不同的地方有三个:
1、客户端不再使用connect()方法连接AsyncChannel,而是使用fullyConnectSync()方法建立双向通道;
2、调用fullyConnectSync()建立通道时,使用的是服务端的Handler对象(serviceHandler)而不是Messenger对象;
3、调用fullyConnectSync()建立通道时,此方法有个返回值,可以明确知道通道是否建立成功;
接下来我们看此时的服务端的流程。
当客户端通过fullyConnectSync()申请双向通道时,服务端就可以收到CMD_CHANNEL_FULL_CONNECTION的消息,然后服务端需要连接上AsyncChannel后回复成功的命令即可完成通道的建立:
- @AsyncChannelServiceFull.java
- public void handleMessage(Message msg) {
- switch (msg.what) {
- case AsyncChannel.CMD_CHANNEL_FULL_CONNECTION: {
- //收到双向通道建立请求,如果服务端同意,则需要连接上AsyncChannel,然后恢复STATUS_SUCCESSFUL即可
- sServiceAsyncChannel.connect(AsyncChannelServiceFull.this, mServiceHandler, msg.replyTo);
- //将建立结果传递给客户端
- sServiceAsyncChannel.replyToMessage(msg, AsyncChannel.CMD_CHANNEL_FULLY_CONNECTED, AsyncChannel.STATUS_SUCCESSFUL);
- break;
- }
- }
- }
@AsyncChannelServiceFull.java
public void handleMessage(Message msg) {
switch (msg.what) {
case AsyncChannel.CMD_CHANNEL_FULL_CONNECTION: {
//收到双向通道建立请求,如果服务端同意,则需要连接上AsyncChannel,然后恢复STATUS_SUCCESSFUL即可
sServiceAsyncChannel.connect(AsyncChannelServiceFull.this, mServiceHandler, msg.replyTo);
//将建立结果传递给客户端
sServiceAsyncChannel.replyToMessage(msg, AsyncChannel.CMD_CHANNEL_FULLY_CONNECTED, AsyncChannel.STATUS_SUCCESSFUL);
break;
}
}
}
经过上面服务端的操作,客户端就在fullyConnectSync()返回值中获取到通道建立成功的消息,至此双向通道建立完毕。
从这个过程中我们看到该方式更加方便和有效, 他省掉了客户端CMD_CHANNEL_HALF_CONNECTED的请求过程,而且客户端可以知道通道的建立结果。这也是官方推荐的做法。
以上就是快速双向通道的建立过程。
三、消息的使用
我们建立通道的最终目的是为了在两个Handler间传输信息,而消息又分为两类:异步消息和同步消息,接下来分别介绍这两种消息的使用方法。
3.1、异步消息使用方法
所谓异步消息,就是客户端(或服务端)发送消息之后在Handler中等待回应,而不是立刻拿到消息结果。无论是客户端或者是双向通道中的服务端,都可以通过自己的AsyncChannel对象向对方发送异步消息。
在该Demo中,当点击界面上的“发送异步信息”按钮时,就会在客户端中向服务端发送一个MainActivity.MSG_ASYNC_REQ的请求,接下来在Server端的handleMessage中就能收到该请求,我们在Server收到该请求后,创建一个MSG_SYNC_REPLY的消息,并在其中放入一个字串“ServiceAsyncReply”返回给客户端,接下来客户端就可以在自己的handleMessage中检测到该回应,最终我们在客户端的handleMessage中把该字串打印出来。接下来看具体的代码:
当点击“客户端发送异步消息”的按钮时,进入客户端的sendMsgToService()方法中:
- @AsyncChannelClient.java
- public static void sendMsgToService() {
- // 客户端用AsyncChannel给服务端发送MSG_ASYNC_REQ的请求
- sClientAsyncChannel.sendMessage(MainActivity.MSG_ASYNC_REQ);
- }
@AsyncChannelClient.java
public static void sendMsgToService() {
// 客户端用AsyncChannel给服务端发送MSG_ASYNC_REQ的请求
sClientAsyncChannel.sendMessage(MainActivity.MSG_ASYNC_REQ);
}
接下来就会在服务端的handleMessage中接收到该请求:
- @AsyncChannelService.java
- public void handleMessage(Message msg) {
- switch (msg.what) {
- case MainActivity.MSG_ASYNC_REQ: {
- //接收到客户端请求
- Message reply = msg.obtain();
- reply.what = MainActivity.MSG_ASYNC_REPLY;
- reply.obj = "ServiceAsyncReply";
- try {
- //给客户端发送回应,回应的内容中what=MSG_ASYNC_REPLY,obj="ServiceAsyncReply"
- msg.replyTo.send(reply);
- } catch (RemoteException e) {
- }
- break;
- }
- }
@AsyncChannelService.java
public void handleMessage(Message msg) {
switch (msg.what) {
case MainActivity.MSG_ASYNC_REQ: {
//接收到客户端请求
Message reply = msg.obtain();
reply.what = MainActivity.MSG_ASYNC_REPLY;
reply.obj = "ServiceAsyncReply";
try {
//给客户端发送回应,回应的内容中what=MSG_ASYNC_REPLY,obj="ServiceAsyncReply"
msg.replyTo.send(reply);
} catch (RemoteException e) {
}
break;
}
}
然后客户端就会收到MSG_ASYNC_REPLY的回应:
- @AsyncChannelClient.java
- public void handleMessage(Message message) {
- switch (message.what) {
- case MainActivity.MSG_ASYNC_REPLY: {
- //收到服务端回应,并将服务端放入的字串打印出来,异步消息结束
- String msg = (String) message.obj;
- Log.d(tag, "get service async reply msg = " + msg);
- break;
- }
- }
- }
@AsyncChannelClient.java
public void handleMessage(Message message) {
switch (message.what) {
case MainActivity.MSG_ASYNC_REPLY: {
//收到服务端回应,并将服务端放入的字串打印出来,异步消息结束
String msg = (String) message.obj;
Log.d(tag, "get service async reply msg = " + msg);
break;
}
}
}
至此就完成了整个异步消息的调用。
3.2、同步消息使用方法
从上面的异步消息看到,无论是客户端发送消息还是服务端返回消息,都是异步的,都需要在发送完毕后被动等待消息结果,而同步消息就是客户端(或服务端)发送消息之后可以直接拿到返回值。
接下来我们通过Demo来演示同步消息的使用方法。在该Demo中,当点击“发送同步信息”按钮后,客户端将会给服务端发送一个“MSG_SYNC_REQ”的同步消息,然后等待返回值,此时的Server端将会收到该消息,等服务端处理完毕后通过replyToMessage()返回后,客户端就收到了返回值,整个过程对于客户端来说,是同步的,也就是说调用后立刻拿到了消息回应。
我们先来看客户端发送同步信息的方式:
- @AsyncChannelClient.java
- public static void sendSyncMsgToService() {
- Message replyMsg = sClientAsyncChannel.sendMessageSynchronously(MainActivity.MSG_SYNC_REQ);
- String msg = (String) replyMsg.obj;
- Log.d(tag, "get service sync reply msg = " + msg);
- }
@AsyncChannelClient.java
public static void sendSyncMsgToService() {
Message replyMsg = sClientAsyncChannel.sendMessageSynchronously(MainActivity.MSG_SYNC_REQ);
String msg = (String) replyMsg.obj;
Log.d(tag, "get service sync reply msg = " + msg);
}
从这里的发送过程就可以看出,对于发送端来说,“好像”发送完请求后,立刻得到了消息。当调用AsyncChannel的sendMessageSynchronously()方法后,服务端将会接收到该消息,并进行消息处理:
- @AsyncChannelService.java
- public void handleMessage(Message msg) {
- switch (msg.what) {
- case MainActivity.MSG_SYNC_REQ: {
- //服务端接收到同步消息请求
- Message reply = msg.obtain();
- reply.what = MainActivity.MSG_SYNC_REPLY;
- reply.obj = "ServiceSyncReply";
- //将返回值发送给客户端
- sServiceAsyncChannel.replyToMessage(msg, reply);
- break;
- }
- }
- }
@AsyncChannelService.java
public void handleMessage(Message msg) {
switch (msg.what) {
case MainActivity.MSG_SYNC_REQ: {
//服务端接收到同步消息请求
Message reply = msg.obtain();
reply.what = MainActivity.MSG_SYNC_REPLY;
reply.obj = "ServiceSyncReply";
//将返回值发送给客户端
sServiceAsyncChannel.replyToMessage(msg, reply);
break;
}
}
}
从服务端消息处理可以看到,服务端接收到MSG_SYNC_REQ请求后,包装了一个reply的Message对象,然后通过服务端的AsyncChannel对象将该消息返回给消息的发送者。然后客户端就收到了服务端的回应。
这就是同步消息的使用方法。
四、AsyncChannel通道的内部机制
以上通过Demo介绍了AsyncChannel的使用方法,接下来我们介绍AsyncChannel的内部原理。
4.1、单向通道的建立过程
从前面介绍的通道使用方法来看,第一种双向通道是在单向通道基础上搭建的,我们先来看单项通道的建立过程。
从通道的建立方法可以知道,创建通道需要三个步骤:1、准备服务端的Messenger对象;
2、创建本地的Handler对象;
3、创建AsyncChannel对象,然后调用connect()方法。
其中前两个条件容易满足,下面我们主要分析AsyncChannel的创建过程和connect()方法。
我们先来看一下AsyncChannel的属性:
public class AsyncChannel {}
发现他没有父类,然后看他的构造方法:
@AsyncChannel.java
public AsyncChannel() {
}
构造方法里面也没有任何操作。然后来看connect()方法:
- public void connect(Context srcContext, Handler srcHandler, Messenger dstMessenger) {
- connected(srcContext, srcHandler, dstMessenger);
- replyHalfConnected(STATUS_SUCCESSFUL);
- }
public void connect(Context srcContext, Handler srcHandler, Messenger dstMessenger) {
connected(srcContext, srcHandler, dstMessenger);
replyHalfConnected(STATUS_SUCCESSFUL);
}
这里面有两个调用,我们先来看第一个connected()方法:
- public void connected(Context srcContext, Handler srcHandler, Messenger dstMessenger) {
- //初始化一些变量
- mSrcContext = srcContext;
- mSrcHandler = srcHandler;
- mSrcMessenger = new Messenger(mSrcHandler);
- mDstMessenger = dstMessenger;
- }
public void connected(Context srcContext, Handler srcHandler, Messenger dstMessenger) {
//初始化一些变量
mSrcContext = srcContext;
mSrcHandler = srcHandler;
mSrcMessenger = new Messenger(mSrcHandler);
mDstMessenger = dstMessenger;
}
在这里只是初始化一些变量,我们记得在使用AsyncChannel时,传递了本地的Handler对象和目标的Messenger对象,在这里用本地的Handler对象创建Messenger对象,也就是说,
在AsyncChannel中,拥有了本地和远端的Messenger对象,分别标记mSrcMessenger和mDeathMonitor。
然后我们接着看connect()中的第二个方法:
- private void replyHalfConnected(int status) {
- //准备CMD_CHANNEL_HALF_CONNECTED消息
- Message msg = mSrcHandler.obtainMessage(CMD_CHANNEL_HALF_CONNECTED);
- msg.arg1 = status;
- msg.obj = this;
- msg.replyTo = mDstMessenger;
- if (mConnection == null) {
- mDeathMonitor = new DeathMonitor();
- try {
- //监听远端的服务是否死掉
- mDstMessenger.getBinder().linkToDeath(mDeathMonitor, 0);
- } catch (RemoteException e) {
- mDeathMonitor = null;
- msg.arg1 = STATUS_BINDING_UNSUCCESSFUL;
- }
- }
- //将CMD_CHANNEL_HALF_CONNECTED发送给本地,也就是客户端
- mSrcHandler.sendMessage(msg);
- }
private void replyHalfConnected(int status) {
//准备CMD_CHANNEL_HALF_CONNECTED消息
Message msg = mSrcHandler.obtainMessage(CMD_CHANNEL_HALF_CONNECTED);
msg.arg1 = status;
msg.obj = this;
msg.replyTo = mDstMessenger;
if (mConnection == null) {
mDeathMonitor = new DeathMonitor();
try {
//监听远端的服务是否死掉
mDstMessenger.getBinder().linkToDeath(mDeathMonitor, 0);
} catch (RemoteException e) {
mDeathMonitor = null;
msg.arg1 = STATUS_BINDING_UNSUCCESSFUL;
}
}
//将CMD_CHANNEL_HALF_CONNECTED发送给本地,也就是客户端
mSrcHandler.sendMessage(msg);
}
在这里主要完成了一件事情,也就是
向客户端发送CMD_CHANNEL_HALF_CONNECTED的消息。
然后AsyncChannel的connect()就调用结束,他的调用过程可以分为两步:
1、初始化AsyncChannel中的本地和远程的Messenger对象;
2、向本地(也就是客户端)发送CMD_CHANNEL_HALF_CONNECTED的消息;
至此,单项通道建立完毕。
该流程可以用如下图来描述:
4.2、双向通道的建立过程
下面介绍双向通道的建立过程。前面的使用方法中我们知道,双向通道的建立需要在客户端收到CMD_CHANNEL_HALF_CONNECTED消息后向AsyncChannel对象发送CMD_CHANNEL_FULL_CONNECTION消息完成的,也就是如下的入口:
- public void handleMessage(Message message) {
- switch (message.what) {
- case AsyncChannel.CMD_CHANNEL_HALF_CONNECTED: {
- //向AsyncChannel申请双向通道
- sClientAsyncChannel.sendMessage(AsyncChannel.CMD_CHANNEL_FULL_CONNECTION);
- break;
- }
- }
- }
public void handleMessage(Message message) {
switch (message.what) {
case AsyncChannel.CMD_CHANNEL_HALF_CONNECTED: {
//向AsyncChannel申请双向通道
sClientAsyncChannel.sendMessage(AsyncChannel.CMD_CHANNEL_FULL_CONNECTION);
break;
}
}
}
接下来看AsyncChannel的sendMessage()过程:
- @AsyncChannel.java
- public void sendMessage(int what) {
- Message msg = Message.obtain();
- msg.what = what;
- sendMessage(msg);
- }
- public void sendMessage(Message msg) {
- msg.replyTo = mSrcMessenger;
- try {
- //向mDstMessenger发送消息
- mDstMessenger.send(msg);
- } catch (RemoteException e) {
- replyDisconnected(STATUS_SEND_UNSUCCESSFUL);
- }
- }
@AsyncChannel.java
public void sendMessage(int what) {
Message msg = Message.obtain();
msg.what = what;
sendMessage(msg);
}
public void sendMessage(Message msg) {
msg.replyTo = mSrcMessenger;
try {
//向mDstMessenger发送消息
mDstMessenger.send(msg);
} catch (RemoteException e) {
replyDisconnected(STATUS_SEND_UNSUCCESSFUL);
}
}
从这里看到,AsyncChannel其实只做了一件事情,就是将CMD_CHANNEL_FULL_CONNECTION的消息转发给mDstMessenger,这里的mDstMessenger就是AsyncChannel被创建时初始化的AsyncChannelService中的Handler,然后服务端就收到了CMD_CHANNEL_FULL_CONNECTION的消息。
从前面的使用方法中介绍过,当服务端收到该消息后,将会通过connect()方法将自己连接上AsyncChannel:
- @AsyncChannelService.java
- public void handleMessage(Message msg) {
- switch ((msg.what)) {
- case AsyncChannel.CMD_CHANNEL_FULL_CONNECTION: {
- //服务端接收到双向通道的建立请求
- //如果同意客户端建立,则需要服务端向AsyncChannel申请连接请求
- sServiceAsyncChannel.connect(AsyncChannelService.this, mServiceHandler, msg.replyTo);
- break;
- }
- }
- }
@AsyncChannelService.java
public void handleMessage(Message msg) {
switch ((msg.what)) {
case AsyncChannel.CMD_CHANNEL_FULL_CONNECTION: {
//服务端接收到双向通道的建立请求
//如果同意客户端建立,则需要服务端向AsyncChannel申请连接请求
sServiceAsyncChannel.connect(AsyncChannelService.this, mServiceHandler, msg.replyTo);
break;
}
}
}
然后服务端的AsyncChannel将会进入connect()中处理:
- @AsyncChannel.java
- public void connect(Context srcContext, Handler srcHandler, Messenger dstMessenger) {
- //做同样的初始化动作
- connected(srcContext, srcHandler, dstMessenger);
- //然后告诉服务端CMD_CHANNEL_HALF_CONNECTED
- replyHalfConnected(STATUS_SUCCESSFUL);
- }
@AsyncChannel.java
public void connect(Context srcContext, Handler srcHandler, Messenger dstMessenger) {
//做同样的初始化动作
connected(srcContext, srcHandler, dstMessenger);
//然后告诉服务端CMD_CHANNEL_HALF_CONNECTED
replyHalfConnected(STATUS_SUCCESSFUL);
}
这个过程与建立单向通道时客户端所做的动作完全一致,就是初始化服务端AsyncChannel中的mSrcMessenger、mSrcHandler、mDstMessenger等对象,然后向服务端自己发送CMD_CHANNEL_HALF_CONNECTED的消息。
从这个过程来看,其实双向通道的建立过程就是在客户端和服务端分别连接(connect)上自己的AsyncChannel对象的过程。
下面就是双向通道的建立流程图:
4.3、更有效的双向通道的建立过程
下面我们来看快速双向通道的建立过程。
该过程是通过客户端使用fullyConnectSync()方法来触发的:- @AsyncChannel.java
- public int fullyConnectSync(Context srcContext, Handler srcHandler, Handler dstHandler) {
- int status = connectSync(srcContext, srcHandler, dstHandler);
- if (status == STATUS_SUCCESSFUL) {
- Message response = sendMessageSynchronously(CMD_CHANNEL_FULL_CONNECTION);
- status = response.arg1;
- }
- return status;
- }
@AsyncChannel.java
public int fullyConnectSync(Context srcContext, Handler srcHandler, Handler dstHandler) {
int status = connectSync(srcContext, srcHandler, dstHandler);
if (status == STATUS_SUCCESSFUL) {
Message response = sendMessageSynchronously(CMD_CHANNEL_FULL_CONNECTION);
status = response.arg1;
}
return status;
}
这个方法内部有两个调用,一个connectSync、一个是sendMessageSynchronously,我们先来追踪第一个:
- public int connectSync(Context srcContext, Handler srcHandler, Handler dstHandler) {
- return connectSync(srcContext, srcHandler, new Messenger(dstHandler));
- }
- public int connectSync(Context srcContext, Handler srcHandler, Messenger dstMessenger) {
- connected(srcContext, srcHandler, dstMessenger);
- return STATUS_SUCCESSFUL;
- }
- public void connected(Context srcContext, Handler srcHandler, Messenger dstMessenger) {
- //初始化变量
- mSrcContext = srcContext;
- mSrcHandler = srcHandler;
- mSrcMessenger = new Messenger(mSrcHandler);
- mDstMessenger = dstMessenger;
- }
public int connectSync(Context srcContext, Handler srcHandler, Handler dstHandler) {
return connectSync(srcContext, srcHandler, new Messenger(dstHandler));
}
public int connectSync(Context srcContext, Handler srcHandler, Messenger dstMessenger) {
connected(srcContext, srcHandler, dstMessenger);
return STATUS_SUCCESSFUL;
}
public void connected(Context srcContext, Handler srcHandler, Messenger dstMessenger) {
//初始化变量
mSrcContext = srcContext;
mSrcHandler = srcHandler;
mSrcMessenger = new Messenger(mSrcHandler);
mDstMessenger = dstMessenger;
}
整个过程的结果就是调用connected()方法,这与connect()唯一不同的就是
没有发送CMD_CHANNEL_HALF_CONNECTED消息。
然后来看sendMessageSynchronously()方法,记得此时传递的消息是CMD_CHANNEL_FULL_CONNECTION:
- public Message sendMessageSynchronously(int what) {
- Message msg = Message.obtain();
- msg.what = what;
- Message resultMsg = sendMessageSynchronously(msg);
- return resultMsg;
- }
public Message sendMessageSynchronously(int what) {
Message msg = Message.obtain();
msg.what = what;
Message resultMsg = sendMessageSynchronously(msg);
return resultMsg;
}
继续:
- public Message sendMessageSynchronously(Message msg) {
- Message resultMsg = SyncMessenger.sendMessageSynchronously(mDstMessenger, msg);
- return resultMsg;
- }
public Message sendMessageSynchronously(Message msg) {
Message resultMsg = SyncMessenger.sendMessageSynchronously(mDstMessenger, msg);
return resultMsg;
}
继续:
- private static Message sendMessageSynchronously(Messenger dstMessenger, Message msg) {
- //创建SyncMessenger对象
- SyncMessenger sm = SyncMessenger.obtain();
- try {
- if (dstMessenger != null && msg != null) {
- //将SyncMessenger的Messenger放入消息包中
- msg.replyTo = sm.mMessenger;
- synchronized (sm.mHandler.mLockObject) {
- //将CMD_CHANNEL_FULL_CONNECTION发送给远端的服务
- dstMessenger.send(msg);
- //阻塞监听唤醒
- sm.mHandler.mLockObject.wait();
- }
- } else {
- sm.mHandler.mResultMsg = null;
- }
- } catch (InterruptedException e) {
- sm.mHandler.mResultMsg = null;
- } catch (RemoteException e) {
- sm.mHandler.mResultMsg = null;
- }
- Message resultMsg = sm.mHandler.mResultMsg;
- sm.recycle();
- //将结果返回给客户端
- return resultMsg;
- }
private static Message sendMessageSynchronously(Messenger dstMessenger, Message msg) {
//创建SyncMessenger对象
SyncMessenger sm = SyncMessenger.obtain();
try {
if (dstMessenger != null && msg != null) {
//将SyncMessenger的Messenger放入消息包中
msg.replyTo = sm.mMessenger;
synchronized (sm.mHandler.mLockObject) {
//将CMD_CHANNEL_FULL_CONNECTION发送给远端的服务
dstMessenger.send(msg);
//阻塞监听唤醒
sm.mHandler.mLockObject.wait();
}
} else {
sm.mHandler.mResultMsg = null;
}
} catch (InterruptedException e) {
sm.mHandler.mResultMsg = null;
} catch (RemoteException e) {
sm.mHandler.mResultMsg = null;
}
Message resultMsg = sm.mHandler.mResultMsg;
sm.recycle();
//将结果返回给客户端
return resultMsg;
}
整个过程的核心在sendMessageSynchronously中处理,该方法中创建了一个SyncMessenger的对象,这是AsyncChannel的内部静态类,
作用就是负责同步传输消息。
那么SyncMessenger是如何同步传输消息的呢?
其原理就是当向远端的服务发送消息之后,SyncMessenger就进入阻塞状态(也就是停留在wait这里),等待远程服务端的回应,当拿到返回消息之后,将会唤醒SyncMessenger,然后再将结果返回给客户端。
结合代码来看就是,在将消息发送给服务端之前,将当前SyncMessenger的Messenger对象作为replyTo存放在消息包中:
msg.replyTo = sm.mMessenger;
然后将消息发送给服务端:
dstMessenger.send(msg);
然后进入阻塞状态:
sm.mHandler.mLockObject.wait();
经过这个操作,服务端就收到CMD_CHANNEL_FULL_CONNECTION的消息,并且该消息的replyTo对象是SyncMessenger,然后我们来看该SyncMessenger的唤醒过程。
在前面我们介绍过,当服务端接收到该请求后,如果同意建立双向通道,则需要connect()之后给出OK的回应,也就是:
- @AsyncChannelServiceFull.java
- public void handleMessage(Message msg) {
- switch (msg.what) {
- case AsyncChannel.CMD_CHANNEL_FULL_CONNECTION: {
- //先连接上AsyncChannel
- sServiceAsyncChannel.connect(AsyncChannelServiceFull.this, mServiceHandler, msg.replyTo);
- //然后给出OK的回应
- sServiceAsyncChannel.replyToMessage(msg, AsyncChannel.CMD_CHANNEL_FULLY_CONNECTED, AsyncChannel.STATUS_SUCCESSFUL);
- break;
- }
- }
- }
@AsyncChannelServiceFull.java
public void handleMessage(Message msg) {
switch (msg.what) {
case AsyncChannel.CMD_CHANNEL_FULL_CONNECTION: {
//先连接上AsyncChannel
sServiceAsyncChannel.connect(AsyncChannelServiceFull.this, mServiceHandler, msg.replyTo);
//然后给出OK的回应
sServiceAsyncChannel.replyToMessage(msg, AsyncChannel.CMD_CHANNEL_FULLY_CONNECTED, AsyncChannel.STATUS_SUCCESSFUL);
break;
}
}
}
我们通过上面回应的流程来看如何唤醒SyncMessenger,记得这里最后一个参数是STATUS_SUCCESSFUL:
- @AsyncChannel.java
- public void replyToMessage(Message srcMsg, int what, int arg1) {
- Message msg = Message.obtain();
- msg.what = what;
- msg.arg1 = arg1;
- replyToMessage(srcMsg, msg);
- }
@AsyncChannel.java
public void replyToMessage(Message srcMsg, int what, int arg1) {
Message msg = Message.obtain();
msg.what = what;
msg.arg1 = arg1;
replyToMessage(srcMsg, msg);
}
继续往下走:
- public void replyToMessage(Message srcMsg, Message dstMsg) {
- try {
- dstMsg.replyTo = mSrcMessenger;
- //这里的replyTo记录的就是当初的SyncMessenger的Handler对象
- srcMsg.replyTo.send(dstMsg);
- } catch (RemoteException e) {
- log("TODO: handle replyToMessage RemoteException" + e);
- e.printStackTrace();
- }
- }
public void replyToMessage(Message srcMsg, Message dstMsg) {
try {
dstMsg.replyTo = mSrcMessenger;
//这里的replyTo记录的就是当初的SyncMessenger的Handler对象
srcMsg.replyTo.send(dstMsg);
} catch (RemoteException e) {
log("TODO: handle replyToMessage RemoteException" + e);
e.printStackTrace();
}
}
到这里我们看到,通过replyToMessage方法,把服务端的消息发送给了Message的replyTo对象,这个对象其实就是我们当初给服务端发送CMD_CHANNEL_FULL_CONNECTION消息时放入的SyncMessenger的Handler对象,因此,此时的SyncMessenger将会收到服务端的消息:
- @AsyncChannel.java
- private class SyncHandler extends Handler {
- public void handleMessage(Message msg) {
- mResultMsg = Message.obtain();
- mResultMsg.copyFrom(msg);
- synchronized(mLockObject) {
- //唤醒SyncMessenger
- mLockObject.notify();
- }
- }
- }
@AsyncChannel.java
private class SyncHandler extends Handler {
public void handleMessage(Message msg) {
mResultMsg = Message.obtain();
mResultMsg.copyFrom(msg);
synchronized(mLockObject) {
//唤醒SyncMessenger
mLockObject.notify();
}
}
}
在这里,我们终于看到将SyncMessenger唤醒的操作,当该Handler被唤醒时,
sendMessageSynchronously()方法就通过wait()方法继续往下执行,然后就将服务端的消息从SyncMessenger的Handler中取出来,最终return给客户端的fullyConnectSync()调用者。
至此,双向通道的流程结束,服务端不仅连接上了通道,而且客户端拿到了服务端STATUS_SUCCESSFUL的消息。
下面用一张图来描述这个过程:
五、消息派发的机制
消息派发的机制其实在上一节的通道建立机制中简单介绍过了,因此接下来的解释就比较容易理解了。
5.1、异步消息派发过程
我们知道,异步消息的派发是通过AsyncChannel的sendMessage()来完成的:
- @AsyncChannelClient.java
- public static void sendMsgToService() {
- sClientAsyncChannel.sendMessage(MainActivity.MSG_ASYNC_REQ);
- }
@AsyncChannelClient.java
public static void sendMsgToService() {
sClientAsyncChannel.sendMessage(MainActivity.MSG_ASYNC_REQ);
}
然后来看AsyncChannel的sendMessage方法:
- @AsyncChannel.java
- public void sendMessage(int what) {
- Message msg = Message.obtain();
- msg.what = what;
- sendMessage(msg);
- }
- public void sendMessage(Message msg) {
- msg.replyTo = mSrcMessenger;
- try {
- //向mDstMessenger发送消息
- mDstMessenger.send(msg);
- } catch (RemoteException e) {
- replyDisconnected(STATUS_SEND_UNSUCCESSFUL);
- }
- }
@AsyncChannel.java
public void sendMessage(int what) {
Message msg = Message.obtain();
msg.what = what;
sendMessage(msg);
}
public void sendMessage(Message msg) {
msg.replyTo = mSrcMessenger;
try {
//向mDstMessenger发送消息
mDstMessenger.send(msg);
} catch (RemoteException e) {
replyDisconnected(STATUS_SEND_UNSUCCESSFUL);
}
}
这个过程与前面4.2节中双向通道建立过程是相同的,其实就是将消息通过AsyncChannel发送给mDstMessenger,也就是远程服务端。
5.2、同步消息派发过程
同步消息的处理其实在前面4.3节中快速双向通道建立流程中介绍过,我们来看一下其流程。
发送同步消息是通过sendMessageSynchronously()方法实现的:- @AsyncChannelClient.java
- public static void sendSyncMsgToService() {
- Message replyMsg = sClientAsyncChannel.sendMessageSynchronously(MainActivity.MSG_SYNC_REQ);
- String msg = (String) replyMsg.obj;
- Log.d(tag, "get service sync reply msg = " + msg);
- }
- @AsyncChannel.java
- public Message sendMessageSynchronously(int what) {
- Message msg = Message.obtain();
- msg.what = what;
- Message resultMsg = sendMessageSynchronously(msg);
- return resultMsg;
- }
- public Message sendMessageSynchronously(Message msg) {
- Message resultMsg = SyncMessenger.sendMessageSynchronously(mDstMessenger, msg);
- return resultMsg;
- }
- private static Message sendMessageSynchronously(Messenger dstMessenger, Message msg) {
- //创建SyncMessenger对象
- SyncMessenger sm = SyncMessenger.obtain();
- try {
- if (dstMessenger != null && msg != null) {
- //将SyncMessenger的Messenger放入消息包中
- msg.replyTo = sm.mMessenger;
- synchronized (sm.mHandler.mLockObject) {
- //将CMD_CHANNEL_FULL_CONNECTION发送给远端的服务
- dstMessenger.send(msg);
- //阻塞监听唤醒
- sm.mHandler.mLockObject.wait();
- }
- } else {
- sm.mHandler.mResultMsg = null;
- }
- } catch (InterruptedException e) {
- sm.mHandler.mResultMsg = null;
- } catch (RemoteException e) {
- sm.mHandler.mResultMsg = null;
- }
- Message resultMsg = sm.mHandler.mResultMsg;
- sm.recycle();
- //将结果返回给客户端
- return resultMsg;
- }
@AsyncChannelClient.java
public static void sendSyncMsgToService() {
Message replyMsg = sClientAsyncChannel.sendMessageSynchronously(MainActivity.MSG_SYNC_REQ);
String msg = (String) replyMsg.obj;
Log.d(tag, "get service sync reply msg = " + msg);
}
@AsyncChannel.java
public Message sendMessageSynchronously(int what) {
Message msg = Message.obtain();
msg.what = what;
Message resultMsg = sendMessageSynchronously(msg);
return resultMsg;
}
public Message sendMessageSynchronously(Message msg) {
Message resultMsg = SyncMessenger.sendMessageSynchronously(mDstMessenger, msg);
return resultMsg;
}
private static Message sendMessageSynchronously(Messenger dstMessenger, Message msg) {
//创建SyncMessenger对象
SyncMessenger sm = SyncMessenger.obtain();
try {
if (dstMessenger != null && msg != null) {
//将SyncMessenger的Messenger放入消息包中
msg.replyTo = sm.mMessenger;
synchronized (sm.mHandler.mLockObject) {
//将CMD_CHANNEL_FULL_CONNECTION发送给远端的服务
dstMessenger.send(msg);
//阻塞监听唤醒
sm.mHandler.mLockObject.wait();
}
} else {
sm.mHandler.mResultMsg = null;
}
} catch (InterruptedException e) {
sm.mHandler.mResultMsg = null;
} catch (RemoteException e) {
sm.mHandler.mResultMsg = null;
}
Message resultMsg = sm.mHandler.mResultMsg;
sm.recycle();
//将结果返回给客户端
return resultMsg;
}
以上过程是不是很熟悉?没错,这就是建立快速双向通道中最关键的部分,其原理就是在客户端发送消息后,AsyncChannel内部创建一个SyncMessenger对象,等消息发送给服务端之后,SyncMessenger就进入阻塞状态,当服务端回应消息时,SyncMessenger就解除阻塞,然后将结果返回给客户端。
这就是同步消息的传输机制。