前言

Android Framework 層程式碼中大量使用了 Binder IPC 通訊方式，除此之外，Socket 也是一種重要的 IPC 通訊方式，比如StorageManagerService（8.0 之前叫 MountService）與 Vold 之前的通訊，SystemServer 和 Zygote 之間也是通過 Socket 進行通訊的。

本文簡單總結下 Android Java 層在使用 Socket 通訊時的一般步驟，然後給出一個簡單的 demo。

原理性的東西涉及到不同網路層之間的協議，本著簡單、實用、粗暴的原則，本文暫不涉及原理性的東西。

上圖是從 https://blog.csdn.net/yhaolpz/article/details/59483916 處扒來的圖片，以下例項程式碼也是從該處獲取，非原創。

1，Socket通訊的實現步驟

Socket 通訊和 Binder 通訊類似，也是一種 C/S 模型的通訊方式。

1.1 Server 服務端

步驟一： 建立一個伺服器 Socket

常見的一個伺服器 Socket 類是 ServerSocket，ServerSocket 類常用三個方法：binder 、accept、close。

bind 方法為 ServerSocket 繫結 IP 地址和埠號，並開始監聽該埠；accept 方法為 ServerSocket 接收請求並返回一個Socket 物件，accept 方法呼叫之後將一直阻塞，直到有請求達到；close 方法關閉一個 ServerSocket 物件。

初始化是一般需要設定 IP 地址和埠號

步驟二： 通過監聽獲取一個用於通訊的 Socket 物件

這一步直接通過上述 accept 方法的執行就可實現

步驟三： 在一個新執行緒中，通過對 Socket 物件進行封裝，分別得到輸入、輸出流的引用物件，通過這兩個物件向 Client 端傳送或者從 Client 端接收資料，進而實現 Socket 通訊。

一般選擇在迴圈中讀取 Client 傳送過來的資訊，並作出對應的處理，比如反饋 Client 端：自己已成功收到相應的訊息。

步驟四： 在適當的時機關閉 Socket 連線

服務端程式碼：

public class SocketTest {

    private static final int PORT = 9999;
    private List<Socket> mList = new ArrayList<Socket>();
    private ServerSocket server = null;
    private ExecutorService mExecutorService = null;
    private String receiveMsg;
    private String sendMsg;

    public static void main(String[] args) {
        new SocketTest();
    }

    public SocketTest() {
        try {
            server = new ServerSocket(PORT);                         //步驟一
 

            mExecutorService = Executors.newCachedThreadPool();
            System.out.println("伺服器已啟動...");
            Socket client = null;
            while (true) {
                client = server.accept();         //步驟二，每接受到一個新Socket連線請求，就會新建一個Thread去處理與其之間的通訊
                mList.add(client);
                mExecutorService.execute(new Service(client));
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    class Service implements Runnable {
        private Socket socket;
        private BufferedReader in = null;
        private PrintWriter printWriter=null;

        public Service(Socket socket) {                         //這段程式碼對應步驟三
            this.socket = socket;
            try {
                printWriter = new PrintWriter(new BufferedWriter(new OutputStreamWriter( socket.getOutputStream(), "UTF-8")), true);
                in = new BufferedReader(new InputStreamReader(
                        socket.getInputStream(),"UTF-8"));
                printWriter.println("成功連線伺服器"+"（伺服器傳送）");
                System.out.println("成功連線伺服器");
            } catch (IOException e) {
                e.printStackTrace();
            }

        }

        @Override
        public void run() {
            try {
                while (true) {                                   //迴圈接收、讀取 Client 端傳送過來的資訊
                    if ((receiveMsg = in.readLine())!=null) {
                        System.out.println("receiveMsg:"+receiveMsg);
                        if (receiveMsg.equals("0")) {
                            System.out.println("客戶端請求斷開連線");
                            printWriter.println("服務端斷開連線"+"（伺服器傳送）");
                            mList.remove(socket);
                            in.close();
                            socket.close();                         //接受 Client 端的斷開連線請求，並關閉 Socket 連線
                            break;
                        } else {
                            sendMsg = "我已接收：" + receiveMsg + "（伺服器傳送）";
                            printWriter.println(sendMsg);           //向 Client 端反饋、傳送資訊
                        }
                    }
                }
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
    }
}

1.2 Client 客戶端

步驟一： 初始化 Socket 物件

客戶端一般選擇在一個新的執行緒中，初始化一個 Socket 物件，初始化是需要設定 IP 和埠號，以幫助低層網路路由找到相應的服務端程序。

步驟二： 獲取與 Server 端通訊的引用

此步和 Server 端建立連線後的步驟類似：根據步驟一中獲取的 Socket 物件，進行封裝，得到相應的輸入、輸出流物件，這些輸入、輸出流物件就是和 Server 端進行通訊的引用。

步驟三： 通過步驟二中得到的引用，迴圈的讀取（在新執行緒中） Server 端傳送過來的訊息，並做相應的處理

步驟四：在合適的時機關閉與 Server 端的 Socket 連線

參考以下客戶端程式碼：

public class SocketActivity extends AppCompatActivity {

    private EditText mEditText;
    private TextView mTextView;
    private static final String TAG = "TAG";
    private static final String HOST = "192.168.23.1";
    private static final int PORT = 9999;
    private PrintWriter printWriter;
    private BufferedReader in;
    private ExecutorService mExecutorService = null;
    private String receiveMsg;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_socket);
        mEditText = (EditText) findViewById(R.id.editText);
        mTextView = (TextView) findViewById(R.id.textView);
        mExecutorService = Executors.newCachedThreadPool();
    }

    public void connect(View view) {
        mExecutorService.execute(new connectService());  //在一個新的執行緒中請求 Socket 連線
    }

    public void send(View view) {
        String sendMsg = mEditText.getText().toString();
        mExecutorService.execute(new sendService(sendMsg));
    }

    public void disconnect(View view) {
        mExecutorService.execute(new sendService("0"));
    }

    private class sendService implements Runnable {
        private String msg;

        sendService(String msg) {
            this.msg = msg;
        }

        @Override
        public void run() {
            printWriter.println(this.msg);
        }
    }

    private class connectService implements Runnable {
        @Override
        public void run() {//可以考慮在此處新增一個while迴圈，結合下面的catch語句，實現Socket物件獲取失敗後的超時重連，直到成功建立Socket連線
            try {
                Socket socket = new Socket(HOST, PORT);      //步驟一
                socket.setSoTimeout(60000);
                printWriter = new PrintWriter(new BufferedWriter(new OutputStreamWriter(   //步驟二
                        socket.getOutputStream(), "UTF-8")), true);
                in = new BufferedReader(new InputStreamReader(socket.getInputStream(), "UTF-8"));
                receiveMsg();
            } catch (Exception e) {
                Log.e(TAG, ("connectService:" + e.getMessage()));   //如果Socket物件獲取失敗，即連線建立失敗，會走到這段邏輯
            }
        }
    }

    private void receiveMsg() {
        try {
            while (true) {                                      //步驟三
                if ((receiveMsg = in.readLine()) != null) {
                    Log.d(TAG, "receiveMsg:" + receiveMsg);
                    runOnUiThread(new Runnable() {
                        @Override
                        public void run() {
                            mTextView.setText(receiveMsg + "\n\n" + mTextView.getText());
                        }
                    });
                }
            }
        } catch (IOException e) {
            Log.e(TAG, "receiveMsg: ");
            e.printStackTrace();
        }
    }
}

2. 總結

原諒我這篇文章結構上的簡潔和草率，哈哈，第二部分就直接結束了

在實現Socket通訊時要重點關注新執行緒和while迴圈的使用。

在Android主執行緒中不能進行網路通訊的大原則下，Server端和Client端分別使用不同的機制，在新執行緒中啟動Socket連線；連線建立之後，通過while迴圈實現通訊雙方的“準實時”訊息處理。