Netty指南（8）：Netty的TCP粘包和拆包解决方案

已于 2022-08-24 13:32:24 修改
阅读量680 收藏 3
点赞数 1
分类专栏： Netty 文章标签： java rpc tcp/ip 网络协议 netty
于 2022-05-06 00:44:58 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_50275872/article/details/124601129
版权

一、Netty编解码器与Handler调用机制

1.1 基本说明

  1. Netty 的组件设计：Netty 的主要组件有 Channel、EventLoop、ChannelFuture、ChannelHandler、ChannelPipe 等
  2. ChannelHandler 充当了处理入站和出站数据的应用程序逻辑的容器。例如，实现 ChannelInboundHandler 接口（或 ChannelInboundHandlerAdapter），你就可以接收入站事件和数据，这些数据会被业务逻辑处理。当要给客户端发送响应时，也可以从 ChannelInboundHandler 冲刷数据。业务逻辑通常写在一个或者多个 ChannelInboundHandler 中。ChannelOutboundHandler 原理一样，只不过它是用来处理出站数据的
  3. ChannelPipeline 提供了 ChannelHandler 链的容器。以客户端应用程序为例，如果事件的运动方向是从客户端到服务端的，那么我们称这些事件为出站的，即客户端发送给服务端的数据会通过 pipeline 中的一系列 ChannelOutboundHandler，并被这些 Handler 处理，反之则称为入站的

1.2编码解码器

  1. 当 Netty 发送或者接受一个消息的时候，就将会发生一次数据转换。入站消息会被解码：从字节转换为另一种格式（比如 java 对象）；如果是出站消息，它会被编码成字节。
  2. Netty 提供一系列实用的编解码器，他们都实现了 ChannelInboundHadnler 或者 ChannelOutboundHandler 接口。在这些类中，channelRead 方法已经被重写了。以入站为例，对于每个从入站 Channel 读取的消息，这个方法会被调用。随后，它将调用由解码器所提供的 decode() 方法进行解码，并将已经解码的字节转发给 ChannelPipeline 中的下一个 ChannelInboundHandler。

1.3 解码器 - ByteToMessageDecoder

  1. 关系继承图

  1. 由于不可能知道远程节点是否会一次性发送一个完整的信息，tcp 有可能出现粘包拆包的问题，这个类会对入站数据进行缓冲，直到它准备好被处理.
  2. 一个关于 ByteToMessageDecoder 实例分析

1.4 Netty 的 handler 链的调用机制

实例要求:

  1. 使用自定义的编码器和解码器来说明 Netty 的 handler 调用机制
    客户端发送 long -> 服务器
    服务端发送 long -> 客户端
  2. 案例演示

  1. 结论
    • 不论解码器 handler 还是编码器 handler 即接收的消息类型必须与待处理的消息类型一致，否则该 handler 不会被执行
    • 在解码器进行数据解码时，需要判断缓存区（ByteBuf）的数据是否足够，否则接收到的结果会期望结果可能不一致

1.5 解码器 - ReplayingDecoder

  1. public abstract class ReplayingDecoder<S> extends ByteToMessageDecoder
  2. ReplayingDecoder 扩展了 ByteToMessageDecoder 类，使用这个类，我们不必调用 readableBytes() 方法。参数 S 指定了用户状态管理的类型，其中 Void 代表不需要状态管理
  3. 应用实例：使用 ReplayingDecoder 编写解码器，对前面的案例进行简化[案例演示]
package com.atguigu.netty.inboundhandlerandoutboundhandler;

import io.netty.buffer.ByteBuf;
import io.netty.channel.ChannelHandlerContext;
import io.netty.handler.codec.ReplayingDecoder;

import java.util.List;

public class MyByteToLongDecoder2 extends ReplayingDecoder<Void> {
    
    @Override
    protected void decode(ChannelHandlerContext ctx, ByteBuf in, List<Object> out) throws Exception {
        System.out.println("MyByteToLongDecoder2 被调用");
        //在 ReplayingDecoder 不需要判断数据是否足够读取，内部会进行处理判断
        out.add(in.readLong());
    }
}
  1. ReplayingDecoder 使用方便，但它也有一些局限性：
    • 并不是所有的 ByteBuf 操作都被支持，如果调用了一个不被支持的方法，将会抛出一个 UnsupportedOperationException。
    • ReplayingDecoder 在某些情况下可能稍慢于 ByteToMessageDecoder，例如网络缓慢并且消息格式复杂时，消息会被拆成了多个碎片，速度变慢

1.6 其它编解码器

1.6.1 其它解码器

  1. LineBasedFrameDecoder：这个类在 Netty 内部也有使用，它使用行尾控制字符（\n或者\r\n）作为分隔符来解析数据。
  2. DelimiterBasedFrameDecoder：使用自定义的特殊字符作为消息的分隔符。
  3. HttpObjectDecoder：一个 HTTP 数据的解码器
  4. LengthFieldBasedFrameDecoder：通过指定长度来标识整包消息，这样就可以自动的处理黏包和半包消息。

二、TCP粘包和拆包及解决方案

2.1 TCP 粘包和拆包基本介绍

  1. TCP 是面向连接的，面向流的，提供高可靠性服务。收发两端（客户端和服务器端）都要有一一成对的 socket，因此，发送端为了将多个发给接收端的包，更有效的发给对方，使用了优化方法（Nagle 算法），将多次间隔较小且数据量小的数据，合并成一个大的数据块，然后进行封包。这样做虽然提高了效率，但是接收端就难于分辨出完整的数据包了，因为面向流的通信是无消息保护边界的
  2. 由于 TCP 无消息保护边界,需要在接收端处理消息边界问题，也就是我们所说的粘包、拆包问题,看一张图
  3. 示意图 TCP 粘包、拆包图解

对图的说明:
假设客户端分别发送了两个数据包 D1 和 D2 给服务端，由于服务端一次读取到字节数是不确定的，故可能存在以下四种情况：

  1. 服务端分两次读取到了两个独立的数据包，分别是 D1 和 D2，没有粘包和拆包
  2. 服务端一次接受到了两个数据包，D1 和 D2 粘合在一起，称之为 TCP 粘包
  3. 服务端分两次读取到了数据包，第一次读取到了完整的 D1 包和 D2 包的部分内容，第二次读取到了 D2 包的剩余内容，这称之为 TCP 拆包
  4. 服务端分两次读取到了数据包，第一次读取到了 D1 包的部分内容 D1_1，第二次读取到了 D1 包的剩余部分内容 D1_2 和完整的 D2 包。

2.2 TCP 粘包和拆包现象实例

在编写 Netty 程序时，如果没有做处理，就会发生粘包和拆包的问题

看一个具体的实例：

// 核心代码

MyClientHandler.java

package com.atguigu.netty.tcp;

import io.netty.buffer.ByteBuf;
import io.netty.buffer.Unpooled;
import io.netty.channel.ChannelHandlerContext;
import io.netty.channel.SimpleChannelInboundHandler;

import java.nio.charset.Charset;

public class MyClientHandler extends SimpleChannelInboundHandler<ByteBuf> {

    private int count;

    @Override
    public void channelActive(ChannelHandlerContext ctx) throws Exception {
        //使用客户端发送10条数据 hello,server 编号
        for (int i = 0; i < 10; ++i) {
            ByteBuf buffer = Unpooled.copiedBuffer("hello,server " + i, Charset.forName("utf-8"));
            ctx.writeAndFlush(buffer);
        }
    }

    @Override
    protected void channelRead0(ChannelHandlerContext ctx, ByteBuf msg) throws Exception {
        byte[] buffer = new byte[msg.readableBytes()];
        msg.readBytes(buffer);

        String message = new String(buffer, Charset.forName("utf-8"));
        System.out.println("客户端接收到消息=" + message);
        System.out.println("客户端接收消息数量=" + (++this.count));

    }

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

MyServerHandler.java

package com.atguigu.netty.tcp;

import io.netty.buffer.ByteBuf;
import io.netty.buffer.Unpooled;
import io.netty.channel.ChannelHandlerContext;
import io.netty.channel.SimpleChannelInboundHandler;

import java.nio.charset.Charset;
import java.util.UUID;

public class MyServerHandler extends SimpleChannelInboundHandler<ByteBuf> {
    
    private int count;

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

    @Override
    protected void channelRead0(ChannelHandlerContext ctx, ByteBuf msg) throws Exception {

        byte[] buffer = new byte[msg.readableBytes()];
        msg.readBytes(buffer);

        //将buffer转成字符串
        String message = new String(buffer, Charset.forName("utf-8"));

        System.out.println("服务器接收到数据 " + message);
        System.out.println("服务器接收到消息量=" + (++this.count));

        //服务器回送数据给客户端, 回送一个随机id ,
        ByteBuf responseByteBuf = Unpooled.copiedBuffer(UUID.randomUUID().toString() + " ", Charset.forName("utf-8"));
        ctx.writeAndFlush(responseByteBuf);

    }
}

2.3 TCP 粘包和拆包解决方案

  1. 使用自定义协议+编解码器来解决
  2. 关键就是要解决服务器端每次读取数据长度的问题，这个问题解决，就不会出现服务器多读或少读数据的问题，从而避免的 TCP 粘包、拆包。
  3. netty有现成的比如LineBasedFrameDecoder和StringDecoder可用来按行发送和接受数据。

2.4 看一个具体的实例

  1. 要求客户端发送 5 个 Message 对象，客户端每次发送一个 Message 对象
  2. 服务器端每次接收一个 Message，分 5 次进行解码，每读取到一个 Message，会回复一个 Message 对象给客户端。

  1. 代码演示，全部代码核心
// 核心

package com.atguigu.netty.protocoltcp;

//协议包
public class MessageProtocol {
    
    private int len; //关键
    
    private byte[] content;

    public int getLen() {
        return len;
    }

    public void setLen(int len) {
        this.len = len;
    }

    public byte[] getContent() {
        return content;
    }

    public void setContent(byte[] content) {
        this.content = content;
    }
}

package com.atguigu.netty.protocoltcp;

import io.netty.channel.ChannelHandlerContext;
import io.netty.channel.SimpleChannelInboundHandler;

import java.nio.charset.Charset;

public class MyClientHandler extends SimpleChannelInboundHandler<MessageProtocol> {

    private int count;

    @Override
    public void channelActive(ChannelHandlerContext ctx) throws Exception {
        //使用客户端发送10条数据 "今天天气冷，吃火锅" 编号

        for (int i = 0; i < 5; i++) {
            String mes = "今天天气冷，吃火锅";
            byte[] content = mes.getBytes(Charset.forName("utf-8"));
            int length = mes.getBytes(Charset.forName("utf-8")).length;

            //创建协议包对象
            MessageProtocol messageProtocol = new MessageProtocol();
            messageProtocol.setLen(length);
            messageProtocol.setContent(content);
            ctx.writeAndFlush(messageProtocol);
        }
    }

    //    @Override
    protected void channelRead0(ChannelHandlerContext ctx, MessageProtocol msg) throws Exception {

        int len = msg.getLen();
        byte[] content = msg.getContent();

        System.out.println("客户端接收到消息如下");
        System.out.println("长度=" + len);
        System.out.println("内容=" + new String(content, Charset.forName("utf-8")));

        System.out.println("客户端接收消息数量=" + (++this.count));
    }

    @Override
    public void exceptionCaught(ChannelHandlerContext ctx, Throwable cause) throws Exception {
        System.out.println("异常消息=" + cause.getMessage());
        ctx.close();
    }
}

package com.atguigu.netty.protocoltcp;

import io.netty.buffer.ByteBuf;
import io.netty.channel.ChannelHandlerContext;
import io.netty.handler.codec.MessageToByteEncoder;

public class MyMessageEncoder extends MessageToByteEncoder<MessageProtocol> {
    
    @Override
    protected void encode(ChannelHandlerContext ctx, MessageProtocol msg, ByteBuf out) throws Exception {
        System.out.println("MyMessageEncoder encode 方法被调用");
        out.writeInt(msg.getLen());
        out.writeBytes(msg.getContent());
    }
}

package com.atguigu.netty.protocoltcp;

import io.netty.buffer.ByteBuf;
import io.netty.channel.ChannelHandlerContext;
import io.netty.handler.codec.ReplayingDecoder;

import java.util.List;

public class MyMessageDecoder extends ReplayingDecoder<Void> {
    
    @Override
    protected void decode(ChannelHandlerContext ctx, ByteBuf in, List<Object> out) throws Exception {
        System.out.println("MyMessageDecoder decode 被调用");
        //需要将得到二进制字节码-> MessageProtocol 数据包(对象)
        int length = in.readInt();

        byte[] content = new byte[length];
        in.readBytes(content);

        //封装成 MessageProtocol 对象，放入 out， 传递下一个handler业务处理
        MessageProtocol messageProtocol = new MessageProtocol();
        messageProtocol.setLen(length);
        messageProtocol.setContent(content);
        out.add(messageProtocol);
    }
}

package com.atguigu.netty.protocoltcp;

import io.netty.channel.ChannelHandlerContext;
import io.netty.channel.SimpleChannelInboundHandler;

import java.nio.charset.Charset;
import java.util.UUID;


//处理业务的handler
public class MyServerHandler extends SimpleChannelInboundHandler<MessageProtocol> {
    
    private int count;

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

    @Override
    protected void channelRead0(ChannelHandlerContext ctx, MessageProtocol msg) throws Exception {
        //接收到数据，并处理
        int len = msg.getLen();
        byte[] content = msg.getContent();

        System.out.println();
        System.out.println();
        System.out.println();
        System.out.println("服务器接收到信息如下");
        System.out.println("长度=" + len);
        System.out.println("内容=" + new String(content, Charset.forName("utf-8")));

        System.out.println("服务器接收到消息包数量=" + (++this.count));

        //回复消息
        String responseContent = UUID.randomUUID().toString();
        int responseLen = responseContent.getBytes("utf-8").length;
        byte[] responseContent2 = responseContent.getBytes("utf-8");
        //构建一个协议包
        MessageProtocol messageProtocol = new MessageProtocol();
        messageProtocol.setLen(responseLen);
        messageProtocol.setContent(responseContent2);

        ctx.writeAndFlush(messageProtocol);
    }
}

Netty分隔符解码器DelimiterBaesedFrameDecoder和定长解码器FixedLengthFrameDecoder可以直接使用，非常方便。

注：笔记整理自韩顺平老师 Netty 课程《尚硅谷 Netty 视频教程》，迁移自自己语雀文档

非常之观常在险远
关注
  • 1
    点赞
  • 踩
  • 3
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
netty解决tcp粘包和拆包问题
远方的少年
01-20 2843
tcp为了提高效率会将多个数据包批量发送过来，所以就会存在粘包和拆包的问题。使用Netty,可以通过自定义协议+编解码器来解决粘包和拆包的问题。 1.定义协议 public class MessageProtocol { private int len; private byte[] content; public int getLen() { return len; } public void setLen(int len) {
使用Netty解决TCP粘包和拆包问题过程详解
08-25
使用Netty解决TCP粘包和拆包问题过程详解 Netty是一个流行的Java网络编程框架，提供了简洁、灵活的API来处理网络编程的各种问题。其中，解决TCP粘包和拆包问题是Netty的一个重要应用场景。本文将详细介绍使用Netty...
Netty学习（八）：TCP的粘包拆包与解决方案
m0_49499183的博客
03-17 1345
TCP是面向连接的，面向流的，提供高可靠性服务。收发两端（客户端和服务器端）都要有一一成对的socket,因此，发送端为了将多个发给接收端的包，更有效的发给对方，使用了优化方法(Nagle算法)，将多次间隔较小且数据量小的数据，合并成一个大的数据块，然后进行封包。这样做虽然提高了效率，但是接收端就难于分辨出完整的数据包了，因为面向流的通信是无消息保护边界的。由于TCP无消息保护边界,需要在接收端处理消息边界问题，这也就是我们所说的粘包、拆包问题。
Netty中的粘包、拆包与丢包问题及其解决方案详解
微笑听雨
06-19 4443
在Netty中，通过使用合适的解码器（如定长解码器、换行符解码器、分隔符解码器和长度字段解码器）可以有效解决粘包和拆包问题。同时，结合TCP的重传机制和应用层的重传策略，可以有效地减少丢包现象，确保数据传输的可靠性。选择合适的方案需要根据具体的应用场景和协议要求来定。
Netty核心技术九--TCP 粘包和拆包及解决方案
qq_31745863的博客
07-08 727
要求客户端发送 5 个 Message 对象, 客户端每次发送一个Message对象服务器端每次接收一个Message, 分5次进行解码，每读取到一个Message,会回复一个Message 对象 给客户端.示例1的代码基础上做扩充len:每个数据包的长度content:每个数据包的内容//协议包 public class MessageProtocol {//关键 private byte [ ] content;return len;} }个人总结。
Netty学习六：编解码之粘包和拆包
weixin_41402069的博客
07-11 933
Netty学习系列
netty基础_10.Netty TCP 粘包和拆包及解决方案
07-10 263
假设客户端分别发送了两个数据包 和 给服务端，由于服务端一次读取到字节数是不确定的，故可能存在以下四种情况：在编写 程序时，如果没有做处理，就会发生粘包和拆包的问题看一个具体的实例： MyServerHandler MyClient MyClientHandler 关键代码: 这个地方是一个依赖tcp长链接,进行循环 效果 可以看到第一次运行时，服务器一次性将10个数据都接收了，第二次运行时分六次接收的，这就很形象的看出了TCP的粘包现象。 服务器端接受到的消息都不一样,由于tcp是长链接导致
【Netty】TCP粘包/拆包解决方案
程序员小潘
06-11 1300
TCP作为传输层(4层)协议，并不知道你的应用层(7层)数据报文的含义，因此使用TCP传输数据时，可能会出现「粘包/拆包」，需要引用层通过特定的协议去解决。 1. 什么是TCP粘包/拆包？ 「粘包/拆包」在Socket编程中经常会出现，使用TCP协议传输数据时，如果对端连续发送多个小的数据包，TCP会将这些小的数据包打包，合并成一个TCP报文发送出去，这就是「粘包」。如果对端发送一个超大的数据包，TCP会根据缓冲区的情况，将这个超大数据包拆分成多个小的TCP报文发送出去，这就是「拆包」。 ​ 拿HTTP服.
Netty如何解决TCP中的粘包和拆包问题
lengyingzhang的博客
07-29 3120
粘包和拆包是TCP网络编程中不可避免的，无论是服务端还是客户端，当我们读取或者发送消息的时候，都需要考虑TCP底层的粘包/拆包机制。TCP是个“流”协议，所谓流，就是没有界限的一串数据。TCP底层并不了解上层业务数据的具体含义，它会根据TCP缓冲区的实际情况进行包的划分，所以在业务上认为，一个完整的包可能会被TCP拆分成多个包进行发送，也有可能把多个小的包封装成一个大的数据包发送，这就是所谓的TCP粘包和拆包问题。...
【三】Netty 解决粘包和拆包问题
echohuangshihuxue的博客
01-06 2587
一:介绍了下 TCP的粘包和拆包的原理以及主流的解决方案。 二:详细的用代码展示了粘包例子和 如何解决。 三:简单介绍了下 编码解码原理以及自己遇到的坑
Netty(二)、TCP粘包/拆包问题的解决之道
weixin_55730337的博客
06-25 730
​ 为了解决TCP粘包/拆包问题导致的半包读写问题，Netty默认提供了多种解码器用于处理半包，只要熟练掌握这些类库的使用，TCP粘包的问题从此变得非常简单，你甚至不用关心他们，这也是其他NIO框架和原生的NIO API所无法匹敌的。在上一章的时间服务器的案例中，就没有考虑读半包的问题，这在功能测试中没有问题，但压力一旦上来了，或者发送大报文之后，就会存在粘包/拆包问题。改动的地方在于，每次应答都会计数。由于上面的例子没有考虑TCP的粘包/拆包问题，所以当发生TCP粘包的时候，我们的程序就不能正常工作了。
Netty粘包拆包问题解决方案
08-18
Netty 粘包拆包问题解决方案 Netty 是一个基于 Java 的网络编程框架，它提供了一个便捷的方式来处理网络数据的...解决粘包和拆包问题需要根据实际情况选择合适的方法，Netty 提供了多种解码器来帮助我们解决这个问题。
面试题：聊聊TCP的粘包、拆包以及解决方案.docx
10-26
TCP的粘包和拆包是网络编程中遇到的常见问题，尤其在基于TCP协议的通讯中，如RPC框架和Netty等。TCP是一种面向字节流的协议，它没有明确的数据包边界，这可能导致发送的数据在接收端看起来像是被粘在一起或是被拆...
Netty中粘包和拆包的解决方案.docx
10-26
解决TCP粘包和拆包的方法主要在应用层协议设计上，包括： 1. **固定长度**：每个消息的长度都是固定的，这样接收端一旦收到相应长度的数据，就知道一个消息结束了。 2. **结束符**：在消息尾部添加特定的回车换行符...
netty拆包粘包解决方案示例
07-28
本文将深入探讨Netty中解决拆包粘包问题的策略，以及客户端断线重连的实现方式。 首先，我们需要理解什么是“拆包”和“粘包”。在TCP/IP通信中，由于TCP协议的流式传输特性，数据可能会被分片或者合并，这就可能...
golang 接口
m0_70982551的博客
07-24 931
接口定义了一组方法，这些方法没有具体的实现。接口类型的变量可以存储任何实现了这些方法的类型的值。// 更多方法...在Go语言中，接口值是指存储了实现某个接口的具体类型值的变量。接口值由两部分组成：1.动态类型：这是接口值当前存储的实际类型。2.动态值：这是实际存储的值，该值必须实现了接口中定义的所有方法。
Swagger使用Map接受参数时，页面如何显示具体参数及说
最新发布
a1058926697的博客
07-26 504
后端使用Map接受参数，要求在swagger页面上显示具体的参数名称、类型及说明。当Map接受参数数量少时，可以使用Swagger自带的注解。自定义注解 @ApiGlobalModel。编写处理注解对应的插件。
springboot之自动装配
weixin_50153914的博客
07-23 621
Spring Boot 通过一系列注解和条件配置实现了自动装配机制，使得开发者无需手动配置大量的 XML 文件或 Java 配置类。自动配置机制利用文件中的自动配置类，并结合条件注解和组件扫描，实现了灵活且强大的自动装配功能。这样，开发者可以专注于业务逻辑的实现，而无需处理繁琐的配置细节。
netty tcp粘包和拆包
07-30
Netty中的TCP粘包和拆包问题是由于底层的TCP协议无法理解上层的业务数据而导致的。...综上所述，Netty提供了多种解决方案来解决TCP粘包和拆包问题，可以根据具体的业务需求选择合适的解决方案[1][3]。
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值