基于Java Socket的自定義協議，實現Android與服務器的長連接（一）

作者：枚杉 2016-12-05 17:08:30

Socket本質是編程接口(API)，對TCP/IP的封裝，TCP/IP也要提供可供程序員做網絡開發所用的接口，這就是Socket編程接口，通常也稱作"套接字"。套接字之間的連接過程可以分為三個步驟：客戶端請求，服務端回復收到，客戶端收到服務端的回復，即三次握手。連接成功時，應用程序兩端都會產生一個Socket實例，操作這個實例完成所需的會話。

一、基礎知識準備

在正式給大家介紹自定義協議之前，我們先對網絡傳輸和協議解析的相關知識點做一個基本的介紹，盡管這些知識點我們在學校里學過，但難免會有所遺忘，這里先做一個簡單的介紹，以便對后文的內容理解更加順暢。

[[178013]]

1. 網絡七層協議

OSI的7層從上到下分別是：7 應用層、 6 表示層、 5 會話層、 4 傳輸層、 3 網絡層、 2 數據鏈路層、 1 物理層;其中高層(即7、6、5、4層)定義了應用程序的功能，下面3層(即3、2、1層)主要面向通過網絡的端到端的數據流。應用層常見的協議有：HTTP、FTP、SMTP等;常見的傳輸層有：TCP、UDP。本文主要是基于TCP自定義協議實現客戶端與服務端的長連接。

2. Socket

3. 位(bit)、字節(byte)

“位(bit)”是電子計算機中最小的數據單位。每一位的狀態只能是0或1;“字節(Byte)”由8個二進制位構成(即1byte=8bit)，它是存儲空間的基本計量單位，它能表示到數值范圍為0到255(即2的8次方減1);

4. 算術移位運算(符號位不變，低位補0)

左移運算：1<<2，1的二進制位是1，向左移兩位是100，轉為十進制數即為4，所以1<<2的運算結果是4;
右移運算：7>>2，7的二進制位是111，向右移兩位是1，所以7>>2的運算結果是1 。

5. Java中各類型占字節數

byte      8位，1個字節 
boolean   8位，1個字節 
char      16位，2個字節 
short     16位，2個字節 
int       32位，4個字節 
float     32位，4個字節 
double    64位，8個字節 
long      64位，8個字節

6. Java中socket相關函數

Socket構造函數
- Socket(InetAddress address, int port)throws UnknownHostException, IOException
- Socket(InetAddress address, int port, InetAddress localAddress, int localPort)throws IOException
- Socket(String host, int port)throws UnknownHostException, IOException
- Socket(String host, int port, InetAddress localAddress, int localPort)throws IOException
- 還可以通過以下方式生成socket：

SocketFactory.getDefault().createSocket(String address, String port) throws ConnectException

Socket方法
- getInetAddress(); // 遠程服務端的IP地址
- getPort(); // 遠程服務端的端口
- getLocalAddress(); // 本地客戶端的IP地址
- getLocalPort(); // 本地客戶端的端口
- getInputStream(); // 獲得輸入流
- getOutStream(); // 獲得輸出流
Socket狀態
- isClosed(); // 連接是否已關閉，若關閉，返回true;否則返回false
- isConnect(); // 如果曾經連接過，返回true;否則返回false
- isBound(); // 如果Socket已經與本地一個端口綁定，返回true;否則返回false
- 判斷Socket的狀態是否處于連接中

boolean isConnected = socket.isConnected() && !socket.isClosed(); // 判斷當前是否處于連接

ServerSocket構造函數
- ServerSocket()throws IOException
- ServerSocket(int port)throws IOException
- ServerSocket(int port, int backlog)throws IOException
- ServerSocket(int port, int backlog, InetAddress bindAddr)throws IOException
服務端接收客戶端的連接請求：
- Socket socket = serverSocket.accept();

7. Java中常見流操作類

輸入流
- InputStream
  - 抽象類，描述流的輸入
- ByteArrayInputStream
  - 從字節數組讀取的輸入流
- BufferedInputStream
  - 緩沖輸入流
- FileInputStream
  - 從文件讀入的輸入流
- ObjectInputStream
  - 對象輸入流(所讀寫的對象必須實現Serializable接口)
- DataInputStream
  - 包含了讀取Java標準數據類型的輸入流
輸出流
- OutputStream
  - 抽象類，描述流的輸入
- ByteArrayOutputStream
  - 寫入字節數組的輸出流
- BufferedOutputStream
  - 緩沖輸出流
- FileOutputStream
  - 寫入文件的輸出流
- ObjectOutputStream
  - 對象輸出流(所讀寫的對象必須實現Serializable接口)
- DataOutputStream
  - 包含了寫Java標準數據類型的輸出流

二、一個簡單的socket連接例子

注：先運行服務端代碼的main函數，再運行客戶端代碼的main函數，即可看到打印連接成功

1. 客戶端

import java.net.Socket; 
 
/** 
 * Created by meishan on 16/12/1. 
 */ 
public class Client { 
    public static void main(String[] args) throws Exception { 
        boolean isConnected; 
        String host = "127.0.0.1"; 
        int port = 1122; 
        Socket socket = null; 
        try { 
            socket = SocketFactory.getDefault().createSocket(host, port); 
            isConnected = true; 
            System.out.println("連接成功！"); 
        } catch (ConnectException e) { 
            isConnected = false; 
            e.printStackTrace(); 
            System.out.println("連接失敗！"); 
        } 
 
        if (!isConnected) { 
            return; 
        } 
 
        Thread.sleep(5000); 
 
        socket.close(); 
        System.out.println("斷開連接！"); 
    } 
}

2. 服務端

import java.io.IOException; 
import java.net.ServerSocket; 
import java.net.Socket; 
 
/** 
 * Created by meishan on 16/12/1. 
 */ 
public class Server { 
 
    private int port = 1122; 
    private ServerSocket serverSocket; 
 
    public Server() throws Exception { 
        serverSocket = new ServerSocket(port, 3);//顯式設置連接請求隊列的長度為3 
        System.out.println("服務器啟動!"); 
    } 
 
    public void service() { 
        while (true) { 
            Socket socket = null; 
            try { 
                socket = serverSocket.accept(); 
                System.out.println("New connection accepted " + socket.getInetAddress() + ":" + socket.getPort()); 
            } catch (IOException e) { 
                e.printStackTrace(); 
            } finally { 
                if (socket != null) { 
                    try { 
                        socket.close(); 
                    } catch (IOException e) { 
                        e.printStackTrace(); 
                    } 
                } 
            } 
        } 
    } 
 
    public static void main(String[] args) throws Exception { 
        Server server = new Server(); 
        Thread.sleep(3000); 
        server.service(); 
    } 
}

三、一個簡單的自定義協議例子

例子中，數據包的定義：消息對象=包類型+包長度+消息內容

包類型 byte 型
包長度 int 型
消息內容 byte[] 型

1. 客戶端

import java.io.DataOutputStream; 
import java.io.IOException; 
import java.io.OutputStream; 
import java.net.Socket; 
import java.net.UnknownHostException; 
import java.util.Scanner; 
 
/** 
 * Created by meishan on 16/12/1. 
 */ 
public class Client { 
 
    public static void main(String[] args) { 
        try { 
            Socket client = new Socket("127.0.0.1", 9091); 
            OutputStream out = client.getOutputStream(); 
            DataOutputStream outs = new DataOutputStream(out); 
            while (true) { 
                Scanner scaner = new Scanner(System.in); 
                genProtocol(outs, scaner.next()); 
            } 
        } catch (UnknownHostException e) { 
            e.printStackTrace(); 
        } catch (IOException e) { 
            e.printStackTrace(); 
        } 
    } 
 
    /** 
     * 構造協議 
     * 
     * @param out 
     * @param msg 
     * @throws IOException 
     */ 
    private static void genProtocol(DataOutputStream out, String msg) throws IOException { 
        int type = 1;                          //消息類型 
        byte[] bytes = msg.getBytes();         //消息內容 
        int totalLen = 1 + 4 + bytes.length;   //消息長度 
 
        out.writeByte(type);                   //寫入消息類型 
        out.writeInt(totalLen);                //寫入消息長度 
        out.write(bytes);                      //寫入消息內容 
 
        out.flush(); 
    } 
}

2. 服務端

import java.io.DataInputStream; 
import java.io.IOException; 
import java.io.InputStream; 
import java.net.ServerSocket; 
import java.net.Socket; 
 
/** 
 * Created by meishan on 16/12/1. 
 */ 
public class Server { 
 
    public static void main(String[] args) { 
        try { 
            ServerSocket server = new ServerSocket(9091); 
            while (true) { 
                Socket client = server.accept(); 
                System.out.println("客戶端" + client.getRemoteSocketAddress() + "連接成功"); 
                parseProtocol(client); 
            } 
        } catch (IOException e) { 
            e.printStackTrace(); 
        } 
    } 
 
    /** 
     * 消息解析 
     * 
     * @param client 
     * @throws IOException 
     */ 
    private static void parseProtocol(Socket client) throws IOException { 
        InputStream is = client.getInputStream(); 
        DataInputStream dis = new DataInputStream(is); //讀取Java標準數據類型的輸入流 
 
        //協議解析 
        while (true) { 
            byte type = dis.readByte();               //讀取消息類型 
            int totalLen = dis.readInt();             //讀取消息長度 
            byte[] data = new byte[totalLen - 4 - 1]; //定義存放消息內容的字節數組 
            dis.readFully(data);                      //讀取消息內容 
            String msg = new String(data);            //消息內容 
 
            System.out.println("接收消息類型" + type); 
            System.out.println("接收消息長度" + totalLen); 
            System.out.println("發來的內容是:" + msg); 
        } 
    } 
}

四、總結

本文簡單介紹了socket通信和自定義協議的相關知識點，為后續的深入做一些準備工作，下一篇文章《基于Java Socket的自定義協議，實現Android與服務器的長連接(二)》將通過一個實例來詳細講解自定義協議實現長連接通信。

責任編輯：龐桂玉來源： segmentfault