一、基础知识准备

在正式给大家介绍自定义协议之前，我们先对网络传输和协议解析的相关知识点做一个基本的介绍，尽管这些知识点我们在学校里学过，但难免会有所遗忘，这里先做一个简单的介绍，以便对后文的内容理解更加顺畅。

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

Socket本质是编程接口(API)，对TCP/IP的封装，TCP/IP也要提供可供程序员做网络开发所用的接口，这就是Socket编程接口，通常也称作"套接字"。套接字之间的连接过程可以分为三个步骤：客户端请求，服务端回复收到，客户端收到服务端的回复，即三次握手。连接成功时，应用程序两端都会产生一个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中各类型占字节数

1. byte      8位，1个字节 
2. boolean   8位，1个字节 
3. char      16位，2个字节 
4. short     16位，2个字节 
5. int       32位，4个字节 
6. float     32位，4个字节 
7. double    64位，8个字节 
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的状态是否处于连接中 

1. 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. 客户端

1. import java.net.Socket; 
2.  
3. /** 
4.  * Created by meishan on 16/12/1. 
5.  */ 
6. public class Client { 
7.     public static void main(String[] args) throws Exception { 
8.         boolean isConnected; 
9.         String host = "127.0.0.1"; 
10.         int port = 1122; 
11.         Socket socket = null; 
12.         try { 
13.             socket = SocketFactory.getDefault().createSocket(host, port); 
14.             isConnected = true; 
15.             System.out.println("连接成功！"); 
16.         } catch (ConnectException e) { 
17.             isConnected = false; 
18.             e.printStackTrace(); 
19.             System.out.println("连接失败！"); 
20.         } 
21.  
22.         if (!isConnected) { 
23.             return; 
24.         } 
25.  
26.         Thread.sleep(5000); 
27.  
28.         socket.close(); 
29.         System.out.println("断开连接！"); 
30.     } 
31. }  

2. 服务端

1. import java.io.IOException; 
2. import java.net.ServerSocket; 
3. import java.net.Socket; 
4.  
5. /** 
6.  * Created by meishan on 16/12/1. 
7.  */ 
8. public class Server { 
9.  
10.     private int port = 1122; 
11.     private ServerSocket serverSocket; 
12.  
13.     public Server() throws Exception { 
14.         serverSocket = new ServerSocket(port, 3);//显式设置连接请求队列的长度为3 
15.         System.out.println("服务器启动!"); 
16.     } 
17.  
18.     public void service() { 
19.         while (true) { 
20.             Socket socket = null; 
21.             try { 
22.                 socket = serverSocket.accept(); 
23.                 System.out.println("New connection accepted " + socket.getInetAddress() + ":" + socket.getPort()); 
24.             } catch (IOException e) { 
25.                 e.printStackTrace(); 
26.             } finally { 
27.                 if (socket != null) { 
28.                     try { 
29.                         socket.close(); 
30.                     } catch (IOException e) { 
31.                         e.printStackTrace(); 
32.                     } 
33.                 } 
34.             } 
35.         } 
36.     } 
37.  
38.     public static void main(String[] args) throws Exception { 
39.         Server server = new Server(); 
40.         Thread.sleep(3000); 
41.         server.service(); 
42.     } 
43. }  

三、一个简单的自定义协议例子

例子中，数据包的定义：消息对象=包类型+包长度+消息内容

• 包类型 byte 型
• 包长度 int 型
• 消息内容 byte[] 型

1. 客户端

1. import java.io.DataOutputStream; 
2. import java.io.IOException; 
3. import java.io.OutputStream; 
4. import java.net.Socket; 
5. import java.net.UnknownHostException; 
6. import java.util.Scanner; 
7.  
8. /** 
9.  * Created by meishan on 16/12/1. 
10.  */ 
11. public class Client { 
12.  
13.     public static void main(String[] args) { 
14.         try { 
15.             Socket client = new Socket("127.0.0.1", 9091); 
16.             OutputStream out = client.getOutputStream(); 
17.             DataOutputStream outs = new DataOutputStream(out); 
18.             while (true) { 
19.                 Scanner scaner = new Scanner(System.in); 
20.                 genProtocol(outs, scaner.next()); 
21.             } 
22.         } catch (UnknownHostException e) { 
23.             e.printStackTrace(); 
24.         } catch (IOException e) { 
25.             e.printStackTrace(); 
26.         } 
27.     } 
28.  
29.     /** 
30.      * 构造协议 
31.      * 
32.      * @param out 
33.      * @param msg 
34.      * @throws IOException 
35.      */ 
36.     private static void genProtocol(DataOutputStream out, String msg) throws IOException { 
37.         int type = 1;                          //消息类型 
38.         byte[] bytes = msg.getBytes();         //消息内容 
39.         int totalLen = 1 + 4 + bytes.length;   //消息长度 
40.  
41.         out.writeByte(type);                   //写入消息类型 
42.         out.writeInt(totalLen);                //写入消息长度 
43.         out.write(bytes);                      //写入消息内容 
44.  
45.         out.flush(); 
46.     } 
47. }  

2. 服务端

1. import java.io.DataInputStream; 
2. import java.io.IOException; 
3. import java.io.InputStream; 
4. import java.net.ServerSocket; 
5. import java.net.Socket; 
6.  
7. /** 
8.  * Created by meishan on 16/12/1. 
9.  */ 
10. public class Server { 
11.  
12.     public static void main(String[] args) { 
13.         try { 
14.             ServerSocket server = new ServerSocket(9091); 
15.             while (true) { 
16.                 Socket client = server.accept(); 
17.                 System.out.println("客户端" + client.getRemoteSocketAddress() + "连接成功"); 
18.                 parseProtocol(client); 
19.             } 
20.         } catch (IOException e) { 
21.             e.printStackTrace(); 
22.         } 
23.     } 
24.  
25.     /** 
26.      * 消息解析 
27.      * 
28.      * @param client 
29.      * @throws IOException 
30.      */ 
31.     private static void parseProtocol(Socket client) throws IOException { 
32.         InputStream is = client.getInputStream(); 
33.         DataInputStream dis = new DataInputStream(is); //读取Java标准数据类型的输入流 
34.  
35.         //协议解析 
36.         while (true) { 
37.             byte type = dis.readByte();               //读取消息类型 
38.             int totalLen = dis.readInt();             //读取消息长度 
39.             byte[] data = new byte[totalLen - 4 - 1]; //定义存放消息内容的字节数组 
40.             dis.readFully(data);                      //读取消息内容 
41.             String msg = new String(data);            //消息内容 
42.  
43.             System.out.println("接收消息类型" + type); 
44.             System.out.println("接收消息长度" + totalLen); 
45.             System.out.println("发来的内容是:" + msg); 
46.         } 
47.     } 
48. }  

四、总结

本文简单介绍了socket通信和自定义协议的相关知识点，为后续的深入做一些准备工作，下一篇文章《基于Java Socket的自定义协议，实现Android与服务器的长连接(二)》将通过一个实例来详细讲解自定义协议实现长连接通信。