1、什麼是粘包/拆包

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

2、解決辦法

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

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

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

3、Netty中提供了DelimiterBasedFrameDecoder解碼器可以幫助我們輕鬆實現第二種解決方案，、包尾新增特殊分隔符。

4、加入DelimiterBasedFrameDecoder解碼器

      4.1 在服務端，加入DelimiterBasedFrameDecoder解碼器

      4.2 在客戶端，加入DelimiterBasedFrameDecoder解碼器

5、用到的分隔符的定義

public class ConstValue {
	public final static String FUHAO = "$_";
}
 

import io.netty.bootstrap.ServerBootstrap;
import io.netty.buffer.ByteBuf;
import io.netty.buffer.Unpooled;
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;
import io.netty.handler.codec.DelimiterBasedFrameDecoder;
import io.netty.handler.codec.string.StringDecoder;
import io.netty.handler.codec.string.StringEncoder;

public class Server {
	public void bind(int port) throws Exception {
		// 伺服器執行緒組 用於網路事件的處理 一個用於伺服器接收客戶端的連線
		// 另一個執行緒組用於處理SocketChannel的網路讀寫
		EventLoopGroup bossGroup = new NioEventLoopGroup();
		EventLoopGroup workerGroup = new NioEventLoopGroup();
		try {
			// NIO伺服器端的輔助啟動類 降低伺服器開發難度
			ServerBootstrap serverBootstrap = new ServerBootstrap();
			serverBootstrap.group(bossGroup, workerGroup)
					.channel(NioServerSocketChannel.class)// 類似NIO中serverSocketChannel
					.option(ChannelOption.SO_BACKLOG, 1024)// 配置TCP引數
					.option(ChannelOption.SO_BACKLOG, 1024) // 設定tcp緩衝區
					.option(ChannelOption.SO_SNDBUF, 32 * 1024) // 設定傳送緩衝大小
					.option(ChannelOption.SO_RCVBUF, 32 * 1024) // 這是接收緩衝大小
					.option(ChannelOption.SO_KEEPALIVE, true) // 保持連線
					.childHandler(new ChildChannelHandler());// 最後繫結I/O事件的處理類
																// 處理網路IO事件

			// 伺服器啟動後 繫結監聽埠 同步等待成功 主要用於非同步操作的通知回撥 回撥處理用的ChildChannelHandler
			ChannelFuture f = serverBootstrap.bind(port).sync();
			System.out.println("Server啟動");
			// 等待服務端監聽埠關閉
			f.channel().closeFuture().sync();

		} finally {
			// 優雅退出 釋放執行緒池資源
			bossGroup.shutdownGracefully();
			workerGroup.shutdownGracefully();
			System.out.println("伺服器優雅的釋放了執行緒資源...");
		}

	}

	/**
	 * 網路事件處理器
	 */
	private class ChildChannelHandler extends ChannelInitializer<SocketChannel> {
		@Override
		protected void initChannel(SocketChannel ch) throws Exception {
			ch.pipeline().addLast(new StringEncoder());
			// 設定特殊分隔符
			ByteBuf buf = Unpooled.copiedBuffer("$_".getBytes());
			ch.pipeline().addLast(new DelimiterBasedFrameDecoder(1024, buf));
			// 設定字串形式的解碼
			ch.pipeline().addLast(new StringDecoder());
			ch.pipeline().addLast(new ServerHandler());
		}
	}

	public static void main(String[] args) throws Exception {
		int port = 9998;
		new Server().bind(port);
	}

}
 

import io.netty.channel.ChannelHandlerAdapter;
import io.netty.channel.ChannelHandlerContext;

public class ServerHandler extends ChannelHandlerAdapter {

	@Override
	public void channelRead(ChannelHandlerContext ctx, Object msg)
			throws Exception {
		String request = (String) msg;
		System.out.println("Server :" + msg);
		String response = request;
		ctx.writeAndFlush(response + ConstValue.FUHAO);
	}

	@Override
	public void exceptionCaught(ChannelHandlerContext ctx, Throwable t)
			throws Exception {
		ctx.close();
	}

}

import io.netty.bootstrap.Bootstrap;
import io.netty.buffer.ByteBuf;
import io.netty.buffer.Unpooled;
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;
import io.netty.handler.codec.DelimiterBasedFrameDecoder;
import io.netty.handler.codec.string.StringDecoder;
import io.netty.handler.codec.string.StringEncoder;

public class Client {

	/**
	 * 連線伺服器
	 * 
	 * @param port
	 * @param host
	 * @throws Exception
	 */
	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 MyChannelHandler());//
			// 非同步連結伺服器 同步等待連結成功
			ChannelFuture f = b.connect(host, port).sync();
			// 等待連結關閉
			f.channel().closeFuture().sync();

		} finally {
			group.shutdownGracefully();
			System.out.println("客戶端優雅的釋放了執行緒資源...");
		}

	}

	/**
	 * 網路事件處理器
	 */
	private class MyChannelHandler extends ChannelInitializer<SocketChannel> {
		@Override
		protected void initChannel(SocketChannel ch) throws Exception {
			ch.pipeline().addLast(new StringEncoder());
			// 設定特殊分隔符
			ByteBuf buf = Unpooled.copiedBuffer("$_".getBytes());
			ch.pipeline().addLast(new DelimiterBasedFrameDecoder(1024, buf));
			ch.pipeline().addLast(new StringDecoder());
			// 客戶端的處理器
			ch.pipeline().addLast(new ClientHandler());
		}

	}

	public static void main(String[] args) throws Exception {
		new Client().connect(9998, "127.0.0.1");

	}

}

import io.netty.channel.ChannelHandlerAdapter;
import io.netty.channel.ChannelHandlerContext;

public class ClientHandler extends ChannelHandlerAdapter {

	@Override
	public void channelActive(ChannelHandlerContext ctx) throws Exception {
		// 客戶端連線成功，給服務端傳送資料
		ctx.channel().writeAndFlush("aaaaabbbbb" + ConstValue.FUHAO);
		// 增加空格，達到定長
		ctx.channel().writeAndFlush("ccccccc   " + ConstValue.FUHAO);
	}

	@Override
	public void channelRead(ChannelHandlerContext ctx, Object msg)
			throws Exception {
		String response = (String) msg;
		System.out.println("Client: " + response);
	}

	@Override
	public void exceptionCaught(ChannelHandlerContext ctx, Throwable cause)
			throws Exception {
		ctx.close();
	}

}