Netty粘包拆包问题说明、演示拆包粘包情况代码以及解决

最新推荐文章于 2024-02-29 09:58:51 发布
最新推荐文章于 2024-02-29 09:58:51 发布
阅读量404 收藏 2
点赞数 1
分类专栏： netty 文章标签： netty 网络通信 socket
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_40837310/article/details/111752226
版权
概述

TCP传输协议是面向连接的，面向流提供高可靠的服务。收发两端（服务端和客户端）都要有一一成对的socket，因此，发送端为了将多个发给接收端的包，更有效地发给对方，使用了优化算法（Nagle算法），将多次间隔时间较小且数据较小的数据包，合成一个大的数据块，然后进行封包，这样做虽然提高了传输的效率，但是这样接收端就难以分辨出一个个完整的包的大小了，因为面向流的通信时无消息保护边界的。

由于TCP无消息保护边界，需要在接收端处理消息边界问题，也就是粘包、拆包问题。

示意图：
在这里插入图片描述
说明：

  1. 服务端给客户端发送D1、D2两个数据包。
  2. 第一种情况是服务端两次都读取到的是两个独立的数据包，无拆包粘包问题，可以正常解析。
  3. 第二种情况D1、D2包合并在一起一次发送，服务端一次性接收了两个数据包，分别是D1、D2，我们称之为粘包，因为不知道边界，所以服务端不知如何拆出来解析。
  4. 第三种情况，服务端第一次接收到了完整D1包和部分D2包，第二次接收到了剩余的D2包，D2包被拆开来分多次发送了，我们称之为拆包。
  5. 第四种情况，服务端第一次接收到了部分D1包，第二次接收到了剩余部分D1包和完整D2包，也称之为拆包。

总的来说拆包和粘包问题，因为没有边界，最终会在正常情况下导致接收方无法分辨出一个一个包。

粘包实例

以下实例证实了粘包的存在：
服务端及服务端的Handler：

public class NettyTcpServer {


    private  int port;

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


    public void start() throws InterruptedException {

        NioEventLoopGroup bossGroup = new NioEventLoopGroup();
        NioEventLoopGroup workerGroup = new NioEventLoopGroup();

        ServerBootstrap serverBootstrap = new ServerBootstrap();

        serverBootstrap.group(bossGroup,workerGroup)
                .channel(NioServerSocketChannel.class)
                .childHandler(new ChannelInitializer<SocketChannel>() {
                    @Override
                    protected void initChannel(SocketChannel ch) throws Exception {
                        ChannelPipeline pipeline = ch.pipeline();
                        pipeline.addLast(new NettyTcpServerChannelHandler());
                    }
                });

        ChannelFuture channelFuture = serverBootstrap.bind(port);
        channelFuture.channel().closeFuture().sync();
    }

    public static void main(String[] args) throws InterruptedException {
        NettyTcpServer nettyTcpServer = new NettyTcpServer(8989);
        nettyTcpServer.start();
    }
}


public class NettyTcpServerChannelHandler extends ChannelInboundHandlerAdapter {

    private int count;
    @Override
    public void channelRead(ChannelHandlerContext ctx, Object msg) throws Exception {
        ByteBuf byteBuf = (ByteBuf) msg;
        System.out.println("数据是：" + byteBuf.toString(CharsetUtil.UTF_8));
        System.out.println("count = " + (++count));
        super.channelRead(ctx, msg);
    }
}

客户端及客户端的Handler

public class NettyTcpClient {

    private  int serverPort;


    public NettyTcpClient(int serverPort){
        this.serverPort = serverPort;
    }

    public void start() throws InterruptedException {
        NioEventLoopGroup worker = new NioEventLoopGroup();

        Bootstrap bootstrap = new Bootstrap();
        bootstrap.group(worker)
                .channel(NioSocketChannel.class)
                .handler(new ChannelInitializer<SocketChannel>() {
                    @Override
                    protected void initChannel(SocketChannel ch) throws Exception {
                        ChannelPipeline pipeline = ch.pipeline();
                        pipeline.addLast(new NettyTcpClientChannelHandler());
                    }
                });

        ChannelFuture connect = bootstrap.connect("127.0.0.1", serverPort);
        connect.channel().closeFuture().sync();
    }

    public static void main(String[] args) throws InterruptedException {
        NettyTcpClient nettyTcpClient = new NettyTcpClient(8989);
        nettyTcpClient.start();
    }
}


public class NettyTcpClientChannelHandler extends ChannelInboundHandlerAdapter {
    @Override
    public void channelActive(ChannelHandlerContext ctx) throws Exception {
        //发生这个事件代表通道已经顺利连接到远端，可以收发数据。我们就在这里发送数据、
        //分十次发送
        for (int i = 0;i<10;i++){
            ctx.channel().writeAndFlush(Unpooled.copiedBuffer("Hello I am John;", CharsetUtil.UTF_8));
        }
        ctx.fireChannelActive();
    }
}

执行结果：
在这里插入图片描述
这个是服务端的输出结果，如果是没有拆包粘包的话，客户端分十次发送了数据，那么服务端也应该分十次接收，count应该等于10，但是此时count=1，然后数据一次性显示出来了 ，说明客户端的数据时把十次合并成一个数据包发送的，数据粘包现象。

拆包演示

将一次发送的数据量弄大一点，比mss大，就会发生拆包现象。
上面粘包演示的客户端和服务端不变，把两个Handler修改一下。

@Override
    public void channelActive(ChannelHandlerContext ctx) throws Exception {
        //发生这个事件代表通道已经顺利连接到远端，可以收发数据。我们就在这里发送数据、
        //分十次发送
        //一次发送102400字节数据
        byte[] bytes = new byte[102400];
        Arrays.fill(bytes, (byte) 10);
        for (int i = 0;i<10;i++){
            ctx.channel().writeAndFlush(Unpooled.copiedBuffer(bytes));
        }
        ctx.fireChannelActive();
    }

@Override
public void channelRead(ChannelHandlerContext ctx, Object msg) throws Exception {
    ByteBuf byteBuf = (ByteBuf) msg;
    System.out.println("长度是：" + byteBuf.readableBytes());
    System.out.println("count = " + (++count));
    super.channelRead(ctx, msg);
}

执行结果：
在这里插入图片描述
每次发送的数据长度都小于102400，并且发送次数count>10次，所以发生了拆包。

解决方案

使用自定义协议加编码解码器来解决。
需要对Netty的解码编码机制有一定的理解。

关键就是定义每一个数据包的边界，让服务端知道如何对粘包进行拆分和对拆包进行拆分和组合，从而避免拆包粘包问题。

服务端代码

public class NettyTcpServer {


    private  int port;

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


    public void start() throws InterruptedException {

        NioEventLoopGroup bossGroup = new NioEventLoopGroup();
        NioEventLoopGroup workerGroup = new NioEventLoopGroup();

        ServerBootstrap serverBootstrap = new ServerBootstrap();

        serverBootstrap.group(bossGroup,workerGroup)
                .channel(NioServerSocketChannel.class)
                .childHandler(new ChannelInitializer<SocketChannel>() {
                    @Override
                    protected void initChannel(SocketChannel ch) throws Exception {
                        ChannelPipeline pipeline = ch.pipeline();
                        //这里添加一个解码器，顺序必须在业务处理的Handler前面。
                        //因为要对数据先解码了才能进行业务处理。
                        pipeline.addLast(new MessageProtocolDecoder());
                        pipeline.addLast(new NettyTcpServerChannelHandler());
                    }
                });

        ChannelFuture channelFuture = serverBootstrap.bind(port);
        channelFuture.channel().closeFuture().sync();
    }

    public static void main(String[] args) throws InterruptedException {
        NettyTcpServer nettyTcpServer = new NettyTcpServer(8989);
        nettyTcpServer.start();
    }
}

客户端：

public class NettyTcpClient {

    private  int serverPort;


    public NettyTcpClient(int serverPort){
        this.serverPort = serverPort;
    }

    public void start() throws InterruptedException {
        NioEventLoopGroup worker = new NioEventLoopGroup();

        Bootstrap bootstrap = new Bootstrap();
        bootstrap.group(worker)
                .channel(NioSocketChannel.class)
                .handler(new ChannelInitializer<SocketChannel>() {
                    @Override
                    protected void initChannel(SocketChannel ch) throws Exception {
                        ChannelPipeline pipeline = ch.pipeline();
                        pipeline.addLast(new NettyTcpClientChannelHandler());
                        //这里添加一个编码器，对发送的数据进行编码，因为编码器属于出站的Handler。
                        //而上面的业务逻辑Handler：NettyTcpClientChannelHandler属于入站Handler，所以添加顺序在这里暂时还没所谓。
                        pipeline.addLast(new MessageProtocolEncode());
                    }
                });

        ChannelFuture connect = bootstrap.connect("127.0.0.1", serverPort);
        connect.channel().closeFuture().sync();
    }

    public static void main(String[] args) throws InterruptedException {
        NettyTcpClient nettyTcpClient = new NettyTcpClient(8989);
        nettyTcpClient.start();
    }
}

协议类：

@Data
public class MessageProtocol {

	//内容
    private byte[] content;
	//长度
    private int len;
    public MessageProtocol(byte[] content){
        this.content = content;
        //计算出长度并赋值
        this.len = content.length;
    }
}

服务端的业务处理Handler：

public class NettyTcpServerChannelHandler extends ChannelInboundHandlerAdapter {

    private int count;
    @Override
    public void channelRead(ChannelHandlerContext ctx, Object msg) throws Exception {
        MessageProtocol messageProtocol = (MessageProtocol) msg;
        System.out.println("数据是：" + new String(messageProtocol.getContent(),CharsetUtil.UTF_8) + ",长度是：" + messageProtocol.getLen());
        System.out.println("count = " + (++count));
        super.channelRead(ctx, msg);
    }
}

客户端的业务处理类：


//由原来的直接发送字符串，修改成现在使用协议对象来发送
public class NettyTcpClientChannelHandler extends ChannelInboundHandlerAdapter {
    @Override
    public void channelActive(ChannelHandlerContext ctx) throws Exception {
        //发生这个事件代表通道已经顺利连接到远端，可以收发数据。我们就在这里发送数据、
        //分十次发送
        for (int i = 0;i<10;i++){
            byte[] content = "Hello I am John;".getBytes(CharsetUtil.UTF_8);
            //创建协议对象
            MessageProtocol message = new MessageProtocol(content);
            //发送
            ctx.channel().writeAndFlush(message);
        }
        super.channelActive(ctx);
    }
}

服务端的解码器：

public class MessageProtocolDecoder extends ByteToMessageDecoder {
    @Override
    protected void decode(ChannelHandlerContext ctx, ByteBuf in, List<Object> out) throws Exception {
        //记录初始的读偏移量，用于拆包情况下的偏移量回滚
        int beginReadIndex = in.readerIndex();


        //首先读数据的长度出来先

        int len = in.readInt();

        if (in.readableBytes() < len){
            //这种情况下就是发生了拆包问题，因读取的数据长度没有len长，这个包还有数据没有到达。
            //重置读偏移量,等待下次重新读写
            in.readerIndex(beginReadIndex);
            //直接返回，等待下次
            return;
        }



        //能到这里，就证明包是完整的

        //读数据
        byte[] data = new byte[len];
        in.readBytes(data);



        MessageProtocol messageProtocol = new MessageProtocol(data);

        //写出给下一个Handler处理。
        out.add(messageProtocol);
    }
}

客户端的编码器：

public class MessageProtocolEncode  extends MessageToByteEncoder<MessageProtocol> {


    @Override
    protected void encode(ChannelHandlerContext ctx, MessageProtocol msg, ByteBuf out) throws Exception {
        //对协议的编码时，把数据的前4个字节固定为数据的长度，跟着就是数据的内容
        int len = msg.getLen();
        //先写数据的长度
        out.writeInt(len);
        //再写数据的内容
        out.writeBytes(msg.getContent());
    }
}

结果：
在这里插入图片描述
由上图可见，解决了粘包问题。

下面来测试是否解决了拆包问题。发送的数据使用上面的拆包演示代码，修改一下成用协议即可。
修改后的业务逻辑处理Handler

//客户端
 @Override
    public void channelActive(ChannelHandlerContext ctx) throws Exception {
        //发生这个事件代表通道已经顺利连接到远端，可以收发数据。我们就在这里发送数据、
        //分十次发送
        //一次发送102400字节数据
        byte[] bytes = new byte[102400];
        Arrays.fill(bytes, (byte) 10);
        for (int i = 0;i<10;i++){
            MessageProtocol messageProtocol = new MessageProtocol(bytes);
            ctx.channel().writeAndFlush(messageProtocol);
        }
        ctx.fireChannelActive();
    }
//服务端
@Override
    public void channelRead(ChannelHandlerContext ctx, Object msg) throws Exception {
        MessageProtocol messageProtocol = (MessageProtocol) msg;
        System.out.println("长度是：" + messageProtocol.getLen());
        System.out.println("count = " + (++count));
        super.channelRead(ctx, msg);
    }

运行结果：

在这里插入图片描述
由上图可知拆包问题已经解决，每次读取的数据都为102400.这里就只打印长度了，因为数据太大，就不打印了。

至此，完毕。

我会努力变强的
关注
  • 1
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
基于netty实现请求和tcpclient通讯（使用postman和NetAssist通讯）
11-06
使用postman发送post携带body的请求，通过中间件发送至NetAssist，实现两者之间的通讯 技术：netty
Netty粘包拆包解决方案.docx
10-26
Netty粘包拆包解决方案.docx
Netty 解决粘包和拆包问题的四种方案
最新发布
weixin_44749255的博客
02-29 1441
Netty 解决粘包和拆包问题的四种方案
使用Netty解决TCP粘包和拆包问题过程详解
08-25
主要介绍了使用Netty解决TCP粘包和拆包问题过程详解,文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下
netty拆包粘包解决方案示例
07-28
netty的知识，主要是解决拆包粘包的问题、内部含有客户端断线重连的代码，非常适合netty入门
使用netty实现一个tcp客户端
qq_42723556的博客
09-22 427
最近要写一个关于tcp协议连接硬件的 ，自己没事研究了一下。`使用netty实现一个简单的tcp客户端。提供先进的推理，复杂的指令，更多的创造力。初学netty代码如下。
使用 Netty 实现 HTTP 和 TCP
weixin_44492502的博客
04-02 3574
使用 Netty 实现 HTTP 和 TCPHttp ClientHttpClient 客户端HttpClientHandler 处理类Http ServerNettyHttpServer 服务端HttpServerInitializer 初始化类HttpServerRequestHandler 处理类Tcp ClientRpcRequest 实体类RpcResponse 实体类RpcEncoder 编码RpcDecoder 解码TcpClient 客户端TcpClientInitializer 初始化
netty入门（一）
weixin_43897440的博客
03-23 1077
socket: 套接字就是两台主机逻辑连接的端点。 我们先看一下HTTP以及TCP， HTTP协议作为应用层协议主要解决如何包装数据， TCP/IP协议集处理传输层数据如何传输。而socket是通信的基石， 是支持TCP协议的网络通信的基本操作单元 。它具备了网络传输必须的5种信息， 之前讲过TCP连接前的TCB传输控制块中就有socket信息。 1. 连接使用的协议 2. 源IP 3. 源端口 4. 目的端口 5. 目的IP 我们网络的传输通过不同的IO模型构建的通道，性能肯定是不一样的。BIO N
3.Netty TCP客户端（TcpClient）
相互学习 共同进步
01-29 1426
当需要更多地控制写入过程时，作为I/O处理程序的替代方案，可以使用Connection#outbound. 与在提供的Publisher完成时关闭连接的I/O处理程序相反（在finite的情况下Publisher），当使用时Connection#outbound，必须显式调用Connection#dispose以关闭连接。如果DNS服务器返回的DNS资源记录的生存时间大于此最大生存时间，则此解析器将忽略来自DNS服务器的生存时间并使用此最大生存时间。默认情况下，TcpClient资源的初始化是按需进行的。
从NIO到netty(16) Netty的粘包拆包问题与解决方案
m0_37139189的博客
05-07 279
关于粘包和拆包问题的产生，我在dubbo源码解析中已经解释过了，这里用一个例子来演示如果不加相应的处理器，产生的问题 服务端handler public class MyServerHandler extends SimpleChannelInboundHandler<ByteBuf> { private int count ; @Override pro...
Netty实现TCP通信
做兴趣使然的Hero
10-03 2601
Netty实现TCP通信 1 基本步骤 2 具体代码 2.1 服务端代码 /** * @desc: Server端 * @author: YanMingXin * @create: 2021/9/27-15:30 **/ public class NettyTcpServer { public static void main(String[] args) { //boosGroup处理连接请求 NioEventLoopGroup boosGroup =
Netty粘包拆包问题解决方案
08-18
主要介绍了Netty粘包拆包问题解决方案,文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下
netty消息拆包粘包编解码(java代码)
10-22
netty消息拆包粘包编解码(java代码)
Netty学习之---TCP粘包和拆包
Crazer_cy的博客
08-29 420
TCP粘包/拆包问题： 1.TCP是个“流协议”，所谓流，就是没有界限的一串数据。 2.它会根据TCP缓冲区的实际情况进行包的划分，所以在业务上认为，一个完整的包可能会被     TCP拆分成多个包进行发送，也有可能把多个小的包封装成一个大的数据包发送，这就是TCP粘包             和拆包问题。 3.TCP粘包/拆包发生的原因： ①应用程序write写入的字节大小大于套接口
reactor-netty中HttpClient对TcpClient的封装
weixin_34208283的博客
02-19 950
序 本文主要研究一下reactor-netty中HttpClient对TcpClien的封装 maven <dependency> <groupId>io.projectreactor.ipc</groupId> <artifactI...
开源一个自用的Android IM库，基于Netty+TCP+Protobuf实现
choutang6247的博客
08-12 603
写在前面 一直想写一篇关于im即时通讯分享的文章，无奈工作太忙，很难抽出时间。今天终于从公司离职了，打算好好休息几天再重新找工作，趁时间空闲，决定静下心来写一篇文章，毕竟从前辈那里学到了很多东西。工作了五年半，这三四年来一直在做社交相关的项目，有 直播、 即时通讯、 短视频分享、 社区论坛 ...
《Netty实战篇》通过搭建TCP服务端了解基本组件
一个不断前行的程序者
03-20 679
到这里，我们已经通过Netty搭建完成了一个TCP服务端了，并且对他的ChannelHandler、EventLoop和ChanneFuture有了一定的学习。但是这些只是简单的通过Netty来使用TCP服务端，我们在后面的实战系列文章中，还会更深入一步的分享Netty运用的设计模式、零拷贝、池化技术。！！
BIO NIO 粘包与拆包
fanduifandui的博客
07-08 567
BIO NIO 粘包与拆包动机什么是粘包与拆包那为什么我们经常把粘包拆包问题与NIO一起谈在TCP相关的API中没有packet相关的概念NIO模式 与粘包拆包 动机 Netty 提供了大量的开箱即用的组件, 这些组件对使用者透明了很多技术实现细节, 粘包拆包就是其中很有趣的部分. 本人在使用LengthFieldBasedFrameDecoder(在自定义通讯协议的场景下经常被使用: 作为TCP数据包 -> 业务数据包的拆包解析器)时对这个组件的参数还有用法产生了困惑,查阅了一些资料也阅读了源码…写
reactor-netty中TcpClient的create过程
weixin_34000916的博客
02-20 498
序 本文主要研究一下reactor-netty中TcpClient的create的过程 maven <dependency> <groupId>io.projectreactor.ipc</groupId> <artifactId&g...
netty怎么解决粘包和拆包问题
05-24
Netty提供了多种解决粘包和拆包问题的方式，其中比较常用的有以下几种： 1. 固定长度解码器：将接收到的数据按照固定的长度进行拆分，每个数据包的大小都是一样的。 2. 行分隔符解码器：将接收到的数据按照行分隔符进行拆分，常用的行分隔符有"\n"、"\r\n"等。 3. 自定义协议解码器：实现自定义的解码器，按照自定义的协议对接收到的数据进行拆分。 4. 分包器：在发送数据时先进行分包，每个数据包的大小都是固定的，接收方只需要按照固定的长度进行拆分即可。 5. 消息头+消息体解码器：在消息头中包含消息体的长度信息，接收方先读取消息头，然后根据消息头中的长度信息读取对应长度的消息体。 需要根据具体的业务场景选择合适的解决方案。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值