本文內容基于《Android開發藝術探索》，強烈推薦，值得一看。
Messenger是一種輕量級的IPC解決方案，通過它可以在不同進程之間傳遞Message對象，從而實現進程間通信，首先我們來看一下它部分源碼：
public Messenger(Handler target) {
mTarget = target.getIMessenger();
}
public Messenger(IBinder target) {
mTarget = IMessenger.Stub.asInterface(target);
}
public void send(Message message) throws RemoteException {
mTarget.send(message);
}
public IBinder getBinder() {
return mTarget.asBinder();
}
從IMessenger或是Stub.asInterface可以看出來Messenger多進程通信，底層實現還是AIDL，IMessenger.aidl的實現如下
package android.os;
import android.os.Message;
/** @hide */
oneway interface IMessenger {
void send(in Message msg);
}
接下來我們看一下如何使用Messenger實現多進程通信
- 服務端
public class MessengerService extends Service {
private static final String TAG = MessengerService.class.getSimpleName();
private Messenger mMessenger = new Messenger(new Handler() {
@Override
public void handleMessage(Message msg) {
switch (msg.what) {
case 1:
Log.e(TAG, "receive msg from Client:" + msg.getData().getString("msg"));
Messenger client = msg.replyTo;
Message relpyMessage = Message.obtain(null, 0);
Bundle bundle = new Bundle();
bundle.putString("reply", "嗯，你的消息我已經收到，稍后會回復你。");
relpyMessage.setData(bundle);
try {
client.send(relpyMessage);
} catch (RemoteException e) {
e.printStackTrace();
}
break;
default:
super.handleMessage(msg);
}
}
});
@Nullable
@Override
public IBinder onBind(Intent intent) {
return mMessenger.getBinder();
}
}
- 客戶端
public class MainActivity extends AppCompatActivity {
private static final String TAG = MainActivity.class.getSimpleName();
private Messenger messenger;
private Messenger replyMessager = new Messenger(new Handler(){
@Override
public void handleMessage(Message msg) {
switch (msg.what){
case 0:
Log.e(TAG, "receive msg from Server:" + msg.getData().getString("reply"));
break;
default:
break;
}
}
});
private ServiceConnection connection = new ServiceConnection() {
@Override
public void onServiceConnected(ComponentName name, IBinder service) {
messenger = new Messenger(service);
Message m = Message.obtain(null, 1);
Bundle b = new Bundle();
b.putString("msg", "我是客戶端,我找你");
m.setData(b);
m.replyTo = replyMessager;
try {
messenger.send(m);
} catch (RemoteException e) {
e.printStackTrace();
}
}
@Override
public void onServiceDisconnected(ComponentName name) {
}
};
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_main);
Intent intent = new Intent(this, MessengerService.class); //這邊我是在同一個應用中指定MessengerService的android:process屬性實現多線程所以用的是顯示調用，不同應用要通過隱式調用
bindService(intent, connection, BIND_AUTO_CREATE);
}
}
服務端我們主要的操作有：
- 創建了一個Service來處理客戶端的請求;
- 通過創建的Handler對象來創建Messenger對象，用Handler中的MessengerImpl對象為Messenger的mTarget賦值;
- 在onBind方法中返回Messenger中的IBinder對象(即mTarget.asBinder())，客戶的可以用來創建Messenger對象向服務端發送消息
- 從客戶的傳來的Message對象中獲取客戶端的Messenger對象，通過Messenger#send(Message msg)發送消息給客戶的。
客戶端我們的主要操作有：
- 綁定服務，用服務端返回的IBinder對象初始化Messenger對象，用來向服務端發送消息；
- 通過創建的Handler對象來創建自己的Messenger對象，用Handler中的MessengerImpl對象為Messenger的mTarget賦值;
- 創建消息把自己的Messenger對象賦值給Message.replyTo，服務端接收消息后從Message對象中取出客戶端的Messenger對象向客戶端發送消息
從最上面Messenger的部分源碼我們可以知道，Messenger#send(Message msg)發送消息是調用了IMessenger#send(in Message msg)，從Handler中的相關源碼(如下)可以看出Messenger發送消息本質上還是用Handler發送的。
final IMessenger getIMessenger() {
synchronized (mQueue) {
if (mMessenger != null) {
return mMessenger;
}
mMessenger = new MessengerImpl();
return mMessenger;
}
}
private final class MessengerImpl extends IMessenger.Stub { //AIDL，實現IMessenger.Stub
public void send(Message msg) {
Handler.this.sendMessage(msg);//由 Handler來發送消息
}
}
我理解的Messenger多進程通信，希望大家指正
服務端通過客戶端綁定服務時，把服務端Hanlder中的MessengerImpl對象(繼承自IMessenger.Stub，IMessenger.Stub繼承自android.os.Binder并實現IMessenger接口，它持有Handler對象的引用)返回給客戶端，客戶綁定服務時用服務端返回的MessengerImpl對象創建用于向服務端發送消息的Messenger對象，最終客戶端通過該Messenger對象中MessengerImpl對象持有的服務端的Handler對象的引用發送消息給服務端，消息中帶有客戶端自己的Messenger對象引用，服務端通過調用客戶端Messenger對象的引用繼而調用客戶端中的Handler對象回復消息，從而實現進程間通信。
注：Messenger通信本質上也就是Hanlder發送處理消息，一次只處理一個請求，所以不需要考慮線程同步的問題。
本人技術有限，歡迎指正，謝謝！
