跟着Netty 学习 23 种设计模式

原创 于 2025-06-20 21:51:45 发布 · 898 阅读 · 18 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#Netty #学习 #设计模式

以下是 Netty 框架中涉及的 23 种设计模式的分类、技术原理及代码示例：

一、创建型模式

1. 工厂方法模式 (Factory Method)

作用：定义创建对象的接口，由子类决定实例化哪个类。

Netty 实现：

  • ChannelFactory 工厂：根据配置创建不同类型的 Channel（如 NIO、Epoll）。
ChannelFactory factory = new NioServerSocketChannelFactory(
    Executors.newCachedThreadPool(),
    Executors.newCachedThreadPool()
);
ServerBootstrap bootstrap = new ServerBootstrap(factory); // 通过工厂创建 Channel
2. 抽象工厂模式 (Abstract Factory)

作用：创建一组相关或依赖的对象，而无需指定具体类。

Netty 实现：

  • EventLoopGroup 抽象工厂：根据配置创建不同事件循环组（如 NIO、Epoll）。
EventLoopGroup group = new NioEventLoopGroup(); // NIO 事件循环组
ServerBootstrap bootstrap = new ServerBootstrap();
bootstrap.group(group); // 设置抽象工厂
3. 单例模式 (Singleton)

作用：确保一个类只有一个实例，并提供全局访问点。

Netty 实现：

  • ResourceLeakDetector 实例：通过静态内部类实现线程安全的单例。
public class ResourceLeakDetector {
    private static class Holder {
        static final ResourceLeakDetector INSTANCE = new ResourceLeakDetector();
    }

    public static ResourceLeakDetector getInstance() {
        return Holder.INSTANCE;
    }
}
4. 建造者模式 (Builder)

作用：逐步构建复杂对象，允许用户通过链式调用设置属性。

Netty 实现：

  • ServerBootstrap 建造者：通过链式调用配置服务端参数。
ServerBootstrap bootstrap = new ServerBootstrap();
bootstrap.group(group)
         .channel(NioServerSocketChannel.class)
         .childHandler(new ChannelInitializer<SocketChannel>() {
             @Override
             protected void initChannel(SocketChannel ch) {
                 ch.pipeline().addLast(new EchoServerHandler());
             }
         }); // 链式调用配置
5. 原型模式 (Prototype)

作用：通过克隆现有对象创建新实例。

Netty 实现：

  • ByteBuf 克隆：通过 ByteBuf.copy() 创建缓冲区副本。
ByteBuf buf = Unpooled.buffer(1024);
buf.writeBytes("Hello, Netty".getBytes());
ByteBuf clonedBuf = buf.copy(); // 创建副本

二、结构型模式

6. 适配器模式 (Adapter)

作用：将接口转换为客户端期望的另一个接口。

Netty 实现：

  • ChannelInboundHandlerAdapter 适配器：适配不同处理器接口。
public class SimpleHandlerAdapter extends ChannelInboundHandlerAdapter {
    @Override
    public void channelRead(ChannelHandlerContext ctx, Object msg) {
        // 适配具体处理逻辑
    }
}
7. 装饰器模式 (Decorator)

作用：动态为对象添加附加功能。

Netty 实现：

  • ChannelHandler 装饰器：通过 ChannelDuplexHandler 添加日志功能。
public class LoggingHandler extends ChannelDuplexHandler {
    @Override
    public void channelRead(ChannelHandlerContext ctx, Object msg) {
        System.out.println("Received: " + msg);
        super.channelRead(ctx, msg);
    }
}
8. 代理模式 (Proxy)

作用：通过代理对象控制对原对象的访问。

Netty 实现：

  • LocalChannel 代理：通过本地代理实现跨线程通信。
EventLoopGroup group = new DefaultEventLoopGroup();
LocalChannel channel = new LocalChannel(group.next());
channel.writeAndFlush("Hello"); // 通过代理发送消息
9. 外观模式 (Facade)

作用：为复杂子系统提供简化的接口。

Netty 实现：

  • Bootstrap 外观：封装服务端/客户端启动流程。
ServerBootstrap bootstrap = new ServerBootstrap();
bootstrap.bind(8080).sync(); // 简化服务端启动
10. 桥接模式 (Bridge)

作用：将抽象与实现解耦，使两者可以独立变化。

Netty 实现：

  • Channel 桥接：桥接不同传输实现（如 NIO、Epoll）。
Channel channel = new NioSocketChannel(); // NIO 实现
// Channel channel = new EpollSocketChannel(); // Epoll 实现
11. 组合模式 (Composite)

作用：将对象组合成树形结构，以表示“部分-整体”的层次结构。

Netty 实现：

  • ChannelPipeline 组合：通过组合模式管理处理器链。
ChannelPipeline pipeline = ch.pipeline();
pipeline.addLast(new Handler1());
pipeline.addLast(new Handler2()); // 组合处理器
12. 享元模式 (Flyweight)

作用：共享对象以减少内存占用。

Netty 实现：

  • ByteBufAllocator 复用：通过对象池复用 ByteBuf 对象。
ByteBufAllocator allocator = ch.alloc();
ByteBuf buf1 = allocator.buffer(1024);
ByteBuf buf2 = allocator.buffer(1024); // 复用缓冲区

三、行为型模式

13. 模板方法模式 (Template Method)

作用：定义算法骨架，将某些步骤延迟到子类实现。

Netty 实现：

  • ChannelInboundHandlerAdapter 模板：定义处理器骨架，子类实现具体步骤。
public abstract class ChannelInboundHandlerAdapter extends ChannelHandlerAdapter {
    @Override
    public void channelRead(ChannelHandlerContext ctx, Object msg) {
        // 公共逻辑（如解码）
        onChannelRead(ctx, msg); // 调用子类实现
    }

    protected abstract void onChannelRead(ChannelHandlerContext ctx, Object msg);
}
14. 观察者模式 (Observer)

作用：定义对象间的一对多依赖，当一个对象状态改变时，所有依赖者收到通知。

Netty 实现：

  • ChannelFutureListener 监听器：监听 I/O 操作完成事件。
ChannelFuture future = ch.writeAndFlush("Hello");
future.addListener((ChannelFutureListener) f -> {
    if (f.isSuccess()) {
        System.out.println("Write successful");
    } else {
        System.err.println("Write failed");
    }
});
15. 策略模式 (Strategy)

作用：定义一系列算法，并将每个算法封装起来，使它们可以互换。

Netty 实现：

  • EventLoop 策略：根据配置选择不同的事件循环策略（如 NIO、Epoll）。
EventLoopGroup group = new NioEventLoopGroup(); // NIO 策略
// EventLoopGroup group = new EpollEventLoopGroup(); // Epoll 策略
16. 命令模式 (Command)

作用：将请求封装为对象，以便用不同的请求、队列或日志参数化其他对象。

Netty 实现：

  • ChannelPromise 命令：封装 I/O 操作请求。
ChannelPromise promise = ch.newPromise();
ch.writeAndFlush("Hello", promise); // 封装写操作请求
17. 责任链模式 (Chain of Responsibility)

作用：将请求的发送者和接收者解耦，使多个对象都有机会处理请求。

Netty 实现：

  • ChannelPipeline 责任链：通过处理器链处理 I/O 事件。
ChannelPipeline pipeline = ch.pipeline();
pipeline.addLast(new Handler1());
pipeline.addLast(new Handler2()); // 责任链处理
18. 备忘录模式 (Memento)

作用：捕获并保存对象的内部状态，以便后续恢复。

Netty 实现：

  • ChannelConfig 状态保存：通过 ChannelConfig 保存通道配置快照。
ChannelConfig config = ch.config();
config.setAutoRead(false); // 修改状态
config.setAutoRead(true); // 恢复状态
19. 状态模式 (State)

作用：允许对象在内部状态改变时改变行为。

Netty 实现：

  • ChannelState 状态管理：通过状态机管理通道状态。
public enum ChannelState {
    CONNECTED,
    DISCONNECTED,
    CLOSED
}

// 状态管理
public class Channel {
    private ChannelState state = ChannelState.CONNECTED;

    public void close() {
        state = ChannelState.CLOSED; // 修改状态
    }
}
20. 访问者模式 (Visitor)

作用：在对象结构中定义新操作，而无需修改结构本身。

Netty 实现：

  • ChannelHandler 访问者：通过访问者模式遍历处理器链。
public interface ChannelHandlerVisitor {
    void visit(ChannelHandler handler);
}

// 具体访问者
public class LoggingVisitor implements ChannelHandlerVisitor {
    @Override
    public void visit(ChannelHandler handler) {
        System.out.println("Handler: " + handler.getClass().getName());
    }
}
21. 解释器模式 (Interpreter)

作用：给定一种语言，定义其文法表示，并构建解释器来解释语言中的句子。

Netty 实现：

  • HttpObjectDecoder 解释器：解析 HTTP 协议。
public class HttpServerInitializer extends ChannelInitializer<SocketChannel> {
    @Override
    protected void initChannel(SocketChannel ch) {
        ch.pipeline().addLast(new HttpServerCodec()); // 解析 HTTP 协议
    }
}
22. 迭代器模式 (Iterator)

作用：提供一种顺序访问集合元素的方法，而无需暴露其内部表示。

Netty 实现：

  • ChannelHandlerContext 迭代器：遍历处理器链中的处理器。
ChannelHandlerContext ctx = ch.pipeline().firstContext();
while (ctx != null) {
    System.out.println(ctx.handler().getClass().getName());
    ctx = ctx.next();
}
23. 中介者模式 (Mediator)

作用：定义一个中介对象来封装一系列对象之间的交互。

Netty 实现：

  • EventLoop 作为中介者：协调 Channel、ChannelPipeline 等组件之间的交互。
public class EventLoop {
    public void execute(Runnable task) {
        // 协调任务执行
    }
}

// 中介者协调
public class Channel {
    private final EventLoop eventLoop;

    public void write(Object msg) {
        eventLoop.execute(() -> {
            // 执行写操作
        });
    }
}

总结

Netty 框架通过灵活运用 23 种设计模式，实现了高扩展性、低耦合性和灵活性。这些模式覆盖了对象创建、结构组织、行为交互等各个方面，是学习 Java 框架设计的经典案例。

Netty学习篇之零拷贝的实现
Dreamming Time的博客
12-08 584
简述 本博客通过分析零拷贝在Netty中的实现及Socket事件的处理过程，讨论如何能更加深刻地清楚利用Netty实现自己的零拷贝功能。 后面所讲的内容，均建立在读者已经了解零拷贝的概念、JAVA NIO的零拷贝、Netty的基本组成及服务器/客户端的简单创建等，因此文章后面涉及到的一些Netty中的类名或是概念词汇，限于篇幅，很多时候不会再讲解，读者可以自行查考官网或是从我的其它博文中搜询。 JAVA NIO Socket连接及事件转发流程 客户端主动连接 假设已经有一个Netty Server正常工作，
Netty
12-29 1263
粘包问题是指发送方发送的多个数据包在接收方被合并成一个数据包接收。粘包问题通常发生在发送方发送的数据包较小且频繁的情况下。比如发送方发送了两个数据包A和B，数据包A的内容是"Hello"，数据包B的内容是"World"。由于TCP是基于字节流的协议，接收方可能会将这两个数据包合并成一个数据包接收，内容为"HelloWorld"。粘包问题的原因主要有两个：1.发送方发送的数据包较小且频繁：当发送方发送的数据包较小且频繁时，TCP可能会将多个数据包合并成一个数据包发送，导致接收方接收到合并的数据包。
spring MVC设计模式理念讲解
04-27
针对spring mvc设计模式中的概念性知识点进行简单易懂的讲解
Mybatis 中经典的 9 种设计模式
yamaxifeng_132的专栏
01-13 1520
虽然我们都知道有23个设计模式，但是大多停留在概念层面，真实开发中很少遇到。Mybatis源码中使用了大量的设计模式，阅读源码并观察设计模式在其中的应用，能够更深入的理解设计模式。 Mybatis至少遇到了以下的设计模式的使用： 1、Builder模式，例如SqlSessionFactoryBuilder、XMLConfigBuilder、XMLMapperBuilder、XMLStateme...
Mybatis中用到的设计模式
weixin_34115824的博客
03-15 316
Mybatis中用到至少用到以下设计模式， Builder模式，例如SqlSessionFactoryBuilder、XMLConfigBuilder、XMLMapperBuilder、XMLStatementBuilder、CacheBuilder； 工厂模式，例如SqlSessionFactory、ObjectFactory、MapperProxyFactory； 单例模式，例如Er...
跟着Spring 学习 23 种设计模式
csdn_tom_168的博客
06-20 654
本文系统介绍了Spring框架中23种设计模式的分类、技术原理及实现示例。主要内容包括： 创建型模式：工厂方法模式(BeanFactory)、抽象工厂模式(DataSource)、单例模式(DefaultSingletonBeanRegistry)、建造者模式(BeanDefinitionBuilder)和原型模式(prototype作用域)的实现原理。 结构型模式：适配器模式(HandlerAdapter)、装饰器模式(AOP增强)、代理模式(动态代理)、外观模式(JdbcTemplate)、桥接模式(P
mybatis 之 设计模式
u012391423的博客
07-10 594
目录 一、建造者模式 二、工厂模式 三、单例模式 四、代理模式 五、适配器模式 六、模板方法 七、装饰器模式 八、责任链模式 一、建造者模式 建造者模式（builder Pattern） ： 使用多个简单的对象一步一步构建成一个复杂的对象。 mybatis中以Buidler结尾的对象基本上都是建造者模式。比如 SqlSessionFactoryBuilder,用以构建SqlSessionFactory对象。 mybatis中有一个很完整的构造者模式： 二、工厂模
跟闪电侠学Netty：Netty即时聊天实战与底层原理-book-netty.zip
11-07
《跟闪电侠学Netty：Netty即时聊天实战与底层原理》是一本深入浅出的Netty技术指南，旨在...通过学习这本书，你不仅可以学会Netty的基本使用，还能深入了解其设计思想和优化手段，为你的Java网络编程之路打下坚实基础。
2022最新 Netty底层数据交互源码剖析二
m0_52255061的博客
08-18 852
当有连接建立时服务端底层做了哪些事情；无非就是生成socketChannel并初始化pipeline设置事件为读事件；最后将其注册到workerGroup中的其中一个EventLoop上，底层流程与上一节ServerSocketChannel一样的流程！以及当触发读事件时EventLoop做了哪些工作才保证了数据的正常到达，这里又涉及到了Netty直接内存的概念以及零拷贝原理；最后把整个netty的设计精髓做了一些专门的讲解以及源码级别剖析！最后贴一张整个Netty源码流程图！...
Java设计模式笔试题（10~13题）
java364100的博客
06-20 446
10、谈谈 JVM 的内存结构和内存分配● Java内存模型：Java虚拟机将其管辖的内存大致分三个逻辑部分：方法区(Method Area)、Java栈和Java堆。● 方法区是静态分配的，编译器将变量绑定在某个存储位置上，而且这些绑定不会在运行时改变。常数池，源代码中的命名常量、String常量和static变量保存在方法区。● Java Stack是一个逻辑概念，特点是后进先出。一个栈的空间可能是连续的，也可能是不连续的。最典型的Stack应用是方法的调用，Java虚拟机每调用一次方法就创建一个方法帧
MyBatis中用到的设计模式
Angus
06-13 9782
面试官:“谈谈MyBatis中都用到了那些设计模式?”。 疯狂的蚂蚁JavaGuide 本文转载自:https://dwz.cn/KFgol1De由JavaGuide整理排版。 虽然我们都知道有26个设计模式，但是大多停留在概念层面，真实开发中很少遇到，Mybatis源码中使用了大量的设计模式，阅读源码并观察设计模式在其中的应用，能够更深入的理解设计模式。 目录 面试官:“谈...
Spring-涉及到的设计模式汇总
huangshulang1234的博客
02-01 895
Spring-涉及到的设计模式汇总 1. 简单工厂 又叫做静态工厂方法（StaticFactory Method）模式，但不属于23种GOF设计模式之一。 简单工厂模式的实质是由一个工厂类根据传入的参数，动态决定应该创建哪一个产品类。 Spring中的BeanFactory就是简单工厂模式的体现，根据传入一个唯一的标识来获得Bean对象，但是否是在传入参数后创建还是传入
面试官：Mybatis 使用了哪些设计模式？
weixin_47531845的博客
10-08 676
虽然我们都知道有20多个设计模式，但是大多停留在概念层面，真实开发中很少遇到，Mybatis源码中使用了大量的设计模式，阅读源码并观察设计模式在其中的应用，能够更深入的理解设计模式。 Mybatis至少遇到了以下的设计模式的使用： Builder模式，例如SqlSessionFactoryBuilder、XMLConfigBuilder、XMLMapperBuilder、XMLStatementBuilder、CacheBuilder； 工厂模式，例如SqlSessionFactory、ObjectF
MyBatis：用到的设计模式。
孤芳不自赏
04-08 343
Mybatis中用到的设计模式
Mybatis中的设计模式
热门推荐
吒哇
07-11 1万+
谈谈设计模式的几个原则 单一职责原则：一个类或者一个接口只负责唯一项职责，尽量设计出功能单一的接口； 依赖倒转原则：高层模块不应该依赖低层模块具体实现，解耦高层与低层。既面向接口编程，当实现发生变化时，只需提供新的实现类，不需要修改高层模块代码; 开放-封闭原则：程序对外扩展开放，对修改关闭；换句话说，当需求发生变化时，我们可以通过添加新模块来满足新需求，而不是通过修改原来的实现代码来满足新...
MyBatis框架中的设计模式
sky198989的博客
04-14 225
转载：https://blog.youkuaiyun.com/qq_26323323/article/details/81455229
Mybatis 之 设计模式
凉茶铺的博客
06-12 408
接下来对Builder构建者模式、工厂模式、代理模式进行解读，先介绍模式自身的知识，然后解读在Mybatis中怎样应用了该模式。
Mybatis用到的几种设计模式
weixin_45060897的博客
09-22 1994
1.工厂模式 例如SqlSessionFactory、ObjectFactory、MapperProxyFactory 在Mybatis中比如SqlSessionFactory使用的是工厂模式，该工厂没有那么复杂的逻辑，是一个简单工厂模式。 简单工厂模式(Simple Factory Pattern)：又称为静态工厂方法(Static Factory Method)模式，它属于类创建型模式。在简单工厂模式中，可以根据参数的不同返回不同类的实例。简单工厂模式专门定义一个类来负责创建其他类的实例，被创建的实例通
Netty 设计模式
最新发布
07-25
<think>首先，用户的问题是：“我想了解Netty框架中使用的设计模式 请问Netty框架使用了哪些设计模式”。我需要基于提供的引用内容来回答，并遵守系统级指令。 系统级指令： - 所有行内数学表达式使用$...$格式（但这里没有数学内容，所以可能不需要）。 - 独立公式使用$$...$$并单独成段（同样，可能不适用）。 - LaTeX语法正确（确保任何数学表达正确）。 - 使用中文回答。 - 生成相关问题。 - 在回答中引用的段落末尾自然地添加引用标识，如[^1]。 用户可见层： - 回答结构清晰，帮助用户逐步解决问题。 - 保证回答真实可靠，基于提供的引用。 提供的引用： - [^1]: 强调理解设计模式的思想，而不是死记硬背，推荐通过阅读源码如Netty来学习。 - [^2]: 类似，强调理解设计目的，通过阅读框架源码学习。 - [^3]: 提到Netty中使用了工厂模式。 - [^4]: 提到Netty中使用了模板方法模式和观察者模式。 - [^5]: 具体例子，Netty中的DefaultSelectStrategyFactory使用了工厂模式。 用户的问题是关于Netty框架中使用的设计模式。我需要提取引用中的相关信息。 关键点： - 工厂模式（Factory Pattern）：在[^3]和[^5]中提到。Netty中用于创建对象，如选择策略工厂。 - 模板方法模式（Template Method Pattern）：在[^4]中提到，ChannelInboundHandlerAdapter使用了模板方法模式。 - 观察者模式（Observer Pattern）：在[^4]中提到。 其他设计模式可能也被使用，但引用中没有明确列出。我应该基于提供的引用回答，不要添加未提及的内容。 回答结构： 1. **引言**：简要介绍Netty框架中设计模式的重要性。 2. **具体设计模式**：列出并解释每个模式在Netty中的应用。 3. **引用添加**：在引用段落末尾添加引用标识。 4. **生成相关问题**：在最后添加相关问题部分。 确保使用中文回答。 生成相关问题： - 基于系统指令，需要生成相关问题。例如： - Netty中工厂模式的具体实现是怎样的？ - 模板方法模式在Netty中如何应用？ - 还有其他设计模式在Netty中使用吗？ 完整回答： - 先回答用户问题。 - 然后添加相关问题。 最终输出格式： - 回答部分。 - §§相关问题§§部分。</think>### Netty框架中使用的设计模式 Netty 是一个高性能、异步事件驱动的网络应用框架，广泛用于构建服务器和客户端。在 Netty 的设计中，设计模式被巧妙地应用，以提高代码的可扩展性、可维护性和灵活性。以下基于引用内容，总结 Netty 中主要使用的设计模式及其应用场景。设计模式的学习应注重理解其思想，而非死记硬背，通过阅读源码（如 Netty）能有效提升代码设计能力[^1][^2]。 #### 1. **工厂模式（Factory Pattern）** - **定义**：工厂模式是一种创建型设计模式，它定义一个用于创建对象的接口，但将实例化的过程延迟到子类或具体实现类中，从而隐藏对象的创建细节[^3]。 - **在 Netty 中的应用**：Netty 使用工厂模式来创建策略对象或处理器实例。例如，在事件循环组（EventLoopGroup）中，`DefaultSelectStrategyFactory` 负责创建选择策略对象（SelectStrategy）。这确保了策略的创建过程被封装，便于扩展和替换实现[^5]。 - 示例代码片段（基于引用）： ```java public final class DefaultSelectStrategyFactory implements SelectStrategyFactory { public static final SelectStrategyFactory INSTANCE = new DefaultSelectStrategyFactory(); private DefaultSelectStrategyFactory() { } @Override public SelectStrategy newSelectStrategy() { return DefaultSelectStrategy.INSTANCE; // 延迟创建策略对象 } } ``` - **优势**：提高了代码的灵活性和解耦，允许在不修改客户端代码的情况下更换策略实现[^3][^5]。 #### 2. **模板方法模式（Template Method Pattern）** - **定义**：模板方法模式是一种行为型设计模式，它定义一个算法骨架，将某些步骤延迟到子类实现，从而复用公共逻辑[^4]。 - **在 Netty 中的应用**：Netty 的处理器（Handler）设计中广泛使用此模式。例如，`ChannelInboundHandlerAdapter` 类定义了一个模板方法 `channelRead`，其中包含公共逻辑（如解码），而具体处理步骤（如业务逻辑）由子类通过抽象方法 `onChannelRead` 实现[^4]。 - 示例代码片段（基于引用）： ```java public abstract class ChannelInboundHandlerAdapter extends ChannelHandlerAdapter { @Override public void channelRead(ChannelHandlerContext ctx, Object msg) { // 公共逻辑（如解码） onChannelRead(ctx, msg); // 调用子类实现的具体步骤 } protected abstract void onChannelRead(ChannelHandlerContext ctx, Object msg); } ``` - **优势**：简化了处理器开发，子类只需关注特定步骤，而公共逻辑（如错误处理）在父类中统一维护[^4]。 #### 3. **观察者模式（Observer Pattern）** - **定义**：观察者模式是一种行为型设计模式，它定义对象间的一对多依赖关系，当一个对象状态改变时，所有依赖它的对象都会自动收到通知并更新[^4]。 - **在 Netty 中的应用**：Netty 的事件驱动模型核心就是观察者模式。例如，`ChannelPipeline` 中的处理器（Handler）作为观察者，监听事件（如数据到达或连接关闭）。当事件发生时，`ChannelHandlerContext` 会通知所有注册的处理器，实现异步事件处理[^4]。 - **优势**：支持高并发和事件驱动架构，处理器可以动态添加或移除，增强了框架的扩展性[^4]。 ### 总结 Netty 框架通过上述设计模式（工厂模式、模板方法模式、观察者模式）实现了模块化、可扩展和高性能。这些模式的应用不仅提升了代码质量，还体现了设计模式的核心思想：解决特定问题（如对象创建、算法复用、事件通知）而非炫技[^2]。学习 Netty 源码是掌握设计模式的有效途径，建议结合实际项目或阅读 Spring、MyBatis 等框架源码加深理解[^1][^2]。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值