原文地址：https://www.cnblogs.com/dyg0826/p/11335379.html

    TCP（transport control protocol，传输控制协议）是面向连接的，面向流的，提供高可靠性服务。收发两端（客户端和服务器端）都要有一一成对的socket，因此，发送端为了将多个发往接收端的包，更有效的发到对方，使用了优化方法（Nagle算法），将多次间隔较小且数据量小的数据，合并成一个大的数据块，然后进行封包。这样，接收端，就难于分辨出来了，必须提供科学的拆包机制。即面向流的通信是无消息保护边界的。
    图解TCP的粘包和拆包

    TCP粘包和拆包 - 图1

    假设客户端分别发送了两个数据包D1和D2给服务端，由于服务端一次读取到字节数是不确定的，故可能存在以下四种情况：

    1.服务端分两次读取到了两个独立的数据包，分别是D1和D2，没有粘包和拆包

    2.服务端一次接受到了两个数据包，D1和D2粘合在一起，称之为TCP粘包

    3.服务端分两次读取到了数据包，第一次读取到了完整的D1包和D2包的部分内容，第二次读取到了D2包的剩余内容，这称之为TCP拆包

    4.服务端分两次读取到了数据包，第一次读取到了D1包的部分内容D1_1，第二次读取到了D1包的剩余部分内容D1_2和完整的D2包。

    特别要注意的是，如果TCP的接受滑窗非常小，而数据包D1和D2比较大，很有可能会发生第五种情况，即服务端分多次才能将D1和D2包完全接受，期间发生多次拆包。

    粘包、拆包问题的解决方案：定义通信协议

    目前业界主流的协议(protocol)方案可以归纳如下：

    1 定长协议：假设我们规定每3个字节，表示一个有效报文。

    2.特殊字符分隔符协议：在包尾部增加回车或者空格符等特殊字符进行分割 。

    3.长度编码：将消息分为消息头和消息体，消息头中用一个int型数据(4字节)，表示消息体长度的字段。在解析时，先读取内容长度Length，其值为实际消息体内容(Content)占用的字节数，之后必须读取到这么多字节的内容，才认为是一个完整的数据报文。

    下面我用长度编码方式解决TCP的粘包、拆包问题

    首先看一下不使用长度编码协议的时候会发生什么问题？

    Server端测试代码

    1. public class MyServer {
    3.     public static void main(String[] args) throws Exception {
    4.         EventLoopGroup bossGroup = new NioEventLoopGroup(1);
    5.         EventLoopGroup workerGroup = new NioEventLoopGroup();
    7.         try {
    8.             ServerBootstrap serverBootstrap = new ServerBootstrap();
    9.             serverBootstrap.group(bossGroup, workerGroup).channel(NioServerSocketChannel.class).
    10.                     childHandler(new MyServerInitializer());
    12.             ChannelFuture channelFuture = serverBootstrap.bind(8899).sync();
    13.             channelFuture.channel().closeFuture().sync();
    14.         } finally {
    15.             bossGroup.shutdownGracefully();
    16.             workerGroup.shutdownGracefully();
    17.         }
    18.     }
    19. }
    21. public class MyServerHandler extends SimpleChannelInboundHandler<ByteBuf> {
    22.     private int count;
    23.     @Override
    24.     protected void channelRead0(ChannelHandlerContext ctx, ByteBuf msg) throws Exception {
    25.         byte[] buffer = new byte[msg.readableBytes()];
    26.         msg.readBytes(buffer);
    27.         String message = new String(buffer, Charset.forName("utf-8"));
    28.         System.out.println("服务端接收到的消息内容： " + message);
    29.         System.out.println("服务端接收到的消息数量： " + (++this.count));
    30.         ByteBuf responseByteBuf = Unpooled.copiedBuffer(UUID.randomUUID().toString(), Charset.forName("utf-8"));
    31.         ctx.writeAndFlush(responseByteBuf);
    32.     }
    33.     @Override
    34.     public void exceptionCaught(ChannelHandlerContext ctx, Throwable cause) throws Exception {
    35.         cause.printStackTrace();
    36.         ctx.close();
    37.     }
    38. }
    40. public class MyServerInitializer extends ChannelInitializer<SocketChannel> {
    42.     @Override
    43.     protected void initChannel(SocketChannel ch) throws Exception {
    44.         System.out.println(this);
    46.         ChannelPipeline pipeline = ch.pipeline();
    48.         pipeline.addLast(new MyServerHandler());
    49.     }
    50. }

    Client端测试代码

    1. public class MyClient {
    3.     public static void main(String[] args) throws Exception{
    4.         EventLoopGroup eventLoopGroup = new NioEventLoopGroup();
    6.         try {
    7.             Bootstrap bootstrap = new Bootstrap();
    8.             bootstrap.group(eventLoopGroup).channel(NioSocketChannel.class).
    9.                     handler(new MyClientInitializer());
    11.             ChannelFuture channelFuture = bootstrap.connect("localhost", 8899).sync();
    12.             channelFuture.channel().closeFuture().sync();
    13.         } finally {
    14.             eventLoopGroup.shutdownGracefully();
    15.         }
    16.     }
    17. }
    19. public class MyClientHandler extends SimpleChannelInboundHandler<ByteBuf> {
    20.     private int count;
    21.     @Override
    22.     public void channelActive(ChannelHandlerContext ctx) throws Exception {
    23.         for (int i = 0; i < 10; ++i) {
    24.             ByteBuf buffer = Unpooled.copiedBuffer("sent from client ", Charset.forName("utf-8"));
    25.             ctx.writeAndFlush(buffer);
    26.         }
    27.     }
    28.     @Override
    29.     protected void channelRead0(ChannelHandlerContext ctx, ByteBuf msg) throws Exception {
    30.         byte[] buffer = new byte[msg.readableBytes()];
    31.         msg.readBytes(buffer);
    33.         String message = new String(buffer, Charset.forName("utf-8"));
    35.         System.out.println("客户端接收到的消息内容： " + message);
    36.         System.out.println("客户端接收到的消息数量： " + (++this.count));
    37.     }
    38.     @Override
    39.     public void exceptionCaught(ChannelHandlerContext ctx, Throwable cause) throws Exception {
    40.         cause.printStackTrace();
    41.         ctx.close();
    42.     }
    43. }
    45. public class MyClientInitializer extends ChannelInitializer<SocketChannel> {
    47.     @Override
    48.     protected void initChannel(SocketChannel ch) throws Exception {
    49.         ChannelPipeline pipeline = ch.pipeline();
    51.         pipeline.addLast(new MyClientHandler());
    52.     }
    53. }
    1.  启动服务端，然后
    3.  第一次启动客户端，服务端日志：![](https://img2018.cnblogs.com/blog/1496041/201908/1496041-20190811160831364-758557088.png#crop=0&crop=0&crop=1&crop=1&id=TTgda&originHeight=61&originWidth=1738&originalType=binary&ratio=1&rotation=0&showTitle=false&status=done&style=none&title=)
    5.  第二次启动客户端，服务端日志：

    TCP粘包和拆包 - 图2

    1.  第三次启动客户端，服务端日志：

    TCP粘包和拆包 - 图3

    1.  从结果中可以看出发生了粘包问题。
    3.  用长度编码方式解决TCP的粘包和拆包问题
    5.  自定义协议CustomProtocol，解码器MyDecoder，编码器MyEncoder
    1. public class CustomProtocol {
    3.     private int length;
    5.     private byte[] content;
    7.     public int getLength() {
    8.         return length;
    9.     }
    11.     public void setLength(int length) {
    12.         this.length = length;
    13.     }
    15.     public byte[] getContent() {
    16.         return content;
    17.     }
    19.     public void setContent(byte[] content) {
    20.         this.content = content;
    21.     }
    22. }
    24. public class MyDecoder extends ReplayingDecoder<Void> {
    26.     @Override
    27.     protected void decode(ChannelHandlerContext ctx, ByteBuf in, List<Object> out) throws Exception {
    29.         int length = in.readInt();
    31.         byte[] content = new byte[length];
    32.         in.readBytes(content);
    34.         CustomProtocol personProtocol = new CustomProtocol();
    35.         personProtocol.setLength(length);
    36.         personProtocol.setContent(content);
    38.         out.add(personProtocol);
    39.     }
    40. }
    42. public class MyEncoder extends MessageToByteEncoder<CustomProtocol> {
    44.     @Override
    45.     protected void encode(ChannelHandlerContext ctx, CustomProtocol msg, ByteBuf out) throws Exception {
    47.         out.writeInt(msg.getLength());
    48.         out.writeBytes(msg.getContent());
    49.     }
    50. }
    1.  Server端测试代码
    1. public class MyServer {
    3.     public static void main(String[] args) throws Exception {
    4.         EventLoopGroup bossGroup = new NioEventLoopGroup(1);
    5.         EventLoopGroup workerGroup = new NioEventLoopGroup();
    7.         try {
    8.             ServerBootstrap serverBootstrap = new ServerBootstrap();
    9.             serverBootstrap.group(bossGroup, workerGroup).channel(NioServerSocketChannel.class).
    10.                     childHandler(new ChannelInitializer<SocketChannel>() {
    11.                         @Override
    12.                         protected void initChannel(SocketChannel ch) throws Exception {
    13.                             ChannelPipeline pipeline = ch.pipeline();
    15.                             pipeline.addLast(new MyDecoder());
    16.                             pipeline.addLast(new MyEncoder());
    18.                             pipeline.addLast(new MyClientHandler());
    19.                         }
    20.                     });
    22.             ChannelFuture channelFuture = serverBootstrap.bind(8899).sync();
    23.             channelFuture.channel().closeFuture().sync();
    24.         } finally {
    25.             bossGroup.shutdownGracefully();
    26.             workerGroup.shutdownGracefully();
    27.         }
    28.     }
    29. }
    31. public class MyServerHandler extends SimpleChannelInboundHandler<CustomProtocol> {
    33.     private int count;
    35.     @Override
    36.     protected void channelRead0(ChannelHandlerContext ctx, CustomProtocol msg) throws Exception {
    37.         int length = msg.getLength();
    38.         byte[] content = msg.getContent();
    40.         System.out.println("服务端接收到的数据：");
    41.         System.out.println("长度: " + length);
    42.         System.out.println("内容：" + new String(content, Charset.forName("utf-8")));
    44.         System.out.println("服务端接收到的消息数量：" + (++this.count));
    46.         String responseMessage = UUID.randomUUID().toString();
    47.         int responseLength = responseMessage.getBytes("utf-8").length;
    48.         byte[] responseContent = responseMessage.getBytes("utf-8");
    50.         CustomProtocol personProtocol = new CustomProtocol();
    51.         personProtocol.setLength(responseLength);
    52.         personProtocol.setContent(responseContent);
    54.         ctx.writeAndFlush(personProtocol);
    55.     }
    57.     @Override
    58.     public void exceptionCaught(ChannelHandlerContext ctx, Throwable cause) throws Exception {
    59.         cause.printStackTrace();
    60.         ctx.close();
    61.     }
    62. }
    1.  Client端测试代码
    1. public class MyClient {
    3.     public static void main(String[] args) throws Exception {
    4.         EventLoopGroup eventLoopGroup = new NioEventLoopGroup();
    5.         try {
    6.             Bootstrap bootstrap = new Bootstrap();
    7.             bootstrap.group(eventLoopGroup).channel(NioSocketChannel.class).
    8.                     handler(new ChannelInitializer<SocketChannel>() {
    9.                         @Override
    10.                         protected void initChannel(SocketChannel ch) throws Exception {
    11.                             ChannelPipeline pipeline = ch.pipeline();
    13.                             pipeline.addLast(new MyDecoder());
    14.                             pipeline.addLast(new MyEncoder());
    16.                             pipeline.addLast(new MyClientHandler());
    17.                         }
    18.                     });
    19.             ChannelFuture channelFuture = bootstrap.connect("localhost", 8899).sync();
    20.             channelFuture.channel().closeFuture().sync();
    21.         } finally {
    22.             eventLoopGroup.shutdownGracefully();
    23.         }
    24.     }
    25. }
    27. public class MyClientHandler extends SimpleChannelInboundHandler<CustomProtocol> {
    29.     private int count;
    31.     @Override
    32.     public void channelActive(ChannelHandlerContext ctx) throws Exception {
    33.         for (int i = 0; i < 10; ++i) {
    34.             String messageToBeSent = "sent from client ";
    35.             byte[] content = messageToBeSent.getBytes(Charset.forName("utf-8"));
    36.             int length = messageToBeSent.getBytes(Charset.forName("utf-8")).length;
    38.             CustomProtocol personProtocol = new CustomProtocol();
    39.             personProtocol.setLength(length);
    40.             personProtocol.setContent(content);
    42.             ctx.writeAndFlush(personProtocol);
    43.         }
    44.     }
    46.     @Override
    47.     protected void channelRead0(ChannelHandlerContext ctx, CustomProtocol msg) throws Exception {
    48.         int length = msg.getLength();
    49.         byte[] content = msg.getContent();
    51.         System.out.println("客户端接收到的消息： ");
    53.         System.out.println("长度: " + length);
    54.         System.out.println("内容：" + new String(content, Charset.forName("utf-8")));
    56.         System.out.println("客户端接受到的消息数量：" + (++this.count));
    57.     }
    59.     @Override
    60.     public void exceptionCaught(ChannelHandlerContext ctx, Throwable cause) throws Exception {
    61.         cause.printStackTrace();
    62.         ctx.close();
    63.     }
    64. }

    测试结果： TCP粘包和拆包 - 图4

    结果分析：没有发生Tcp的粘包和拆包。