【Netty入门】解决TCP粘包/分包的实例

回顾TCP粘包/分包问题的解决方法

1.消息定长

2.在包尾都增加特殊字符进行分割

3.将消息分为消息头和消息体

针对这三种方法，下面我会分别举例验证

FixedLengthFrameDecoder类

对应第一种解决方法：消息定长

（1）例1：服务端代码：

public class Server4 {    public static void main(String[] args) throws SigarException {        //boss线程监听端口，worker线程负责数据读写        EventLoopGroup boss = new NioEventLoopGroup();        EventLoopGroup worker = new NioEventLoopGroup();        try{            //辅助启动类            ServerBootstrap bootstrap = new ServerBootstrap();            //设置线程池            bootstrap.group(boss,worker);            //设置socket工厂            bootstrap.channel(NioServerSocketChannel.class);            //设置管道工厂            bootstrap.childHandler(new ChannelInitializer<SocketChannel>() {                @Override                protected void initChannel(SocketChannel socketChannel) throws Exception {                    //获取管道                    ChannelPipeline pipeline = socketChannel.pipeline();                    //定长解码类                    pipeline.addLast(new FixedLengthFrameDecoder(19));                    //字符串解码类                    pipeline.addLast(new StringDecoder());                    //处理类                    pipeline.addLast(new ServerHandler4());                }            });            //绑定端口            ChannelFuture future = bootstrap.bind(8866).sync();            System.out.println("server start ...... ");            //等待服务端监听端口关闭            future.channel().closeFuture().sync();        } catch (InterruptedException e) {            e.printStackTrace();        }finally {            //优雅退出，释放线程池资源            boss.shutdownGracefully();            worker.shutdownGracefully();        }    }}class ServerHandler4 extends SimpleChannelInboundHandler <String>{    //用于记录次数    private int count = 0;    //读取客户端发送的数据    @Override    protected void channelRead0(ChannelHandlerContext ctx, String msg) throws Exception {        System.out.println("RESPONSE--------"+msg+";"+"   @ "+ ++count);    }    //新客户端接入    @Override    public void channelActive(ChannelHandlerContext ctx) throws Exception {        System.out.println("channelActive");    }    //客户端断开    @Override    public void channelInactive(ChannelHandlerContext ctx) throws Exception {        System.out.println("channelInactive");    }    //异常    @Override    public void exceptionCaught(ChannelHandlerContext ctx, Throwable cause) throws Exception {        //关闭通道        ctx.channel().close();        //打印异常        cause.printStackTrace();    }}

（2）例1：客户端代码：

public class Client4 {    public static void main(String[] args) {        //worker负责读写数据        EventLoopGroup worker = new NioEventLoopGroup();        try {            //辅助启动类            Bootstrap bootstrap = new Bootstrap();            //设置线程池            bootstrap.group(worker);            //设置socket工厂            bootstrap.channel(NioSocketChannel.class);            //设置管道            bootstrap.handler(new ChannelInitializer<SocketChannel>() {                @Override                protected void initChannel(SocketChannel socketChannel) throws Exception {                    //获取管道                    ChannelPipeline pipeline = socketChannel.pipeline();                    //定长解码类                    pipeline.addLast(new FixedLengthFrameDecoder(19));                    //字符串编码类                    pipeline.addLast(new StringEncoder());                    //处理类                    pipeline.addLast(new ClientHandler4());                }            });            //发起异步连接操作            ChannelFuture futrue = bootstrap.connect(new InetSocketAddress("127.0.0.1",8866)).sync();            //等待客户端链路关闭            futrue.channel().closeFuture().sync();        } catch (InterruptedException e) {            e.printStackTrace();        } finally {            //优雅的退出，释放NIO线程组            worker.shutdownGracefully();        }    }}class ClientHandler4 extends SimpleChannelInboundHandler<String> {    //接受服务端发来的消息    @Override    protected void channelRead0(ChannelHandlerContext ctx, String msg) throws Exception {        System.out.println("server response ： "+msg);    }    //与服务器建立连接    @Override    public void channelActive(ChannelHandlerContext ctx) throws Exception {        //给服务器发消息        String s = System.getProperty("line.separator");        //发送50次消息        for (int i = 0; i < 50; i++) {            ctx.channel().writeAndFlush("  I am client    "+s);        }    }    //与服务器断开连接    @Override    public void channelInactive(ChannelHandlerContext ctx) throws Exception {        System.out.println("channelInactive");    }    //异常    @Override    public void exceptionCaught(ChannelHandlerContext ctx, Throwable cause) throws Exception {        //关闭管道        ctx.channel().close();        //打印异常信息        cause.printStackTrace();    }}

例1服务端运行结果：

…………………….此处省略多行………………….

分析：从运行结果可以看出，符合我们的预期，并没有TCP粘包问题，这是因为使用的定长解码器的原因，我在此解释一下例1client/server代码中新增加了几个“陌生”的类，若之后再次出现，则不作解释！

• FixedLengthFrameDecoder类：用于固定长度消息的粘包分包处理，可以携带参数，我在代码中指定的参数为19，因为我要发送的字符长度为19。
• StringDecoder类 ：用于字符串的解码。
• StringEncoder类 ：用于字符串的编码。

LineBasedFrameDecoder类

对应第二种解决方法：在包尾都增加特殊字符（行分隔符）进行分割

（1）例2：服务端代码：

public class Server4 {    public static void main(String[] args) throws SigarException {        //boss线程监听端口，worker线程负责数据读写        EventLoopGroup boss = new NioEventLoopGroup();        EventLoopGroup worker = new NioEventLoopGroup();        try{            //辅助启动类            ServerBootstrap bootstrap = new ServerBootstrap();            //设置线程池            bootstrap.group(boss,worker);            //设置socket工厂            bootstrap.channel(NioServerSocketChannel.class);            //设置管道工厂            bootstrap.childHandler(new ChannelInitializer<SocketChannel>() {                @Override                protected void initChannel(SocketChannel socketChannel) throws Exception {                    //获取管道                    ChannelPipeline pipeline = socketChannel.pipeline();                    //行分隔符解码类                    pipeline.addLast(new LineBasedFrameDecoder(1024));                    //字符串解码类                    pipeline.addLast(new StringDecoder());                    //处理类                    pipeline.addLast(new ServerHandler4());                }            });            //绑定端口            ChannelFuture future = bootstrap.bind(8866).sync();            System.out.println("server start ...... ");            //等待服务端监听端口关闭            future.channel().closeFuture().sync();        } catch (InterruptedException e) {            e.printStackTrace();        }finally {            //优雅退出，释放线程池资源            boss.shutdownGracefully();            worker.shutdownGracefully();        }    }}class ServerHandler4 extends SimpleChannelInboundHandler <String>{    //用于记录次数    private int count = 0;    //读取客户端发送的数据    @Override    protected void channelRead0(ChannelHandlerContext ctx, String msg) throws Exception {        System.out.println("RESPONSE--------"+msg+";"+"   @ "+ ++count);    }    //新客户端接入    @Override    public void channelActive(ChannelHandlerContext ctx) throws Exception {        System.out.println("channelActive");    }    //客户端断开    @Override    public void channelInactive(ChannelHandlerContext ctx) throws Exception {        System.out.println("channelInactive");    }    //异常    @Override    public void exceptionCaught(ChannelHandlerContext ctx, Throwable cause) throws Exception {        //关闭通道        ctx.channel().close();        //打印异常        cause.printStackTrace();    }}

（2）例2：客户端代码：

public class Client4 {    public static void main(String[] args) {        //worker负责读写数据        EventLoopGroup worker = new NioEventLoopGroup();        try {            //辅助启动类            Bootstrap bootstrap = new Bootstrap();            //设置线程池            bootstrap.group(worker);            //设置socket工厂            bootstrap.channel(NioSocketChannel.class);            //设置管道            bootstrap.handler(new ChannelInitializer<SocketChannel>() {                @Override                protected void initChannel(SocketChannel socketChannel) throws Exception {                    //获取管道                    ChannelPipeline pipeline = socketChannel.pipeline();                    //行分隔符解码类                    pipeline.addLast(new LineBasedFrameDecoder(1024));                    //字符串编码类                    pipeline.addLast(new StringEncoder());                    //处理类                    pipeline.addLast(new ClientHandler4());                }            });            //发起异步连接操作            ChannelFuture futrue = bootstrap.connect(new InetSocketAddress("127.0.0.1",8866)).sync();            //等待客户端链路关闭            futrue.channel().closeFuture().sync();        } catch (InterruptedException e) {            e.printStackTrace();        } finally {            //优雅的退出，释放NIO线程组            worker.shutdownGracefully();        }    }}class ClientHandler4 extends SimpleChannelInboundHandler<String> {    //接受服务端发来的消息    @Override    protected void channelRead0(ChannelHandlerContext ctx, String msg) throws Exception {        System.out.println("server response ： "+msg);    }    //与服务器建立连接    @Override    public void channelActive(ChannelHandlerContext ctx) throws Exception {        //给服务器发消息        String s = System.getProperty("line.separator");        //发送50次消息        for (int i = 0; i < 50; i++) {            ctx.channel().writeAndFlush("  I am client    "+s);        }    }    //与服务器断开连接    @Override    public void channelInactive(ChannelHandlerContext ctx) throws Exception {        System.out.println("channelInactive");    }    //异常    @Override    public void exceptionCaught(ChannelHandlerContext ctx, Throwable cause) throws Exception {        //关闭管道        ctx.channel().close();        //打印异常信息        cause.printStackTrace();    }}

例2服务端运行结果：

…………………….此处省略多行………………….

分析：从运行结果可以看出没有TCP粘包问题了，细心的你或许已经发现代码中新出现了一个LineBasedFrameDecoder类，它可以携带参数，我指定的参数为1024，含义为在每1024个字节中寻找换行符，若有，就发送消息，否则继续寻找。

DelimiterBasedFrameDecoder类

对应第二种解决方法：在包尾都增加特殊字符（#）进行分割

例3：服务端代码，和例2服务端代码类似，由于篇幅有限，我就仅仅指出它们不一样的地方了！

将例2服务端 第23行 和第24行 代码修改为

//自定义分隔符解码类pipeline.addLast(newDelimiterBasedFrameDecoder(1024,Unpooled.copiedBuffer("#".getBytes())));

例3：客户端代码：（和例2客户端代码的不同之处）

将例2客户端 第24行 和第25行 代码修改为

//自定义分隔符解码类pipeline.addLast(newDelimiterBasedFrameDecoder(1024,Unpooled.copiedBuffer("#".getBytes())));

再将例2客户端 第63行 代码修改为

ctx.channel().writeAndFlush("  I am  client    "+"#");

例3服务端运行结果：

…………………….此处省略多行………………….

分析：从运行结果可以看出TCP粘包问题解决了！代码中新出现了一个DelimiterBasedFrameDecoder类，它可以携带参数，我指定的参数为(1024,Unpooled.copiedBuffer(“#”.getBytes())))，含义为在每1024个字节中寻找#，若有，就发送消息，否则继续寻找。

MyRequestDecoder自定义类

对应第三种方法：将消息分为消息头和消息体

对于消息头和消息体，有三种情况分别如下：

• 有头部的拆包与粘包：

  lengthFieldOffset = 2 长度字段偏移量 ( = 外部头部Header 1的长度)
  lengthFieldLength = 3 长度字段占用字节数
  lengthAdjustment = 0
  initialBytesToStrip = 0

• 长度字段在前且有头部的拆包与粘包：

  lengthFieldOffset = 0 长度字段偏移量
  lengthFieldLength = 3 长度字段占用字节数
  lengthAdjustment = 2 ( Header 1 的长度)
  initialBytesToStrip = 0

• 多扩展头部的拆包与粘包：
  lengthFieldOffset = 1 长度字段偏移量(=头HDR1的长度)
  lengthFieldLength = 2 长度字段占用字节数
  lengthAdjustment = 1 调整长度(= 头HDR2的长度)
  initialBytesToStrip = 3 排除的偏移量(= the length of HDR1 + LEN)

举一个简单的例子

例4：

import netty.EnDecode.Request;/** * 请求解码器 * <pre> * 数据包格式 * +——----——+——-----——+——----——+——----——+——-----——+ * | 包头   | 模块号    | 命令号 |  长度   |   数据   | * +——----——+——-----——+——----——+——----——+——-----——+ * </pre> * 包头4字节 * 模块号2字节short * 命令号2字节short * 长度4字节(描述数据部分字节长度) */public class MyRequestDecoder extends FrameDecoder{    //数据包基本长度    public static final int BASE_LENTH = 4 + 2 + 2 + 4;    @Override    protected Object decode(ChannelHandlerContext arg0, Channel arg1, ChannelBuffer buffer) throws Exception {        //可读长度必须大于基本长度        if(buffer.readableBytes() >= BASE_LENTH){            //防止socket字节流攻击            if(buffer.readableBytes() > 2048){                buffer.skipBytes(buffer.readableBytes());            }            //记录包头开始的index            int beginReader;            while(true){                beginReader = buffer.readerIndex();                buffer.markReaderIndex();                if(buffer.readInt() == -32523523){                    break;                }                //未读到包头，略过一个字节                buffer.resetReaderIndex();                buffer.readByte();                //长度又变得不满足                if(buffer.readableBytes() < BASE_LENTH){                    return null;                }            }            //模块号            short module = buffer.readShort();            //命令号            short cmd = buffer.readShort();            //长度            int length = buffer.readInt();            //判断请求数据包数据是否到齐            if(buffer.readableBytes() < length){                //还原读指针                buffer.readerIndex(beginReader);                return null;            }            //读取data数据            byte[] data = new byte[length];            buffer.readBytes(data);            Request request = new Request();            request.setModule(module);            request.setCmd(cmd);            request.setData(data);            //继续往下传递             return request;        }        //数据包不完整，需要等待后面的包来        return null;    }}

本人才疏学浅，如有错误，请指出
谢谢！