https://www.cnblogs.com/sidesky/p/6913109.html

1、什麼是粘包/拆包

       一般所謂的TCP粘包是在一次接收資料不能完全地體現一個完整的訊息資料。TCP通訊為何存在粘包呢？主要原因是TCP是以流的方式來處理資料，再加上網路上MTU的往往小於在應用處理的訊息資料，所以就會引發一次接收的資料無法滿足訊息的需要，導致粘包的存在。處理粘包的唯一方法就是制定應用層的資料通訊協議，通過協議來規範現有接收的資料是否滿足訊息資料的需要。

2、解決辦法

     2.1、訊息定長，報文大小固定長度，不夠空格補全，傳送和接收方遵循相同的約定，這樣即使粘包了通過接收方程式設計實現獲取定長報文也能區分。

     2.2、包尾新增特殊分隔符，例如每條報文結束都添加回車換行符（例如FTP協議）或者指定特殊字元作為報文分隔符，接收方通過特殊分隔符切分報文區分。

     2.3、將訊息分為訊息頭和訊息體，訊息頭中包含表示資訊的總長度（或者訊息體長度）的欄位

3、自定義協議，來實現TCP的粘包/拆包問題

      3.0  自定義協議，開始標記           

      3.1  自定義協議的介紹

      3.2  自定義協議的類的封裝

      3.3  自定義協議的編碼器

      3.4  自定義協議的解碼器

4、協議相關的實現

      4.1  協議的封裝

[java] view plain copy

 print?

1. import java.util.Arrays;  
2.   
3. /** 
4.  * <pre> 
5.  * 自己定義的協議 
6.  *  資料包格式 
7.  * +——----——+——-----——+——----——+ 
8.  * |協議開始標誌|  長度             |   資料       | 
9.  * +——----——+——-----——+——----——+ 
10.  * 1.協議開始標誌head_data，為int型別的資料，16進製表示為0X76 
11.  * 2.傳輸資料的長度contentLength，int型別 
12.  * 3.要傳輸的資料 
13.  * </pre> 
14.  */  
15. public class SmartCarProtocol {  
16.     /** 
17.      * 訊息的開頭的資訊標誌 
18.      */  
19.     private int head_data = ConstantValue.HEAD_DATA;  
20.     /** 
21.      * 訊息的長度 
22.      */  
23.     private int contentLength;  
24.     /** 
25.      * 訊息的內容 
26.      */  
27.     private byte[] content;  
28.   
29.     /** 
30.      * 用於初始化，SmartCarProtocol 
31.      *  
32.      * @param contentLength 
33.      *            協議裡面，訊息資料的長度 
34.      * @param content 
35.      *            協議裡面，訊息的資料 
36.      */  
37.     public SmartCarProtocol(int contentLength, byte[] content) {  
38.         this.contentLength = contentLength;  
39.         this.content = content;  
40.     }  
41.   
42.     public int getHead_data() {  
43.         return head_data;  
44.     }  
45.   
46.     public int getContentLength() {  
47.         return contentLength;  
48.     }  
49.   
50.     public void setContentLength(int contentLength) {  
51.         this.contentLength = contentLength;  
52.     }  
53.   
54.     public byte[] getContent() {  
55.         return content;  
56.     }  
57.   
58.     public void setContent(byte[] content) {  
59.         this.content = content;  
60.     }  
61.   
62.     @Override  
63.     public String toString() {  
64.         return "SmartCarProtocol [head_data=" + head_data + ", contentLength="  
65.                 + contentLength + ", content=" + Arrays.toString(content) + "]";  
66.     }  
67.   
68. }  

      4.2  協議的編碼器

[java] view plain copy

 print?

1. /** 
2.  * <pre> 
3.  * 自己定義的協議 
4.  *  資料包格式 
5.  * +——----——+——-----——+——----——+ 
6.  * |協議開始標誌|  長度             |   資料       | 
7.  * +——----——+——-----——+——----——+ 
8.  * 1.協議開始標誌head_data，為int型別的資料，16進製表示為0X76 
9.  * 2.傳輸資料的長度contentLength，int型別 
10.  * 3.要傳輸的資料 
11.  * </pre> 
12.  */  
13. public class SmartCarEncoder extends MessageToByteEncoder<SmartCarProtocol> {  
14.   
15.     @Override  
16.     protected void encode(ChannelHandlerContext tcx, SmartCarProtocol msg,  
17.             ByteBuf out) throws Exception {  
18.         // 寫入訊息SmartCar的具體內容  
19.         // 1.寫入訊息的開頭的資訊標誌(int型別)  
20.         out.writeInt(msg.getHead_data());  
21.         // 2.寫入訊息的長度(int 型別)  
22.         out.writeInt(msg.getContentLength());  
23.         // 3.寫入訊息的內容(byte[]型別)  
24.         out.writeBytes(msg.getContent());  
25.     }  
26. }  

      4.3  協議的解碼器

[java] view plain copy

 print?

1. import java.util.List;  
2. import io.netty.buffer.ByteBuf;  
3. import io.netty.channel.ChannelHandlerContext;  
4. import io.netty.handler.codec.ByteToMessageDecoder;  
5.   
6. /** 
7.  * <pre> 
8.  * 自己定義的協議 
9.  *  資料包格式 
10.  * +——----——+——-----——+——----——+ 
11.  * |協議開始標誌|  長度             |   資料       | 
12.  * +——----——+——-----——+——----——+ 
13.  * 1.協議開始標誌head_data，為int型別的資料，16進製表示為0X76 
14.  * 2.傳輸資料的長度contentLength，int型別 
15.  * 3.要傳輸的資料,長度不應該超過2048，防止socket流的攻擊 
16.  * </pre> 
17.  */  
18. public class SmartCarDecoder extends ByteToMessageDecoder {  
19.   
20.     /** 
21.      * <pre> 
22.      * 協議開始的標準head_data，int型別，佔據4個位元組. 
23.      * 表示資料的長度contentLength，int型別，佔據4個位元組. 
24.      * </pre> 
25.      */  
26.     public final int BASE_LENGTH = 4 + 4;  
27.   
28.     @Override  
29.     protected void decode(ChannelHandlerContext ctx, ByteBuf buffer,  
30.             List<Object> out) throws Exception {  
31.         // 可讀長度必須大於基本長度  
32.         if (buffer.readableBytes() >= BASE_LENGTH) {  
33.             // 防止socket位元組流攻擊  
34.             // 防止，客戶端傳來的資料過大  
35.             // 因為，太大的資料，是不合理的  
36.             if (buffer.readableBytes() > 2048) {  
37.                 buffer.skipBytes(buffer.readableBytes());  
38.             }  
39.   
40.             // 記錄包頭開始的index  
41.             int beginReader;  
42.   
43.             while (true) {  
44.                 // 獲取包頭開始的index  
45.                 beginReader = buffer.readerIndex();  
46.                 // 標記包頭開始的index  
47.                 buffer.markReaderIndex();  
48.                 // 讀到了協議的開始標誌，結束while迴圈  
49.                 if (buffer.readInt() == ConstantValue.HEAD_DATA) {  
50.                     break;  
51.                 }  
52.   
53.                 // 未讀到包頭，略過一個位元組  
54.                 // 每次略過，一個位元組，去讀取，包頭資訊的開始標記  
55.                 buffer.resetReaderIndex();  
56.                 buffer.readByte();  
57.   
58.                 // 當略過，一個位元組之後，  
59.                 // 資料包的長度，又變得不滿足  
60.                 // 此時，應該結束。等待後面的資料到達  
61.                 if (buffer.readableBytes() < BASE_LENGTH) {  
62.                     return;  
63.                 }  
64.             }  
65.   
66.             // 訊息的長度  
67.   
68.             int length = buffer.readInt();  
69.             // 判斷請求資料包資料是否到齊  
70.             if (buffer.readableBytes() < length) {  
71.                 // 還原讀指標  
72.                 buffer.readerIndex(beginReader);  
73.                 return;  
74.             }  
75.   
76.             // 讀取data資料  
77.             byte[] data = new byte[length];  
78.             buffer.readBytes(data);  
79.   
80.             SmartCarProtocol protocol = new SmartCarProtocol(data.length, data);  
81.             out.add(protocol);  
82.         }  
83.     }  
84.   
85. }  

      4.4  服務端加入協議的編/解碼器

      4.5  客戶端加入協議的編/解碼器

5、服務端的實現

[java] view plain copy

 print?

1. import io.netty.bootstrap.ServerBootstrap;  
2. import io.netty.channel.ChannelFuture;  
3. import io.netty.channel.ChannelInitializer;  
4. import io.netty.channel.ChannelOption;  
5. import io.netty.channel.EventLoopGroup;  
6. import io.netty.channel.nio.NioEventLoopGroup;  
7. import io.netty.channel.socket.SocketChannel;  
8. import io.netty.channel.socket.nio.NioServerSocketChannel;  
9. import io.netty.handler.logging.LogLevel;  
10. import io.netty.handler.logging.LoggingHandler;  
11.   
12. public class Server {  
13.   
14.     public Server() {  
15.     }  
16.   
17.     public void bind(int port) throws Exception {  
18.         // 配置NIO執行緒組  
19.         EventLoopGroup bossGroup = new NioEventLoopGroup();  
20.         EventLoopGroup workerGroup = new NioEventLoopGroup();  
21.         try {  
22.             // 伺服器輔助啟動類配置  
23.             ServerBootstrap b = new ServerBootstrap();  
24.             b.group(bossGroup, workerGroup)  
25.                     .channel(NioServerSocketChannel.class)  
26.                     .handler(new LoggingHandler(LogLevel.INFO))  
27.                     .childHandler(new ChildChannelHandler())//  
28.                     .option(ChannelOption.SO_BACKLOG, 1024) // 設定tcp緩衝區 // (5)  
29.                     .childOption(ChannelOption.SO_KEEPALIVE, true); // (6)  
30.             // 繫結埠 同步等待繫結成功  
31.             ChannelFuture f = b.bind(port).sync(); // (7)  
32.             // 等到服務端監聽埠關閉  
33.             f.channel().closeFuture().sync();  
34.         } finally {  
35.             // 優雅釋放執行緒資源  
36.             workerGroup.shutdownGracefully();  
37.             bossGroup.shutdownGracefully();  
38.         }  
39.     }  
40.   
41.     /** 
42.      * 網路事件處理器 
43.      */  
44.     private class ChildChannelHandler extends ChannelInitializer<SocketChannel> {  
45.         @Override  
46.         protected void initChannel(SocketChannel ch) throws Exception {  
47.             // 新增自定義協議的編解碼工具  
48.             ch.pipeline().addLast(new SmartCarEncoder());  
49.             ch.pipeline().addLast(new SmartCarDecoder());  
50.             // 處理網路IO  
51.             ch.pipeline().addLast(new ServerHandler());  
52.         }  
53.     }  
54.   
55.     public static void main(String[] args) throws Exception {  
56.         new Server().bind(9999);  
57.     }  
58. }  

6、服務端Handler的實現

[java] view plain copy

 print?

1. import io.netty.channel.ChannelHandlerAdapter;  
2. import io.netty.channel.ChannelHandlerContext;  
3.   
4. public class ServerHandler extends ChannelHandlerAdapter {  
5.     // 用於獲取客戶端傳送的資訊  
6.     @Override  
7.     public void channelRead(ChannelHandlerContext ctx, Object msg)  
8.             throws Exception {  
9.         // 用於獲取客戶端發來的資料資訊  
10.         SmartCarProtocol body = (SmartCarProtocol) msg;  
11.         System.out.println("Server接受的客戶端的資訊 :" + body.toString());  
12.   
13.         // 會寫資料給客戶端  
14.         String str = "Hi I am Server ...";  
15.         SmartCarProtocol response = new SmartCarProtocol(str.getBytes().length,  
16.                 str.getBytes());  
17.         // 當服務端完成寫操作後，關閉與客戶端的連線  
18.         ctx.writeAndFlush(response);  
19.         // .addListener(ChannelFutureListener.CLOSE);  
20.   
21.         // 當有寫操作時，不需要手動釋放msg的引用  
22.         // 當只有讀操作時，才需要手動釋放msg的引用  
23.     }  
24.   
25.     @Override  
26.     public void exceptionCaught(ChannelHandlerContext ctx, Throwable cause)  
27.             throws Exception {  
28.         // cause.printStackTrace();  
29.         ctx.close();  
30.     }  
31. }  

7、客戶端的實現

[java] view plain copy

 print?

1. import io.netty.bootstrap.Bootstrap;  
2. import io.netty.channel.ChannelFuture;  
3. import io.netty.channel.ChannelInitializer;  
4. import io.netty.channel.ChannelOption;  
5. import io.netty.channel.EventLoopGroup;  
6. import io.netty.channel.nio.NioEventLoopGroup;  
7. import io.netty.channel.socket.SocketChannel;  
8. import io.netty.channel.socket.nio.NioSocketChannel;  
9.   
10. public class Client {  
11.   
12.     /** 
13.      * 連線伺服器 
14.      *  
15.      * @param port 
16.      * @param host 
17.      * @throws Exception 
18.      */  
19.     public void connect(int port, String host) throws Exception {  
20.         // 配置客戶端NIO執行緒組  
21.         EventLoopGroup group = new NioEventLoopGroup();  
22.         try {  
23.             // 客戶端輔助啟動類 對客戶端配置  
24.             Bootstrap b = new Bootstrap();  
25.             b.group(group)//  
26.                     .channel(NioSocketChannel.class)//  
27.                     .option(ChannelOption.TCP_NODELAY, true)//  
28.                     .handler(new MyChannelHandler());//  
29.             // 非同步連結伺服器 同步等待連結成功  
30.             ChannelFuture f = b.connect(host, port).sync();  
31.   
32.             // 等待連結關閉  
33.             f.channel().closeFuture().sync();  
34.   
35.         } finally {  
36.             group.shutdownGracefully();  
37.             System.out.println("客戶端優雅的釋放了執行緒資源...");  
38.         }  
39.   
40.     }  
41.   
42.     /** 
43.      * 網路事件處理器 
44.      */  
45.     private class MyChannelHandler extends ChannelInitializer<SocketChannel> {  
46.         @Override  
47.         protected void initChannel(SocketChannel ch) throws Exception {  
48.             // 新增自定義協議的編解碼工具  
49.             ch.pipeline().addLast(new SmartCarEncoder());  
50.             ch.pipeline().addLast(new SmartCarDecoder());  
51.             // 處理網路IO  
52.             ch.pipeline().addLast(new ClientHandler());  
53.         }  
54.   
55.     }  
56.   
57.     public static void main(String[] args) throws Exception {  
58.         new Client().connect(9999, "127.0.0.1");  
59.   
60.     }  
61.   
62. }  

8、客戶端Handler的實現

[java] view plain copy

 print?

1. import io.netty.channel.ChannelHandlerAdapter;  
2. import io.netty.channel.ChannelHandlerContext;  
3. import io.netty.util.ReferenceCountUtil;  
4.   
5. //用於讀取客戶端發來的資訊  
6. public class ClientHandler extends ChannelHandlerAdapter {  
7.   
8.     // 客戶端與服務端，連線成功的售後  
9.     @Override  
10.     public void channelActive(ChannelHandlerContext ctx) throws Exception {  
11.         // 傳送SmartCar協議的訊息  
12.         // 要傳送的資訊  
13.         String data = "I am client ...";  
14.         // 獲得要傳送資訊的位元組陣列  
15.         byte[] content = data.getBytes();  
16.         // 要傳送資訊的長度  
17.         int contentLength = content.length;  
18.   
19.         SmartCarProtocol protocol = new SmartCarProtocol(contentLength, content);  
20.   
21.         ctx.writeAndFlush(protocol);  
22.     }  
23.   
24.     // 只是讀資料，沒有寫資料的話  
25.     // 需要自己手動的釋放的訊息  
26.     @Override  
27.     public void channelRead(ChannelHandlerContext ctx, Object msg)  
28.             throws Exception {  
29.         try {  
30.             // 用於獲取客戶端發來的資料資訊  
31.             SmartCarProtocol body = (SmartCarProtocol) msg;  
32.             System.out.println("Client接受的客戶端的資訊 :" + body.toString());  
33.   
34.         } finally {  
35.             ReferenceCountUtil.release(msg);  
36.         }  
37.     }  
38.   
39.     @Override  
40.     public void exceptionCaught(ChannelHandlerContext ctx, Throwable cause)  
41.             throws Exception {  
42.         ctx.close();  
43.     }  
44.   
45. }