Netty中粘包和拆包的解决方案

最新推荐文章于 2024-07-27 13:31:57 发布
最新推荐文章于 2024-07-27 13:31:57 发布
阅读量1.4k 收藏 3
点赞数
分类专栏： 网络编程 文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/woaiwojialanxi/article/details/123648791
版权

TCP拆包、粘包问题

熟悉TCP编程的可能都知道，无论是服务器端还是客户端，当我们读取或者发送数据的时候，都需要考虑TCP底层的粘包/拆包机制。

TCP是一个“流”协议，所谓流就是没有界限的遗传数据。大家可以想像下如果河里的水好比数据，他们是连成一片的，没有分界线，TCP底层并不了解上层业务数据具体的含义，它会根据TCP缓冲区的实际情况进行包的划分，也就是说在业务上我们是一个完整的包可能会被TCP分成多个包进行发送，也就可能把多个小包分装成一个打的数据包发送出去，这就是所谓的TCP粘包、拆包问题。

分析TCP粘包、拆包问题产生原因：

1.应用write写入的字节大小大于套接字发送缓冲区的大小

2.进行MSS大小的TCP分段

3.以太网帧的payload大于MTU进行IP分片

TCP拆包、粘包解决方案

粘包拆包问题的解决方案，根据业界主流协议的有三方案：

1.消息定长，例如每个报文的大小固定2000个字节，如果不够空位补空格

2.在包尾部增加特殊字符进行分割，例如回车等

3.将消息分为消息头和消息体，在消息头中包含表示消息总长度的字段，然后进行业务逻辑处理

Netty解决TCP拆包粘包问题

1.分隔符类 DelimiterBasedFrameDecoder （自定义分隔符）

2.FixedLengthFrameDecoder（定长）

自定义分隔示例

maven依赖

        <!--netty依赖-->
        <dependency>
            <groupId>io.netty</groupId>
            <artifactId>netty-all</artifactId>
            <version>4.1.20.Final</version>
        </dependency>

服务端

package com.example.netty.pack;

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.FixedLengthFrameDecoder;

/**
 * netty 服务端
 *
 * @author lanx
 * @date 2022/3/20
 */
public class Server {

    public static void main(String[] args) throws InterruptedException {
        //用户接收客户端连接的线程工作组
        EventLoopGroup bossGroup = new NioEventLoopGroup();
        //用于接收客户端连接读写操作的线程组
        EventLoopGroup workerGroup = new NioEventLoopGroup();
        //辅助类 帮我我们创建netty服务
        ServerBootstrap b = new ServerBootstrap();
        b.group(bossGroup, workerGroup)//绑定两个工作组
                .channel(NioServerSocketChannel.class)//设置NIO模式
                //option 针对于服务端配置； childOption 针对于客户端连接通道配置
                .option(ChannelOption.SO_BACKLOG, 1024)//设置tcp缓冲区
                .childOption(ChannelOption.SO_SNDBUF, 32 * 1024)//设置发送数据的缓存大小
                .childOption(ChannelOption.SO_RCVBUF, 32 * 1024)//设置读取数据的缓存大小
                .childOption(ChannelOption.SO_KEEPALIVE, true)//设置保持长连接
                //初始化绑定服务通道
                .childHandler(new ChannelInitializer<SocketChannel>() {
                    @Override
                    protected void initChannel(SocketChannel sc) throws Exception {
                        //为通道进行初始化：数据传输过来的时候会进行拦截和执行 (可以有多个拦截器)

                        //1. 定义特殊字符分割 处理数据
                        ByteBuf delimiter = Unpooled.copiedBuffer("$_".getBytes());
                        /**
                         * int maxFrameLength 传输数据的最大长度
                         * ByteBuf delimiter 分隔符
                         */
                        sc.pipeline().addLast(new DelimiterBasedFrameDecoder(1024, delimiter));

                        sc.pipeline().addLast(new ServerHandler());
                    }
                });
        ChannelFuture cf = b.bind(8765).sync();

        //释放连接
        cf.channel().closeFuture().sync();
        workerGroup.shutdownGracefully();
        bossGroup.shutdownGracefully();

    }
}

package com.example.netty.pack;

import io.netty.buffer.ByteBuf;
import io.netty.buffer.Unpooled;
import io.netty.channel.ChannelFutureListener;
import io.netty.channel.ChannelHandlerContext;
import io.netty.channel.ChannelInboundHandlerAdapter;
import io.netty.util.ReferenceCountUtil;

/**
 * 服务端 监听器
 *
 * @author lanx
 * @date 2022/3/20
 */
public class ServerHandler extends ChannelInboundHandlerAdapter {


    /**
     * 当我们的通道被激活的时候触发的监听
     *
     * @param ctx
     * @throws Exception
     */
    @Override
    public void channelActive(ChannelHandlerContext ctx) throws Exception {
        System.out.println("--------服务端通道激活---------");
    }

    /**
     * 当我们通道里有数据进行读取的时候触发的监听
     *
     * @param ctx netty服务上下文
     * @param msg 实际传输的数据
     * @throws Exception
     */
    @Override
    public void channelRead(ChannelHandlerContext ctx, Object msg) throws Exception {
        try {
            // NIO 通信 （传输的数据是什么？ ---------> Buffer 对象）
            ByteBuf buf = (ByteBuf) msg;
            //定义byte数组
            byte[] req = new byte[buf.readableBytes()];
            // 从缓冲区获取数据到 req
            buf.readBytes(req);
            //读取到的数据转换为字符串
            String body = new String(req, "utf-8");
            System.out.println("服务端读取到数据：" + body);

            //响应给客户端的数据
            ctx.writeAndFlush(Unpooled.copiedBuffer("netty server response data$_".getBytes()));
              // 添加 addListener 可以触发关闭通道监听事件（客户端短连接场景使用）
              // .addListener(ChannelFutureListener.CLOSE);
        }catch (Exception e){
            e.printStackTrace();
        }finally {
            //释放数据
            ReferenceCountUtil.release(msg);
        }

    }

    /**
     * 当我们读取完成数据的时候触发的监听
     *
     * @param ctx
     * @throws Exception
     */
    @Override
    public void channelReadComplete(ChannelHandlerContext ctx) throws Exception {
        System.out.println("--------服务端数据读取完毕---------");
    }

    /**
     * 当我们读取数据异常的时候触发的监听
     *
     * @param ctx
     * @param cause
     * @throws Exception
     */
    public void exceptionCaught(ChannelHandlerContext ctx, Throwable cause) throws Exception {
        System.out.println("--------服务端数据读取异常---------");
        ctx.close();
    }
}

客戶端

package com.example.netty.pack;

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.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.FixedLengthFrameDecoder;

/**
 * netty 客户端
 *
 * @author lanx
 * @date 2022/3/20
 */
public class Client {

    public static void main(String[] args) throws Exception {

        //线程工作组
        EventLoopGroup workerGroup = new NioEventLoopGroup();
        //辅助类 帮我我们创建netty服务
        Bootstrap b = new Bootstrap();
        b.group(workerGroup)//绑定两个工作组
                .channel(NioSocketChannel.class)//设置NIO模式

                //初始化绑定服务通道
                .handler(new ChannelInitializer<SocketChannel>() {
                    @Override
                    protected void initChannel(SocketChannel sc) throws Exception {
                        //为通道进行初始化：数据传输过来的时候会进行拦截和执行 (可以有多个拦截器)

                        //1. 定义特殊字符分割 处理数据
                        ByteBuf delimiter = Unpooled.copiedBuffer("$_".getBytes());
                        /**
                         * int maxFrameLength 传输数据的最大长度
                         * ByteBuf delimiter 分隔符
                         */
                        sc.pipeline().addLast(new DelimiterBasedFrameDecoder(1024, delimiter));


                        sc.pipeline().addLast(new ClientHandler());
                    }
                });
        ChannelFuture cf = b.connect("127.0.0.1", 8765).syncUninterruptibly();
        cf.channel().writeAndFlush(Unpooled.copiedBuffer("netty client request data_1$_".getBytes()));
        cf.channel().writeAndFlush(Unpooled.copiedBuffer("netty client request data_2$_".getBytes()));
        cf.channel().writeAndFlush(Unpooled.copiedBuffer("netty client request data_3$_".getBytes()));
        cf.channel().writeAndFlush(Unpooled.copiedBuffer("netty client request data_4$_".getBytes()));
        cf.channel().writeAndFlush(Unpooled.copiedBuffer("netty client request data_5$_".getBytes()));
        //释放连接
        cf.channel().closeFuture().sync();
        workerGroup.shutdownGracefully();

    }
}

package com.example.netty.pack;

import io.netty.buffer.ByteBuf;
import io.netty.channel.ChannelHandlerContext;
import io.netty.channel.ChannelInboundHandlerAdapter;
import io.netty.util.ReferenceCountUtil;

/**
 * 客户端 监听器
 *
 * @author lanx
 * @date 2022/3/20
 */
public class ClientHandler extends ChannelInboundHandlerAdapter {

    /**
     * 当我们的通道被激活的时候触发的监听
     *
     * @param ctx
     * @throws Exception
     */
    @Override
    public void channelActive(ChannelHandlerContext ctx) throws Exception {
        System.out.println("--------客户端通道激活---------");
    }

    /**
     * 当我们通道里有数据进行读取的时候触发的监听
     *
     * @param ctx netty服务上下文
     * @param msg 实际传输的数据
     * @throws Exception
     */
    @Override
    public void channelRead(ChannelHandlerContext ctx, Object msg) throws Exception {
        try {
            // NIO 通信 （传输的数据是什么？ ---------> Buffer 对象）
            ByteBuf buf = (ByteBuf) msg;
            //定义byte数组
            byte[] req = new byte[buf.readableBytes()];
            // 从缓冲区获取数据到 req
            buf.readBytes(req);
            //读取到的数据转换为字符串
            String body = new String(req, "utf-8");
            System.out.println("客户端读取到数据：" + body);
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            //释放数据 （如果你读取数据后又写出去数据就不需要调用此方法，因为底层代码帮忙实现额释放数据）
            ReferenceCountUtil.release(msg);
        }
    }

    /**
     * 当我们读取完成数据的时候触发的监听
     *
     * @param ctx
     * @throws Exception
     */
    @Override
    public void channelReadComplete(ChannelHandlerContext ctx) throws Exception {
        System.out.println("--------客户端数据读取完毕---------");
    }

    /**
     * 当我们读取数据异常的时候触发的监听
     *
     * @param ctx
     * @param cause
     * @throws Exception
     */
    public void exceptionCaught(ChannelHandlerContext ctx, Throwable cause) throws Exception {
        System.out.println("--------客户端数据读取异常---------");
        ctx.close();
    }
}

定长示例

服务端

package com.example.netty.leng;

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;
import io.netty.handler.codec.FixedLengthFrameDecoder;

/**
 * netty 服务端
 *
 * @author lanx
 * @date 2022/3/20
 */
public class Server {

    public static void main(String[] args) throws InterruptedException {
        //用户接收客户端连接的线程工作组
        EventLoopGroup bossGroup = new NioEventLoopGroup();
        //用于接收客户端连接读写操作的线程组
        EventLoopGroup workerGroup = new NioEventLoopGroup();
        //辅助类 帮我我们创建netty服务
        ServerBootstrap b = new ServerBootstrap();
        b.group(bossGroup, workerGroup)//绑定两个工作组
                .channel(NioServerSocketChannel.class)//设置NIO模式
                //option 针对于服务端配置； childOption 针对于客户端连接通道配置
                .option(ChannelOption.SO_BACKLOG, 1024)//设置tcp缓冲区
                .childOption(ChannelOption.SO_SNDBUF, 32 * 1024)//设置发送数据的缓存大小
                .childOption(ChannelOption.SO_RCVBUF, 32 * 1024)//设置读取数据的缓存大小
                .childOption(ChannelOption.SO_KEEPALIVE, true)//设置保持长连接
                //初始化绑定服务通道
                .childHandler(new ChannelInitializer<SocketChannel>() {
                    @Override
                    protected void initChannel(SocketChannel sc) throws Exception {
                        //为通道进行初始化：数据传输过来的时候会进行拦截和执行 (可以有多个拦截器)

                        //2 定长 处理数据
                        sc.pipeline().addLast(new FixedLengthFrameDecoder(20));

                        sc.pipeline().addLast(new ServerHandler());
                    }
                });
        ChannelFuture cf = b.bind(8765).sync();

        //释放连接
        cf.channel().closeFuture().sync();
        workerGroup.shutdownGracefully();
        bossGroup.shutdownGracefully();

    }
}

package com.example.netty.leng;

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

/**
 * 服务端 监听器
 *
 * @author lanx
 * @date 2022/3/20
 */
public class ServerHandler extends ChannelInboundHandlerAdapter {


    /**
     * 当我们的通道被激活的时候触发的监听
     *
     * @param ctx
     * @throws Exception
     */
    @Override
    public void channelActive(ChannelHandlerContext ctx) throws Exception {
        System.out.println("--------服务端通道激活---------");
    }

    /**
     * 当我们通道里有数据进行读取的时候触发的监听
     *
     * @param ctx netty服务上下文
     * @param msg 实际传输的数据
     * @throws Exception
     */
    @Override
    public void channelRead(ChannelHandlerContext ctx, Object msg) throws Exception {
        try {
            // NIO 通信 （传输的数据是什么？ ---------> Buffer 对象）
            ByteBuf buf = (ByteBuf) msg;
            //定义byte数组
            byte[] req = new byte[buf.readableBytes()];
            // 从缓冲区获取数据到 req
            buf.readBytes(req);
            //读取到的数据转换为字符串
            String body = new String(req, "utf-8");
            System.out.println("服务端读取到数据：" + body);

            //响应给客户端的数据
            ctx.writeAndFlush(Unpooled.copiedBuffer("netty server response data$_".getBytes()));
              // 添加 addListener 可以触发关闭通道监听事件（客户端短连接场景使用）
              // .addListener(ChannelFutureListener.CLOSE);
        }catch (Exception e){
            e.printStackTrace();
        }finally {
            //释放数据
            ReferenceCountUtil.release(msg);
        }

    }

    /**
     * 当我们读取完成数据的时候触发的监听
     *
     * @param ctx
     * @throws Exception
     */
    @Override
    public void channelReadComplete(ChannelHandlerContext ctx) throws Exception {
        System.out.println("--------服务端数据读取完毕---------");
    }

    /**
     * 当我们读取数据异常的时候触发的监听
     *
     * @param ctx
     * @param cause
     * @throws Exception
     */
    public void exceptionCaught(ChannelHandlerContext ctx, Throwable cause) throws Exception {
        System.out.println("--------服务端数据读取异常---------");
        ctx.close();
    }
}

客戶端

package com.example.netty.leng;

import io.netty.bootstrap.Bootstrap;
import io.netty.buffer.Unpooled;
import io.netty.channel.ChannelFuture;
import io.netty.channel.ChannelInitializer;
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.FixedLengthFrameDecoder;

/**
 * netty 客户端
 *
 * @author lanx
 * @date 2022/3/20
 */
public class Client {

    public static void main(String[] args) throws Exception {

        //线程工作组
        EventLoopGroup workerGroup = new NioEventLoopGroup();
        //辅助类 帮我我们创建netty服务
        Bootstrap b = new Bootstrap();
        b.group(workerGroup)//绑定两个工作组
                .channel(NioSocketChannel.class)//设置NIO模式

                //初始化绑定服务通道
                .handler(new ChannelInitializer<SocketChannel>() {
                    @Override
                    protected void initChannel(SocketChannel sc) throws Exception {
                        //为通道进行初始化：数据传输过来的时候会进行拦截和执行 (可以有多个拦截器)
                        //2 定长 处理数据
                        sc.pipeline().addLast(new FixedLengthFrameDecoder(20));
                        sc.pipeline().addLast(new ClientHandler());
                    }
                });
        ChannelFuture cf = b.connect("127.0.0.1", 8765).syncUninterruptibly();
        cf.channel().writeAndFlush(Unpooled.copiedBuffer("netty client request data_1$_".getBytes()));
        cf.channel().writeAndFlush(Unpooled.copiedBuffer("netty client request data_2$_".getBytes()));
        cf.channel().writeAndFlush(Unpooled.copiedBuffer("netty client request data_3$_".getBytes()));
        cf.channel().writeAndFlush(Unpooled.copiedBuffer("netty client request data_4$_".getBytes()));
        cf.channel().writeAndFlush(Unpooled.copiedBuffer("netty client request data_5$_".getBytes()));
        //释放连接
        cf.channel().closeFuture().sync();
        workerGroup.shutdownGracefully();

    }
}

package com.example.netty.leng;

import io.netty.buffer.ByteBuf;
import io.netty.channel.ChannelHandlerContext;
import io.netty.channel.ChannelInboundHandlerAdapter;
import io.netty.util.ReferenceCountUtil;

/**
 * 客户端 监听器
 *
 * @author lanx
 * @date 2022/3/20
 */
public class ClientHandler extends ChannelInboundHandlerAdapter {

    /**
     * 当我们的通道被激活的时候触发的监听
     *
     * @param ctx
     * @throws Exception
     */
    @Override
    public void channelActive(ChannelHandlerContext ctx) throws Exception {
        System.out.println("--------客户端通道激活---------");
    }

    /**
     * 当我们通道里有数据进行读取的时候触发的监听
     *
     * @param ctx netty服务上下文
     * @param msg 实际传输的数据
     * @throws Exception
     */
    @Override
    public void channelRead(ChannelHandlerContext ctx, Object msg) throws Exception {
        try {
            // NIO 通信 （传输的数据是什么？ ---------> Buffer 对象）
            ByteBuf buf = (ByteBuf) msg;
            //定义byte数组
            byte[] req = new byte[buf.readableBytes()];
            // 从缓冲区获取数据到 req
            buf.readBytes(req);
            //读取到的数据转换为字符串
            String body = new String(req, "utf-8");
            System.out.println("客户端读取到数据：" + body);
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            //释放数据 （如果你读取数据后又写出去数据就不需要调用此方法，因为底层代码帮忙实现额释放数据）
            ReferenceCountUtil.release(msg);
        }
    }

    /**
     * 当我们读取完成数据的时候触发的监听
     *
     * @param ctx
     * @throws Exception
     */
    @Override
    public void channelReadComplete(ChannelHandlerContext ctx) throws Exception {
        System.out.println("--------客户端数据读取完毕---------");
    }

    /**
     * 当我们读取数据异常的时候触发的监听
     *
     * @param ctx
     * @param cause
     * @throws Exception
     */
    public void exceptionCaught(ChannelHandlerContext ctx, Throwable cause) throws Exception {
        System.out.println("--------客户端数据读取异常---------");
        ctx.close();
    }
}

终遇你..
关注
  • 0
    点赞
  • 踩
  • 3
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
Netty解决粘包和拆包问题的四种方案
艾利克斯冰的博客
07-01 688
Netty解决粘包和拆包问题的四种方案
Netty粘包拆包问题解决方案
08-18
Netty 粘包拆包问题解决方案 Netty 是一个基于 Java 的网络编程框架，它提供了一个便捷的方式来处理网络数据的读写操作。然而，在使用 Netty 进行网络编程时，经常会遇到粘包和拆包的问题。所谓粘包和拆包，就是指...
Netty 解决粘包和拆包问题的四种方案
weixin_44749255的博客
02-29 2939
Netty 解决粘包和拆包问题的四种方案
Netty中的粘包、拆包与丢包问题及其解决方案详解
微笑听雨
06-19 4431
在Netty中，通过使用合适的解码器（如定长解码器、换行符解码器、分隔符解码器和长度字段解码器）可以有效解决粘包和拆包问题。同时，结合TCP的重传机制和应用层的重传策略，可以有效地减少丢包现象，确保数据传输的可靠性。选择合适的方案需要根据具体的应用场景和协议要求来定。
【Netty】六、Netty粘包和拆包解决方案
weixin_43333483的博客
10-25 838
Netty粘包和拆包解决方案
【三】Netty 解决粘包和拆包问题
echohuangshihuxue的博客
01-06 2586
一:介绍了下 TCP的粘包和拆包的原理以及主流的解决方案。 二:详细的用代码展示了粘包例子和 如何解决。 三:简单介绍了下 编码解码原理以及自己遇到的坑
Java 基于Netty 【粘包和拆包解决方案-定长解码器】
WaaTong的博客
01-31 432
是Netty提供的用于解决粘包和拆包问题的一种解决方案，它会按照固定的长度对接收到的数据进行拆分，从而保证每个消息的长度是固定的，不会出现粘包和拆包的情况。每次连接处理完后手动关闭服务端使用FixedLengthFrameDecoder来按照固定长度 将收到的信息进行解码。
【Netty】粘包和拆包问题及解决
qq_43745578的博客
12-25 1070
Netty粘包和拆包问题及解决
Netty解决粘包和拆包问题的四种方案，简单易懂
热门推荐
lt_xiaodou的博客
08-06 1万+
对于粘包与拆包问题，其实前面三种基本上已经能够满足大多数情形了，但是对于一些更加复杂的协议，可能有一些定制化的需求。对于这些场景，其实本质上，我们也不需要手动从头开始写一份粘包与拆包处理器，而是通过继承LengthFieldBasedFrameDecoder和LengthFieldPrepender来实现粘包和拆包的处理。如果用户确实需要不通过继承的方式实现自己的粘包和拆包处理器，这里可以通过实现MessageToByteEncoder和ByteToMessageDecoder来实现。...
Netty对于粘包和拆包问题的解决方案
qq_44613591的博客
03-15 844
前言 什么是粘包拆包？ 拆包和粘包是在socket编程中经常出现的情况，在socket通讯过程中，如果通讯的一端一次性连续发送多条数据包，tcp协议会将多个数据包打包成一个tcp报文发送出去，这就是所谓的粘包。而如果通讯的一端发送的数据包超过一次tcp报文所能传输的最大值时，就会将一个数据包拆成多个最大tcp长度的tcp报文分开传输，这就叫做拆包。 我们看一下下面这张图就知道了： 粘包拆包产生的原因 数据流在TCP协议下传播，因为协议本身对于流有一些规则的限制，这些规则会导致当前对端接收到的数据包不
Netty中粘包和拆包的解决方案.docx
10-26
在TCP网络编程中，粘包和拆包是常见的问题，主要由于TCP协议的特性——它是一个面向流的协议，不保证数据包的边界。在Netty框架中，这些问题需要通过特定的策略和组件来解决。 TCP粘包和拆包的产生原因是多方面的，...
netty拆包粘包解决方案示例
07-28
本文将深入探讨Netty中解决拆包粘包问题的策略，以及客户端断线重连的实现方式。 首先，我们需要理解什么是“拆包”和“粘包”。在TCP/IP通信中，由于TCP协议的流式传输特性，数据可能会被分片或者合并，这就可能...
Netty粘包拆包解决方案.docx
10-26
Netty 为此提供了多种内置的解码器，方便开发者解决粘包拆包问题： - **LineBasedFrameDecoder**：基于回车换行符`\r\n`或其他指定的行结束符来分割数据。 - **DelimiterBasedFrameDecoder**：基于用户指定的分隔符...
Netty粘包-拆包应用案例及解决方案分析.docx
10-26
TCP 粘包/拆包解决方案分析 TCP 粘包/拆包是 TCP 协议中的一种常见问题，指的是在数据传输过程中，数据包可能会被拆分或粘合成一个大的数据包，导致数据传输不正确。 Netty 作为一个高性能的网络通信框架，提供了...
golang 接口
m0_70982551的博客
07-24 862
接口定义了一组方法，这些方法没有具体的实现。接口类型的变量可以存储任何实现了这些方法的类型的值。// 更多方法...在Go语言中，接口值是指存储了实现某个接口的具体类型值的变量。接口值由两部分组成：1.动态类型：这是接口值当前存储的实际类型。2.动态值：这是实际存储的值，该值必须实现了接口中定义的所有方法。
Swagger使用Map接受参数时，页面如何显示具体参数及说
a1058926697的博客
07-26 385
后端使用Map接受参数，要求在swagger页面上显示具体的参数名称、类型及说明。当Map接受参数数量少时，可以使用Swagger自带的注解。自定义注解 @ApiGlobalModel。编写处理注解对应的插件。
springboot之自动装配
weixin_50153914的博客
07-23 539
Spring Boot 通过一系列注解和条件配置实现了自动装配机制，使得开发者无需手动配置大量的 XML 文件或 Java 配置类。自动配置机制利用文件中的自动配置类，并结合条件注解和组件扫描，实现了灵活且强大的自动装配功能。这样，开发者可以专注于业务逻辑的实现，而无需处理繁琐的配置细节。
Java的@DateTimeFormat注解与@JsonFormat注解的使用对比
最新发布
訾博（ZiBo）的博客
07-27 465
在Spring和Jackson框架中，日期和时间格式化是一个常见需求。注解主要用于Spring的表单绑定，而注解则用于Jackson的JSON序列化和反序列化。了解这两个注解的使用场景和方法，可以帮助开发者更高效地处理日期和时间。和是处理日期和时间格式化的两个重要注解。主要用于Spring MVC的请求参数绑定，而主要用于Jackson的JSON序列化和反序列化。了解它们的使用场景和功能，可以帮助开发者更高效地处理日期和时间格式化需求。通过本文的介绍，希望读者能够更清晰地理解和。
netty tcp粘包和拆包
07-30
Netty中的TCP粘包和拆包问题是由于底层的TCP协议无法理解上层的业务数据而导致的。为了解决这个问题，Netty提供了几种解决方案。其中，常用的解决方案有四种[1]： 1. 固定长度的拆包器（FixedLengthFrameDecoder）：将每个应用层数据包拆分成固定长度的大小。这种拆包器适用于应用层数据包长度固定的情况。 2. 行拆包器（LineBasedFrameDecoder）：将每个应用层数据包以换行符作为分隔符进行分割拆分。这种拆包器适用于应用层数据包以换行符作为结束符的情况。 3. 分隔符拆包器（DelimiterBasedFrameDecoder）：将每个应用层数据包通过自定义的分隔符进行分割拆分。这种拆包器适用于应用层数据包以特定分隔符作为结束标志的情况。 4. 基于数据包长度的拆包器（LengthFieldBasedFrameDecoder）：将应用层数据包的长度作为接收端应用层数据包的拆分依据。根据应用层协议中包含的数据包长度进行拆包。这种拆包器适用于应用层协议中包含数据包长度的情况。 除了使用这些拆包器，还可以根据业界主流协议的解决方案来解决粘包和拆包问题[3]： 1. 消息长度固定：累计读取到长度和为定长LEN的报文后，就认为读取到了一个完整的信息。 2. 使用特殊的分隔符：将换行符或其他特殊的分隔符作为消息的结束标志。 3. 在消息头中定义长度字段：通过在消息头中定义长度字段来标识消息的总长度。 综上所述，Netty提供了多种解决方案来解决TCP粘包和拆包问题，可以根据具体的业务需求选择合适的解决方案[1][3]。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

终遇你..

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

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

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

打赏作者

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

抵扣说明：

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

余额充值