Netty 框架学习(二)：Netty粘包和拆包

一、什么是粘包和拆包

先从数据的发送和接收讲起， Netty 发送和读取数据的单位，使用 ByteBuf 来充当。每一次发送，就是向Channel 写入一个 ByteBuf ；每一次读取，就是从 Channel 读到一个 ByteBuf 。

发送一次数据调用如下方法：

channel.writeAndFlush(buffer);

读取一次数据调用如下方法：

public void channelRead(ChannelHandlerContext ctx, Object msg)
{
		ByteBuf byteBuf = (ByteBuf) msg;
   //....
}

我们理想是：发送端每发送一个buffer，接收端就能接收到一个一模一样的buffer。

但是实际通讯情况可能不能很好的满足，所以就会发生粘包和拆包。

1. 粘包指接收端读取的时候，多个发送过来的 ByteBuf “粘”在了一起。换句话说，接收端读取一次的 ByteBuf ，读到了多个发送端的 ByteBuf ，是为粘包。
2. 就是接收端将一个发送端的ByteBuf “拆”开了，形成一个破碎的包，我们定义这种 ByteBuf 为半包。
   换句话说，接收端读取一次的 ByteBuf ，读到了发送端的一个 ByteBuf的一部分，是为半包。

更加深理解这两个词，我们把Netty权威指南图拿过来看下：

• 服务端分两次读到了两个独立的数据包，分别是D1和D2，没有粘包和拆包
• 服务端一次接收到了两个数据包，D1和D2粘在一起，发生了粘包
• 服务端分两次读到了两个数据包，一次读到了完整的D1包和D2的部分包D2_1，第二次读到了D2剩下的包D2_2
• 服务端分两次读到了两个数据包，一次读到了D1的部分分D1_1,第二次读到了D1的剩下的包D1_2和完整的D2包

二、粘包和拆包示例代码

把上一篇文章的服务端和客户端修改下

1、TimeServerHandler

public class TimeServerHandler extends ChannelInboundHandlerAdapter {

    private int counter;

    /**
     * 收到客户端消息，自动触发
     * @param ctx
     * @param msg
     * @throws Exception
     */
    @Override
    public void channelRead(ChannelHandlerContext ctx, Object msg)
            throws Exception {
        //将 msg 转为 Netty 的 ByteBuf 对象，类似 JDK 中的 java.nio.ByteBuffer，不过 ButeBuf 功能更强，更灵活
        ByteBuf buf = (ByteBuf) msg;
        //readableBytes：获取缓冲区可读字节数,然后创建字节数组
        //从而避免了像 java.nio.ByteBuffer 时，只能盲目的创建特定大小的字节数组，比如 1024

         byte[] req = new byte[buf.readableBytes()];
        //readBytes：将缓冲区字节数组复制到新建的 byte 数组中
        //然后将字节数组转为字符串

        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));
        //回复消息
        //copiedBuffer：创建一个新的缓冲区，内容为里面的参数
        //通过 ChannelHandlerContext 的 write 方法将消息异步发送给客户端*/
        String currentTime = "QUERY TIME ORDER".equalsIgnoreCase(body) ? new java.util.Date(
                System.currentTimeMillis()).toString() : "BAD ORDER";
        ByteBuf resp = Unpooled.copiedBuffer(currentTime.getBytes());
        ctx.write(resp);
    }

    @Override
    public void channelReadComplete(ChannelHandlerContext ctx) throws Exception {
        //flush：将消息发送队列中的消息写入到 SocketChannel 中发送给对方，为了频繁的唤醒 Selector 进行消息发送
        //Netty 的 write 方法并不直接将消息写如 SocketChannel 中，调用 write 只是把待发送的消息放到发送缓存数组中，再通过调用 flush
        //方法，将发送缓冲区的消息全部写入到 SocketChannel 中
        ctx.flush();
    }

    @Override
    public void exceptionCaught(ChannelHandlerContext ctx, Throwable cause) {
        /**当发生异常时，关闭 ChannelHandlerContext，释放和它相关联的句柄等资源 */
        ctx.close();
    }
}

2、TimeClientHandler

public class TimeClientHandler extends ChannelInboundHandlerAdapter {


    private int counter;

    private byte[] req;

    /**
     * Creates a client-side handler.
     */
    public TimeClientHandler() {
       req = ("QUERY TIME ORDER" + System.getProperty("line.separator")).getBytes();
    }

    /**
     * 当客户端和服务端 TCP 链路建立成功之后，Netty 的 NIO 线程会调用 channelActive 方法
     * @param ctx
     */
    @Override
    public void channelActive(ChannelHandlerContext ctx) {
        ByteBuf message = null;
        for (int i = 0;i<100;i++) {
            message = Unpooled.buffer(req.length);
            message.writeBytes(req);
            ctx.writeAndFlush(message);
        }
    }

    /**
     * 当服务端返回应答消息时，channelRead 方法被调用，从 Netty 的 ByteBuf 中读取并打印应答消息
     * @param ctx
     * @param msg
     * @throws Exception
     */
    @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");
        System.out.println("Now is : " + body + "this counter is:" + (++counter));
    }

    @Override
    public void exceptionCaught(ChannelHandlerContext ctx, Throwable cause) {
        // 释放资源
        System.out.println("Unexpected exception from downstream : "
                + cause.getMessage());
        ctx.close();
    }
}

运行程序之后服务端和客户端打印结果为：


说明以上程序发生了粘包。

三、使用Netty解决粘包和拆包

还使用上一节示例代码

1、TimeServerHandler中的ChildChannelHandler

public class ChildChannelHandler extends ChannelInitializer<SocketChannel> {
    protected void initChannel(SocketChannel socketChannel) throws Exception {
        socketChannel.pipeline().addLast(new LineBasedFrameDecoder(1024));
        socketChannel.pipeline().addLast(new StringEncoder());
        socketChannel.pipeline().addLast(new TimeServerHandler());
    }
}

2、TimeClientHandler

public class TimeClientHandler extends ChannelInboundHandlerAdapter {


    private int counter;

    private byte[] req;

    /**
     * Creates a client-side handler.
     */
    public TimeClientHandler() {
       req = ("QUERY TIME ORDER" + System.getProperty("line.separator")).getBytes();
    }

    /**
     * 当客户端和服务端 TCP 链路建立成功之后，Netty 的 NIO 线程会调用 channelActive 方法
     * @param ctx
     */
    @Override
    public void channelActive(ChannelHandlerContext ctx) {
        ByteBuf message = null;
        for (int i = 0;i<100;i++) {
            message = Unpooled.buffer(req.length);
            message.writeBytes(req);
            ctx.writeAndFlush(message);
        }
    }

    /**
     * 当服务端返回应答消息时，channelRead 方法被调用，从 Netty 的 ByteBuf 中读取并打印应答消息
     * @param ctx
     * @param msg
     * @throws Exception
     */
    @Override
    public void channelRead(ChannelHandlerContext ctx, Object msg)
            throws Exception {
        ByteBuf body = (ByteBuf) msg;
        System.out.println("Now is : " + body + "this counter is:" + (++counter));
    }

    @Override
    public void exceptionCaught(ChannelHandlerContext ctx, Throwable cause) {
        // 释放资源
        System.out.println("Unexpected exception from downstream : "
                + cause.getMessage());
        ctx.close();
    }
}

四、LineBasedFrameDecoder和StringEncoder

LineBasedFrameDecoder工作原理是依次遍历ByteBuf中可读字节，判断是否有"\n"，"\r\n"。如果有，就以此位置为结束位置。它是以换行符为结束的解码器。支持携带结束符或者不带结束符两种方式。同时支持配置行数最大长度。如果读取到最大行数还没有发现换行符，就会抛出异常，同时忽略掉以前的异常码流。