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

已于 2022-08-24 13:32:24 修改
阅读量679 收藏 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的多个handler链式模式
weixin_34008784的博客
05-29 4295
1. 老规矩, 引入我们喜闻乐见的maven依赖 1 <dependency> 2 <groupId>io.netty</groupId> 3 <artifactId>netty-all</artifactId> 4 <version>4.1.6.Final</version> ...
Netty大战之Netty编解码器和handler的调用机制
亚索@哈塞给
07-25 638
基本说明 友情提示：这个ChannelHandler就是我们自己写的handler自定义的，用来处理业务逻辑，我们写的都是extends SimpleChannelInboundHandler,他是ChannelInboundHandler的子类，专门处理入栈的，同理也有写出栈的 友情提示:处理业务，要出栈都是出栈的handler,要是入栈都是入栈。 编码解码器 友情提示：为什么后面介绍的粘包问题可以用编码器+协议解决，编码器可以根据协议进行数据的处理，拆分一个完整的包数据。比如：定义一..
Netty之Handler详解与实战
HaSaKing的博客
02-27 1858
在Netty中，Handler是实现网络应用逻辑的核心。它提供了一系列回调方法，例如处理接收到的数据、异常处理、连接活动等。Netty通过ChannelPipeline来管理Handler，可以想象为一个Handler链，数据在这个链上流动，每个Handler对数据进行处理后，可以传递给链上的下一个Handler，这种机制极大地提高了处理流程的灵活性和可定制性。
Netty(二)、TCP粘包/拆包问题的解决之道
最新发布
weixin_55730337的博客
06-25 727
​ 为了解决TCP粘包/拆包问题导致的半包读写问题，Netty默认提供了多种解码器用于处理半包，只要熟练掌握这些类库的使用，TCP粘包的问题从此变得非常简单，你甚至不用关心他们，这也是其他NIO框架和原生的NIO API所无法匹敌的。在上一章的时间服务器的案例中，就没有考虑读半包的问题，这在功能测试中没有问题，但压力一旦上来了，或者发送大报文之后，就会存在粘包/拆包问题。改动的地方在于，每次应答都会计数。由于上面的例子没有考虑TCP的粘包/拆包问题，所以当发生TCP粘包的时候，我们的程序就不能正常工作了。
Netty中粘包和拆包的解决方案
woaiwojialanxi的专栏
03-21 1450
Netty中粘包和拆包的解决方案
Java netty发送接收（TCP、UDP）
weixin_50272584的博客
05-12 2952
Java netty发送接收（TCP、UDP）含项目地址
使用Netty解决TCP粘包和拆包问题过程详解
08-25
使用Netty解决TCP粘包和拆包问题过程详解 Netty是一个流行的Java网络编程框架，提供了简洁、灵活的API来处理网络编程的各种问题。其中，解决TCP粘包和拆包问题是Netty的一个重要应用场景。本文将详细介绍使用Netty...
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协议的流式传输特性，数据可能会被分片或者合并，这就可能...
netty 高低位转码_Netty解决粘包和拆包问题的四种方案
weixin_39670464的博客
12-21 318
在RPC框架中，粘包和拆包问题是必须解决一个问题，因为RPC框架中，各个微服务相互之间都是维系了一个TCP长连接，比如dubbo就是一个全双工的长连接。由于微服务往对方发送信息的时候，所有的请求都是使用的同一个连接，这样就会产生粘包和拆包的问题。本文首先会对粘包和拆包问题进行描述，然后介绍其常用的解决方案，最后会对Netty提供的几种解决方案进行讲解。这里说明一下，由于oschina将“jie m...
channel与outboundhandler下的方法
m0_48187193的博客
05-26 481
channel与outboundhandler下的方法。 文章目录channel与outboundhandler下的方法。前言1.connect方法1.1 寻找outbound connect方法执行执行HeadContext的connect方法。2.close方法2.1连接超时3.write方法3.1 headContext的write方法。3.2最后会执行AbstractChannel的方法3.3 他在写到什么时候才会将数据刷到服务端呢？4.read方法4.1调用unsafe的beginRead方法4.
netty自定义编码解码器解决拆包粘包
dingruibao的博客
11-11 1243
通过发送数据时同时发送数据长度，解决拆包粘包问题 自定义编码器、解码器 消息实体类： public class MyMessage { private int len;//发送内容的长度 private byte[] content;//发送的内容 public int getLen() { return len; } public void setLen(int len) { this.len = len; }
netty中channelHandler实现原理及最佳实践｜极客星球
apkkkk的博客
01-05 809
首先会判断in.isReadable() 是否可读，然后我们的outSize 目前是空， 进入到 decodeRemovalReentryProtection , 该方法会调用子类FixedLengthFrameDecoder的decode方法进行具体解码，该decode 方法比较简单就是当从ByteBuf 读取到指定长度就添加到out 中。上面的实现方式确实减少系统调用，但是在netty 内部当有数据可读，会默认会连续16次，最后在调用channelReadComplete() 方法。
Netty系列Netty组件之ChannelPipeline与ChannelHandler
java1527的博客
09-12 644
ChannelPipeline和ChannelHandler是Netty在进行业务处理时的重要组成组件，简单来说，ChannelHandler是进行一个业务处理的处理器，而Pipeline负责将一个个的处理器串联起来，相当于一个容器，Channel中的数据会进入Pipeline，在容器中的各个处理器中按照顺序进行流转。
用netty实现tcp简单通信
热门推荐
mistt的博客
02-16 1万+
一般我们想要使用tcp通信，最原始的方法就是使用socket套接字，但是每次都要创建新的socket对象，并且在finally中关闭，好浪费资源，很麻烦。所以就是用netty工具，可以轻松地实现tcp通信，当然也可以实现http通信，因为我们需要用tcp通信，所以这里只研究tcp。 最好先了解一下netty是干嘛的，以及NIO是什么。 netty： https://blog.csdn.net/qq_34730511/article/details/98472924?ops_request_misc=&
netty学习05-handler介绍
zhaocuit的博客
10-23 966
1. Netty中Handler 从应用程序开发人员的角度来看，Netty的主要组件是ChannelHandler，而ChannelHandler包括入站和出站两种类型。 数据入站，指的是数据从底层的Java NIO channel到Netty的Channel。 数据出站，指的是通过Netty的Channel来操作底层的 Java NIO chanel。 1.1 inbound 入站（...
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]。
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值