Android教程網 >> Android技術 >> 關於Android編程 >> Android開發二 IPC機制（下）

Android開發二 IPC機制（下）

編輯：關於Android編程

我們繼續來講IPC機制，在本篇中你將會學習到

ContentProvider Socket Binder連接池

一.使用ContentProvider

ContentProvider是Android中提供的專門用來不同應用之間數據共享的方式，從這一點來看，他天生就是適合進程間通信，和Messenger一樣，ContentProvider的底層實現同樣也是Binder，由此可見，Binder在Android系統中是何等的重要，雖然ContentProvider的底層實現是Binder，但是他的使用過程比AIDL簡單多了，這是因為系統為我們封裝了，使得我們無須關心底層實現即可輕松實現IPC，ContentProvider雖然使用起來很簡單，包括自己創建一個ContentProvider也不是什麼難事，盡管如此，它的細節還是相當多，比如CRUD操作，防止SQL注入和權限控制等。由於章節主題限制，在本節中，筆者暫時不對ContentProvider的使用細節以及工作機制進行詳細分析，而是為讀者介紹采用ContentProvider進行跨進程通信的主要流程，至於使用細節和內部工作機制會在後續章節進行詳細分析。

系統預置了許多ContentProvider，比如通訊錄信息、日程表信息等，要跨進程訪問這些信息，只需要通過ContentResolver的query,update、insert 和 delete方法即可，在本節中，我們來實現一個自定義的ContentProvider，並演示如何在其他應用中獲取ContentProvider中的數據從而實現進程間通信這一目的。首先，我們創建一個ContentProvider名字就叫BookProvider。創建一個自定義的ContentProvider很簡單，只需要繼承ContentProvider並且實現它的六個方法：onCreate、query、update、 insert和getType,這六個抽象方法都很好理解，onCreate代表ContentProvider的創建，一般我們要做一些初始化工作；getIype用來返回一個Uri請求的MIME類型（媒體類型，比如圖片），這個媒體類型還是比較復雜的，如果我們的應用不關注這些選項，可以直接在這個方法中返回null或者/，剩下的四個方法對應於CRUD操作，即實現對數據表的增刪查改功能，除了Binder的工作原理，我們知道這六個方法均運行在ContentProvider的進程中，除了onCreate由系統回調並並運行在主線程中，其他五個方法均由外界回調並且運行在Binder線程池中，這一點我們再接下來的例子中可以看到。

ContentProvider主要以表格的形式來組織數據，並且可以包含多個表，對於每個表格來說，它們都具有行和列的層次性，行往往對應一條記錄，而列對應一條記錄中的一個字段，這點和數據庫很類似。除了表格的形式，ContentProvider還支持文件數據，比如圖片、視頻等。文件數據和表格數據的結構不同，因此處理這類數據時可以在ContentProvider中返回文件的句柄給外界從而讓文件來訪問Contentprovider中的文件信息。Android系統所提供的MediaStore功能就是文件類型的ContentProvider，詳細實現可以參考MediaStore。另外，雖然ContentProvide的底層數據看起來很像一個SQLite數據庫，但是ContentProvider對底層的數據存儲方式沒有任何要求，我們既可以使用SQLite數據庫，也可以使用普通的文件，甚至可以采用內存中的一個對象來進行數據的存儲，這一點在後續的章節中會再次介紹，所以這裡不再深入了。

下面看一個最簡單的示例，它演示了ContentProvider的工作工程。首先創建一個BookProvider類，它繼承自ContentProvider並實現了ContentProvider的六個必須需要實現的抽象方法。在下面的代碼中，我們什麼都沒干，盡管如此，這個BookProvider也是可以
工作的，只是它無法向外界提供有效的數據而已。

package com.liuguilin.contentprovidersampler;

/*
 *  項目名：  ContentProviderSampler 
 *  包名：    com.liuguilin.contentprovidersampler
 *  文件名:   BookProvider
 *  創建者:   LGL
 *  創建時間:  2016/10/20 13:49
 *  描述：    ContentProvider
 */

import android.content.ContentProvider;
import android.content.ContentValues;
import android.database.Cursor;
import android.net.Uri;
import android.support.annotation.Nullable;
import android.util.Log;

public class BookProvider extends ContentProvider{

    public static final String TAG = "BookProvider";

    @Override
    public boolean onCreate() {
        Log.i(TAG,"onCreate,current thread:" + Thread.currentThread().getName());
        return false;
    }

    @Nullable
    @Override
    public Cursor query(Uri uri, String[] projection, String selection, String[] selectionArgs, String sortOrder) {
        Log.i(TAG,"query,current thread:" + Thread.currentThread().getName());
        return null;
    }

    @Nullable
    @Override
    public String getType(Uri uri) {
        Log.i(TAG,"getType");
        return null;
    }

    @Nullable
    @Override
    public Uri insert(Uri uri, ContentValues values) {
        Log.i(TAG,"insert");
        return null;
    }

    @Override
    public int delete(Uri uri, String selection, String[] selectionArgs) {
        Log.i(TAG,"delete");
        return 0;
    }

    @Override
    public int update(Uri uri, ContentValues values, String selection, String[] selectionArgs) {
        Log.i(TAG,"update");
        return 0;
    }
}

接著我們需要注冊這個BookProvider，如下所示。其中android:authorities是ContenttProvider的唯一標識，通過這個屬性外部應用就可以訪問我們的BookProvider，因此android:authorities必須是唯一的，這裡建議讀者在命名的時候加上包名前綴。,為了演示進程間通訊，我們讓BookProvider運行在獨立的進程中並給它添加了權限，這樣外界應用如果想訪問BookProvider，就必須聲明com.lgl.PROVIDER這個權限。ContentProvider的的權限還可以細分為讀權限和寫權限，分別對應androidreadPermission和
androidswritePermission 屬性，如果分別聲明了讀權限和寫權限，那麼外界應用也必須依次聲明相應的權限才可以進行讀/寫操作，否則外界應用會異常終止。關於權限這一塊，請讀者自行查閱相關資料，本章不進行詳細介紹。

注冊了ContentProvider之後，我們就可以在外部應用中訪問他了，為了方便演示，這裡我們再統一個應用中其他進程去訪問這個BookProvider,和其他應用中的訪問效果一樣，讀者可以自行試下（要聲明權限）

package com.liuguilin.contentprovidersampler;

/*
 *  項目名：  ContentProviderSampler 
 *  包名：    com.liuguilin.contentprovidersampler
 *  文件名:   ProviderActivity
 *  創建者:   LGL
 *  創建時間:  2016/10/20 13:55
 *  描述：    ContentProvider類
 */

import android.net.Uri;
import android.os.Bundle;
import android.support.v7.app.AppCompatActivity;

public class ProviderActivity extends AppCompatActivity{

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

        Uri uri = Uri.parse("content//com.liuguilin.contentprovidersampler.BookProvider");
        getContentResolver().query(uri,null,null,null,null);
        getContentResolver().query(uri,null,null,null,null);
        getContentResolver().query(uri,null,null,null,null);
    }
}

在上面的代碼中，我們通過ContentResolver對象的query方法去查詢BookProvider中的數據，其中“content//com.liuguilin.contentprovidersampler.BookProvider”唯一標識了BookProvider，而這
個標識正是我們前面為BookProvider的android:authorities屬性所指定的值。我們運行後看一下 log。從下面log可以看出，BookProvider中的query方法被調用了三次，並且這三次調用不在同一個線程中。可以看出，它們運行在一個Binder線程中，前面提到update、insert和delete方法同樣也運行在Binder線程中。另外，onCreate運行在main線程中，也就是
UI線程，所以我們不能在onCreate中做耗時操作。

到這裡，整個ContentProvider的流程我們已經跑通了，雖然ContentProvider中沒有返回任何數據。接下來，在上面的基礎上，我們繼續完善BookProvider，從而使其能夠對外應用提供數據，繼續本章提出的那個例子，現在我們要提供一個BookProvider，外部應用可以通過BookProvider來訪問圖書信息，為了更好地演示ContentProvider，還可以通過BookProvider訪問到用戶信息。為了完成上述功能，我們需要一個數據庫來來管理圖書和用戶信息，這個數據庫不難實現，代碼如下，

package com.liuguilin.contentprovidersampler;

/*
 *  項目名：  ContentProviderSampler 
 *  包名：    com.liuguilin.contentprovidersampler
 *  文件名:   DbOPenHelper
 *  創建者:   LGL
 *  創建時間:  2016/10/20 13:58
 *  描述：    數據庫
 */

import android.content.Context;
import android.database.sqlite.SQLiteDatabase;
import android.database.sqlite.SQLiteOpenHelper;

public class DbOPenHelper extends SQLiteOpenHelper {

    public static final String DB_NAME = "book_provider.db";
    public static final String BOOK_TABLE_NAME = "book";
    public static final String USER_TABLE_NAME = "user";

    public static final int DB_VERSION = 1;

    //圖書和用戶信息表
    private String CREATE_BOOK_TABLE = "CREATE TABLE ID NOT EXISTS" + BOOK_TABLE_NAME + "(_id INTEGER PRIMARY KEY," + "name TEXT)";

    private String CREATE_USER_TABLE = "CREATE TABLE IF NOT EXISTS" + USER_TABLE_NAME + "(_id INTEGER PRIMARY KEY,"+"name TEXT,";

    public DbOPenHelper(Context context) {
        super(context, DB_NAME, null, DB_VERSION);
    }

    @Override
    public void onCreate(SQLiteDatabase db) {
        db.execSQL(CREATE_BOOK_TABLE);
        db.execSQL(CREATE_USER_TABLE);
    }

    @Override
    public void onUpgrade(SQLiteDatabase db, int oldVersion, int newVersion) {

    }
}

上述代碼是一個最簡單的數據庫的實現，我們借助SQLiteOpenHelper來管理數據庫的創建、升級和降級。下面我們就要通過BookProvider向外界提供上述數據庫中的信息了,我們知道，ContentProvider通過Uri來區分外界要訪問的的數據集合，在本例中支持
對BookProvider中的book表和user表進行訪問，為了知道外界要訪問的是哪個表，我需要為它們定義單獨的Uri和Uri_Code，並將Uri和對應的Uru_Code相關聯，我們可以用UriMatcher的addURI方法將Uri和Ur_Code關聯到一起。這樣，當外界請求訪問BookProvider時，我們就可以根據請求的Uri來得到Ur_Code，有了Uri_Code我們就知道外界想要訪問哪個表，然後就可以進行相應的數據操作了，具體代碼如下

public class BookProvider extends ContentProvider {

    public static final String TAG = "BookProvider";

    public static final String AUTHORITY = "com.liuguilin.contentprovidersampler.BookProvider";

    public static final Uri BOOK_CONTENT_URI = Uri.parse("content://" + AUTHORITY + "/book");

    public static final Uri USER_CONTENT_URI = Uri.parse("content://" + AUTHORITY + "/user");

    public static final int BOOK_URI_CODE = 0;

    public static final int USER_URI_CODE = 1;

    public static final UriMatcher sUriMatcher = new UriMatcher(UriMatcher.NO_MATCH);

    static {
        sUriMatcher.addURI(AUTHORITY,"book",BOOK_URI_CODE);
        sUriMatcher.addURI(AUTHORITY,"user",USER_URI_CODE);
    }
    ....
  }

從上面的代碼來看，我們可以通過如下的方式來獲取外界所要訪問的數據源，根據Uri先取出Uri_code，關聯的都是0和1，這個關聯過程就是一句話

 sUriMatcher.addURI(AUTHORITY,"book",BOOK_URI_CODE);
 sUriMatcher.addURI(AUTHORITY,"user",USER_URI_CODE);

將Uri和uri_code管理好之後，我們可以通過如下方式來獲取外界需要訪問的數據，根據Uri先取出uri_code，根據Uri_code再來得到表的名稱，接下來我麼可以響應外界的增刪查改請求了

private String getTableName(Uri uri) {
        String tableName = null;
        switch (sUriMatcher.match(uri)) {
            case BOOK_URI_CODE:
                tableName = DbOPenHelper.BOOK_TABLE_NAME;
                break;
            case USER_URI_CODE:
                tableName = DbOPenHelper.USER_TABLE_NAME;
                break;
        }
        return tableName;
    }

接著我們就可以實現增刪查改的方法了，如果是qurey，首先我們要從拿到外界要訪問的表名稱，然後根據外界傳遞的信息進行數據庫的查詢操作了，這個過程比較簡單：

    @Override
    public Cursor query(Uri uri, String[] projection, String selection, String[] selectionArgs, String sortOrder) {
        Log.i(TAG, "query,current thread:" + Thread.currentThread().getName());
        String table = getTableName(uri);
        if(table == null){
            throw new IllegalArgumentException("Unsupported URI:" + uri);
        }
        return mDb.query(table,projection,selection,selectionArgs,null,null,sortOrder,null);
    }

另外三個方法的實現思路和查詢有點類似，只有一點不同，那就是這三個方法都會引起數據源的改變，這個時候我們需要通過ContentResolver的notifyChange中的數據改變情況，可以通過注冊的方法來注冊觀察者，對於這三個方法，這裡不再詳細說，看代碼：

package com.liuguilin.contentprovidersampler;

/*
 *  項目名：  ContentProviderSampler 
 *  包名：    com.liuguilin.contentprovidersampler
 *  文件名:   BookProvider
 *  創建者:   LGL
 *  創建時間:  2016/10/20 13:49
 *  描述：    ContentProvider
 */

import android.content.ContentProvider;
import android.content.ContentValues;
import android.content.Context;
import android.content.UriMatcher;
import android.database.Cursor;
import android.database.sqlite.SQLiteDatabase;
import android.net.Uri;
import android.support.annotation.Nullable;
import android.util.Log;

public class BookProvider extends ContentProvider {

    public static final String TAG = "BookProvider";

    public static final String AUTHORITY = "com.liuguilin.contentprovidersampler.BookProvider";

    public static final Uri BOOK_CONTENT_URI = Uri.parse("content://" + AUTHORITY + "/book");

    public static final Uri USER_CONTENT_URI = Uri.parse("content://" + AUTHORITY + "/user");

    public static final int BOOK_URI_CODE = 0;

    public static final int USER_URI_CODE = 1;

    public static final UriMatcher sUriMatcher = new UriMatcher(UriMatcher.NO_MATCH);

    static {
        sUriMatcher.addURI(AUTHORITY, "book", BOOK_URI_CODE);
        sUriMatcher.addURI(AUTHORITY, "user", USER_URI_CODE);
    }

    private Context mContext;
    private SQLiteDatabase mDb;

    @Override
    public boolean onCreate() {
        Log.i(TAG, "onCreate,current thread:" + Thread.currentThread().getName());
        mContext = getContext();
        initProviderDate();
        return true;
    }

    private void initProviderDate() {
        mDb = new DbOPenHelper(mContext).getWritableDatabase();
        mDb.execSQL("delete from " + DbOPenHelper.BOOK_TABLE_NAME);
        mDb.execSQL("delete from " + DbOPenHelper.USER_TABLE_NAME);

        mDb.execSQL("insert into book values(3,'Android');");
        mDb.execSQL("insert into book values(4,'IOS');");
        mDb.execSQL("insert into book values(5,'Html5');");
        mDb.execSQL("insert into book values(1,'jake',1);");
        mDb.execSQL("insert into book values(2,'Jasmine',0);");
    }


    @Override
    public Cursor query(Uri uri, String[] projection, String selection, String[] selectionArgs, String sortOrder) {
        Log.i(TAG, "query,current thread:" + Thread.currentThread().getName());
        String table = getTableName(uri);
        if (table == null) {
            throw new IllegalArgumentException("Unsupported URI:" + uri);
        }
        return mDb.query(table, projection, selection, selectionArgs, null, null, sortOrder, null);
    }

    @Nullable
    @Override
    public String getType(Uri uri) {
        Log.i(TAG, "getType");
        return null;
    }

    @Nullable
    @Override
    public Uri insert(Uri uri, ContentValues values) {
        Log.i(TAG, "insert");
        String table = getTableName(uri);
        if (table == null) {
            throw new IllegalArgumentException("Unsupported URI:" + uri);
        }
        mDb.insert(table, null, values);
        mContext.getContentResolver().notifyChange(uri, null);
        return uri;
    }

    @Override
    public int delete(Uri uri, String selection, String[] selectionArgs) {
        Log.i(TAG, "delete");
        String table = getTableName(uri);
        if (table == null) {
            throw new IllegalArgumentException("Unsupported URI:" + uri);
        }
        int count = mDb.delete(table, selection, selectionArgs);
        if (count > 0) {
            getContext().getContentResolver().notifyChange(uri, null);
        }
        return count;
    }

    @Override
    public int update(Uri uri, ContentValues values, String selection, String[] selectionArgs) {
        Log.i(TAG, "update");
        String table = getTableName(uri);
        if (table == null) {
            throw new IllegalArgumentException("Unsupported URI:" + uri);
        }
        int row = mDb.update(table, values, selection, selectionArgs);
        if (row > 0) {
            getContext().getContentResolver().notifyChange(USER_CONTENT_URI, null);
        }
        return row;
    }

    private String getTableName(Uri uri) {
        String tableName = null;
        switch (sUriMatcher.match(uri)) {
            case BOOK_URI_CODE:
                tableName = DbOPenHelper.BOOK_TABLE_NAME;
                break;
            case USER_URI_CODE:
                tableName = DbOPenHelper.USER_TABLE_NAME;
                break;
        }
        return tableName;
    }
}

需要注意的是，增刪查改四大方法是存在多線程並發訪問的，因此方法內部要做好線程同步的工作，在本例中，由於采取了sqlite並且只有一個SQLiteDatabase內部對數據庫的操作式同步處理的，但是如果多個SQLiteDatabase對象來操作數據庫就無法保證線程同步了，因為SQLiteDatabase對象之間無法進程線程同步，如果ContentProvider的底層數據集是一塊內存的話，比如List，在這種情況下同List的遍歷，插入，刪除操作就需要進行線程同步了，否則會引發錯誤，這點尤其需要注意的，到這裡BookProvider已經完成了，接著我們來外部訪問他，看看他能否繼續工作

package com.liuguilin.contentprovidersampler;

/*
 *  項目名：  ContentProviderSampler 
 *  包名：    com.liuguilin.contentprovidersampler
 *  文件名:   ProviderActivity
 *  創建者:   LGL
 *  創建時間:  2016/10/20 13:55
 *  描述：    ContentProvider類
 */

import android.content.ContentValues;
import android.database.Cursor;
import android.net.Uri;
import android.os.Bundle;
import android.support.v7.app.AppCompatActivity;

public class ProviderActivity extends AppCompatActivity{

    public static final String TAG = "ProviderActivity";

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

        Uri bookUri = Uri.parse("content//com.liuguilin.contentprovidersampler.BookProvider/book");

        ContentValues values = new ContentValues();
        values.put("_id",6);
        values.put("name","程序設計的藝術");
        getContentResolver().insert(bookUri,values);
        Cursor bookCursor = getContentResolver().query(bookUri,new String[]{"_id","name"},null,null,null);
        while (bookCursor.moveToNext()){
            Book book = new Book();
            book.id = bookCursor.getInt(0);
            book.name = bookCursor.getString(1);
        }
        bookCursor.close();

        Uri userUri = Uri.parse("content//com.liuguilin.contentprovidersampler.BookProvider/user");
        Cursor userCursor = getContentResolver().query(userUri,new String[]{"_id","name","sex"},null,null,null);
        while (userCursor.moveToNext()){
            User user = new User();
            user.id= userCursor.getInt(0);
            user.name = userCursor.getString(1);
            user.isMale = userCursor.getInt(2) == 1;
        }
        userCursor.close();

    }
}

默認情況下，BookProvider的數據庫中有三本書和兩個用戶，在上面的代碼中，我們首先添加一本書：“程序設計的藝術”。接著查詢所有的圖書，這個時候應該查詢出四本書，，因為我們剛剛添加了一本。然後查詢所有的用戶，這個時候應該查詢出兩個用戶。是不是這樣呢?我們運行一下程序，從log可以看到，我們的確查詢到了4本書和2個用戶，這說明BookProvider已經能夠正確地處理外部的請求了，讀者可以自行驗證一下update和delete操作，這裡就不再驗證了。同時，由於ProviderActivity和BookProvider運行在兩個不同的進程中，因此，這也構成了進程間的通信。ContentProvider除了支持對數據源的增刪改查這四個操作，還支持自定義調用，這個過程是通ContentResolver的Call方法和ContentProvider的Call方法來完成的。關於使用ContentProvider來進行IPC就介紹到這裡，ContentProvider本身還有一些細節這裡並沒有介紹，讀者可以自行了解，本章側重的是各種進程間通信的方法以及它們的區別，因此針對某種特定的方法可能不會介紹得面面俱到。另外，ContentProvider在後續章節還會有進一步的講解，主要包括細節問題和工作原理，讀者可以閱讀後面的相應章節

二.使用Socket

在本節，我們通過Socket來實現進程通信，Socket也叫做套接字，是網絡通信中的概念，他分為流式套接字和用戶數據報套接字兩種，分別是應用於網絡的傳輸控制層中的Tcp和UDP協議，TCP面向的連接協議，提供穩定的雙向通訊功能，TCP連接的建立需要經過“三次握手”才能完成，為了提供穩定的數據傳輸功能，其本身提供了超時重傳機制，因此具有很高的穩定性：而UDP是無連接的，提供不穩定的單向通信功能，當然UDP也可以實現雙向通信功能。在性能上，UDP具有更好的效率，其缺點是不保證數據一定能夠正確傳輸，尤其是在網絡擁塞的情況下。關於TCP和UDP的介紹就這麼多，更詳細的資料請查看相關網絡資料。接下來我們演示一個跨進程的聊天程序，兩個進程可以通過Socket來實現信息的傳輸，Socket本身可以支持傳輸任意字節流，這裡為了簡單起見，僅僅傳輸文本信息，很顯然，這是一種IPC方式。

使用Socket來進行通信，有兩點需要注意，首先需要聲明權限：

其次要注意不能在主線程中訪問網絡，因為這會導致我們的程序無法在Android4.0及其以上的設備中運行，會拋出如下異常：android.os NetworkOnMainThreadException。而且進行網絡操作很可能是耗時的，如果放在主線程中會影響程序的響應效率，從這方面來說，也不應該在主線程中訪問網絡。下面就開始設計我們的聊天室程序了，比較簡單，首先在遠程Service建立一個TCP服務，然後在主界面中連接TCP服務，連接上了以後，就可給服務端發消息。對於我們發送的每一條文本消息，服務端都會隨機地回應我們一句話為了更好地展示Socket的工作機制，在服務端我們做了處理，使其能夠和多個客戶端同時連接建立連接並響應。

先看一下服務端的設計，當Service啟動時，會在線程中建立TCP服務，這裡監聽的是8688端口，然後就可以等待客戶端的連接請求。當有客戶端連接時，就會生成一個新的Socket，通過每次新創建的Socket就可以分別和不同的客戶端通信了。服務端每收到一次客戶端的消息就會隨機回復一句話給客戶端。當客戶端斷開連接時，服務端這邊也會相應的關閉對應Socket並結束通話線程，這點是如何做到的呢?方法有很多，這裡是通過判斷服務端輸入流的返回值來確定的，當客戶端斷開連接後，服務端這邊的輸入流會返回null,這個時候我們就知道客戶端退出了。服務端的代碼如下所示。

package com.liuguilin.contentprovidersampler;

/*
 *  項目名：  ContentProviderSampler 
 *  包名：    com.liuguilin.contentprovidersampler
 *  文件名:   TCPServerService
 *  創建者:   LGL
 *  創建時間:  2016/10/22 15:16
 *  描述：    服務端
 */

import android.app.Service;
import android.content.Intent;
import android.os.IBinder;

import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.OutputStreamWriter;
import java.io.PrintWriter;
import java.net.ServerSocket;
import java.net.Socket;
import java.util.Random;

public class TCPServerService extends Service {

    private boolean mIsServiceDestoeyed = false;
    private String[] mDefinedMessages = {"你好呀", "你叫神馬？", "今天的天氣", "汽車站怎麼走？"};

    @Override
    public void onCreate() {
        new Thread(new TcpServer()).start();
        super.onCreate();
    }

    @Override
    public IBinder onBind(Intent intent) {
        return null;
    }

    @Override
    public void onDestroy() {
        mIsServiceDestoeyed = true;
        super.onDestroy();
    }

    private class TcpServer implements Runnable{

        @Override
        public void run() {
            ServerSocket serverSocket = null;
            try {
                //監聽本地8868端口號
                serverSocket = new ServerSocket(8688);
            } catch (IOException e) {
                e.printStackTrace();
                return;
            }

            while (!mIsServiceDestoeyed){
                try {
                    //接收客戶端的請求
                    final Socket client = serverSocket.accept();
                    new Thread(){
                        @Override
                        public void run() {
                            try {
                                responseClient(client);
                            } catch (IOException e) {
                                e.printStackTrace();
                            }
                        }
                    }.start();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }

    private void responseClient(Socket client) throws IOException{
        //用於接收客戶端的信息
        BufferedReader in = new BufferedReader(new InputStreamReader(client.getInputStream()));
        //用於給客戶端發送消息
        PrintWriter out = new PrintWriter(new BufferedWriter(new OutputStreamWriter(client.getOutputStream())),true);
        out.print("歡迎來到聊天室");
        while (!mIsServiceDestoeyed){
            String str = in.readLine();
            if(str == null){
                break;
            }
            int i = new Random().nextInt(mDefinedMessages.length);
            String msg = mDefinedMessages[i];
            out.print(msg);
        }
        in.close();
        out.close();
        client.close();
    }
}

接下來看一下客戶端，客戶端Activity啟動時，會在onCreate中開啟一個線程去連接服務端的socket，至於為什麼要用線程我們前面已經說了，為了確定能夠連接成功，這裡采用了超時重連的機制，每次連接失敗後都會重新連接，當然，為了降低重試機制的開銷，我們加入了休眠機制，每次重試的事件間隔為1000毫秒

     try {
            //接收服務端的消息
            BufferedReader br = new BufferedReader(new InputStreamReader(socket.getInputStream()));
            while (!TCPClientActivity.this.isFinishing()) {
                String msg = br.readLine();
                if (msg != null) {
                    String time = formatDateTime(System.currentTimeMillis());
                    String showMsg = "server " + time + "：" + msg + "\n";
                    handler.obtainMessage(MESSAGE_RECEIVE_NEW_MSG, showMsg).sendToTarget();
                }
            }

當然，你的activity在退出的時候，就要關閉socket了

  @Override
    protected void onDestroy() {
        if (mClientSocket != null) {
            try {
                mClientSocket.shutdownInput();
                mClientSocket.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
        super.onDestroy();
    }

接收發送消息的整個過程，這個就很簡單了，看完整代碼：

package com.liuguilin.contentprovidersampler;

/*
 *  項目名：  ContentProviderSampler 
 *  包名：    com.liuguilin.contentprovidersampler
 *  文件名:   TCPClientActivity
 *  創建者:   LGL
 *  創建時間:  2016/10/22 15:31
 *  描述：    客戶端
 */

import android.content.Intent;
import android.os.Bundle;
import android.os.Handler;
import android.os.Message;
import android.support.v7.app.AppCompatActivity;
import android.text.TextUtils;
import android.view.View;
import android.widget.Button;
import android.widget.EditText;
import android.widget.TextView;

import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.OutputStreamWriter;
import java.io.PrintWriter;
import java.net.Socket;
import java.text.SimpleDateFormat;
import java.util.Date;

public class TCPClientActivity extends AppCompatActivity implements View.OnClickListener {

    public static final int MESSAGE_RECEIVE_NEW_MSG = 1;
    public static final int MESSAGE_SOCKET_CONNECTED = 2;

    private Button mSendButton;
    private TextView mMessageTextView;
    private EditText mMessageEditText;

    private PrintWriter mPrintWriter;
    private Socket mClientSocket;

    private Handler handler = new Handler() {
        @Override
        public void handleMessage(Message msg) {
            switch (msg.what) {
                case MESSAGE_RECEIVE_NEW_MSG:
                    mMessageTextView.setText(mMessageTextView.getText() + (String) msg.obj);
                    break;
                case MESSAGE_SOCKET_CONNECTED:
                    mSendButton.setEnabled(true);
                    break;
            }
        }
    };

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

    private void initView() {
        mMessageTextView = (TextView) findViewById(R.id.msg_container);
        mSendButton = (Button) findViewById(R.id.send);
        mSendButton.setOnClickListener(this);
        mMessageEditText = (EditText) findViewById(R.id.msg);

        Intent intent = new Intent(this, TCPServerService.class);
        startService(intent);

        new Thread() {
            @Override
            public void run() {
                connectTCPServer();
            }
        }.start();
    }


    @Override
    protected void onDestroy() {
        if (mClientSocket != null) {
            try {
                mClientSocket.shutdownInput();
                mClientSocket.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
        super.onDestroy();
    }

    @Override
    public void onClick(View v) {
        if (v == mSendButton) {
            String msg = mMessageEditText.getText().toString();
            if (!TextUtils.isEmpty(msg)) {
                mPrintWriter.println(msg);
                mMessageEditText.setText("");
                String time = formatDateTime(System.currentTimeMillis());
                String showesMsg = "self" + time + ":" + msg + "\n";
                mMessageTextView.setText(mMessageTextView.getText() + showesMsg);
            }
        }
    }

    private String formatDateTime(long l) {
        return new SimpleDateFormat("(HH:mm:ss)").format(new Date(l));
    }

    private void connectTCPServer() {
        Socket socket = null;
        while (socket == null) {
            try {
                socket = new Socket("localhost", 8688);
                mClientSocket = socket;
                mPrintWriter = new PrintWriter(new BufferedWriter(new OutputStreamWriter(socket.getOutputStream())), true);
                handler.sendEmptyMessage(MESSAGE_SOCKET_CONNECTED);
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
        try {
            //接收服務端的消息
            BufferedReader br = new BufferedReader(new InputStreamReader(socket.getInputStream()));
            while (!TCPClientActivity.this.isFinishing()) {
                String msg = br.readLine();
                if (msg != null) {
                    String time = formatDateTime(System.currentTimeMillis());
                    String showMsg = "server " + time + "：" + msg + "\n";
                    handler.obtainMessage(MESSAGE_RECEIVE_NEW_MSG, showMsg).sendToTarget();
                }
            }

            mPrintWriter.close();
            br.close();
            socket.close();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

}

上述代碼就是通過Socket來進行進程間的通信實例，除了采用套接字，還可以用UDP套接字，OK

三.Binder連接池

上面我們介紹了不同的IPC方式，我們知道，不同的IPC方式有不同的特點和適用場景,當然這個問題會在26節進行介紹，在本節中要再次介紹一下AIdL，原因是AIDL是一種最常用的進程間通信方式，是日常開發中涉及進程間通信時的首選，所以我們需要額外強調一下.

如何使用AIDL在上面的一節中已經進行了介紹，這裡在回顧一下大致流程：首先創建一個Service和一個AIDL接口，接著創建一個類繼承自AIDL接口中的Stub類並實現Stub中的抽象方法，在Service的onBind方法中返回這個類的對象，然後客戶端就可以綁
定服務端Service，建立連接後就可以訪問遠程服務端的方法了。上述過程就是典型的AIDL的使用流程。這本來也沒什麼問題，但是現在考慮一種情況；公司的項目越來越龐大了，現在有10個不同的業務模塊都需要使用AIDL來進行進程間通信，那我們該怎麼處理呢？也許你說：“就按照AIDL的實現方式一個個來吧”，這是可以的，如果用這種方法，首先我們需要創建10個Service，這好像有點多啊！如果有100個地方需要用到AIDL呢，先創建100個Servlce?到這裡，讀者應該明白問題所在了，隨著AIDL數量的增加，我們不能無限制地增Service,Service是四大組件之一，本生是一種系統資源。而且太多的Serice會使得我們的應用看起來很重量級，因為正在運行的Service可以在應用詳情頁看到，當我們的應用詳情顯示有10個個服務正在運行時，這看起來並不是什麼好事。針對上述問題，我們需要減少Service的數量，將所有的AIDL放在同個Service中去管理。

在這種模式下，整個工作機制是這樣的；每個業務模塊創建自己的AIDL接口並實現此接口，這個時候不同業務模塊之間是不能有耦合的，所有實現細節我們要單獨開來，然後向服務端提供自己的唯一標識和其對應的Binder對象；對於服務端來說，只需要一個Service就可以了，服務端提供一個queryBinder接口，這個接口能夠根據業務模塊的特征來返回相應的Binder對象給它們，不同的業務模塊拿到所需的Binder對象後就可以進行遠程方法調用了。由此可見，Binder連接池的主要作用就是將每個業務模塊的Binder請求統一轉發到遠程Service中去執行，從而避免了重復創建Service的過程，它的工作原理如圖所示。

這裡寫圖片描述

通過上面的理論介紹，也許還有點不好理解，下面對Binder連接池的代碼實現做一說明。首先，為了說明問題，我們提供了兩個AIDL接口（ISecurityCenter和ICompute）來模擬上面提到的多個業務模塊都要使用AIDL的情況，其中ISecurityCenter接口提供解密功能，聲明如下：

interface ISecurityCenter {
    String encrypt(String content);
    String decrypt(String password);
}

而ICompute提供了計算加法的功能：

interface ICompute {

    int add(int a,int b);
}

雖然說上面的兩個接口的功能都比較簡單，但是用於分析Binder池的工作原理還是足夠的，讀者可以寫出更加復雜的例子，接下來我們來看一下部分

package com.liuguilin.contentprovidersampler;

/*
 *  項目名：  ContentProviderSampler 
 *  包名：    com.liuguilin.contentprovidersampler
 *  文件名:   SecurityCenterImpl
 *  創建者:   LGL
 *  創建時間:  2016/10/22 17:50
 *  描述：    TODO
 */

import android.os.RemoteException;

public class SecurityCenterImpl extends ISecurityCenter.Stub{

    private static  final  char SECRET_CODE = '^';

    @Override
    public String encrypt(String content) throws RemoteException {
        char [] chars = content.toCharArray();
        for (int i = 0; i < chars.length; i++) {
            chars[i] ^= SECRET_CODE;
        }
        return new String(chars);
    }

    @Override
    public String decrypt(String password) throws RemoteException {
        return encrypt(password);
    }
}

package com.liuguilin.contentprovidersampler;

/*
 *  項目名：  ContentProviderSampler 
 *  包名：    com.liuguilin.contentprovidersampler
 *  文件名:   ComputeImpl
 *  創建者:   LGL
 *  創建時間:  2016/10/22 17:52
 *  描述：    TODO
 */

import android.os.RemoteException;

public class ComputeImpl extends ICompute.Stub {

    @Override
    public int add(int a, int b) throws RemoteException {
        return a + b;
    }
}

現在的業務模塊的AIDL接口定義和實現都已經完成了，注意的是這裡並沒有為每個模塊的AIDL創建單獨的Service,接下來就是服務端和Binder連接池的工作了

interface IBinderPool {

    IBinder queryBinder(int binderCode);
}

接著，為Binder連接池創建遠程Service並實現IBnderPool,下面是queryBinder的具體實現，可以看到請求轉達的實現方法，當Binder連接池連接上遠程服務時，會根據不同的模塊的標識binderCode返回不同的Binder對象，通過這個對象就可以操作全部發生在遠程服務端上：

 public static class BinderPoolImpl extends IBinderPool.Stub{

        public BinderPoolImpl(){
            super();
        }

        @Override
        public IBinder queryBinder(int binderCode) throws RemoteException {
            IBinder binder = null;
            switch (binderCode){
                case BINDER_SECURUITY_CENTER:
                    binder = new SecurityCenterImpl();
                    break;
                case BINDER_COMPUTE:
                    binder = new ComputeImpl();
                    break;
            }
            return binder;
        }
    }

遠程service的實現比較簡單，如下：

package com.liuguilin.contentprovidersampler;

/*
 *  項目名：  ContentProviderSampler 
 *  包名：    com.liuguilin.contentprovidersampler
 *  文件名:   BinderPoolService
 *  創建者:   LGL
 *  創建時間:  2016/10/22 18:01
 *  描述：    Binder
 */

import android.app.Service;
import android.content.Intent;
import android.os.Binder;
import android.os.IBinder;

public class BinderPoolService extends Service{

    private  static final String  TAG = "BinderPoolService";

    private Binder mBinderPool = new BinderPool.BinderPoolImpl();

    @Override
    public void onCreate() {
        super.onCreate();
    }

    @Override
    public IBinder onBind(Intent intent) {
        return mBinderPool;
    }

    @Override
    public void onDestroy() {
        super.onDestroy();
    }
}

下面還剩下Binder連接池的具體實現了，在他的內部首先他要去綁定遠程服務，綁定成功後，客戶端就課堂通過他的queryBinder方法來獲取對應的Binder，拿到所需的Binder之後，不同業務模塊就可以各自操作了

package com.liuguilin.contentprovidersampler;

/*
 *  項目名：  ContentProviderSampler 
 *  包名：    com.liuguilin.contentprovidersampler
 *  文件名:   BinderPool
 *  創建者:   LGL
 *  創建時間:  2016/10/22 18:04
 *  描述：    TODO
 */

import android.content.ComponentName;
import android.content.Context;
import android.content.Intent;
import android.content.ServiceConnection;
import android.os.IBinder;
import android.os.RemoteException;

import java.util.concurrent.CountDownLatch;

public class BinderPool {

    private static final String TAG = "BinderPool";
    public static final int BINDER_NONE = -1;
    public static final int BINDER_COMPUTE = 0;
    public static final int BINDER_SECURUITY_CENTER = 1;

    private Context mContext;
    private IBinderPool mIBinderPool;
    private static volatile BinderPool sInstance;
    private CountDownLatch mConnectBinderPoolCopuntDownLacth;

    private BinderPool(Context context) {
        mContext = context.getApplicationContext();
        connectBinderPoolService();
    }

    public static BinderPool getInstance(Context context) {
        if (sInstance == null) {
            synchronized (BinderPool.class) {
                if (sInstance == null) {
                    sInstance = new BinderPool(context);
                }
            }
        }
        return sInstance;
    }

    private synchronized void connectBinderPoolService() {
        mConnectBinderPoolCopuntDownLacth = new CountDownLatch(1);
        Intent service = new Intent(mContext, BinderPoolService.class);
        mContext.bindService(service, mBinderPoolConnection, Context.BIND_AUTO_CREATE);
        try {
            mConnectBinderPoolCopuntDownLacth.await();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

    public IBinder queryBinder(int binderCode) {
        IBinder binder = null;
        try {
            if (mIBinderPool != null) {
                binder = mIBinderPool.queryBinder(binderCode);
            }
        } catch (RemoteException e) {
            e.printStackTrace();
        }
        return binder;
    }

    private ServiceConnection mBinderPoolConnection  = new ServiceConnection() {

        @Override
        public void onServiceConnected(ComponentName name, IBinder service) {
            mIBinderPool = IBinderPool.Stub.asInterface(service);
            try {
                mIBinderPool.asBinder().linkToDeath(mBinderPoolDeathRecipient,0);
            } catch (RemoteException e) {
                e.printStackTrace();
            }
            mConnectBinderPoolCopuntDownLacth.countDown();
        }

        @Override
        public void onServiceDisconnected(ComponentName name) {

        }
    };

   private IBinder.DeathRecipient mBinderPoolDeathRecipient  = new IBinder.DeathRecipient() {
       @Override
       public void binderDied() {
           mIBinderPool.asBinder().unlinkToDeath(mBinderPoolDeathRecipient,0);
           mIBinderPool = null;
           connectBinderPoolService();
       }
   };

    public static class BinderPoolImpl extends IBinderPool.Stub{

        public BinderPoolImpl(){
            super();
        }

        @Override
        public IBinder queryBinder(int binderCode) throws RemoteException {
            IBinder binder = null;
            switch (binderCode){
                case BINDER_SECURUITY_CENTER:
                    binder = new SecurityCenterImpl();
                    break;
                case BINDER_COMPUTE:
                    binder = new ComputeImpl();
                    break;
            }
            return binder;
        }
    }
}

Binder連接池就具體的分析完了，他的好處顯而易見，針對上面的例子，我們只需要創建一個Service就可以完成多個AIDL的工作，我們現在可以來驗證一下他的功能，新創建一個Activity，在線程中執行如下的操作

package com.liuguilin.contentprovidersampler;

/*
 *  項目名：  ContentProviderSampler 
 *  包名：    com.liuguilin.contentprovidersampler
 *  文件名:   BinderActivity
 *  創建者:   LGL
 *  創建時間:  2016/10/22 18:26
 *  描述：    TODO
 */

import android.os.Bundle;
import android.os.IBinder;
import android.os.RemoteException;
import android.support.v7.app.AppCompatActivity;

public class BinderActivity extends AppCompatActivity{

    private ISecurityCenter mSecurityCenter;
    private ICompute mCompute;

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

        new Thread(new Runnable() {
            @Override
            public void run() {
                dowork();
            }
        }).start();
    }

    private void dowork() {
        BinderPool binderPool = BinderPool.getInstance(BinderActivity.this);
        IBinder securityBinder = binderPool.queryBinder(BinderPool.BINDER_SECURUITY_CENTER);
        mSecurityCenter = SecurityCenterImpl.asInterface(securityBinder);
        String msg = "Android";
        try {
            String password = mSecurityCenter.encrypt(msg);
            System.out.print(mSecurityCenter.decrypt(password));
        } catch (RemoteException e) {
            e.printStackTrace();
        }

        IBinder computeBinder =  binderPool.queryBinder(BinderPool.BINDER_COMPUTE);
        mCompute = ComputeImpl.asInterface(computeBinder);
        try {
            System.out.print(mCompute.add(3,5));
        } catch (RemoteException e) {
            e.printStackTrace();
        }
    }
}

這裡需要額外說明一下，為什麼要在線程中去執行呢？這是因為在Binder連接池的實現中，我們通過CountDownLatch將bindService這一異步操作轉換成了同步操作，這就意味著他有可能是耗時的，然後就是Binder方法的調用過程也可能是耗時的，因此不建議放在主線程中執行。注意到BindePool是一個單例實現，因此在同一個進程中只會初始化一次，所以如果我們提前初始化BinderPool，那麼可以優化程序的體驗，比如我們可以放在Application中提前對BinderPool進行初始化，雖然這不能保證當我們調用BinderPool時它一定是初始化，好的，但是在大多數情況下，這種初始化工作（綁定遠程服務）的時間開銷（如果Binderpool沒有提前初始化完成的話)是可以接受的。另外，BinderPool中有斷線重連的機制，當遠程服務意外終止時，BinderPool會重新建立連接，這個時候如果業務模塊中的Binder調用出了異常，也需要手動去重新獲取最新的Binder對象，這個是需要注意的。

有了BinderPool可以大大方便日常的開發工作，比如如果有一個新的業務模塊需要添加新的AIDL，那麼在他實現自己的AIDL接口後，只需要修改BinderPoolImpl中的queryBinder方法，給自己添加新的binderCode並返回對應的Binder對象就可以，不需要做其他的修改，野不需要創建新的Service，由此可見，BinderPool能夠極大的提高對AIDL的開發效率，並且可以避免大量的Service創建，因此比較建議使用