Netty解决TCP粘包拆包问题

什么是TCP粘包/拆包

TCP是一种面向连接的、可靠的、基于字节流的传输层通信协议。TCP是基于字节流传输的，就像河流一样，数据“流”式传输，数据中间没有分界。

TCP底层并不了解上层业务数据的具体含义，它会根据TCP缓冲区的实际情况进行包的划分，所以一个完整的数据包可能会拆分成多个包传输，或者多个数据包可能会合并成一个包传输，这就是所谓的TCP的粘包/拆包问题。如下图所示：

正常业务逻辑上，Client需要向Server发送D1和D2两个数据包（如上图第一种情况）；但实际在TCP传输的过程中，可能会将D1和D2合并为一个数据包发送（如上图第二种情况）；也有可能D2被拆分成两个数据包，其中一个跟D1合并成了一个数据包（如上图第三种情况）;又或者D1被拆分成两个数据包，其中一个跟D2合并成了一个数据包（如上图第四种情况）。

还有一种可能，当服务端接收滑窗非常小，而D1、D2数据又很大的时候，可能会分多次才能将D1、D2两个数据接收完全。

TCP粘包/拆包发送的原因

TCP发送粘包/拆包的原因主要有以下几个：
(1)应用程序write写入的字节大小大于套接口发送缓冲区大小。
(2)进行MSS（最大报文段长度）大小的TCP分段。当TCP报文段的长度大于MSS时，要进行分段传输。
(3)以太网帧的payload大于MTU（最大传输单元）进行IP分片。一个IP数据报在以太网中 传输，如果它的长度大于该MTU值，就要进行分片传输，使得每片数据报的长度小于MTU。

使用Netty未考虑TCP粘包的示例

仍然还是用之前的客户端向服务端请求时间的案例来改造。之前的示例没有出现粘包/拆包问题是因为客户端与服务器之间只是一问一答，并没有太大的流量压力。这次为了呈现问题，我们将服务器端增加一个计数，每收到一个TCP数据包计数加一；在客户端上，循环发送100条请求，每接收到一条服务端的回复也计数加一。

服务端NettyServerTest类：

package com.test.netty;

import io.netty.bootstrap.ServerBootstrap;
import io.netty.channel.ChannelFuture;
import io.netty.channel.ChannelInitializer;
import io.netty.channel.ChannelOption;
import io.netty.channel.EventLoopGroup;
import io.netty.channel.nio.NioEventLoopGroup;
import io.netty.channel.socket.SocketChannel;
import io.netty.channel.socket.nio.NioServerSocketChannel;

public class NettyServerTest {
   
	
	public void bind(int port) throws InterruptedException {
   
		// NioEventLoopGroup 是用来处理I/O操作的多线程事件循环器
		// 第一个经常被叫做‘boss’，用来接收进来的连接
		EventLoopGroup bossGroup = new NioEventLoopGroup();
		// 第二个经常被叫做‘worker’，用来处理已经被接收的连接，一旦‘boss’接收到连接，就会把连接信息注册到‘worker’上
		EventLoopGroup workerGroup = new NioEventLoopGroup();
		try {
   
			// ServerBootstrap 是一个启动 NIO 服务的辅助启动类
			ServerBootstrap b = new ServerBootstrap();
			b.group(bossGroup, workerGroup)
				.channel(NioServerSocketChannel.class)
				// 设置 socket 的参数选项
				.option(ChannelOption.SO_BACKLOG, 1024)
				.childHandler(new childChannelHandler());
			// 绑定端口，同步等待成功
			ChannelFuture f = b.bind(port).sync();
			
			// 等待服务端监听端口关闭
			f.channel().closeFuture().sync();
			
		}finally {
   
			// 优雅退出，释放线程资源
			bossGroup.shutdownGracefully();
			workerGroup.shutdownGracefully();
		}
	}
	
	/**
	 * ChannelInitializer 是一个特殊的处理类，他的目的是帮助使用者配置一个新的 Channel
	 * @author 
	 *
	 */
	private class childChannelHandler extends ChannelInitializer<SocketChannel>{
   

		@Override
		protected void initChannel(SocketChannel arg0) throws Exception {
   
			arg0.pipeline().addLast(new ServerTestHandler());
		}
		
	}

	public static void main(String[] args) throws InterruptedException {
   
		int port = 8888;
		new NettyServerTest().bind(port);
	}

}

服务端ServerTestHandler类：

package com.test.netty;

import io.netty.buffer.ByteBuf;
import io.netty.buffer.Unpooled;
import io.netty.channel.ChannelHandlerContext;
import io.netty.channel.ChannelInboundHandlerAdapter;

public class ServerTestHandler extends ChannelInboundHandlerAdapter  {
   
	
	private int counter;
	
	/**
	 * 每当从客户端收到新的数据时，channelRead()方法会在收到消息时被调用
	 */
	@Override
	public void channelRead(ChannelHandlerContext ctx, Object msg) throws Exception {
   
		ByteBuf buf = (ByteBuf) msg;
		byte[] req = new byte[buf.readableBytes()];
		buf.readBytes(req);
		String body = new String(req, "UTF-8").substring(0, req.length - System.getProperty("line.separator").length());
		System.out.println("The time server receive order : " + body + " ; the counter is : " + ++counter);
		String currentTime = "QUERY TIME ORDER".equalsIgnoreCase(body) ? new java.util.Date(
				System.currentTimeMillis()).toString() : "BAD ORDER";
			currentTime = currentTime + System.getProperty("line.separator");
		ByteBuf resp = Unpooled.copiedBuffer(currentTime.getBytes());
		ctx.write(resp);
	}
	
	@Override
	public void channelReadComplete(ChannelHandlerContext ctx) throws Exception {
   
		// 将消息发送发送队列中的消息写入到SocketChannel中发送给对方
		ctx.flush();
	}
	
	/**
	 * exceptionCaught() 事件处理方法是当出现 Throwable 对象才会被调用，
	 * 即当 Netty 由于 IO 错误或者处理器在处理事件时抛出的异常时
	 */
	@Override
	public void exceptionCaught(ChannelHandlerContext ctx, Throwable cause) {
   
		System.out.println(cause.getMessage());
		ctx.close();
	}
}

客户端NettyClientTest：

package com.test.netty;

import io.netty.bootstrap.Bootstrap;
import io.netty.channel.ChannelFuture;
import io.netty.channel.ChannelInitializer;
import io.netty.channel.ChannelOption;
import io.netty.channel.EventLoopGroup;
import io.netty.channel.nio.NioEventLoopGroup;
import io.netty.channel.socket.SocketChannel;
import io.netty.channel.socket.nio.NioSocketChannel;

public class NettyClientTest {
   

	public void connect(int port, String host) throws Exception {
   
		// 配置客户端NIO线程组
		EventLoopGroup group = new NioEventLoopGroup();
		try {
   
			Bootstrap b = new Bootstrap();
			b.group(group).channel(NioSocketChannel.class)
				.option(ChannelOption.TCP_NODELAY, true)
				.handler(new ChannelInitializer<SocketChannel>() {
   

				@Override
				protected void initChannel(SocketChannel ch) throws Exception {
   
					// TODO Auto-generated method stub
					ch.pipeline().addLast(new ClientTestHandler());
				}
				
			});
			// 发起异步连接操作
			ChannelFuture f = b.connect(host, port).sync();
			// 等待客户端链路关闭
			f.channel().closeFuture().sync();
		} finally {
   
			// 优雅退出，释放NIO线程组
			group.shutdownGracefully();
		}
	}
	
	public static void main(String[] args) throws Exception {
   
		int port = 8888;
		new NettyClientTest().connect(port, "127.0.0.1");
	}

}

客户端ClientTestHandler类：

package com.test.netty;

import java.util.logging.Logger;

import io.netty.buffer.ByteBuf;
import io.netty.buffer.Unpooled;
import io.netty.channel.ChannelHandlerContext;
import io.netty.channel.ChannelInboundHandlerAdapter;

public class ClientTestHandler extends Cha