Netty解决粘包/半包问题（十）

最新推荐文章于 2023-07-06 22:36:31 发布
最新推荐文章于 2023-07-06 22:36:31 发布
阅读量391 收藏 2
点赞数
分类专栏： 网络协议和Netty相关 文章标签： 网络
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/nandao158/article/details/113812198
版权
今天分享Netty解决粘包/半包问题，通常传输均存在这种问题，比如下面默认的代码：
一、存在粘包、半包问题的示例：
1、服务端代码： 
public class EchoServer  {

    private final int port;

    public EchoServer(int port) {
        this.port = port;
    }

    public static void main(String[] args) throws InterruptedException {
        int port = 9999;
        EchoServer echoServer = new EchoServer(port);
        System.out.println("服务器即将启动");
        echoServer.start();
        System.out.println("服务器关闭");
    }

    public void start() throws InterruptedException {
        final EchoServerHandler serverHandler = new EchoServerHandler();
        /**线程组*/
        EventLoopGroup group  = new NioEventLoopGroup();
        try {
            /**服务端启动必备*/
            ServerBootstrap b = new ServerBootstrap();
            b.group(group)
                    .channel(NioServerSocketChannel.class)/**指定使用NIO的通信模式*/
            .localAddress(new InetSocketAddress(port))/**指定监听端口*/
            .childHandler(new ChannelInitializer<SocketChannel>() {
                @Override
                protected void initChannel(SocketChannel ch) throws Exception {
                    ch.pipeline().addLast(serverHandler);
                }
            });
            ChannelFuture f = b.bind().sync();/**异步绑定到服务器，sync()会阻塞到完成*/
            f.channel().closeFuture().sync();/**阻塞当前线程，直到服务器的ServerChannel被关闭*/
        } finally {
            group.shutdownGracefully().sync();
        }
    }
}

服务端操作的业务代码：

@ChannelHandler.Sharable
public class EchoServerHandler extends ChannelInboundHandlerAdapter {

    @Override
    public void channelRead(ChannelHandlerContext ctx, Object msg) throws Exception {
        ByteBuf in = (ByteBuf)msg;
        System.out.println("Server accept: "+in.toString(CharsetUtil.UTF_8));
//
        ctx.writeAndFlush(in);
        //ctx.close();
    }

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

2、客户端代码：

public class EchoClient {

    private final int port;
    private final String host;

    public EchoClient(int port, String host) {
        this.port = port;
        this.host = host;
    }

    public void start() throws InterruptedException {
        EventLoopGroup group = new NioEventLoopGroup();/*线程组*/
        try {
            final Bootstrap b = new Bootstrap();;/*客户端启动必须*/
            b.group(group)/*将线程组传入*/
                    .channel(NioSocketChannel.class)/*指定使用NIO进行网络传输*/
                    .remoteAddress(new InetSocketAddress(host,port))/*配置要连接服务器的ip地址和端口*/
                    .handler(new ChannelInitializer<SocketChannel>() {
                        protected void initChannel(SocketChannel ch) throws Exception {
                            ch.pipeline().addLast(new EchoClientHandler());
                        }
                    });
            ChannelFuture f = b.connect().sync();
            f.channel().closeFuture().sync();
        } finally {
            group.shutdownGracefully().sync();
        }
    }

    public static void main(String[] args) throws InterruptedException {
        new EchoClient(9999,"127.0.0.1").start();
    }
}

客户端操作业务的代码：

public class EchoClientHandler extends SimpleChannelInboundHandler<ByteBuf> {

    private AtomicInteger counter = new AtomicInteger(0);

    /*** 客户端读取到网络数据后的处理*/
    protected void channelRead0(ChannelHandlerContext ctx, ByteBuf msg) throws Exception {
        System.out.println("client Accept["+msg.toString(CharsetUtil.UTF_8)
                +"] and the counter is:"+counter.incrementAndGet());
    }

    /*** 客户端被通知channel活跃后，做事*/
    @Override
    public void channelActive(ChannelHandlerContext ctx) throws Exception {
        ByteBuf msg = null;
        String request = "LILI,Lisi,zhangsan,Wangwu,zhaoliu"
                + System.getProperty("line.separator");
        for(int i=0;i<100;i++){
            msg = Unpooled.buffer(request.length());
            msg.writeBytes(request.getBytes());
            ctx.writeAndFlush(msg);
        }
    }

    /*** 发生异常后的处理*/
    @Override
    public void exceptionCaught(ChannelHandlerContext ctx, Throwable cause) throws Exception {
        cause.printStackTrace();
        ctx.close();
    }
}

3、分别启动服务端和客户端，执行：

服务端执行：

客户端执行结果：

 结果显示仅推送了两次数据，证明发生了粘包问题。
 
二、粘包/半包详解
1、什么是 TCP 粘包半包？如下图所示:
 
 
假设客户端分别发送了两个数据包 D1 和 D2 给服务端，由于服务端一次读取到的字节 数是不确定的，故可能存在以下 4 种情况。
（ 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 包接收完全，期间发生多次拆包。
 
三、TCP 粘包 / 半包发生的原因
由于 TCP 协议本身的机制（面向连接的可靠地协议 - 三次握手机制）客户端与服务器会 维持一个连接（Channel ），数据在连接不断开的情况下，可以持续不断地将多个数据包发 往服务器，但是如果发送的网络数据包太小，那么他本身会启用 Nagle 算法（可配置是否启 用）对较小的数据包进行合并（基于此，TCP 的网络延迟要 UDP 的高些）然后再发送（超 时或者包大小足够）。那么这样的话，服务器在接收到消息（数据流）的时候就无法区分哪 些数据包是客户端自己分开发送的，这样产生了粘包；服务器在接收到数据库后，放到缓冲 区中，如果消息没有被及时从缓存区取走，下次在取数据的时候可能就会出现一次取出多个 数据包的情况，造成粘包现象 UDP：本身作为无连接的不可靠的传输协议（适合频繁发送较小的数据包），他不会对 数据包进行合并发送（也就没有 Nagle 算法之说了），他直接是一端发送什么数据，直接就 发出去了，既然他不会对数据合并，每一个数据包都是完整的（数据+UDP 头 +IP 头等等发一 次数据封装一次）也就没有粘包一说了。 分包产生的原因就简单的多：可能是 IP 分片传输导致的，也可能是传输过程中丢失部分包导致出现的半包，还有可能就是一个包可能被分成了两次传输，在取数据的时候，先取 到了一部分（还可能与接收的缓冲区大小有关系），总之就是一个数据包被分成了多次接收。
更具体的原因有三个，分别如下。
1. 应用程序写入数据的字节大小大于套接字发送缓冲区的大小
2. 进行 MSS 大小的 TCP 分段。 MSS 是最大报文段长度的缩写。 MSS 是 TCP 报文段中的数据字段的最大长度。数据字段加上 TCP 首部才等于整个的 TCP 报文段。所以 MSS 并不是 TCP 报文段的最大长度，而是： MSS=TCP 报文段长度 -TCP 首部长度
3. 以太网的 payload 大于 MTU 进行 IP 分片。 MTU 指：一种通信协议的某一层上面所能 通过的最大数据包大小。如果 IP 层有一个数据包要传，而且数据的长度比链路层的 MTU 大， 那么IP 层就会进行分片，把数据包分成托干片，让每一片都不超过 MTU 。注意， IP 分片可以发生在原始发送端主机上，也可以发生在中间路由器上。
四、解决粘包半包问题
由于底层的 TCP 无法理解上层的业务数据，所以在底层是无法保证数据包不被拆分和重组的，这个问题只能通过上层的应用协议栈设计来解决，根据业界的主流协议的解决方案，
可以归纳如下。
1、  在包尾增加分割符，比如回车换行符进行分割，例如 FTP 协议；（回车换行符进行分割）测试代码如下：
服务端核心代码： 
public class LineBaseEchoServer {

    public static final int PORT = 9998;

    public static void main(String[] args) throws InterruptedException {
        LineBaseEchoServer lineBaseEchoServer = new LineBaseEchoServer();
        System.out.println("服务器即将启动");
        lineBaseEchoServer.start();
    }

    public void start() throws InterruptedException {
        final LineBaseServerHandler serverHandler = new LineBaseServerHandler();
        EventLoopGroup group = new NioEventLoopGroup();/*线程组*/
        try {
            ServerBootstrap b = new ServerBootstrap();/*服务端启动必须*/
            b.group(group)/*将线程组传入*/
                .channel(NioServerSocketChannel.class)/*指定使用NIO进行网络传输*/
                .localAddress(new InetSocketAddress(PORT))/*指定服务器监听端口*/
                /*服务端每接收到一个连接请求，就会新启一个socket通信，也就是channel，
                所以下面这段代码的作用就是为这个子channel增加handle*/
                .childHandler(new ChannelInitializerImp());
            ChannelFuture f = b.bind().sync();/*异步绑定到服务器，sync()会阻塞直到完成*/
            System.out.println("服务器启动完成，等待客户端的连接和数据.....");
            f.channel().closeFuture().sync();/*阻塞直到服务器的channel关闭*/
        } finally {
            group.shutdownGracefully().sync();/*优雅关闭线程组*/
        }
    }

    private static class ChannelInitializerImp extends ChannelInitializer<Channel> {

        @Override
        protected void initChannel(Channel ch) throws Exception {
            ch.pipeline().addLast(new LineBasedFrameDecoder(1024));
            ch.pipeline().addLast(new LineBaseServerHandler());
        }
    }

}

服务端业务代码：

@ChannelHandler.Sharable
public class LineBaseServerHandler extends ChannelInboundHandlerAdapter {

    private AtomicInteger counter = new AtomicInteger(0);

    @Override
    public void channelActive(ChannelHandlerContext ctx) throws Exception {
        System.out.println("客户端：["+ctx.channel().remoteAddress()+"]已连接.........");
    }

    /*** 服务端读取到网络数据后的处理*/
    @Override
    public void channelRead(ChannelHandlerContext ctx, Object msg) throws Exception {
        ByteBuf in = (ByteBuf)msg;
        String request = in.toString(CharsetUtil.UTF_8);
        System.out.println("Server Accept["+request
                +"] and the counter is:"+counter.incrementAndGet());
        String resp = "Hello,"+request+". Welcome to Netty World!"
                + System.getProperty("line.separator");
        ctx.writeAndFlush(Unpooled.copiedBuffer(resp.getBytes()));
    }

    /*** 服务端读取完成网络数据后的处理*/
    @Override
    public void channelReadComplete(ChannelHandlerContext ctx) throws Exception {
        //ctx.writeAndFlush(Unpooled.EMPTY_BUFFER).addListener(ChannelFutureListener.CLOSE);
    }

    /*** 发生异常后的处理*/
    @Override
    public void exceptionCaught(ChannelHandlerContext ctx, Throwable cause) throws Exception {
        cause.printStackTrace();
        ctx.close();
    }

    @Override
    public void channelInactive(ChannelHandlerContext ctx) throws Exception {
        System.out.println(ctx.channel().remoteAddress()+"即将关闭...");
    }
}

客户端核心代码：

public class LineBaseEchoClient {

    private final String host;

    public LineBaseEchoClient(String host) {
        this.host = host;
    }

    public void start() throws InterruptedException {
        EventLoopGroup group = new NioEventLoopGroup();/*线程组*/
        try {
            final Bootstrap b = new Bootstrap();;/*客户端启动必须*/
            b.group(group)/*将线程组传入*/
                    .channel(NioSocketChannel.class)/*指定使用NIO进行网络传输*/
                    .remoteAddress(new InetSocketAddress(host,LineBaseEchoServer.PORT))/*配置要连接服务器的ip地址和端口*/
                    .handler(new ChannelInitializerImp());
            ChannelFuture f = b.connect().sync();
            System.out.println("已连接到服务器.....");
            f.channel().closeFuture().sync();
        } finally {
            group.shutdownGracefully().sync();
        }
    }

    private static class ChannelInitializerImp extends ChannelInitializer<Channel> {

        @Override
        protected void initChannel(Channel ch) throws Exception {
            ch.pipeline().addLast(new LineBasedFrameDecoder(1024));
            ch.pipeline().addLast(new LineBaseClientHandler());
        }
    }

    public static void main(String[] args) throws InterruptedException {
        new LineBaseEchoClient("127.0.0.1").start();
    }
}

客户端业务代码：

public class LineBaseClientHandler extends SimpleChannelInboundHandler<ByteBuf> {

    private AtomicInteger counter = new AtomicInteger(0);

    /*** 客户端读取到网络数据后的处理*/
    protected void channelRead0(ChannelHandlerContext ctx, ByteBuf msg) throws Exception {
        System.out.println("client Accept["+msg.toString(CharsetUtil.UTF_8)
                +"] and the counter is:"+counter.incrementAndGet());
        ctx.close();
    }

    /*** 客户端被通知channel活跃后，做事*/
    @Override
    public void channelActive(ChannelHandlerContext ctx) throws Exception {
        ByteBuf msg = null;
        String request = "LILI,Lisi,zhangsan,Wangwu,zhaoliu"
                + System.getProperty("line.separator");
        for(int i=0;i<10;i++){
            msg = Unpooled.buffer(request.length());
            msg.writeBytes(request.getBytes());
            ctx.writeAndFlush(msg);
        }
    }

    /*** 发生异常后的处理*/
    @Override
    public void exceptionCaught(ChannelHandlerContext ctx, Throwable cause) throws Exception {
        cause.printStackTrace();
        ctx.close();
    }
}

服务端执行结果：

客户端执行结果：

2、（自定义分割符）测试核心代码
 
服务端核心代码： 
public class DelimiterEchoServer {

    public static final String DELIMITER_SYMBOL = "@~";
    public static final int PORT = 9997;

    public static void main(String[] args) throws InterruptedException {
        DelimiterEchoServer delimiterEchoServer = new DelimiterEchoServer();
        System.out.println("服务器即将启动");
        delimiterEchoServer.start();
    }

    public void start() throws InterruptedException {
        final DelimiterServerHandler serverHandler = new DelimiterServerHandler();
        EventLoopGroup group = new NioEventLoopGroup();/*线程组*/
        try {
            ServerBootstrap b = new ServerBootstrap();/*服务端启动必须*/
            b.group(group)/*将线程组传入*/
                .channel(NioServerSocketChannel.class)/*指定使用NIO进行网络传输*/
                .localAddress(new InetSocketAddress(PORT))/*指定服务器监听端口*/
                /*服务端每接收到一个连接请求，就会新启一个socket通信，也就是channel，
                所以下面这段代码的作用就是为这个子channel增加handle*/
                .childHandler(new ChannelInitializerImp());
            ChannelFuture f = b.bind().sync();/*异步绑定到服务器，sync()会阻塞直到完成*/
            System.out.println("服务器启动完成，等待客户端的连接和数据.....");
            f.channel().closeFuture().sync();/*阻塞直到服务器的channel关闭*/
        } finally {
            group.shutdownGracefully().sync();/*优雅关闭线程组*/
        }
    }

    private static class ChannelInitializerImp extends ChannelInitializer<Channel> {

        @Override
        protected void initChannel(Channel ch) throws Exception {
            ByteBuf delimiter = Unpooled.copiedBuffer(DELIMITER_SYMBOL.getBytes());
            ch.pipeline().addLast(new DelimiterBasedFrameDecoder(1024,
                    delimiter));
            ch.pipeline().addLast(new DelimiterServerHandler());
        }
    }
}
服务端业务代码： 
@ChannelHandler.Sharable
public class DelimiterServerHandler extends ChannelInboundHandlerAdapter {

    private AtomicInteger counter = new AtomicInteger(0);

    /*** 服务端读取到网络数据后的处理*/
    @Override
    public void channelRead(ChannelHandlerContext ctx, Object msg) throws Exception {
        ByteBuf in = (ByteBuf) msg;
        String request = in.toString(CharsetUtil.UTF_8);
        System.out.println("Server Accept["+request
                +"] and the counter is:"+counter.incrementAndGet());
        String resp = "Hello,"+request+". Welcome to Netty World!"
                + DelimiterEchoServer.DELIMITER_SYMBOL;
        ctx.writeAndFlush(Unpooled.copiedBuffer(resp.getBytes()));
    }

    /*** 服务端读取完成网络数据后的处理*/
    @Override
    public void channelReadComplete(ChannelHandlerContext ctx) throws Exception {
        ctx.writeAndFlush(Unpooled.EMPTY_BUFFER).addListener(ChannelFutureListener.CLOSE);
    }

    /*** 发生异常后的处理*/
    @Override
    public void exceptionCaught(ChannelHandlerContext ctx, Throwable cause) throws Exception {
        cause.printStackTrace();
        ctx.close();
    }
}

客户端核心代码：

public class DelimiterEchoClient {

    private final String host;

    public DelimiterEchoClient(String host) {
        this.host = host;
    }

    public void start() throws InterruptedException {
        EventLoopGroup group = new NioEventLoopGroup();/*线程组*/
        try {
            final Bootstrap b = new Bootstrap();;/*客户端启动必须*/
            b.group(group)/*将线程组传入*/
                    .channel(NioSocketChannel.class)/*指定使用NIO进行网络传输*/
                    .remoteAddress(new InetSocketAddress(host,DelimiterEchoServer.PORT))/*配置要连接服务器的ip地址和端口*/
                    .handler(new ChannelInitializerImp());
            ChannelFuture f = b.connect().sync();
            System.out.println("已连接到服务器.....");
            f.channel().closeFuture().sync();
        } finally {
            group.shutdownGracefully().sync();
        }
    }

    private static class ChannelInitializerImp extends ChannelInitializer<Channel> {

        @Override
        protected void initChannel(Channel ch) throws Exception {
            ByteBuf delimiter = Unpooled.copiedBuffer(
                    DelimiterEchoServer.DELIMITER_SYMBOL.getBytes());
            ch.pipeline().addLast(new DelimiterBasedFrameDecoder(1024,
                    delimiter));
            ch.pipeline().addLast(new DelimiterClientHandler());
        }
    }

    public static void main(String[] args) throws InterruptedException {
        new DelimiterEchoClient("127.0.0.1").start();
    }
}
客户端业务代码： 
public class DelimiterClientHandler extends SimpleChannelInboundHandler<ByteBuf> {

    private AtomicInteger counter = new AtomicInteger(0);

    /*** 客户端读取到网络数据后的处理*/
    protected void channelRead0(ChannelHandlerContext ctx, ByteBuf msg) throws Exception {
        System.out.println("client Accept["+msg.toString(CharsetUtil.UTF_8)
                +"] and the counter is:"+counter.incrementAndGet());
    }

    /*** 客户端被通知channel活跃后，做事*/
    @Override
    public void channelActive(ChannelHandlerContext ctx) throws Exception {
        ByteBuf msg = null;
        String request = "LILI,Lisi,zhangsan,Wangwu,zhaoliu"
                + DelimiterEchoServer.DELIMITER_SYMBOL;
        for(int i=0;i<10;i++){
            msg = Unpooled.buffer(request.length());
            msg.writeBytes(request.getBytes());
            ctx.writeAndFlush(msg);
        }
    }

    /*** 发生异常后的处理*/
    @Override
    public void exceptionCaught(ChannelHandlerContext ctx, Throwable cause) throws Exception {
        cause.printStackTrace();
        ctx.close();
    }
}

服务端执行结果：

客户端执行结果：

3、消息定长，例如每个报文的大小为固定长度 200 字节，如果不够，空位补空格；

服务端核心代码： 
public class FixedLengthEchoServer {

    public static final String RESPONSE = "Welcome to Netty!";
    public static final int PORT = 9996;

    public static void main(String[] args) throws InterruptedException {
        FixedLengthEchoServer fixedLengthEchoServer = new FixedLengthEchoServer();
        System.out.println("服务器即将启动");
        fixedLengthEchoServer.start();
    }

    public void start() throws InterruptedException {
        final FixedLengthServerHandler serverHandler = new FixedLengthServerHandler();
        EventLoopGroup group = new NioEventLoopGroup();/*线程组*/
        try {
            ServerBootstrap b = new ServerBootstrap();/*服务端启动必须*/
            b.group(group)/*将线程组传入*/
                .channel(NioServerSocketChannel.class)/*指定使用NIO进行网络传输*/
                .localAddress(new InetSocketAddress(PORT))/*指定服务器监听端口*/
                /*服务端每接收到一个连接请求，就会新启一个socket通信，也就是channel，
                所以下面这段代码的作用就是为这个子channel增加handle*/
                .childHandler(new ChannelInitializerImp());
            ChannelFuture f = b.bind().sync();/*异步绑定到服务器，sync()会阻塞直到完成*/
            System.out.println("服务器启动完成，等待客户端的连接和数据.....");
            f.channel().closeFuture().sync();/*阻塞直到服务器的channel关闭*/
        } finally {
            group.shutdownGracefully().sync();/*优雅关闭线程组*/
        }
    }

    private static class ChannelInitializerImp extends ChannelInitializer<Channel> {

        @Override
        protected void initChannel(Channel ch) throws Exception {
            ch.pipeline().addLast(
                    new FixedLengthFrameDecoder(
                            FixedLengthEchoClient.REQUEST.length()));
            ch.pipeline().addLast(new FixedLengthServerHandler());
        }
    }
}
服务端业务代码： 
@ChannelHandler.Sharable
public class FixedLengthServerHandler extends ChannelInboundHandlerAdapter {

    private AtomicInteger counter = new AtomicInteger(0);

    /*** 服务端读取到网络数据后的处理*/
    @Override
    public void channelRead(ChannelHandlerContext ctx, Object msg) throws Exception {
        ByteBuf in = (ByteBuf) msg;
        String request = in.toString(CharsetUtil.UTF_8);
        System.out.println("Server Accept["+request
                +"] and the counter is:"+counter.incrementAndGet());
        ctx.writeAndFlush(Unpooled.copiedBuffer(
                FixedLengthEchoServer.RESPONSE.getBytes()));
    }

    /*** 发生异常后的处理*/
    @Override
    public void exceptionCaught(ChannelHandlerContext ctx, Throwable cause) throws Exception {
        cause.printStackTrace();
        ctx.close();
    }
}

客户端核心代码：

public class FixedLengthEchoClient {

    public final static String REQUEST = "LILI,Lisi,zhangsan,Wangwu,zhaoliu";

    private final String host;

    public FixedLengthEchoClient(String host) {
        this.host = host;
    }

    public void start() throws InterruptedException {
        EventLoopGroup group = new NioEventLoopGroup();/*线程组*/
        try {
            final Bootstrap b = new Bootstrap();;/*客户端启动必须*/
            b.group(group)/*将线程组传入*/
                    .channel(NioSocketChannel.class)/*指定使用NIO进行网络传输*/
                    .remoteAddress(new InetSocketAddress(host,FixedLengthEchoServer.PORT))/*配置要连接服务器的ip地址和端口*/
                    .handler(new ChannelInitializerImp());
            ChannelFuture f = b.connect().sync();
            System.out.println("已连接到服务器.....");
            f.channel().closeFuture().sync();
        } finally {
            group.shutdownGracefully().sync();
        }
    }

    private static class ChannelInitializerImp extends ChannelInitializer<Channel> {

        @Override
        protected void initChannel(Channel ch) throws Exception {
            ch.pipeline().addLast(
                    new FixedLengthFrameDecoder(
                            FixedLengthEchoServer.RESPONSE.length()));
            ch.pipeline().addLast(new FixedLengthClientHandler());
        }
    }

    public static void main(String[] args) throws InterruptedException {
        new FixedLengthEchoClient("127.0.0.1").start();
    }
}
客户端业务代码： 
public class FixedLengthClientHandler extends SimpleChannelInboundHandler<ByteBuf> {

    private AtomicInteger counter = new AtomicInteger(0);

    /*** 客户端读取到网络数据后的处理*/
    protected void channelRead0(ChannelHandlerContext ctx, ByteBuf msg) throws Exception {
        System.out.println("client Accept["+msg.toString(CharsetUtil.UTF_8)
                +"] and the counter is:"+counter.incrementAndGet());
    }

    /*** 客户端被通知channel活跃后，做事*/
    @Override
    public void channelActive(ChannelHandlerContext ctx) throws Exception {
        ByteBuf msg = null;
        for(int i=0;i<10;i++){
            msg = Unpooled.buffer(FixedLengthEchoClient.REQUEST.length());
            msg.writeBytes(FixedLengthEchoClient.REQUEST.getBytes());
            ctx.writeAndFlush(msg);
        }
    }

    /*** 发生异常后的处理*/
    @Override
    public void exceptionCaught(ChannelHandlerContext ctx, Throwable cause) throws Exception {
        cause.printStackTrace();
        ctx.close();
    }
}

执行结果：

服务端执行结果：

客户端执行结果：

以上三种方案，均能解决粘包和半包问题。
4、 将消息分为消息头和消息体，消息头中包含表示消息总长度（或者消息体长度） 的字段，通常设计思路为消息头的第一个字段使用 int32 来表示消息的总长度，使用
LengthFieldBasedFrameDecoder ，也可以解决，后期有时间会详细说明和使用，其实以上三种方案足够使用解决问题。
 
Netty解决粘包/半包问题到此分析完成，下篇我们分析Netty 编解码器框架，敬请期待！
 
寅灯
关注
专栏目录
Netty 粘包 & 半包
m0_66225491的博客
01-10 1083
TCP 是面向流的，提供高可靠性服务。收发两端都要有成对的 Socket 因此发送端为了将多个发给接收端的包，更有效的发送给对方，使用了 Nagle 算法优化 将多次间隔较小且数量小的数据，合并为一个大的数据块，然后进行封包， 这样虽然提高了效率，但是接收端就难以分辨出完整的数据包了，因为面向流的通信是无消息保护边界的 粘包 现象 发送 abc def，接收为 abcdef 原因 应用层：接收方 ByteBuf 设置太大（Netty默认1024） 滑动窗口：假设发送方256bytes表示一
Netty自定义序列化编解码器的解决粘包/半包问题的编解码方案方案一：使用LengthFieldPrepender与LengthFieldBasedFrameDecoder
07-05 756
通过扩展MessageToByteEncoder和ByteToMessageDecoder来自定义编解码器 原理 使用int数据类型来记录整个消息的字节数组长度，然后将该int数据作为消息的消息头一起传输 服务端接收消息数据时，先接收4个字节的int数据类型数据，此数据即为整个消息字节数组的长度，再接收剩余字节，直到接收的字节数组长度等于最先接收的int数据类型数据大小，即字节数组的长度 类似...
netty--粘包、半包解决方案
weixin_45980031的博客
10-17 368
闲着没事研究了一下netty怎么用。如有错误，还请指正。 在数据传输的过程中，TCP协议会将多个较小的数据包放在一起传输，或者是将数据拆分进行传输，这就导致在更上层需要进行判断收到是否为一个完整的数据包，否则进行就没办法玩了。下面列举几个常用的方案。 一、强制每个数据包单独发送 通过设置参数，强制要求不进行合并和拆包发送，简单粗暴，两行代码搞定问题。但是这样因为每次传送的数据较少，在频繁通信的时候会导致网络拥堵，不推荐使用。 服务端配置： // 强制要求，每次.
netty(3)--粘包半包问题
TOPsnap的博客
02-24 419
netty粘包半包问题
Java NIO 框架 Netty 之美：粘包与半包问题
GitChat
07-03 1695
Netty 是一个可以快速开发网络应用程序的 NIO 框架，它大大简化了 TCP 或者 UDP 服务器的网络编程。Netty 的简易和快速开发并不意味着由它开发的程序将失去可维护性或者存在性能问题，它的设计参考了许多协议的实现，比如 FTP，SMTP，HTTP 和各种二进制和基于文本的传统协议，因此 Netty 成功的实现了兼顾快速开发，性能，稳定性，灵活性为一体，不需要为了考虑一方面原因而妥协其...
Netty处理半包粘包问题
baidu_30130783的博客
07-27 396
无论是服务端还是客户端，当我们读取或者发送消息的时候，都需要考虑TCP底层的粘包/拆包机制。 TCP粘包/拆包发生的根本原因【流式协议，消息无边界】 粘包主要原因 发送方每次写入数据 < 套接字缓冲区大小 接收方读取套接字缓冲区数据不够及时 半包的主要原因： 发送方写入数据 > 套接字缓冲区大小 发送的数据大于协议的 MTU（Maximum Transmission Unit，最大传输单元），必须拆包 拆包、粘包示例 假设客户端分别发送了两个数据包D1和D2给服务端，由于服务端一次
Netty 粘包/半包原理与拆包实战 源码
11-11
本实例是《Netty 粘包/半包原理与拆包实战》 一文的源代码工程。 大家好，我是作者尼恩。 在前面的文章中，完成了一个...在开始聊天器实战开发之前，还有一个非常基础的问题，需要解决：这就是通讯的粘包和半包问题。
Netty 粘包/半包原理与拆包实战 【源代码 新】
11-11
- 本实例是《Netty 粘包/半包原理与拆包实战》 一文的源代码工程。 大家好，我是作者尼恩。 在前面的文章中，完成了一个高性能的 Java 聊天程序，尼恩已经再一次的进行了通讯协议的选择...本实例，解决粘包和半包问题
Netty对Protobuf的解决粘包/半包问题的编解码方案
07-04 6318
protobuf编解码内置方案 解码工具类：ProtobufDecoder+ProtobufVarint32FrameDecoder 编码工具类：ProtobufEncoder+ProtobufVarint32LengthFieldPrepender 原理 代码： 1.user.proto syntax="proto2"; package netty.protobuf; option j...
Netty字符串类型消息粘包/半包问题解决方案一示例代码：DelimiterBasedFrameDecoder+StringDecoder
07-04 1212
原理 使用特殊的字符，将其作为数据包的结束位置，使TCP能够区分完整的业务应用数据边界，按照边界完整地接受Netty传输的数据； 此特殊字符需要保证正式报文数据里面不会出现相同的字符，以免破坏消息传输的完整性 代码 1.DelimiterBaseServer：服务器 /** * 服务器 * @author pdc */ public class DelimiterBaseServer...
记一次解决netty半包问题的经历
weixin_30832351的博客
11-16 212
最近学习了netty，想写一个简单的rpc，结果发现发送消息时遇到难题了，网上搜了一下，这种情况是半包问题和粘包问题，主要是出现在并发高一些的时候。 talk is cheap 客户端编码： protected void encode(ChannelHandlerContext channelHandlerContext, Object o, ByteBuf byte...
Netty使用篇：半包&粘包
热门推荐
七叔的博客
11-13 2万+
Netty使用篇：半包&粘包
Netty解决粘包半包问题&自定义协议
最新发布
weixin_54232666的博客
07-06 2196
Netty进阶篇之网络通信解决粘包半包问题的几种方式以及Netty如何解决的，Netty网络通信怎么用HTTP请求编解码和如何自定义编解码器。
netty之黏包半包问题详解
小尘_OnMyWay的博客
04-06 619
文章目录黏包问题半包问题出现问题的原因解决方案短连接定长解码器行解码器LTC解码器 黏包问题 在客户端循环发送十次数据，服务器端会出现黏包现象。 ChannelFuture future = bootstrap.handler(new ChannelInitializer<SocketChannel>() { @Override protected void initChannel(SocketChannel ch) throws
Netty TCP 粘包拆包问题 演示实例
爪白白的个人博客
08-02 1022
首先启动服务端，接着启动客户端， 当客户端与服务端建立连接，客户端发送十条消息给服务端 服务端接收到客户端发送过来的消息，控制台输出收到消息的内容与数量 消息数量为一，显示服务端只收到一条消息 服务端每接收到客户端的消息，就返回给客户端一个UUID 客户端接收到UUID数量为一 粘包问题：当连续发送数据时，TCP协议会将较小的内容拼接成大的内容，一次性发送到服务器端，因此造成粘包 具体代码...
Netty进阶 黏包与半包问题的处理，数据解码器详解
清风
11-20 2132
概述 假设客户端分别发送了两个数据包D1和D2给服务端，由于服务端一次读取到的字节数是不确定的，故可能存在以下4种情况。 （1）服务端分两次读取到了两个独立的数据包，分别是D1和D2，没有半包和拆包； （2）服务端一次接收到了两个数据包，D1和D2粘合在一起，被称为TCP半包； （3）服务端分两次读取到了两个数据包，第一次读取到了完整的D1包和D2包的部分内容，第二次读取到了D2包的剩余内容，这被称为TCP拆包； （4）服务端分两次读取到了两个数据包，第一次读取到了D1包的部分内容D1_1，第二次
Netty如何解决粘包半包问题
Little_fxc的博客
08-26 1228
何为粘包 / 半包? 为什么会出现粘包 / 半包? 粘包/半包的原因?本质原因？ 怎么解决粘包 / 半包？ Netty 是如何支持的？
netty粘包半包问题常见解决方案及总结
weixin_38312719的博客
09-26 456
解决粘包半包主要目的 解决粘包半包问题其实就是围绕一个主题，那就是从TCP包中，通过一定字节作为标记，然后标记前字节 必定是一个可反序列化的字节Buff, 这样就可以解决粘包半包问题 解决粘包方案 1.通过指定固定字节数作为分隔标准 2.指定特殊字符作为分隔标准 3.默认使用换行符作为分隔标准（指定特殊字符作为分隔标准一种情况） 解决粘包方案图解 FixedLengthFrameDecoder //截取固定长度的字节作为一个包 //子类解码实现，由ByteToMessageDecoder主流程的chan
02.Netty进阶之粘包与半包解决方案
weixin_38598961的博客
04-23 289
02.Netty进阶之粘包与半包解决方案
Netty半包和粘包问题如何解决
03-24
Netty半包和粘包问题通常可以通过以下几种方法来解决： 1. 定长方法：通过指定消息的长度来解决，比如在消息头中添加消息长度字段，服务器接收到消息后先判断消息长度是否足够，不够则继续等待，够了则读取数据。 ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

寅灯

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值