ByteBuf（秒懂）- 图解Netty系列

最新推荐文章于 2024-05-27 22:25:41 发布
最新推荐文章于 2024-05-27 22:25:41 发布
阅读量7.6k 收藏 39
点赞数 7
分类专栏： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/crazymakercircle/article/details/84198042
版权

Netty ByteBuf（图解 ）之一

疯狂创客圈 Java 分布式聊天室【 亿级流量】实战系列之15 【 博客园 总入口 】

文章目录

源码工程

源码IDEA工程获取链接：Java 聊天室 实战 源码

写在前面

​ 大家好，我是作者尼恩。

​ 今天是百万级流量 Netty 聊天器 打造的系列文章的第15篇，这是一个基础篇。

​ 由于关于ByteBuf的内容比较多，分两篇文章：

​ 第一篇：图解 ByteBuf的分配、释放和如何避免内存泄露

​ 第二篇：图解 ByteBuf的具体使用

​

​ 本篇为第一篇。

Netty ByteBuf 优势

Netty 提供了ByteBuf，来替代Java NIO的 ByteBuffer 缓，来操纵内存缓冲区。

与Java NIO的 ByteBuffer 相比，ByteBuf的优势如下：

  1. Pooling (池化，这点减少了内存复制和GC，提升效率)

  2. 可以自定义缓冲类型

  3. 通过一个内置的复合缓冲类型实现零拷贝

  4. 扩展性好，比如 StringBuffer

  5. 不需要调用 flip()来切换读/写模式

  6. 读取和写入索引分开

  7. 方法链

  8. 引用计数

手动获取与释放ByteBuf

Netty环境下，业务处理的代码，基本上都在Handler处理器中的各个入站和出站方法中。

一般情况下，采用如下方法获取一个Java 堆中的缓冲区：

ByteBuf heapBuffer = ctx.alloc().heapBuffer();

使用完成后，通过如下的方法，释放缓冲区：

ReferenceCountUtil.release(heapBuffer );

上面的代码很简单，通过release方法减去 heapBuffer 的使用计数，Netty 会自动回收 heapBuffer 。

缓冲区内存的回收、二次分配等管理工作，是 Netty 自动完成的。

自动获取和释放 ByteBuf

方式一：TailHandler 自动释放

​ Netty默认会在ChannelPipline的最后添加的那个 TailHandler 帮你完成 ByteBuf的release。

​ 先看看，自动创建的ByteBuf实例是如何登场的？

​ Netty自动创建 ByteBuf实例

​ Netty 的 Reactor 线程会在 AbstractNioByteChannel.NioByteUnsafe.read() 处调用 ByteBufAllocator创建ByteBuf实例，将TCP缓冲区的数据读取到 Bytebuf 实例中，并调用 pipeline.fireChannelRead(byteBuf) 进入pipeline 入站处理流水线。

默认情况下，TailHandler自动释放掉ByteBuf实例

​ Netty的ChannelPipleline的流水线的末端是TailHandler，默认情况下如果每个入站处理器Handler都把消息往下传，TailHandler会释放掉ReferenceCounted类型的消息。
在这里插入图片描述

说明：

上图中，TailHandler 写成了TailContext，这个是没有错的。

对于流水线的头部和尾部Hander来说， Context和Hander ，是同一个类。

HeadContext 与HeadHandler ，也是同一个类。

关于Context与Handler 的关系，请看 疯狂创客圈 的系列文章。

​ 如果没有到达末端呢？

​ 一种没有到达入站处理流水线pipeline末端的情况，如下图所示：
在这里插入图片描述

​ 这种场景下，也有一种自动释放的解决办法，它就是：

​ 可以继承 SimpleChannelInboundHandler，实现业务Handler。 SimpleChannelInboundHandler 会完成ByteBuf 的自动释放，释放的处理工作，在其入站处理方法 channelRead 中。

方式二：SimpleChannelInboundHandler 自动释放

​

​ 如果业务Handler需要将 ChannelPipleline的流水线的默认处理流程截断，不进行后边的inbound入站处理操作,这时候末端 TailHandler自动释放缓冲区的工作，自然就失效了。

​ 这种场景下，业务Handler 有两种选择：

  • 手动释放 ByteBuf 实例

  • 继承 SimpleChannelInboundHandler，利用它的自动释放功能。

本小节，我们聚焦的是第二种选择：看看 SimpleChannelInboundHandler是如何自动释放的。

利用这种方法，业务处理Handler 必须继承 SimpleChannelInboundHandler基类。并且，业务处理的代码，必须 移动到 重写的 channelRead0(ctx, msg)方法中。

如果好奇，想看看 SimpleChannelInboundHandler 是如何释放ByteBuf 的，那就一起来看看Netty源码。

截取的代码如下所示：

public abstract class SimpleChannelInboundHandler<I> extends ChannelInboundHandlerAdapter 
{
//...
@Override
public void channelRead(ChannelHandlerContext ctx, Object msg) throws Exception {
    boolean release = true;
    try {
        if (acceptInboundMessage(msg)) {
            @SuppressWarnings("unchecked")
            I imsg = (I) msg;
            channelRead0(ctx, imsg);
        } else {
            release = false;
            ctx.fireChannelRead(msg);
        }
    } finally {
        if (autoRelease && release) {
            ReferenceCountUtil.release(msg);
        }
    }
}

源码中，执行完重写的channelRead0()后，在 finally 语句块中，ByteBuf 的生命被结束掉了。

上面两种，都是入站处理（inbound）过程中的自动释放。

**出站处理（outbound）**流程，又是如何自动释放呢？

方式三：HeadHandler 自动释放

出站处理流程中，申请分配到的 ByteBuf，通过 HeadHandler 完成自动释放。

出站处理用到的 Bytebuf 缓冲区，一般是要发送的消息，通常由应用所申请。在出站流程开始的时候，通过调用 ctx.writeAndFlush(msg)，Bytebuf 缓冲区开始进入出站处理的 pipeline 流水线 。在每一个出站Handler中的处理完成后，最后消息会来到出站的最后一棒 HeadHandler，再经过一轮复杂的调用，在flush完成后终将被release掉。

在这里插入图片描述

强调一下，HeadContext （HeadHandler）是出站处理流程的最后一棒。

出站处理的全过程，请查看疯狂创客圈的专门文章。

如何避免内存泄露

​ 基本上，在 Netty的开发中，通过 ChannelHandlerContext 或 Channel 获取的缓冲区ByteBuf 默认都是Pooled，所以需要再合适的时机对其进行释放，避免造成内存泄漏。

自动释放的注意事项

我们已经知道了三种自动释放方法：

  • 通过 TailHandler 自动释放入站 ByteBuf

  • 继承 SimpleChannelInboundHandler 的完成 入站ByteBuf 自动释放

  • 通过HeadHandler自动释放出站 ByteBuf

    自动释放，注意事项如下：

  • 入站处理流程中，如果对原消息不做处理，默认会调用 ctx.fireChannelRead(msg) 把原消息往下传，由流水线最后一棒 TailHandler 完成自动释放。

  • 如果截断了入站处理流水线，则可以继承 SimpleChannelInboundHandler ，完成入站ByteBuf 自动释放。

  • 出站处理过程中，申请分配到的 ByteBuf，通过 HeadHandler 完成自动释放。

    出站处理用到的 Bytebuf 缓冲区，一般是要发送的消息，通常由应用所申请。在出站流程开始的时候，通过调用 ctx.writeAndFlush(msg)，Bytebuf 缓冲区开始进入出站处理的 pipeline 流水线 。在每一个出站Handler中的处理完成后，最后消息会来到出站的最后一棒 HeadHandler，再经过一轮复杂的调用，在flush完成后终将被release掉。

手动释放的注意事项

​ 手动释放是自动释放的重要补充和辅助。

​ 手动释放操作，大致有如下注意事项：

  • 入站处理中，如果将原消息转化为新的消息并调用 ctx.fireChannelRead(newMsg)往下传，那必须把原消息release掉;

  • 入站处理中，如果已经不再调用 ctx.fireChannelRead(msg) 传递任何消息，也没有继承SimpleChannelInboundHandler 完成自动释放，那更要把原消息release掉;

  • 多层的异常处理机制，有些异常处理的地方不一定准确知道ByteBuf之前释放了没有，可以在释放前加上引用计数大于0的判断避免异常； 有时候不清楚ByteBuf被引用了多少次，但又必须在此进行彻底的释放，可以循环调用reelase()直到返回true。

特别需要强调的，是上边的第一种情况。
如果在入站处理的 handlers 传递过程中，传递了新的ByteBuf 值，老ByteBuf 值需要自己手动释放。老的ByteBuf 值，就是从pipeline流水线入口传递过来的 ByteBuf 实例。

​

总之，只要是在传递过程中，没有传递下去的ByteBuf就需要手动释放，避免不必要的内存泄露。

缓冲区 Allocator 分配器

Netty通过 ByteBufAllocator分配缓冲区。

Netty提供了ByteBufAllocator的两种实现：PoolByteBufAllocator和UnpooledByteBufAllocator。前者将ByteBuf实例放入池中，提高了性能，将内存碎片减少到最小。这个实现采用了一种内存分配的高效策略，称为 jemalloc。它已经被好几种现代操作系统所采用。后者则没有把ByteBuf放入池中，每次被调用时，返回一个新的ByteBuf实例。

分配器 Allocator的类型

在这里插入图片描述

PooledByteBufAllocator：可以重复利用之前分配的内存空间。

为了减少内存的分配回收以及产生的内存碎片，Netty提供了PooledByteBufAllocator 用来分配可回收的ByteBuf，可以把PooledByteBufAllocator 看做一个池子，需要的时候从里面获取ByteBuf，用完了放回去，以此提高性能。

UnpooledByteBufAllocator：不可重复利用，由JVM GC负责回收。

顾名思义Unpooled就是不会放到池子里，所以根据该分配器分配的ByteBuf，不需要放回池子，由JVM自己GC回收。

这两个类，都是AbstractByteBufAllocator的子类，AbstractByteBufAllocator实现了一个接口，叫做ByteBufAllocator。

可以做一个对比试验：

使用UnpooledByteBufAllocator的方式创建ByteBuf的时候，单台24核CPU的服务器，16G内存，刚启动时候，10000个长连接，每秒所有的连接发一条消息，短时间内，可以看到内存占到10G多点，但随着系统的运行，内存不断增长，直到整个系统内存溢出挂掉。

把UnpooledByteBufAllocator换成PooledByteBufAllocator，通过试验，内存使用量机器能维持在一个连接占用1M左右，内存在10G左右，经常长期的运行测试，发现都能维持在这个数量，系统内存不会崩溃。

默认的分配器

​ 默认的分配器 ByteBufAllocator.DEFAULT ，可以通过 Java 系统参数（SystemProperty ）选项 io.netty.allocator.type 去配置，使用字符串值：“unpooled”，“pooled”。

​ 关于这一段，Netty的源代码截取如下：

        String allocType = SystemPropertyUtil.get("io.netty.allocator.type", "unpooled").toLowerCase(Locale.US).trim();
        Object alloc;
        if("unpooled".equals(allocType)) {
            alloc = UnpooledByteBufAllocator.DEFAULT;
            logger.debug("-Dio.netty.allocator.type: {}", allocType);
        } else if("pooled".equals(allocType)) {
            alloc = PooledByteBufAllocator.DEFAULT;
            logger.debug("-Dio.netty.allocator.type: {}", allocType);
        } else {
            alloc = UnpooledByteBufAllocator.DEFAULT;
            logger.debug("-Dio.netty.allocator.type: unpooled (unknown: {})", allocType);
        }


不同的Netty版本，源码不一样。

​ 上面的代码，是4.0版本的源码，默认为UnpooledByteBufAllocator。

​ 而4.1 版本，默认为 PooledByteBufAllocator。因此，4.1版本的代码，是和上面的代码稍微有些不同的。

设置通道Channel的分配器

在4.x版本中，UnpooledByteBufAllocator是默认的allocator，尽管其存在某些限制。

现在PooledByteBufAllocator已经广泛使用一段时间，并且我们有了增强的缓冲区泄漏追踪机制，所以是时候让PooledByteBufAllocator成为默认了。

ServerBootstrap b = new ServerBootstrap()
        .group(bossGroup, workerGroup)
        .channel(NioServerSocketChannel.class)
        .localAddress(port)
        .childOption(ChannelOption.ALLOCATOR, PooledByteBufAllocator.DEFAULT)
        .childHandler(new ChannelInitializer<SocketChannel>() {
            @Override
            public void initChannel(SocketChannel ch) throws Exception {
                ch.pipeline().addLast(...);
            }
        });

使用Netty带来的又一个好处就是内存管理。只需一行简单的配置，就能获得到内存池带来的好处。在底层，Netty实现了一个Java版的Jemalloc内存管理库，为我们做完了所有“脏活累活”！

缓冲区内存的类型

​ 说完了分配器的类型，再来说下缓冲区的类型。

​ 依据内存的管理方不同，分为堆缓存和直接缓存。也就是Heap ByteBuf 和 Direct ByteBuf。另外，为了方便缓冲区进行组合，提供了一种组合缓存区。

在这里插入图片描述
​

​ 三种缓冲区的介绍如下：

使用模式描述优点劣势
堆缓冲区数据存存储在JVM的堆空间中，又称为支撑数组，通过 hasArray 来判断是不是在堆缓冲区中没使用池化情况下能提供快速的分配和释放发送之前都会拷贝到直接缓冲区
直接缓冲区存储在物理内存中能获取超过jvm堆限制大小的空间；
写入channel比堆缓冲区更快		释放和分配空间昂贵(使用系统的方法) ；
操作时需要复制一次到堆上
复合缓冲单个缓冲区合并多个缓冲区表示操作多个更方便-

​ 上面三种缓冲区的类型，无论哪一种，都可以通过池化、非池化的方式，去获取。

Unpooled 非池化缓冲区的使用方法

Unpooled也是用来创建缓冲区的工具类，Unpooled 的使用也很容易。

看下面代码：

//创建复合缓冲区

CompositeByteBuf compBuf = Unpooled.compositeBuffer();

//创建堆缓冲区
ByteBuf heapBuf = Unpooled.buffer(8);
//创建直接缓冲区
ByteBuf directBuf = Unpooled.directBuffer(16);

Unpooled 提供了很多方法，详细方法大致如下：

方法名称描述
buffer()
buffer(int initialCapacity)
buffer(int initialCapacity, int maxCapacity)		返回 heap ByteBuf
directBuffer()
directBuffer(int initialCapacity)
directBuffer(int initialCapacity, intmaxCapacity)		返回 direct ByteBuf
compositeBuffer()返回 CompositeByteBuf
copiedBuffer()返回 copied ByteBuf

Unpooled类的应用场景

Unpooled类让ByteBuf也同样适用于不需要其他的Netty组件的、无网络操作的项目，这些项目可以从这个高性能的、可扩展的buffer API中获益。

写在最后

​ 至此为止，终于完成ByteBuf的分配、释放和如何避免内存泄露介绍。

​ 接下来是：

​ 第二篇：图解 ByteBuf的具体使用

疯狂创客圈 Java 死磕系列

  • Java (Netty) 聊天程序【 亿级流量】实战 开源项目实战
40岁资深老架构师尼恩
关注
  • 7
    点赞
  • 踩
  • 39
    收藏
    觉得还不错? 一键收藏
  • 3
    评论
专栏目录
Netty大纲-同步netty专栏
07-07
- **组件**：Netty中的EventLoop负责事件处理，Handler处理不同类型的事件，ByteBuf作为缓冲区，提供了池化和直接内存的高效管理，Pipeline则负责消息的编解码和传递。 4. **Netty进阶** - **粘包与半包**：在...
netty代码-同步netty专栏
07-07
这个“netty代码-同步netty专栏”很可能是关于如何使用Netty进行同步编程的一系列教程或代码示例集合。下面将详细探讨Netty以及同步在Netty中的应用。 Netty 的核心概念： 1. **NIO（Non-blocking I/O）**：Netty ...
JAVA学习 equals方法
qq_44977060的博客
09-11 148
JAVA学习 equals方法 java中创建对象时会重写equals方法，经常用来比较是否相等，其和==号的区别为 ==号比较的是地址是否相等，而equals比较值是否相等 假定有一个Person类 public class Person{ private String name; private int age; } 重写其equals方法为 @Override public boolean equals(Object o){ if(this==o) return true; //如果是自己返
java.nio.ByteBuffer 类
先相信你自己，然后别人才会相信你。
06-28 1398
<br />java.nio.ByteBuffer 类<br /><br />来自http://blog.csdn.net/daijialin/archive/2004/12/27/231384.aspx<br /><br /><br />最近要写麻将程序时.  偶然看到这个类.  在JDK帮助文档上看了半天模模糊糊的. 还好上边的帖子有个例子才弄清了. <br />在需要一个缓冲区的时候应该考虑用这个类.<br /><br /><br />Buffer 类<br />定义了一个可以线性存放primitiv
ByteBuf使用详解：ByteBuff组成、扩容、retain、release、零拷贝（slice、duplicate、compositeByteBuf、unpolled）、深拷贝。
最新发布
FLJS_T的博客
05-27 855
ByteBuf是对字节数据的封装。是netty的Server与Client之间通信的数据传输载体(Netty的数据容器)，它提供了一个byte数组(byte[])的抽象视图，既解决了JDK API的局限性，又为网络应用程序的开发者提供了更好的API。ByteBuf使用详解：ByteBuff组成、扩容、retain、release、零拷贝（slice、duplicate、compositeByteBuf、unpolled）、深拷贝。
ByteBuf详解和Netty中的拆包粘包原理解析
moneywenxue的博客
09-27 1651
前言 本章重点： ByteBuf零拷贝 netty拆包粘包 LengthFieldBasedFrameDecoder解码器 一、ByteBuf详解 1.1 ByteBuf的存储结构 1.2ByteBuf中常用的方法 1.3Reader相关方法 1.4ByteBuf的零拷贝机制 1.5Unpooled 1.6内存释放（可以不讲） 二、Netty中的拆包粘包问题 三、应用层定义通信协议 3.1消息长度固定 3.2特定分隔符 3.3消息长度加消息内容加分隔符 3.4...
Netty基础必备知识，ByteBuffer和ByteBuf底层原理
叶新东老师的博客
10-24 1846
前言 本文章只讨论ByteBuffer和ByteBuf的底层结构的区别，如果想要了解堆内内存和堆外内存的区别，请看我的另一篇文章：java堆外内存详解（又名直接内存）和ByteBuffer 什么是Buffer 中文称为缓冲区，指的是从网络或者文件读写数据的时候，在他们中间多了个缓冲区，应用程序只需要对着缓冲区 进行读写即可；然后缓冲区在将数据复制到内核或者从内核读取数据；这种方式加快读写速度，减少了IO次数；小文件的读写用不用缓冲区速度都没有多大区别，但是当我们进行大文件进行读写的时候一般都会使用到缓冲区；
简单认识java中的bytebuffer和netty中的bytebuf
diligence-zpf
09-18 2941
一 nio中的bytebuffer的认识 1.bytebuffer的数据结构 对于ByteBuffer，其主要有五个属性：mark，position，limit，capacity和array。这五个属性的作用如下： mark：记录了当前所标记的索引下标； position：对于写入模式，表示当前可写入数据的下标，对于读取模式，表示接下来可以读取的数据的下标； limit：对于写入模式，表示当前可以...
bytebuf-rs:类似于Netty ByteBuf的ByteBuf的Rust实现
04-16
在Rust编程语言中，`bytebuf-rs`项目是一个模仿Netty ByteBuf设计的库，旨在提供类似的性能特性和功能。本文将深入探讨`bytebuf-rs`的设计理念、主要功能以及与Netty ByteBuf的异同。 首先，`bytebuf-rs`的核心目标...
Netty初步学习-HelloNetty.rar
11-03
6. **ByteBuf**：Netty 自定义的缓冲区，提供了高效的数据读写操作，比 Java 的 ByteBuffer 更加灵活。 7. **Handler 的实现**：在 "第二课netty服务端" 中，你可能会看到自定义的 ChannelInboundHandler 或 ...
netty-study:netty-study netty的学习
03-24
ByteBuf 是 Netty 提供的高效缓冲区，替代了 Java NIO 中的 ByteBuffer。ByteBuf 提供了更方便的方法来管理内存，并且可以更容易地处理网络数据。 5. **Handler**： ChannelHandler 是事件处理的组件，可以处理 I...
Netty 教程 – ByteBuf详解
二师兄撒欢之地
03-13 798
相比其它的JAVA对象，缓冲区的分配(包括动态扩容)与释放是一个耗时操作，因此需要尽可能的复用。, 在内存中预留指定大小的存储空间来存放临时数据，其他。为什么会自动扩容呢？扩容的大小是怎么计算的？却可以很好的帮我们做到扩容，它的内部维护了。来的方便，无需关心读写切换指针的问题，在。无法做到自动扩容，当内容超出的时候会抛出。实现原理各不相同，我们先看最基本的。，当我们读取后内部会通过调用。的特别的麻烦，远远没有。来释放这部分空间，类似。之间空间是可写的，等同。中，由于只有一个一个。两个指针，一开始都是。
netty学习，将ByteBuf转为String
jjkang的博客
03-11 2070
netty将ByteBuf转为String public String convertByteBufToString(ByteBuf buf) { String str; if (buf.hasArray()) { // 处理堆缓冲区 str = new String(buf.array(), buf.arrayOffset() + buf....
netty之ByteBuf
weixin_40964170的博客
04-29 659
1、创建ByteBuf import io.netty.buffer.ByteBuf; import io.netty.buffer.ByteBufAllocator; import static io.netty.buffer.ByteBufUtil.appendPrettyHexDump; import static io.netty.util.internal.StringUtil.NEWLINE; public class TestByteBuf { public static void
Netty: ByteBuf转String
amadeus_liu2的博客
03-24 706
package tju.SpringBootPostServer.controller; import java.io.UnsupportedEncodingException; import java.util.Date; import io.netty.buffer.ByteBuf; import io.netty.buffer.Unpooled; import io.netty.util.CharsetUtil; public class TestMe { public static voi
netty那些bytebuf踩过的坑
热门推荐
natural_的博客
06-01 2万+
程序超过256个字节以后用抓包工具抓包显示消息已经发送给服务端并且服务端也回发了ack表示已经收到了，但是在read方法里并没有收到消息。 几经辗转发现问题出现在编解码器上，自己定义的解码器是这样的： ByteBuf heapBuffer = ctx.alloc().heapBuffer(); in.readBytes(heapBuffer, in.resetReaderInd...
Netty ByteBuf
sugar-foxs
07-01 579
网络数据的基本字节总是字节.Java NIO提供了ByteBuffer作为它的字节容器,但这个类用起来有点复杂. Netty用ByteBuf代替了ByteBuffer,下面介绍ByteBuf: ByteBuf维护了两个不同的索引:readerIndex用于读取,writerIndex用于写入.当你从ByteBuf读取时,readerIndex将会递增已经被读取的字节数,同样当你写入ByteBu
Netty的数据容器ByteBuf
qq_34254462的博客
08-10 541
1：ByteBuf是如何工作的 ByteBuf 维护了两个不同的索引：一个用于读取，一个用于写入。当你从 ByteBuf 读取时，它的 readerIndex 将会被递增已经被读取的字节数。同样地，当你写入 ByteBuf 时，它的writerIndex 也会被递增。 2：ByteBuf 的使用模式 2.1．堆缓冲区 最常用的 ByteBuf 模式是将数据存储在 JVM 的堆空间中。这种模式被称为支撑数组（backing array），它能在没有使用池化的情况下提供快速的分配和释放。 2.2．直接缓冲区
netty ByteBuf
12-28
Netty中的ByteBuf是一个可扩展的字节容器，用于在网络通信中存储和操作字节数据。它提供了一种高效的方式来处理网络数据，同时也支持零拷贝操作。 以下是对Netty ByteBuf的介绍和演示： 1. 创建和操作ByteBuf ```java ByteBuf buf = Unpooled.buffer(10); // 创建一个容量为10的ByteBuf buf.writeBytes(new byte[]{1, 2, 3, 4}); // 向ByteBuf写入字节数据 byte b = buf.readByte(); // 从ByteBuf读取一个字节 System.out.println(ByteBufUtil.prettyHexDump(buf)); // 打印ByteBuf的十六进制表示 ``` 2. 切片操作 ```java ByteBuf origin = Unpooled.buffer(10); origin.writeBytes(new byte[]{1, 2, 3, 4}); ByteBuf slice = origin.slice(1, 2); // 切片操作，从索引1开始，长度为2 System.out.println(ByteBufUtil.prettyHexDump(slice)); // 打印切片后的ByteBuf的十六进制表示 ```

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值