kafka入门到实战三（单线程实现顺序消费，含demo）

已于 2023-03-02 17:00:07 修改
阅读量1k 收藏 2
点赞数
文章标签： kafka docker java
于 2023-03-02 16:57:41 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_42388853/article/details/129304286
版权

这里需要前面两章的基础，如果没有环境或者看不懂在说什么，就翻一翻前两章。

kafka顺序消费（单线程）

顺序消费

顺序消费：是指消息的产生顺序和消费顺序相同。不管你用的是什么q或者kafka还是sofa，顺序依赖都是一样的意思。

举个例子：订单A的消息为A1，A2，A3，发送顺序也如此，订单B的消息为B1，B2，B3，A订单消息先发送，B订单消息后发送。

  • A1，A2，A3，B1，B2，B3是全局顺序消息，严重降低了系统的并发度。完全的FIFO，导致无法使用多线程，速度极慢。
  • A1，B1，A2，A3，B2，B3是局部顺序消息，可以被接受。假设A1，A2，A3是创造，支付，完成订单。不论两者如何穿插，只要A1,A2,A3的顺序没有变，即可。
  • A2，B1，A1，B2，A3，B3不可接受，因为A2出现在了A1的前面。

要保证顺序消费，无非就是发送到topic的过程，发到同一个Partitioning（同一个分区视为一个队列，顺序一定是正确的）。消费的时候，按顺序获取即可，单线程直接取，没什么说的。多线程则需要

整体结构

在这里插入图片描述

  • yml文件：
spring:
  application:
    name: kafka-sort-consume
  kafka:
    bootstrap-servers: 192.168.56.101:9092,192.168.56.101:9093
    consumer:
      group-id: sort-consume
server:
  port: 8088
kafka:
  server: 192.168.56.101:9092
  order:
    topic: sort-consume
    concurrent: 3
  • log配置文件：
<?xml version="1.0" encoding="UTF-8"?>
<configuration>
    <!-- 文件输出格式 -->
    <property name="PATTERN" value="- %d{yyyy-MM-dd HH:mm:ss.SSS}, %5p, [%thread], %logger{39} - %m%n" />

    <appender name="CONSOLE" class="ch.qos.logback.core.ConsoleAppender">
        <encoder charset="UTF-8">
            <pattern>${PATTERN}</pattern>
        </encoder>
    </appender>

    <root level="info">
        <appender-ref ref="CONSOLE" />
    </root>

</configuration>
  • 生产者
@RestController
@RequestMapping
@Slf4j
public class OrderController {
    @Autowired
    KafkaTemplate kafkaTemplate;
    @GetMapping
    public void send(){
        for (long i = 0; i <100 ; i++) {
            CreateOrderDTO createOrderDTO =new CreateOrderDTO();
            PayOrderDTO payOrderDTO = new PayOrderDTO();
            FinishOrderDTO finishOrderDTO = new FinishOrderDTO();
            createOrderDTO.setOrderName("创建订单号："+i);payOrderDTO.setOrderName("支付订单号："+i);finishOrderDTO.setOrderName("完成订单号："+i);
            createOrderDTO.setId(i);payOrderDTO.setId(i);finishOrderDTO.setId(i);
            kafkaTemplate.send("sort-consume",GsonUtil.gsonToString(createOrderDTO));
            kafkaTemplate.send("sort-consume",GsonUtil.gsonToString(payOrderDTO));
            kafkaTemplate.send("sort-consume",GsonUtil.gsonToString(finishOrderDTO));

        }
    }
}
  • 消费者
@Component
public class KafkaConsumer {
    @KafkaListener(topics = {"sort-consume"})
    public void onMessage1(ConsumerRecord<?, ?> record){
        System.out.println(record);
    }
}
  • DTO：这里三个类放一起了，要用的话，回头自行拆分下。
@Data
@AllArgsConstructor
@NoArgsConstructor
public class CreateOrderDTO {
    private Long id;
    private Long status;
    private String orderName;

}

@Data
@AllArgsConstructor
@NoArgsConstructor
public class PayOrderDTO {
    private Long id;
    private Long status;
    private String orderName;
}

@Data
@AllArgsConstructor
@NoArgsConstructor
public class FinishOrderDTO {
    private Long id;
    private Long status;
    private String orderName;
}
  • Gson工具包
public class GsonUtil {

    private static Gson gson = null;

    static {
        if (Objects.isNull(gson)) {
            gson = new GsonBuilder()
                    .registerTypeAdapter(LocalDateTime.class, (JsonDeserializer<LocalDateTime>) (json, type, jsonDeserializationContext) -> {
                        String datetime = json.getAsJsonPrimitive().getAsString();
                        return LocalDateTime.parse(datetime, DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss"));
                    })
                    .registerTypeAdapter(LocalDate.class, (JsonDeserializer<LocalDate>) (json, type, jsonDeserializationContext) -> {
                        String datetime = json.getAsJsonPrimitive().getAsString();
                        return LocalDate.parse(datetime, DateTimeFormatter.ofPattern("yyyy-MM-dd"));
                    })
                    .registerTypeAdapter(Date.class, (JsonDeserializer<Date>) (json, type, jsonDeserializationContext) -> {
                        String datetime = json.getAsJsonPrimitive().getAsString();
                        LocalDateTime localDateTime = LocalDateTime.parse(datetime, DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss"));
                        return Date.from(localDateTime.atZone(ZoneId.systemDefault()).toInstant());
                    })
                    .registerTypeAdapter(LocalDateTime.class, (JsonSerializer<LocalDateTime>) (src, typeOfSrc, context) -> new JsonPrimitive(src.format(DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss"))))
                    .registerTypeAdapter(LocalDate.class, (JsonSerializer<LocalDate>) (src, typeOfSrc, context) -> new JsonPrimitive(src.format(DateTimeFormatter.ofPattern("yyyy-MM-dd"))))
                    .registerTypeAdapter(Date.class, (JsonSerializer<Date>) (src, typeOfSrc, context) -> {
                        LocalDateTime localDateTime = LocalDateTime.ofInstant(src.toInstant(), ZoneId.systemDefault());
                        return new JsonPrimitive(localDateTime.format(DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss")));
                    })
                    .create();
        }
    }

    public GsonUtil() {
    }

    /**
     * 将object对象转成json字符串
     *
     * @param object
     * @return
     */
    public static String gsonToString(Object object) {
        String gsonString = null;
        if (gson != null) {
            gsonString = gson.toJson(object);
        }
        return gsonString;
    }

    /**
     * 将gsonString转成泛型bean
     *
     * @param gsonString
     * @param cls
     * @return
     */
    public static <T> T gsonToBean(String gsonString, Class<T> cls) {
        T t = null;
        if (gson != null) {
            t = gson.fromJson(gsonString, cls);
        }
        return t;
    }

    /**
     * 转成list
     * 泛型在编译期类型被擦除导致报错
     * @param gsonString
     * @param cls
     * @return
     */
    public static <T> List<T> gsonToList(String gsonString, Class<T> cls) {
        List<T> list = null;
        if (gson != null) {
            list = gson.fromJson(gsonString, TypeToken.getParameterized(List.class,cls).getType());
        }
        return list;
    }

    /**
     * 转成list中有map的
     *
     * @param gsonString
     * @return
     */
    public static <T> List<Map<String, T>> gsonToListMaps(String gsonString) {
        List<Map<String, T>> list = null;
        if (gson != null) {
            list = gson.fromJson(gsonString,
                    new TypeToken<List<Map<String, T>>>() {
                    }.getType());
        }
        return list;
    }


    /**
     * 转成map的
     *
     * @param gsonString
     * @return
     */
    public static <T> Map<String, T> gsonToMaps(String gsonString) {
        Map<String, T> map = null;
        if (gson != null) {
            map = gson.fromJson(gsonString, new TypeToken<Map<String, T>>() {
            }.getType());
        }
        return map;
    }

    /**
     * 把一个bean（或者其他的字符串什么的）转成json
     * @param object
     * @return
     */
    public static String beanToJson(Object object){
        return gson.toJson(object);
    }
}
  • 启动类
@SpringBootApplication
public class KafkaSortConsumeDemoApplication {

    public static void main(String[] args) {
        SpringApplication.run(KafkaSortConsumeDemoApplication.class, args);
    }
}
  • 加下来，启动项目，然后访问http://localhost:8089/，访问结果如下：
ConsumerRecord(topic = sort-consume, partition = 2, leaderEpoch = 4, offset = 1404, CreateTime = 1677746104033, serialized key size = -1, serialized value size = 42, headers = RecordHeaders(headers = [], isReadOnly = false), key = null, value = {"id":8,"orderName":"支付订单号：8"})
ConsumerRecord(topic = sort-consume, partition = 2, leaderEpoch = 4, offset = 1405, CreateTime = 1677746104033, serialized key size = -1, serialized value size = 42, headers = RecordHeaders(headers = [], isReadOnly = false), key = null, value = {"id":8,"orderName":"完成订单号：8"})
ConsumerRecord(topic = sort-consume, partition = 2, leaderEpoch = 4, offset = 1406, CreateTime = 1677746104033, serialized key size = -1, serialized value size = 44, headers = RecordHeaders(headers = [], isReadOnly = false), key = null, value = {"id":10,"orderName":"支付订单号：10"})
ConsumerRecord(topic = sort-consume, partition = 2, leaderEpoch = 4, offset = 1407, CreateTime = 1677746104033, serialized key size = -1, serialized value size = 44, headers = RecordHeaders(headers = [], isReadOnly = false), key = null, value = {"id":10,"orderName":"完成订单号：10"})
ConsumerRecord(topic = sort-consume, partition = 2, leaderEpoch = 4, offset = 1408, CreateTime = 1677746104033, serialized key size = -1, serialized value size = 44, headers = RecordHeaders(headers = [], isReadOnly = false), key = null, value = {"id":11,"orderName":"创建订单号：11"})
ConsumerRecord(topic = sort-consume, partition = 2, leaderEpoch = 4, offset = 1409, CreateTime = 1677746104033, serialized key size = -1, serialized value size = 44, headers = RecordHeaders(headers = [], isReadOnly = false), key = null, value = {"id":11,"orderName":"支付订单号：11"})
ConsumerRecord(topic = sort-consume, partition = 0, leaderEpoch = 4, offset = 1182, CreateTime = 1677746104038, serialized key size = -1, serialized value size = 44, headers = RecordHeaders(headers = [], isReadOnly = false), key = null, value = {"id":35,"orderName":"支付订单号：35"})
ConsumerRecord(topic = sort-consume, partition = 0, leaderEpoch = 4, offset = 1181, CreateTime = 1677746104033, serialized key size = -1, serialized value size = 44, headers = RecordHeaders(headers = [], isReadOnly = false), key = null, value = {"id":10,"orderName":"创建订单号：10"})
ConsumerRecord(topic = sort-consume, partition = 0, leaderEpoch = 4, offset = 1183, CreateTime = 1677746104039, serialized key size = -1, serialized value size = 44, headers = RecordHeaders(headers = [], isReadOnly = false), key = null, value = {"id":35,"orderName":"完成订单号：35"})
ConsumerRecord(topic = sort-consume, partition = 0, leaderEpoch = 4, offset = 1184, CreateTime = 1677746104039, serialized key size = -1, serialized value size = 44, headers = RecordHeaders(headers = [], isReadOnly = false), key = null, value = {"id":36,"orderName":"创建订单号：36"})
  • 结果分析：先看10号，他先支付了订单，然后完成订单，最后支付订单，明显不符合我们所说的部分顺序。
  • 原因：因为kafka默认随机分配分区，不同分区下的消费顺序并不能得到保障，所以我们需要为发送的消息指定好分区。
@RestController
@RequestMapping
@Slf4j
public class OrderController {
    @Autowired
    KafkaTemplate kafkaTemplate;
    @GetMapping
    public void send(){
        for (long i = 0; i <100 ; i++) {
            CreateOrderDTO createOrderDTO =new CreateOrderDTO();
            PayOrderDTO payOrderDTO = new PayOrderDTO();
            FinishOrderDTO finishOrderDTO = new FinishOrderDTO();
            createOrderDTO.setOrderName("创建订单号："+i);payOrderDTO.setOrderName("支付订单号："+i);finishOrderDTO.setOrderName("完成订单号："+i);
            createOrderDTO.setId(i);payOrderDTO.setId(i);finishOrderDTO.setId(i);
            kafkaTemplate.send("sort-consume",new Integer((int) i%3),null ,GsonUtil.gsonToString(createOrderDTO));
            kafkaTemplate.send("sort-consume",new Integer((int) i%3),null,GsonUtil.gsonToString(payOrderDTO));
            kafkaTemplate.send("sort-consume",new Integer((int) i%3),null,GsonUtil.gsonToString(finishOrderDTO));

        }
    }
}
  • 再次执行，查看结果：发现结果都正确
ConsumerRecord(topic = sort-consume, partition = 1, leaderEpoch = 4, offset = 1344, CreateTime = 1677746610654, serialized key size = -1, serialized value size = 42, headers = RecordHeaders(headers = [], isReadOnly = false), key = null, value = {"id":1,"orderName":"创建订单号：1"})
ConsumerRecord(topic = sort-consume, partition = 1, leaderEpoch = 4, offset = 1345, CreateTime = 1677746610654, serialized key size = -1, serialized value size = 42, headers = RecordHeaders(headers = [], isReadOnly = false), key = null, value = {"id":1,"orderName":"支付订单号：1"})
ConsumerRecord(topic = sort-consume, partition = 1, leaderEpoch = 4, offset = 1346, CreateTime = 1677746610654, serialized key size = -1, serialized value size = 42, headers = RecordHeaders(headers = [], isReadOnly = false), key = null, value = {"id":1,"orderName":"完成订单号：1"})
ConsumerRecord(topic = sort-consume, partition = 1, leaderEpoch = 4, offset = 1347, CreateTime = 1677746610656, serialized key size = -1, serialized value size = 42, headers = RecordHeaders(headers = [], isReadOnly = false), key = null, value = {"id":4,"orderName":"创建订单号：4"})
ConsumerRecord(topic = sort-consume, partition = 1, leaderEpoch = 4, offset = 1348, CreateTime = 1677746610656, serialized key size = -1, serialized value size = 42, headers = RecordHeaders(headers = [], isReadOnly = false), key = null, value = {"id":4,"orderName":"支付订单号：4"})
ConsumerRecord(topic = sort-consume, partition = 1, leaderEpoch = 4, offset = 1349, CreateTime = 1677746610656, serialized key size = -1, serialized value size = 42, headers = RecordHeaders(headers = [], isReadOnly = false), key = null, value = {"id":4,"orderName":"完成订单号：4"})
ConsumerRecord(topic = sort-consume, partition = 1, leaderEpoch = 4, offset = 1350, CreateTime = 1677746610657, serialized key size = -1, serialized value size = 42, headers = RecordHeaders(headers = [], isReadOnly = false), key = null, value = {"id":7,"orderName":"创建订单号：7"})
ConsumerRecord(topic = sort-consume, partition = 1, leaderEpoch = 4, offset = 1351, CreateTime = 1677746610657, serialized key size = -1, serialized value size = 42, headers = RecordHeaders(headers = [], isReadOnly = false), key = null, value = {"id":7,"orderName":"支付订单号：7"})
ConsumerRecord(topic = sort-consume, partition = 1, leaderEpoch = 4, offset = 1352, CreateTime = 1677746610657, serialized key size = -1, serialized value size = 42, headers = RecordHeaders(headers = [], isReadOnly = false), key = null, value = {"id":7,"orderName":"完成订单号：7"})
  • 至此，单线程保证顺序消费的方法，就掌握了。单线程可以放在不同的分区（分区就是队列），然后先后拿取即可。但，消费者有可能是并发的。同一个分区，A线程拿了支付订单，B拿了完成订单。但B线程执行的比较快，这就会出现先完成了订单然后才支付订单。这就很尴尬了，怎么解决呢？下篇章再来一起探讨。
年轻的猴
关注
  • 0
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
一看就会的kafka多线程顺序消费【内附Demo哦】
qq_32179907的博客
01-20 6216
Hello，这里是爱 Coding，爱 Hiphop，爱喝点小酒的 AKA 柏炎。 Kafka是一个分布式的，支持多分区、多副本，基于 Zookeeper 的分布式消息流平台，它同时也是一款开源的基于发布订阅模式的消息引擎系统。 kafka如何保证消息不丢失、顺序消费、重复消费？ 这三个问题熟不熟悉？是不是在面试的时候经常被问到，在日常工作中也经常碰到？ 保证消息不丢失与重复消费其实操作上还是比较简单的。是一些常规的八股文，本文不展开讨论，感兴趣的同学可以给我留言，我单独出一期讲解。 本文将着重与大家讨论K
kafka多线程顺序消费
nsa65223的专栏
07-17 906
为了避免有的小伙伴第一次接触顺序消费的概念，我还是先介绍一下顺序消费是个什么东西。双十一，大量的用户抢在0点下订单。为了用户的友好体验，我们把订单生成逻辑与支付逻辑包装成一个个的MQ消息发送到Kafka中，让kafka积压部分消息，防止瞬间的流量压垮服务。那么这里的问题就出现了，订单生成与支付都被包装成了消息。这两个消息是有严格的先后顺序的，订单生成逻辑肯定在支付之前。如果支付与订单生成对应不同的topic，你只能在consumer层面去处理了。
【踩坑日记】SpringBoot集成Kafka，消息没有按照顺序消息问题【已解决】
yunnuo的博客
04-26 364
### 为什么kafka发送消息无法保证顺序问题？ kafka使用`send`方法，不调用`get()`的话，默认是进行异步批量发送消息的（这是kafka`高吞吐量`的一个手段之一），这样是无法保证你先调用`send`方法发送的消息先发送的情况，需要进行get方法进行获取到响应（也就是`同步`的意思），达到发送的消息有序性的效果。当然：同步消耗的性能和时间肯定是没有异步更快的。 ### 为什么kafka消费是可以保证消费消息的有序性？ **这是个不准确的问题** 因为只有在同一个topic下的同一个p
kafka 示例（spring boot）顺序消息
weixin_43931625的博客
10-26 756
springbootkafka顺序消息 实现方式：将需要顺序消费的消息发送到同一个分区 ********************************************* 使用示例 ******************************** application.yml spring: kafka: bootstrap-serv...
【2024】kafka streams结合案例分析进行实际项目开发使用（3）
最新发布
weixin_52315708的博客
06-19 948
前面已经大致介绍了kafka streams的基本使用了，这里结合一个实际案例来进行练习使用kafka streams。下面案例是一个商场购物的场景，就比如我们去一个购物商场购买东西时，在购买的时候。商场会记录下来我们这一次消费的信息，一般首先会先把银行卡等信息进行一个加***隐藏，然后再把信息分别发送发送给需要的topic，如累计积分的，把购买的金额转为积分返回给用户账号；根据购买产品的不同发送给不同的topic。执行流程通过split把用户购买产品的记录存入到不同的分支。
Kafka 怎么顺序消费？
weixin_44421461的博客
07-06 852
点击上方“Java基基”，选择“设为星标”做积极的人，而不是积极废人！每天14:00更新文章，每天掉亿点点头发...源码精品专栏原创 | Java 2021超神之路，很肝~中文详细注释的开源项目RPC 框架 Dubbo 源码解析网络应用框架 Netty 源码解析消息中间件 RocketMQ 源码解析数据库中间件 Sharding-JDBC 和 MyCAT 源码解析作业调度中间件 Elast...
kafka 分布式的情况下，如何保证消息的顺序消费?
杨荧的CSDN博客
08-10 5689
kafka 分布式的情况下，如何保证消息的顺序消费?
kafka Consumer 消费者使用多线程并发执行，并保证顺序消费， 第一种使用纯线程方式、第二种使用Executors线程池
AutoEE-自动智能开发平台
08-25 3896
kafka Consumer 消费者 多线程 顺序消费 Executors 线程池
kafka demo ，两种线程消费方式
09-20
在本文中，我们将深入探讨Apache Kafka的两种线程消费方式，这是基于提供的标题"Kafka Demo，两种线程消费方式"。Kafka是一种分布式流处理平台，广泛用于实时数据处理和消息传递。在这个示例中，我们将关注如何使用...
Kafka急速入门与实战.doc
12-23
【Kafka急速入门与实战】 Kafka是一种分布式流处理平台，由Apache开发，主要用于构建实时数据管道和流应用。作为消息中间件（MQ），Kafka提供了高效、可靠且可扩展的数据传输能力，常用于大数据处理、日志收集、...
python kafka 多线程消费者&手动提交实例
01-20
from kafka import KafkaConsumer, TopicPartition, OffsetAndMetadata from consumers.db_util import * from consumers.json_dispose import * from collections import OrderedDict threads = []
kafka demo 两种线程消费方式
04-25
【标题】"Kafka Demo 两种线程消费方式"展示了在Kafka中处理消息的两种常见线程模型，这是理解Kafka消费者工作原理的关键部分。Kafka是一个分布式流处理平台，用于构建实时数据管道和应用，它允许生产者发布消息到...
如何保证Kafka顺序消费
KevinChen2019的博客
07-17 3714
在Kafka中Partition(分区)是真正保存消息的地方，发送的消息都存放在这里。Partition(分区)又存在于Topic（主题）中，并且一个Topic（主题）可以指定多个Partition(分区)。在Kafka中，只保证Partition(分区)内有序，不保证Topic所有分区都是有序的。所以Kafka要保证消息的消费顺序，可以有2种方法。...
KAFKA保证顺序消费
qq_36601631的博客
02-01 810
kafka保证顺序消费
Kafka 如何保证消息的消费顺序
SO_zxn的博客
03-30 1589
kafka kafka顺序消费
如何保证kafka消费的顺序性
热门推荐
java_atguigu的博客
04-02 2万+
在Kafka中Partition(分区)是真正保存消息的地方，发送的消息都存放在这里。Partition(分区)又存在于Topic（主题）中，并且一个Topic（主题）可以指定多个Partition(分区)。 在Kafka中，只保证Partition(分区)内有序，不保证Topic所有分区都是有序的。 所以 Kafka 要保证消息的消费顺序，可以有2种方法： 一、1个Topic（主题）只创建1个Partition(分区)，这样生产者的所有数据都发送到了一个Partition(分区)，保证了消息的消费顺
实现 Kafka 分区内消费者多线程顺序消费
npk191954的专栏
07-11 2127
生产者在写的时候，可以指定一个 key，被分发到同一个 partition 中去，而且这个 partition 中的数据一定是有顺序的。消费者从 partition 中取出来数据的时候，也一定是有顺序的。到这里，顺序还是没有错乱的。但是消费者里可能会有多个线程来并发处理消息，而多个线程并发处理的话，顺序可能就乱掉了。
Kafka如何保证消息的消费顺序【全局有序、局部有序】、Kafka如何保证消息不被重复消费、Kafka为什么这么快？【重点】、Kafka常见问题汇总【史上最全】
FLJS_T的博客
02-26 4553
Kafka如何保证消息的消费顺序【全局有序、局部有序】、Kafka如何保证消息不被重复消费、Kafka为什么这么快？【重点】这个时候重发的消息会被服务端拒掉从而避免消息重复。并且为了达到严格的顺序消费还需要。比如操作订单消息，可以把订单id作为key，在消费消息时，通过setnx命令设置一下，Kafka如何保证消息的消费顺序【全局有序、局部有序】、Kafka如何保证消息不被重复消费、Kafka为什么这么快？【重点】、Kafka常见问题汇总【史上最全】
Kafka入门：发布/订阅、架构与生产消费实战
这篇笔记旨在帮助读者从基础入门到实践操作，了解Kafka的核心功能和应用场景，适用于希望在大数据和实时流处理领域深入学习的读者。通过阅读和实践，学习者能够掌握如何有效地利用Kafka构建高效的数据传输和处理系统...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值