2. 程式人生 > >Android程序間通訊(3)-Messenger實現

Android程序間通訊(3)-Messenger實現

阿新 • • 發佈：2019-02-12

前面兩篇文章中已經介紹了兩種實現程序間通訊的方式，那是不是隻有這兩種方式實現程序間通訊呢？當然不是，還有更好的實現方式，那就是Messenger。本篇文章將帶領大家一起來學習下Messenger.

沒有看我寫的上面兩篇文章的同學，建議先去看下上面兩篇文章，以更好的理解。

什麼是基於訊息的程序通訊？
這裡寫圖片描述
該圖片是引用自弘揚大神的部落格

其實基於訊息的程序通訊就是客戶端通過Handler傳送一條Message，服務端收到這條Message然後獲取到客戶端的值，服務端進行處理，再將結果封裝成Message傳遞給客戶端。通過這種方式實現aidl有什麼好處呢？

  • 不用再寫aidl檔案了（很多同學一提到aidl就頭疼）
  • 基於Message，這個大家已經很熟悉了

接下來我們通過程式碼詳細的介紹下。

1，服務端，我們定義一個MessengerService.java的Service，程式碼如下：

package com.wms.github.aidl.server;

import android.app.Service;
import android.content.Intent;
import android.os.Bundle;
import android.os.Handler;
import android.os.IBinder;
import android.os.Message;
import
 
 android.os.Messenger;
import android.os.RemoteException;
import android.util.Log;

/**
 * Created by 王夢思 on 2017/5/25.
 */

public class MessengerService extends Service {
    private static final String TAG = "MessengerService";
    private Messenger messenger = new Messenger(new Handler() {
        @Override
 

        public void handleMessage(Message clientMsg) {
            if (clientMsg.what == 0x001) {
                //注意這個裡clientMsg是客戶端傳送過來的訊息
                Bundle bundle = (Bundle) clientMsg.obj;
                String str = bundle.getString("str");
                str = str.toUpperCase();
                //服務端處理完邏輯後，將資料通過Messeage的方式傳遞給客戶端
                Message message = Message.obtain();
                Bundle sendBundle = new Bundle();
                sendBundle.putString("str", str);
                message.obj = sendBundle;
                message.what = 0x001;
                try {
                    //將訊息傳送到客戶端
                    clientMsg.replyTo.send(message);
                } catch (RemoteException e) {
                    e.printStackTrace();
                }
            }
            super.handleMessage(clientMsg);
        }
    });

    @Override
    public IBinder onBind(Intent intent) {
        Log.e(TAG, "onBind...");
        //這裡不能返回null，必須要返回我們建立的Binder物件
        return messenger.getBinder();
    }

    @Override
    public boolean onUnbind(Intent intent) {
        Log.e(TAG, "onUnbind...");
        return super.onUnbind(intent);
    }

    @Override
    public void onStart(Intent intent, int startId) {
        Log.e(TAG, "onStart...");
        super.onStart(intent, startId);
    }

    @Override
    public int onStartCommand(Intent intent, int flags, int startId) {
        Log.e(TAG, "onStartCommand...");
        return super.onStartCommand(intent, flags, startId);
    }

    @Override
    public void onCreate() {
        Log.e(TAG, "onCreate...");
        super.onCreate();
    }

    @Override
    public void onDestroy() {
        Log.e(TAG, "onDestroy...");
        super.onDestroy();
    }
}

服務端就一個Service，可以看到程式碼相當的簡單，只需要去宣告一個Messenger物件，然後onBind方法返回messenger.getBinder()；
然後坐等客戶端將訊息傳送到handleMessage想法，根據message.what去判斷進行什麼操作，然後做對應的操作，最終將結果通過 clientMsg.replyTo.send()，這裡注意一定要呼叫clientMsg.replyTo.send()去傳送訊息，不然客戶端接收不到。

註冊MessengerService

<service
            android:name="com.wms.github.aidl.server.MessengerService"
            android:exported="true">
            <intent-filter>
                <action android:name="com.wms.github.aidl.server.MessengerService"/>
                <category android:name="android.intent.category.DEFAULT"/>
            </intent-filter>
        </service>

2，客戶端。在客戶端我新建一個MessengerActivity.java，程式碼如下：

package com.wms.github.aidl.client;

import android.content.ComponentName;
import android.content.Context;
import android.content.Intent;
import android.content.ServiceConnection;
import android.os.Bundle;
import android.os.Handler;
import android.os.IBinder;
import android.os.Message;
import android.os.Messenger;
import android.os.RemoteException;
import android.util.Log;
import android.view.View;
import android.widget.EditText;

/**
 * Created by 王夢思 on 2017/5/25.
 */

public class MessengerActivity extends MainActivity {
    private EditText mEditText;
    private Messenger mService;

    private Messenger clientMessenger = new Messenger(new Handler() {
        @Override
        public void handleMessage(Message msg) {

            if (msg.what == 0x001) {
                Bundle bundle = (Bundle) msg.obj;
                mEditText.setText(bundle.getString("str"));
            }

            super.handleMessage(msg);
        }
    });

    private ServiceConnection mServiceConn = new ServiceConnection() {
        @Override
        public void onServiceConnected(ComponentName name, IBinder service) {
            //當繫結成功後呼叫
            Log.e("MainActivity", "onServiceConnected...");
            mService = new Messenger(service);
        }

        @Override
        public void onServiceDisconnected(ComponentName name) {
            Log.e("MainActivity", "onServiceDisconnected...");
        }
    };

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);

        mEditText = (EditText) findViewById(R.id.id_edittext);

        findViewById(R.id.bind).setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View v) {
                bindService();
            }
        });

        findViewById(R.id.unbind).setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View v) {
                unBindService();
            }
        });

        findViewById(R.id.invokeServer).setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View v) {
                invokeServer();
            }
        });
    }

    /**
     * 繫結服務
     */
    public void bindService() {
        Intent intent = new Intent();
        intent.setAction("com.wms.github.aidl.server.MessengerService");
        //Android 5.0以上必須要加這句程式碼，不然報錯
        intent.setPackage("com.wms.github.aidl.server");
        bindService(intent, mServiceConn, Context.BIND_AUTO_CREATE);
    }

    public void unBindService() {
        unbindService(mServiceConn);
    }

    public void invokeServer() {
        String inputStr = mEditText.getText().toString().trim();
        try {
            Message message = Message.obtain();
            message.what = 0x001;
            Bundle bundle = new Bundle();
            bundle.putString("str",inputStr);
            message.obj = bundle;

            //將訊息的迴應設定為clientMessenger，這樣客戶端傳送訊息就能在客戶端收到了。
            message.replyTo = clientMessenger;
            mService.send(message);
        } catch (RemoteException e) {
            //這裡會丟擲遠端異常
            e.printStackTrace();
        }
    }
}

佈局檔案和上篇文章中一樣。

MessengerActivity.java中程式碼也很簡單，就是繫結一個服務，然後再onServiceConnect中例項化一個Messenger，這個Messenger和MessengerActivity中屬性clientMessenger不一樣，因為這個Messenger例項化的時候把Binder驅動傳遞進來了。所以當客戶端呼叫mService.send(message); 後，服務端將會收到客戶端傳遞過來的資料，服務端處理完之後，返回到Client端的clientMessenger中的Handler的handleMessage方法中，這樣就完成了客戶端和服務端的通訊。

效果圖：
這裡寫圖片描述

當我們點選呼叫服務端轉換後，服務端就把大寫字母回傳給客戶端。以上就是簡單的Messenger的使用，肯定很多人有疑問，為什麼這樣可以實現程序間的通訊呢？下面我將帶領大家一起來從原始碼的角度來看看。

1，先分析服務端，服務端中onBind()方法裡面我們返回了messenger.getBinder(); 很簡單，就一行程式碼，我們進入Messenger的內部看下getBinder內部到底做了什麼事情

/**
     * 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();
    }

getBinder方法也很簡單，也就一行程式碼。這裡mTarget是什麼呢？檢視下原始碼，private final IMessenger mTarget; 可以看出mTarget是一個IMessenger物件，mTarget賦值是在我們例項化clientMessenger物件的時候Messenger構造方法裡面。我們再來看看Messenger的構造方法

/**
     * 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內部的getImessenger方法

final IMessenger getIMessenger() {
        synchronized (mQueue) {
            if (mMessenger != null) {
                return mMessenger;
            }
            mMessenger = new MessengerImpl();
            return mMessenger;
        }
    }

恍然大悟，原來mTarget其實是一個MessengerImpl物件。再回到Messenger中的getBinder方法，其實就是呼叫了MessengerImpl內部的asBinder方法，我們進入到MessengerImpl中的asBinder中看看其內部做了什麼事情。

MessengerImpl原來是繼承自IMessenger.Stub，是不是很熟悉？這不又回到了我們前面的文章中通過aidl實現程序通訊的了麼？原來Android內部已經幫我們實現了一個IMessenger.aidl檔案，這個檔案位於framework中的platform_frameworks_base/core/java/android/os/IMessenger.aidl，大家可以下載framework原始碼去檢視下。由於aidl程式碼較少，我下面貼出IMessenger.aidl內部程式碼如下：

package android.os;

import android.os.Message;

/** @hide */
oneway interface IMessenger {
    void send(in Message msg);
}

哇，好簡答，就一個send方法，send方法裡面傳遞的是一個Message物件。所以這一切又回到了我們前面所說的aidl進行程序通訊的內容了。如果不明白的可以看我之前寫過的一篇文章 基於aidl實現的程序通訊

2，接下來我們分析下客戶端原始碼
當客戶端呼叫繫結服務的時候，會呼叫onServiceConnect方法

private ServiceConnection mServiceConn = new ServiceConnection() {
        @Override
        public void onServiceConnected(ComponentName name, IBinder service) {
            //當繫結成功後呼叫
            Log.e("MainActivity", "onServiceConnected...");
            mService = new Messenger(service);
        }

        @Override
        public void onServiceDisconnected(ComponentName name) {
            Log.e("MainActivity", "onServiceDisconnected...");
        }
    };

在onServiceConnected中我們例項化了一個Messenger，並且傳遞了一個IBinder物件，這個IBinder物件就是一直說的Binder驅動。我們進入Messenger這個建構函式中看看：

/**
     * 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);
    }

是不是又很熟悉？這不就是我們在 基於aidl實現的程序通訊 中onSeviceConnect方法實現的一樣麼？

綜上分析客戶端和服務端的原始碼，其實和我們寫aidl完全一樣，沒有任何區別，Messenger底層其實就是基於aidl來實現的程序通訊，只是Android內部已經給我們寫好了一個IMessnger.aidl檔案，不需要我們手動實現了。

到此，我們就已經分析完了原始碼了，如果還是不明白的同學建議去翻看下Messenger的原始碼，並不複雜，到此Android中實現程序通訊的常用方式已經介紹完了。

程式碼傳送門 : http:github.com/wms1993/blog_aidl_demo

相關推薦

Android程序間通訊(3)-Messenger實現

前面兩篇文章中已經介紹了兩種實現程序間通訊的方式，那是不是隻有這兩種方式實現程序間通訊呢？當然不是，還有更好的實現方式，那就是Messenger。本篇文章將帶領大家一起來學習下Messenger. 沒有看我寫的上面兩篇文章的同學，建議先去看下上面兩篇文章，

Android-Android程序間通訊之messenger

轉自‘https://www.cnblogs.com/makaruila/p/4869912.html 平時一說程序間通訊，大家都會想到AIDL，其實messenger和AIDL作用一樣，都可以進行程序間通訊。它是基於訊息的程序間通訊，就像子執行緒和UI執行緒傳送訊息那樣，是不是很簡單，還不用去寫AIDL檔

android程序間通訊AIDL的簡單實現。

aidl程序間通訊，肯定是兩個程序之間了，我們可以簡單的將其分為服務端和客戶端，客戶端負責發起一個求和的請求，服務端則負責執行這個求和的動作並將求和的結果返回給客戶端。 先看看服務端的程式碼建立吧，用的開發工具是AndroidStudio，右鍵新建aidl檔案，程式碼如下

【程序間通訊】Android 程序間通訊的幾種實現方式

一、整體結構 下面將逐一介紹4種通訊方式 二、4種通訊方式 1、Activity Android內建了許多可供其他程式跨程序訪問的Activity,比如跳至打電話頁面（指定Action,uri跨程序訪問） Intent call

Android 程序間通訊實現原理分析

/**  * 客戶端控制介面  */ public class MainActivity extends Activity {  public static final String TAG = "MainActivity";  // 服務端 AndroidManifest.xml中的intent-fil

android程序間通訊--Binder

深入理解之程序間通訊–Binder 同一個程式中的兩個方法能夠直接呼叫的根本原因是處於相同的記憶體空間中。兩個不同的應用程式因為不在同一個程序中，他們是沒有辦法直接通過記憶體地址來訪問到對方的函式和變數的。同一個程序中物件的傳遞是傳遞的記憶體地址，這個地址並不是真正的實體地址，而是邏

Android程序間通訊——ContentProvider的使用

前言 ContentProvider作為四大元件之一，一直以來存在感都很低，但其實它的功能還是很強大的，尤其是在實現程序間通訊的時候。和AIDL一樣，ContentProvider的底層實現也是Binder，但是由於系統已經為我們做了封裝，所以它的使用過程要簡單的多。 一、什麼是Conten

Android程序間通訊 - 幾種方式的對比總結

什麼是RPC RPC（Remote Procedure Call）即遠端過程呼叫，它是一種通過網路從遠端計算機程式上請求服務，在不需要了解底層網路技術的協議下，即可獲取計算機程序中的資料。RPC使得開發包括網路分散式多程式在內的應用程式更加容易。 RPC在OSI網路通訊7層模型中

Android程序間通訊 - Socket使用（TCP、UDP）

在使用Socket實現程序間通訊前，先對網路協議相關知識進行簡單回顧。 網路分層 一般情況會將網路分為5層： 應用層     常見協議：HTTP、FTP、POP3等 傳輸層     

Android程序間通訊 - ContentProvider內容提供者

簡介 ContentProvider主要用於在不同的應用程式間實現資料共享的功能，允許一個程式訪問另外一個程式中的資料，還能保證資料訪問的安全性。 是Android跨程序實現資料共享的標準方式。 ContentProvider相當於程序間的搬運工，

Android程序間通訊的幾種方式

定義多程序 Android應用中使用多程序只有一個辦法（用NDK的fork來做除外），就是在AndroidManifest.xml中宣告元件時，用android:process屬性來指定。 不知定process屬性，則預設執行在主程序中，主程序名字為包名。 andr

android程序間通訊：使用AIDL

  from: http://blog.csdn.net/saintswordsman/article/details/5130947 歡迎閱讀本文，你能關注本文，你知道你需要程序間通訊、需要AIDL（以及Binder），那麼可以預設你對這些概念已經有了一些

Android 程序間通訊（AIDL）

在Android平臺，一個程序通常不能訪問另一個程序的記憶體空間，所以要想對話，需要將物件分解成作業系統可以理解的基本單元，並且有序的通過程序邊界。通過程式碼來實現這個資料傳輸過程是冗長乏味的，Android提供了AIDL工具來處理這項工作。 AIDL (An

AIDL 程序間通訊講解及實現步驟

server端的實現1.建立 aidl檔案 （例如ICatl.aidl）2。建立一個server 並在server中建立一個內部類，繼承aidl檔案的stub例如：public class AidlService extends Service { pri

[心得]Android程序間通訊之Broadcast Receiver

Android框架層提供的一些通訊機制Broadcast、Intent、Content Provider，主要用於應用程式開發時提供跨程序或應用程式內部的通訊。 android中，通過廣播（broadcast）可以通知廣播接受者某個事件發生了。比如一些系統時間：電源不足，

Android程序間通訊(IPC)之Socket

Socket也被稱為“套接字”程式設計，它分為流式套接字和使用者資料套接字兩種，分別對應於網路傳輸控制中層中TCP和UDP協議。TCP協議是面向連線的協議，提供穩定的雙向通訊功能，TCP連線的建立需要經過”三次握手”才能實現，為了實現穩定的資料傳輸功能，其本身提

Android程序間通訊（二）——傳遞複雜資料

上一篇文章中介紹瞭如何在Android不同程序間傳遞資料，但是傳遞的都是基本資料型別或者String型別，這些都是系統資料型別。如何傳遞自定義資料型別呢？ 下面我們來舉個栗子。假設我們有兩個自定義的類，一個是Person類，一個是Car類。一個Person

Android程序間通訊系列-----------程序間的資料傳遞載體Parcel

一、Android中的新的序列化機制         JAVA中的Serialize機制，其作用是能將資料物件存入位元組流當中，在需要時重新生成物件。主要應用是利用外部儲存裝置儲存物件狀態，以及通過網路傳輸物件等。         在Android系統中，定位為針對記憶體

Android 程序間通訊

/**  * 客戶端控制介面  */ public class MainActivity extends Activity {  public static final String TAG = "MainActivity";  // 服務端 AndroidManifest.xml中的intent-fil

Android程序間通訊之Socket

Socket也稱為“套接字”，是網路通訊中的概念，它分為流式套接字和使用者資料報套接字兩種，分別對應於網路傳輸控制層中的TCP和UDP協議。 TCP協議是面向連線的協議，提供穩定的雙向通訊功能，TCP連線的建立需要經過“三次握手”才能完成，為了提供穩定的資料傳輸功能，其本身