深入解析AndroidIPC中的Messenger机制

在之前的文章中，我们探讨了使用 AIDL 实现 Android IPC 的方法。今天我们将聚焦于另一种常用的 IPC 方式——Messenger。

### 一、Messenger 概述

Messenger 是一种基于消息传递的进程间通信机制。它允许不同进程之间的对象通过 Handler 发送和接收消息。具体来说，一个进程可以通过创建指向本地 Handler 的 Messenger 对象，并将其传递给另一个进程来实现跨进程通信。

#### 工作原理

1. **服务端与客户端**：Messenger 需要服务端和客户端两部分。客户端需要绑定到远程服务，成功后可以获取远程 IBinder 对象并由此得到远程的 Messenger 对象。
2. **消息发送**：客户端向服务端发送消息时，需使用从服务端获取的 Messenger 对象，并将自身的 Messenger 对象作为回复地址附加在消息中。
3. **消息回复**：服务端接收到消息后，可以通过消息中的 replyTo 属性找到客户端的 Messenger 对象，从而向客户端发送响应。


### 二、实例演示

为了展示 Messenger 的实际应用，我们可以创建两个独立的应用程序，分别作为服务端和客户端。这里以服务端为例，展示如何处理来自客户端的消息并返回响应。

```java
public class MessengerService extends Service {
private static final String TAG = "MessengerService";
private static final int WHAT = 0x101;
private final Handler mHandler = new Handler(Looper.getMainLooper()) {
@Override
public void handleMessage(Message msg) {
switch (msg.what) {
case WHAT:
Bundle bundle = (Bundle) msg.obj;
String str = bundle.getString("str");
Log.e(TAG, "收到客户端消息: " + str);
// 回复客户端
Message reply = Message.obtain();
Bundle replyBundle = new Bundle();
replyBundle.putString("str", "已收到，继续努力！");
reply.setData(replyBundle);
try {
msg.replyTo.send(reply);
} catch (RemoteException e) {
e.printStackTrace();
}
break;
}
}
};
private final Messenger mMessenger = new Messenger(mHandler);

@Nullable
@Override
public IBinder onBind(Intent intent) {
return mMessenger.getBinder();
}
}
```

客户端代码负责绑定服务并发送初始消息。当接收到服务端的响应时，会显示在日志中。

```java
public class MainActivity extends AppCompatActivity {
private static final String TAG = "MainActivity";
private static final int WHAT = 0x102;
private boolean isBound;
private Messenger mClientMessenger = new Messenger(new Handler(Looper.getMainLooper()) {
@Override
public void handleMessage(Message msg) {
if (msg.what == WHAT) {
Bundle bundle = msg.getData();
String respOnse= bundle.getString("str");
Log.e(TAG, "收到服务端回复: " + response);
}
}
});
private Messenger mServiceMessenger;
private ServiceConnection mCOnnection= new ServiceConnection() {
@Override
public void onServiceConnected(ComponentName name, IBinder service) {
mServiceMessenger = new Messenger(service);
isBound = true;
sendInitialMessage();
}

@Override
public void onServiceDisconnected(ComponentName name) {
mServiceMessenger = null;
isBound = false;
}
};

private void sendInitialMessage() {
Message message = Message.obtain(null, WHAT);
Bundle bundle = new Bundle();
bundle.putString("str", "你好，我是客户端");
message.setData(bundle);
message.replyTo = mClientMessenger;
try {
mServiceMessenger.send(message);
} catch (RemoteException e) {
e.printStackTrace();
}
}

@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_main);
findViewById(R.id.btn_start_service).setOnClickListener(v -> bindService());
}

private void bindService() {
Intent intent = new Intent("cn.xinxing.messengerservice");
bindService(intent, mConnection, Context.BIND_AUTO_CREATE);
}

@Override
protected void onDestroy() {
super.onDestroy();
if (isBound) {
unbindService(mConnection);
}
}
}
```

### 三、源码剖析

Messenger 的核心在于其构造函数和内部使用的 IMessenger 接口。构造函数接受一个 Handler 并从中提取出 IMessenger 对象。IMessenger 是一个 AIDL 接口，定义了 send 方法用于跨进程传递消息。

```java
public Messenger(Handler target) {
mTarget = target.getIMessenger();
}
```

`getIMessenger()` 方法返回一个实现了 IMessenger 接口的对象，即 `MessengerImpl`。这个类重写了 send 方法，利用 Handler 来分发消息。

```java
private final class MessengerImpl extends IMessenger.Stub {
public void send(Message msg) {
msg.sendingUid = Binder.getCallingUid();
Handler.this.sendMessage(msg);
}
}
```

### 四、总结

- **底层实现**：Messenger 基于 AIDL 构建，但封装了复杂的细节，简化了开发者的使用。
- **通信方式**：服务端和客户端之间通过各自持有的 Messenger 对象进行消息交换。
- **参数传递**：所有数据必须实现 Parcelable 接口，推荐使用 Bundle 封装参数。
- **线程支持**：Messenger 默认是单线程的，不支持并发操作。若需多线程，请考虑使用 AIDL 或其他方案。

希望本文能帮助你更深入地理解 Android IPC 中的 Messenger 机制及其应用场景。