【朝花夕拾】Messenger篇——Messenger使用與源碼分析

前言

      轉載請聲明，轉自【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、服務端代碼實現

public class MessengerService extends Service {
    private static final String TAG = "Messenger-Demo";
    private static final int MSG_CLIENT = 0x001;
    private static final int MSG_SERVER = 0X002;
    private static final String KEY_CLIENT = "key_client";
    private static final String KEY_SERVER = "key_server";

    private final Messenger mMessenger = new Messenger(new MessageHandler());

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

    private static class MessageHandler extends Handler {
        @Override
        public void handleMessage(Message msg) {
            switch (msg.what) {
                case MSG_CLIENT:
                    Log.d(TAG, "receive msg from Client:" + msg.getData().getString(KEY_CLIENT));
                    Messenger messenger = msg.replyTo;
                    Message serverMsg = Message.obtain();
                    serverMsg.what = MSG_SERVER;
                    Bundle bundle = new Bundle();
                    bundle.putString(KEY_SERVER, "Hello Client! I am fine, thank you");
                    serverMsg.setData(bundle);
                    try {
                        messenger.send(serverMsg);
                    } catch (RemoteException e) {
                        e.printStackTrace();
                    }
                    break;
                default:
                    super.handleMessage(msg);
            }
        }
    }
}

       對應清單文件中的注冊

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

這里需要注意的是第三行，該Service需要提供給其它應用調用，需要將該屬性值設置為true。

  2、客戶端代碼實現

public class MessengerClientActivity extends AppCompatActivity {

    private static final String TAG = "Messenger-Demo";
    private static final int MSG_CLIENT = 0x001;
    private static final int MSG_SERVER = 0X002;
    private static final String KEY_CLIENT = "key_client";
    private static final String KEY_SERVER = "key_server";
    private static final String SERVER_PKGNAME = "com.example.messageserver";
    private static final String SERVICE_PATH = "com.example.messageserver.MessengerService";
    private Messenger mRemoteMessenger;
    private Messenger mLocalMessenger = new Messenger(new MessengerClientHandler());

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        Log.d(TAG,"onCreate");
        bindService();
    }

    private void bindService() {
        Intent intent = new Intent();
        ComponentName componentName = new ComponentName(SERVER_PKGNAME, SERVICE_PATH);
        intent.setComponent(componentName);
        bindService(intent, mServiceConnection, Context.BIND_AUTO_CREATE);
    }

    private static class MessengerClientHandler extends Handler {
        @Override
        public void handleMessage(Message msg) {
            switch (msg.what) {
                case MSG_SERVER:
                    Log.d(TAG, "receive msg from Server:" + msg.getData().getString(KEY_SERVER));
                    break;
                default:
                    break;
            }
            super.handleMessage(msg);
        }
    }

    private ServiceConnection mServiceConnection = new ServiceConnection() {
        @Override
        public void onServiceConnected(ComponentName name, IBinder service) {
            mRemoteMessenger = new Messenger(service);
            Message clientMsg = Message.obtain();
            clientMsg.what = MSG_CLIENT;
            Bundle bundle = new Bundle();
            bundle.putString(KEY_CLIENT, "Hello,Server! How are you ?");
            clientMsg.setData(bundle);
            clientMsg.replyTo = mLocalMessenger;
            try {
                mRemoteMessenger.send(clientMsg);
            } catch (RemoteException e) {
                e.printStackTrace();
            }
        }

        @Override
        public void onServiceDisconnected(ComponentName name) {

        }
    };

    @Override
    protected void onDestroy() {
        super.onDestroy();
        unbindService(mServiceConnection);
    }
}

  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對象。

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

第4行的mMessenger變量，它在第2行中創建，我們跟進到源碼中看一下它的構造方法：

//=============Messenger.java============
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();
}

//==============Handler.java===========
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);
    }
}

        第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后可以看到如下內容：

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

Stub繼承自android.os.Binder，可見MessengerImpl實際上也是一個Binder對象，而Binder是IBinder的實現類。現在我們就搞清楚了在創建Messenger對象時所創建的mTarget，實際上就是一個Binder。（這里講到的AIDL相關的內容，可以參照文章開頭處提到的文章，里面有講到AIDL編譯后生成的內容）。

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

//=============MessengerService.java=========

public IBinder onBind(Intent intent) {
    return mMessenger.getBinder();
}

//============Messenger.java=============
/**
 * 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();
}

 第7~13行注釋有說明：該方法用於獲取IBinder，當前Messenger（即mMessenger）正在用這個IBinder和與自己關聯的Handler進行通信。這里仍然需要借助aidl生成的java接口文件中的內容（下面這個Stub在前面提到過）來理解：

public static abstract class Stub extends android.os.Binder implements xxx {
      ......
      @Override
        public android.os.IBinder asBinder() {
            return this;
        }
      ......
}

通過前面的分析，我們已經知道了繼承鏈：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) {
      mRemoteMessenger = new Messenger(service);
      ......
}

這里我們又看到了另外一種創建Messenger的方式，我們看看源碼：

//=====================Messenger.java=================
1 /**
 * 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);
}

我們仍然先翻譯一下注釋：從一個原始的IBinder創建一個Messenger，該IBinder之前通過getBinder方法來獲取得到。參數為IBinder類型，當前Messenger應該和這個IBinder進行通信。當我們看到第8行的時候，是不是又仿佛看到了AIDL中客戶端創建服務端代理類呢？

       結合上述代碼的分析，已經很明確地驗證了第二節中說的，Messenger的底層仍然是AIDL！

 

  3、Client端向Server端發送消息

        在MessengerClientActivity類的第53行，也就是下面的第7行，就是遠程Messenger向服務端發送消息。

//===============MessengerClientActivity.java=============
 1 @Override
public void onServiceConnected(ComponentName name, IBinder service) {
    mRemoteMessenger = new Messenger(service);
    Message clientMsg = Message.obtain();
    ......
    try {
        mRemoteMessenger.send(clientMsg);
    } catch (RemoteException e) {
        e.printStackTrace();
    }
}

我們查看send的源碼：

//============Messenger.java===========
/**
 * 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);
}

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

我們仍然先簡單看看注釋：發送Message給該Messenger的Handler（該Messenger來自於Server端，所以這里的Handler也就是Server端自定義那個Handler）。第1點中講過，mTarget就是MessengerImpl的實例，所以第12行就是執行的第17行。第19行我們再熟悉不過了，Handler發送Message，所以我們這里就很明確了，遠程Messenger的send方法，實際上就是通過Handler來發送數據的。

 

  4、Server端向Client端發送消息

       實現Server端向Client端發送數據，關鍵代碼如下：

//=======  MessengerClientActivity========
private Messenger mLocalMessenger = new Messenger(new MessengerClientHandler());
@Override
public void onServiceConnected(ComponentName name, IBinder service) {
    mRemoteMessenger = new Messenger(service);
    Message clientMsg = Message.obtain();
    ......
    clientMsg.replyTo = mLocalMessenger;
    ......
    try {
        mRemoteMessenger.send(clientMsg);
    } catch (RemoteException e) {
        e.printStackTrace();
    }
}

//==========AidlService========
Messenger messenger = msg.replyTo;
Message serverMsg = Message.obtain();
......
try {
    messenger.send(serverMsg);
} catch (RemoteException e) {
    e.printStackTrace();
}

這里關鍵中的關鍵是第8行，和第18行。客戶端需要將本地Messenger發送給Server端，也就是第8行，其源碼如下：

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

這里的replyTo是一個Messenger類型的，第8行就將本地Messenger裝進Message中，發送到Server端了。在Server端就會接收該Messenger，如第18行中所示。這樣，Server端就拿到了Client端的本地Messenger對象，然后就可以通過這個Messenger給Client端發送消息了，接收者為Client端本地Messenger關聯的Handler，這樣就實現了服務端向客戶端發送消息。

       到這里，Messenger通信流程的源碼分析就結束了。簡單來說，Messenger原理就是封裝了AIDL，以及使用Handler來發送消息。

 

結語

       由於筆者水平有限，文章中如果有描述不准確或者不妥當的地方，還請讀者不吝賜教，非常感謝！