RocketMq的消息消费-延时消息消费（三）

最新推荐文章于 2024-01-03 19:00:53 发布
最新推荐文章于 2024-01-03 19:00:53 发布
阅读量2.8k 收藏 1
点赞数
分类专栏： RocketMq
原文链接：https://cloud.tencent.com/developer/article/1581368
版权

概述

延迟消息也叫定时消息，是指需要在一段时间后被消费的消息。考虑这种场景：用户下单后10分钟后不付款将订单取消，可以在用户下单后发送延迟消息，延迟10分钟检查订单如果未支付则取消订单。RocketMQ本身的commitLog采用顺序存储消息的方式，如果在commitLog实现延迟消息，需要对commitLog排序等处理，这与RocketMQ的设计理念不合。故RocketMQ针对延迟消息，只支持特定时间的延迟处理，不支持任意延迟时间，具体的时间可以为1s、 5s、 10s、 30s、 1m、 2m、 3m、 4m、 5m、 6m、 7m、 8m、 9m、 10m、 20m、 30m、 1h、 2h。

延时消息的主要设计思路

Broker端内置延迟消息处理能力，核心实现思路都是一样：将延迟消息通过一个临时存储进行暂存，到期后才投递到目标Topic中。如下图所示：
在这里插入图片描述

步骤说明如下：

  1. producer要将一个延迟消息发送到某个Topic中
  2. Broker判断这是一个延迟消息后，将其通过临时存储进行暂存。
  3. Broker内部通过一个延迟服务(delay
    service)检查消息是否到期，将到期的消息投递到目标Topic中。这个的延迟服务名字为delay
    service，不同消息中间件的延迟服务模块名称可能不同。
  4. 消费者消费目标topic中的延迟投递的消息

在这里插入图片描述

整体设计

在这里插入图片描述
延迟消息在RocketMQ Broker端的流转如下图所示：
在这里插入图片描述

可以看到，总共有6个步骤，下面会对这6个步骤进行详细的讲解：

  1. 修改消息Topic名称和队列信息
  2. 转发消息到延迟主题的CosumeQueue中
  3. 延迟服务消费SCHEDULE_TOPIC_XXXX消息
  4. 将信息重新存储到CommitLog中
  5. 将消息投递到目标Topic中
  6. 消费者消费目标topic中的数据

源码剖析

topic替换
在org.apache.rocketmq.store.CommitLog#putMessage；

    public PutMessageResult putMessage(final MessageExtBrokerInner msg) {
        msg.setStoreTimestamp(System.currentTimeMillis());
        msg.setBodyCRC(UtilAll.crc32(msg.getBody()));
        AppendMessageResult result = null;
        StoreStatsService storeStatsService = this.defaultMessageStore.getStoreStatsService();

        String topic = msg.getTopic();
        int queueId = msg.getQueueId();

        final int tranType = MessageSysFlag.getTransactionValue(msg.getSysFlag());
        if (tranType == MessageSysFlag.TRANSACTION_NOT_TYPE
            || tranType == MessageSysFlag.TRANSACTION_COMMIT_TYPE) {
            // 延迟消息
            if (msg.getDelayTimeLevel() > 0) {
                if (msg.getDelayTimeLevel() > this.defaultMessageStore.getScheduleMessageService().getMaxDelayLevel()) {
                    msg.setDelayTimeLevel(this.defaultMessageStore.getScheduleMessageService().getMaxDelayLevel());
                }

                topic = ScheduleMessageService.SCHEDULE_TOPIC;
                queueId = ScheduleMessageService.delayLevel2QueueId(msg.getDelayTimeLevel());

                // 存储原始的topic, queueId
                MessageAccessor.putProperty(msg, MessageConst.PROPERTY_REAL_TOPIC, msg.getTopic());
                MessageAccessor.putProperty(msg, MessageConst.PROPERTY_REAL_QUEUE_ID, String.valueOf(msg.getQueueId()));
                msg.setPropertiesString(MessageDecoder.messageProperties2String(msg.getProperties()));
                // 设置topic为延迟队列topic
                msg.setTopic(topic);
                msg.setQueueId(queueId);
            }
        }
    }

延迟队列的topic为 SCHEDULE_TOPIC_XXXX：

生成consumequeue
说一下延迟级别和queueid的对应关系，queueid=延迟级别-1。再一个是对consumequeue消息的tagcode特殊处理，将tagcode值设置为消息触发时间，逻辑见.CommitLog.checkMessageAndReturnSize:

// Timing message processing
                {
                    String t = propertiesMap.get(MessageConst.PROPERTY_DELAY_TIME_LEVEL);
                    if (ScheduleMessageService.SCHEDULE_TOPIC.equals(topic) && t != null) {
                        int delayLevel = Integer.parseInt(t);

                        if (delayLevel > this.defaultMessageStore.getScheduleMessageService().getMaxDelayLevel()) {
                            delayLevel = this.defaultMessageStore.getScheduleMessageService().getMaxDelayLevel();
                        }

                        if (delayLevel > 0) {
                            tagsCode = this.defaultMessageStore.getScheduleMessageService().computeDeliverTimestamp(delayLevel,
                                storeTimestamp);
                        }
                    }
                }

延迟消息定时任务 ScheduleMessageService

继承自ConfigManager，初始化延迟级别相关的配置和定时任务。

定时任务执行;

直接看具体逻辑;

        public void executeOnTimeup() {
            // 获取consumequeue
            ConsumeQueue cq =
                ScheduleMessageService.this.defaultMessageStore.findConsumeQueue(SCHEDULE_TOPIC,
                    delayLevel2QueueId(delayLevel));

            long failScheduleOffset = offset;

            if (cq != null) {
                // 消息获取
                SelectMappedBufferResult bufferCQ = cq.getIndexBuffer(this.offset);
                if (bufferCQ != null) {
                    try {
                        long nextOffset = offset;
                        int i = 0;
                        ConsumeQueueExt.CqExtUnit cqExtUnit = new ConsumeQueueExt.CqExtUnit();
                        // 消息遍历，因为是consumequeue ，消息长度固定
                        for (; i < bufferCQ.getSize(); i += ConsumeQueue.CQ_STORE_UNIT_SIZE) {
                            long offsetPy = bufferCQ.getByteBuffer().getLong();
                            int sizePy = bufferCQ.getByteBuffer().getInt();
                            long tagsCode = bufferCQ.getByteBuffer().getLong();

                            // 延迟消息的tagcode值为消息触发时间
                            if (cq.isExtAddr(tagsCode)) {
                                if (cq.getExt(tagsCode, cqExtUnit)) {
                                    tagsCode = cqExtUnit.getTagsCode();
                                } else {
                                    //can't find ext content.So re compute tags code.
                                    log.error("[BUG] can't find consume queue extend file content!addr={}, offsetPy={}, sizePy={}",
                                        tagsCode, offsetPy, sizePy);
                                    long msgStoreTime = defaultMessageStore.getCommitLog().pickupStoreTimestamp(offsetPy, sizePy);
                                    tagsCode = computeDeliverTimestamp(delayLevel, msgStoreTime);
                                }
                            }

                            long now = System.currentTimeMillis();
                            long deliverTimestamp = this.correctDeliverTimestamp(now, tagsCode);

                            nextOffset = offset + (i / ConsumeQueue.CQ_STORE_UNIT_SIZE);

                            long countdown = deliverTimestamp - now;
                            // 达到触发条件
                            if (countdown <= 0) {
                                MessageExt msgExt =
                                    ScheduleMessageService.this.defaultMessageStore.lookMessageByOffset(
                                        offsetPy, sizePy);

                                if (msgExt != null) {
                                    try {
                                        // 还原原始消息
                                        MessageExtBrokerInner msgInner = this.messageTimeup(msgExt);
                                        // put 到commitlog
                                        PutMessageResult putMessageResult =
                                            ScheduleMessageService.this.writeMessageStore
                                                .putMessage(msgInner);

                                        if (putMessageResult != null
                                            && putMessageResult.getPutMessageStatus() == PutMessageStatus.PUT_OK) {
                                            continue;
                                        } else {
                                            // XXX: warn and notify me
                                            log.error(
                                                "ScheduleMessageService, a message time up, but reput it failed, topic: {} msgId {}",
                                                msgExt.getTopic(), msgExt.getMsgId());
                                            ScheduleMessageService.this.timer.schedule(
                                                new DeliverDelayedMessageTimerTask(this.delayLevel,
                                                    nextOffset), DELAY_FOR_A_PERIOD);
                                            ScheduleMessageService.this.updateOffset(this.delayLevel,
                                                nextOffset);
                                            return;
                                        }
                                    } catch (Exception e) {
                                        /*
                                         * XXX: warn and notify me



                                         */
                                        log.error(
                                            "ScheduleMessageService, messageTimeup execute error, drop it. msgExt="
                                                + msgExt + ", nextOffset=" + nextOffset + ",offsetPy="
                                                + offsetPy + ",sizePy=" + sizePy, e);
                                    }
                                }
                            } else {
                                ScheduleMessageService.this.timer.schedule(
                                    new DeliverDelayedMessageTimerTask(this.delayLevel, nextOffset),
                                    countdown);
                                ScheduleMessageService.this.updateOffset(this.delayLevel, nextOffset);
                                return;
                            }
                        } // end of for

                        nextOffset = offset + (i / ConsumeQueue.CQ_STORE_UNIT_SIZE);
                        ScheduleMessageService.this.timer.schedule(new DeliverDelayedMessageTimerTask(
                            this.delayLevel, nextOffset), DELAY_FOR_A_WHILE);
                        ScheduleMessageService.this.updateOffset(this.delayLevel, nextOffset);
                        return;
                    } finally {

                        bufferCQ.release();
                    }
                } // end of if (bufferCQ != null)
                else {

                    long cqMinOffset = cq.getMinOffsetInQueue();
                    if (offset < cqMinOffset) {
                        failScheduleOffset = cqMinOffset;
                        log.error("schedule CQ offset invalid. offset=" + offset + ", cqMinOffset="
                            + cqMinOffset + ", queueId=" + cq.getQueueId());
                    }
                }
            } // end of if (cq != null)

            ScheduleMessageService.this.timer.schedule(new DeliverDelayedMessageTimerTask(this.delayLevel,
                failScheduleOffset), DELAY_FOR_A_WHILE);
        }

推介文章：https://cloud.tencent.com/developer/article/1581368

little sky
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
RocketMQ消息消费五：延迟消息
夏天的伞
08-25 4994
概述 延迟消息也叫定时消息，是指需要在一段时间后被消费的消息。考虑这种场景：用户下单后10分钟后不付款将订单取消，可以在用户下单后发送延迟消息，延迟10分钟检查订单如果未支付则取消订单。RocketMQ本身的commitLog采用顺序存储消息的方式，如果在commitLog实现延迟消息，需要对commitLog排序等处理，这与RocketMQ的设计理念不合。故RocketMQ针对延迟消息，只支持特...
RocketMQ讲义-03.pdf
04-25
3.1.2消费消息 3.2 顺序消息 3.3 ⼴播消息 3.4 延时消息 3.4.1 延时消息介绍 3.4.2 RocketMQ中的延迟消息 3.5 批量消息 3.6 过滤消息 3.6.1 TAG模式过滤 3.6.2 SQL表达式过滤 3.6.3 类过滤模式（基于4.2.0版本） 3.7...
rocketmq-spring-boot-starter:RocketMQ客户端封装类，基于最新版本4.5.2
05-26
spring boot starter for RocketMQ 项目介绍 是由阿里巴巴团队开发并捐赠给apache团队的优秀消息中间件，目前已经是apache的顶级项目之一，承受过历年双十一大促的考验。 你可以通过本项目轻松的集成Rocketmq到你的SpringBoot项目中。 本项目主要包含以下特性 同步发送消息 异步发送消息 广播发送消息 有序发送和消费消息 发送延时消息 消息tag和key支持 自动序列化和反序列化消息体 发送事务消息(NEW) ... 简单入门实例 模块介绍： rocketmq-spring-boot-starter：组件的依赖入口 rocketmq-spring-boot-autoconfigure： 自动配置模块 rocketmq-spring-boot-app：Demo示例，里面包含了最基本功能的用法 1. 添加maven依赖： <de
RocketMQ 8：延时消息
Fisher3652的博客
07-01 251
1.Producer 将消息发送到消息队列 RocketMQ 服务端，但并不期望这条消息立马投递，而是延迟一定时间后才投递到 Consumer 进行消费， 该消息即延时消息。 适用场景： 消息生产和消费有时间窗口要求：比如在电商交易中超时未支付关闭订单的场景，在订单创建时会发送一条延时消息。这条消息将会在 30 分钟以 后投递给消费者，消费者收到此消息后需要判断对应的订单是否已完成支付。 如支付未完成，则关闭订单。如已完成支付则忽略。 “1s 5s 10s 30s 1m 2m 3m 4m 5m 6m 7m
RocketMQ实现延迟队列精确到秒级实现
专注基础架构领域
02-24 947
3.运行 broker ，打开 src\main\java\org\apache\rocketmq\broker\BrokerStartup.java，执行main方法，其实对于大部分的功能是够用了的，但是以前的项目，全部都是使用了阿里云的rocketmq，原因是不同的供应商的订单的延时时间是不同的。5.既然要改造rocketmq，在哪里改呢，debug，debug，debug（一直到天荒地老），功夫不负有心人，找到啦，运行一下，成功了，开心的发一条消息，试试，哦哦哦哦哦。
RocketMQ 延迟队列
专注基础架构领域
02-24 6523
RocketMQ直接一步到位，功能类似于RabbitMQ的延迟交换器插件、而RabbitMQ提供了延迟队列，但如果是基于消息设置每个消息设置不同的延迟时间，会产生前面的消息早已过期，但后面的消息还存在消息队列中，故此RabbitMQ提供了延迟交换器插件，而RocketMQ 延迟队列设计就比较好了。默认值为“1s 5s 10s 30s 1m 2m 3m 4m 5m 6m 7m8m 9m 10m 20m 30m 1h 2h”，18个level。指消息发送到某个队列后，在指定多长时间之后才能被消费。
RocketMQ系列5——4.X版本延迟消息
xiaodigua1024的博客
03-29 3057
延迟消息是在业务场景中比较常用的功能，可以作为延迟队列。比如订单n分钟未支付自动取消，活动倒计时，定时发消息都可以使用到延迟消息。
深入理解RocketMQ延迟消息
meser88的博客
12-09 1445
延迟消息是实际开发中一个非常有用的功能，本文第一部分从整体上介绍秒级精度延迟消息的实现思路，在第二部分结合RocketMQ的延迟消息实现，进行细致的讲解，点出关键部分的源码。第三步介绍延迟消息与消息重试的关系。 1 延迟消息介绍 基本概念：延迟消息是指生产者发送消息后，不能立刻被消费者消费，需要等待指定的时间后才可以被消费。 场景案例：用户下了一个订单之后，需要在指定时间内(例如30分钟)进行支付，在到期之前可以发送一个消息提醒用户进行支付。 一些消息中间件的Broker端内置了延迟消息支持的能力，
RocketMQ（八）RocketMQ延时消息
热门推荐
weixiaohuai的博客
03-27 2万+
目录 一、什么是延时消息 二、延时消息等级 三、延时消息使用场景 四、延时消息示例 五、延时消息实现原理 一、什么是延时消息 当消息写入到Broker后，不能立刻被消费者消费，需要等待指定的时长后才可被消费处理的消息，称为延时消息。 二、延时消息等级 RocketMQ延时消息的延迟时长不支持随意时长的延迟，是通过特定的延迟等级来指定的。默认支持18个等级的延迟消息，延时等级定义在RocketMQ服务端的MessageStoreConfig类中的如下变量中： // MessageStor
RocketMQ 延迟消息
聚沙成塔
01-06 1564
延迟消息是实际开发中一个非常有用的功能，本文第一部分从整体上介绍秒级精度延迟消息的实现思路，在第二部分结合RocketMQ的延迟消息实现，进行细致的讲解，点出关键部分的源码。第三步介绍延迟消息与消息重试的关系。 1 延迟消息介绍 基本概念：延迟消息是指生产者发送消息发送消息后，不能立刻被消费者消费，需要等待指定的时间后才可以被消费。 场景案例：用户下了一个订单之后，需要在指...
【RocketMQ】RocketMQ实例--定时/延时消息
ProBaiXiaodi的博客
12-23 3390
RocketMQ实例--定时/延时消息
消息中间件 RocketMQ 性能压测工具
03-10
2 功能强大，覆盖普通消息、定时（延时）消息、事务消息（提交、回滚）等基本场景的发送场景。集群订阅和广播订阅的消费场景。内含多种命令行参数（例如消费位点的调整，消息体大小调整，并发数调整，JVM 参数调优，...
使用Kotlin+RocketMQ实现延时消息的示例代码
01-20
延时消息是指消息被发送以后，并不想让消费者立即拿到消息，而是等待指定时间后，消费者才拿到这个消息进行消费。 使用延时消息的典型场景，例如： 在电商系统中，用户下完订单30分钟内没支付，则订单可能会被取消...
rocketmq支持任意时间的延时，基于时间轮和高效mmap文件实现
05-08
rocketmq支持任意时间的延时...定时消息与延时消息在代码配置上存在一些差异，但是最终达到的效果相同：消息在发送到消息队列RocketMQ版服务端后并不会立马投递，而是根据消息中的属性延迟固定时间后才投递给消费者
5. rocketmq延迟消息队列
刘本龙的专栏
01-21 3044
什么是延迟消息队列 对于消息中间件来说，producer将消息发送到mq的服务器，但并不期望这条消息马上被消费，而是推迟到当前时间点之后的某个时间点后再投递到queue中让consumer进行消费。 也可以认为是定时消息。 延迟消息的使用场景很多，一种比较常见的场景就是在电商系统中，订单创建后，会有一个等待用户支付的时间窗口，一般为30分钟，30分钟后consumer收到这条订单消息，然后程序去订...
RocketMQ5.0延时消息时间轮算法
最新发布
程序员小潘
01-03 1740
RocketMQ 相较于其它消息队列产品的一个特性是支持延时消息，也就是说消息发送到 Broker 不会立马投递给消费者，要等待一个指定的延迟时间再投递，适用场景例如：下单后多长时间没付款系统自动关闭订单。RocketMQ 4.x 版本的延时消息存在一定的局限性，实现原理是：Broker 内置了名称为的Topic，包含 18 个对应延时级别的队列，每个延时级别的时间是固定的。
【RocketMQ】延迟消息(延迟队列)
m0_45406092的博客
08-12 4888
文章目录1. 什么是延迟消息1.1 延时消息的使用场景2. 示例3. 原理参考 1. 什么是延迟消息 发送消息后，消费者要等待一定的时间才能消费到该消息。 RocketMQ 不支持任意时间自定义的延迟消息，仅支持内置预设值的延迟时间间隔的延迟消息。 预设值的延迟时间间隔为：1s、 5s、 10s、 30s、 1m、 2m、 3m、 4m、 5m、 6m、 7m、 8m、 9m、 10m、 20m、 30m、 1h、 2h 对于开源版是这样，而对于专业版，是可以自定义时间的。 1.1 延时消息的使用场景
SpringBoot+RocketMQ实现异步延时队列案例
yqqの博客
12-06 209
【代码】SpringBoot+RocketMQ实现异步延时队列案例。
RocketMQ 基于时间轮算法实现指定时间点的定时消息原理解析
LoveSummer
10-07 1844
RocketMQ 的延时消息是指 Producer 发送消息后，Consumer 不会立即消费，而是需要等待固定的时间才能消费。在一些场景下，延时消息是很有用的，比如电商场景下关闭 30 分钟内未支付的订单。使用延时消息非常简单，只需要给消息的 delayTimeLevel 属性赋值就可以。//第 3 个级别，10s.build())//定义消息投递时间.build()).build()),RocketMQ 4.x 版本只支持延时消息，有一些局限性。
RocketMQ延时消息源码
06-10
RocketMQ的延时消息实现是基于timerWheel的算法，主要包括以下几个步骤： 1. 发送延时消息时，将消息的过期时间与当前时间进行比较，如果过期时间比当前时间早，则直接丢弃消息。 2. 如果消息没有过期，则计算该消息应该被放置在timerWheel的哪个槽中，这个槽的位置是通过将消息的过期时间与timerWheel的时间轮进行计算得出的。 3. 将消息放置在相应的槽中，如果该槽中已经存在消息，则将新的消息插入到该槽中的链表的尾部。 4. 启动一个后台线程，定时遍历timerWheel，查找到期的消息，并将这些消息发送到对应的消费者。 以下是RocketMQ的延时消息源码实现： 1. 发送延时消息时，将消息的过期时间与当前时间进行比较，如果过期时间比当前时间早，则直接丢弃消息。 ``` public SendResult send(Message msg, long timeout) throws MQClientException, RemotingException, MQBrokerException, InterruptedException { long maxTimeout = System.currentTimeMillis() + timeout; if (msg.getDelayTimeLevel() > 0) { long delayTime = calculateDelayTime(msg.getDelayTimeLevel()); if ((msg.getBornTimestamp() + delayTime) < maxTimeout) { msg.setDelayTimeLevel(0); } } //...省略其他代码 } ``` 2. 如果消息没有过期，则计算该消息应该被放置在timerWheel的哪个槽中，这个槽的位置是通过将消息的过期时间与timerWheel的时间轮进行计算得出的。 ``` private static long calculateDelayTimeLevel(long delayTime) { for (int i = 0; i < DELAY_LEVEL.length; i++) { if (delayTime < DELAY_LEVEL[i]) { return i; } } return DELAY_LEVEL.length - 1; } private static long calculateDelayTime(long level) { return DELAY_LEVEL[(int) Math.min(level, DELAY_LEVEL.length - 1)]; } private long computeDeliverTimestamp(final long startDeliverTime, final long delayTimeLevel) { long offset = DELAY_LEVEL[(int) delayTimeLevel]; return startDeliverTime + offset; } ``` 3. 将消息放置在相应的槽中，如果该槽中已经存在消息，则将新的消息插入到该槽中的链表的尾部。 ``` public void scheduleMessage(MessageExt msg) { long now = System.currentTimeMillis(); long deliverTimestamp = msg.getStoreTimestamp() + msg.getDelayTimeLevel(); long delay = deliverTimestamp - now; if (delay < 0) { delay = 0; } if (delay > config.getMaxDelayTime()) { delay = config.getMaxDelayTime(); } int index = (int) (delay / config.getTickTime()); long expireTime = deliverTimestamp - (deliverTimestamp % config.getTickTime()); try { lock.writeLock().lockInterruptibly(); TimerTaskList taskList = timerWheel[index]; if (taskList == null) { taskList = new TimerTaskList(expireTime); timerWheel[index] = taskList; } taskList.add(msg); } catch (InterruptedException e) { log.error("scheduleMessage error, ", e); } finally { lock.writeLock().unlock(); } } ``` 4. 启动一个后台线程，定时遍历timerWheel，查找到期的消息，并将这些消息发送到对应的消费者。 ``` private class TimerTask implements Runnable { private int index; private long currentTime; public TimerTask(int index, long currentTime) { this.index = index; this.currentTime = currentTime; } @Override public void run() { try { lock.writeLock().lockInterruptibly(); TimerTaskList taskList = timerWheel[index]; if (taskList != null) { List<MessageExt> messages = taskList.remove(currentTime); if (messages != null && !messages.isEmpty()) { putMessagesInQueue(messages); } } } catch (InterruptedException e) { log.error("TimerTask error, ", e); } finally { lock.writeLock().unlock(); } } } private class TimerThread implements Runnable { private volatile boolean stop = false; @Override public void run() { long lastExpireTime = 0; while (!stop) { long currentTime = System.currentTimeMillis(); if (currentTime > lastExpireTime) { for (int i = 0; i < config.getWheelSize(); i++) { long expireTime = lastExpireTime + (i + 1) * config.getTickTime(); if (expireTime <= currentTime) { executor.execute(new TimerTask(i, expireTime)); } } lastExpireTime = currentTime; } else { try { Thread.sleep(1); } catch (InterruptedException e) { log.error("TimerThread error, ", e); } } } } } ```

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值