Kafka-流量控制（Consumer上线、下线 && ConsumerRebalanceListener）

最新推荐文章于 2024-08-06 11:38:50 发布
最新推荐文章于 2024-08-06 11:38:50 发布
阅读量1.9k 收藏 2
点赞数 1
分类专栏： 消息系统 文章标签： kafka
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/pp_lan/article/details/118608781
版权
"本文介绍了一种在Kafka消费者中实现消息消费的并发控制策略，以应对第三方工具并发限制。通过使用线程安全的计数器控制并发数量，当达到阈值时，消费者会"下线"，释放其他消费者消费同一分区的消息，防止消息积压。此外，还展示了如何在重平衡时修正offset，以及如何手动提交和获取offset。"
摘要由CSDN通过智能技术生成

1. 需求

每一个消费者消费消息后，异步调用任务时需要对任务的并发数量进行控制

2. 实现思路

1. 消费者消费消息，发送异步任务

2. 添加线程安全的计数器控制并发数量

3. 消费者A并发阻塞后，需要让A进行"下线"， 使得其他消费者空闲的情况下可以消费A对应分区的消息（ps: 每个分区只会对应一个消费者，不下线，其他消费者无法消费该分区会形成消息积压）

3. 代码实现

最新代码: git@github.com:hzhulan/kafkahelper.git

3.1 流量控制消费者

需要手动提交offset，并且在重平衡的时候通过重平衡监听的两个回调函数将offset进行修正。

package com.fh.kafka.kafkahelper.consumer;

import com.fh.kafka.kafkahelper.common.bean.KafkaConfig;
import org.apache.kafka.clients.consumer.*;
import org.apache.kafka.common.TopicPartition;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import java.util.*;
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.TimeUnit;

/**
 * 需求：kafka的消费者中消费消息后，调用第三方工具发送异步任务，但是第三方工具的并发有一定的限制，需要我们进行控制
 * 实现: 定义一个线程安全的计数器TaskCount, 根据并发限制消费者的上线、下线。
 * 并发足够：消费者消费；并发不够，消费者下线，防止该分区阻塞
 * 例如： 3个分区对应最多3个消费者同时消费，一个消费者对应一个分区。但是消费者A的并发用完了，一直卡着，他对应分区后面的消息无法被其他消费者消费到，
 * 形成了消息积压，这个时候会将该消费者“下线”， 让其消费者B或消费者C“兼职”消费该分区。
 */
public class ConcurrentConsumer {

    private static final Logger LOGGER = LoggerFactory.getLogger(ConcurrentConsumer.class);

    private String name;

    private TaskCount count = new TaskCount(3);


    private List<String> data = new ArrayList<>();

    private KafkaConfig kafkaConfig;

    private KafkaConsumer<String, String> consumer;

    /**
     * 抢救时间，单位：秒
     */
    private static final int RESCUE_SECOND = 3;

    /**
     * 模拟任务执行时间，单位：秒
     */
    private static final int TASK_EXECUTE_TIME = 5;

    /**
     * 重新订阅时间间隔，单位：秒
     */
    private static final int RESUBSCRIBE_PERIOD = 60;

    /**
     * 测试使用暂时用，可以持久化到数据库中
     */
    private Map<TopicPartition, OffsetAndMetadata> currentOffset = new ConcurrentHashMap<>();

    public ConcurrentConsumer(String name) {
        this.name = name;
        this.kafkaConfig = new KafkaConfig();
        buildConsumer();
    }

    public void buildConsumer() {

        //1.创建消费者
        this.consumer = new KafkaConsumer<>(this.kafkaConfig.buildConsumerProps());

        //2.订阅Topic
        this.consumer.subscribe(Collections.singletonList(this.kafkaConfig.getTopic()));

    }

    public void consume() {
        this.consume(true);
    }

    /**
     * 消费主体
     * @param isFirst
     */
    private void consume(boolean isFirst) {

        // 阻塞等待
        waitForExecute();

        if (!isFirst) {
            reSubscribe();
        }

        LOGGER.info("【{}】上线", this.name);


        try {
            outWhile:
            while (count.hasAuth()) {

                ConsumerRecords<String, String> records = consumer.poll(100);
                for (ConsumerRecord<String, String> record : records) {

                    // 消费者抢救，如果等待后仍无权限，退出循环，下线
                    if (!count.hasAuth()) {
                        TimeUnit.SECONDS.sleep(RESCUE_SECOND);
                        if (!count.hasAuth()) {
                            break outWhile;
                        }
                    }

                    // 日志打印，可忽略
                    data.add(record.value());
                    LOGGER.info("【{}消费消息】size: {}, partition: {}, offset: {}, value: {}\ndata: {}.", name,
                            data.size(),record.partition(), record.offset(), record.value(), data);

                    // 获取执行资格
                    count.acquire();

                    // 设置需要提交的偏移量
                    currentOffset.put(new TopicPartition(record.topic(), record.partition()), new OffsetAndMetadata(record.offset() + 1));

                    // 提交偏移量
                    commitOffset();

                    // 执行内容
                    new Thread(() -> {
                        try {
                            TimeUnit.SECONDS.sleep(TASK_EXECUTE_TIME);
                        } catch (InterruptedException e) {
                            LOGGER.error("等待中断", e);
                        } finally {
                            count.release();
                        }
                    }).start();

                }
            }

        } catch (Exception e) {
            LOGGER.error("执行异常", e);
        }

        // 下线
        logout();
        this.consume(false);
    }

    /**
     * 阻塞等待执行权限
     */
    private void waitForExecute() {
        while (!count.hasAuth()) {
            try {
                TimeUnit.SECONDS.sleep(RESUBSCRIBE_PERIOD);
            } catch (InterruptedException e) {
                LOGGER.error("【等待中断】", e);
            }

            LOGGER.info("【{}排队等待获取执行权限】", name);
        }
    }

    /**
     * 重新"上线"
     */
    private void reSubscribe() {
        this.consumer = new KafkaConsumer<>(this.kafkaConfig.buildConsumerProps());
        this.consumer.subscribe(Collections.singletonList(this.kafkaConfig.getTopic()), new ConsumerRebalanceListener() {

            /**
             * rebalance之前调用
             * @param partitions
             */
            @Override
            public void onPartitionsRevoked(Collection<TopicPartition> partitions) {
                LOGGER.info("=============== 重平衡开始 ==============");
                commitOffset();
            }

            /**
             * rebalance之后调用， 对变化的分区使用保存的offset，进行seek
             * @param partitions
             */
            @Override
            public void onPartitionsAssigned(Collection<TopicPartition> partitions) {
                try {
                    for (TopicPartition partition : partitions) {
                        if (getOffset(partition) != null) {
                            consumer.seek(partition, getOffset(partition));
                            LOGGER.info("【重平衡seek】partition: {}, offset: {}.", partition.partition(), getOffset(partition));
                        } else {
                            LOGGER.info("【offset为空】partition: {}", partition.partition());
                        }
                    }
                } catch (Exception e) {
                    LOGGER.error("重平衡异常", e);
                }
                LOGGER.info("=============== 重平衡结束 ==============");
            }
        });
        this.consumer.resume(this.consumer.assignment());
    }

    /**
     * 消费者下线
     */
    private void logout() {
        this.consumer.unsubscribe();//此处不取消订阅暂停太久会出现订阅超时的错误
        this.consumer.pause(consumer.assignment());
    }

    /**
     * ============================ 自定义offset， 可以放到数据库中进行维护 =================================
     */
    private Long getOffset(TopicPartition partition) {
        if (currentOffset.get(partition) == null) {
            return null;
        }
        return currentOffset.get(partition).offset();
    }

    private void commitOffset() {

        this.consumer.commitAsync(currentOffset, (offsets, exception) -> {
            if (exception != null) {
                LOGGER.info("commit失败！！！！！！！！！！！！！！！！！");
            }
        });

        currentOffset.clear();
    }


    public static void main(String[] args) {
        ConcurrentConsumer factory = new ConcurrentConsumer(String.format("消费者"));
        factory.consume();
    }
}

3.2 普通消费者

package com.fh.kafka.kafkahelper.consumer;

import com.fh.kafka.kafkahelper.common.bean.KafkaConfig;
import org.apache.kafka.clients.consumer.*;
import org.apache.kafka.common.TopicPartition;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import java.util.Collection;
import java.util.Collections;
import java.util.Map;
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.atomic.AtomicInteger;

/**
 * 简单消费者不作并发限制， 和ConsumerFactory中的消费者一起消费
 */
public class SimpleConsumer {

    private static final Logger LOGGER = LoggerFactory.getLogger(SimpleConsumer.class);

    private KafkaConfig kafkaConfig;

    private KafkaConsumer<String, String> consumer;

    /**
     * 测试使用暂时用，可以持久化到数据库中
     */
    private Map<TopicPartition, OffsetAndMetadata> currentOffset = new ConcurrentHashMap<>();

    public SimpleConsumer() {
        this.kafkaConfig = new KafkaConfig();
        buildConsumer();
    }

    private KafkaConsumer buildConsumer() {
        //1.创建消费者
        this.consumer = new KafkaConsumer<>(this.kafkaConfig.buildConsumerProps());

        //2.订阅Topic
        //创建一个只包含单个元素的列表，Topic的名字叫作customerCountries
        this.consumer.subscribe(Collections.singletonList(kafkaConfig.getTopic()), new ConsumerRebalanceListener() {
            /**
             * rebalance之前调用
             * @param partitions
             */
            @Override
            public void onPartitionsRevoked(Collection<TopicPartition> partitions) {
                LOGGER.info("=============== 重平衡开始 ==============");
                commitOffset();
            }

            /**
             * rebalance之后调用， 对变化的分区使用保存的offset，进行seek
             * @param partitions
             */
            @Override
            public void onPartitionsAssigned(Collection<TopicPartition> partitions) {
                try {
                    for (TopicPartition partition : partitions) {
                        if (getOffset(partition) != null) {
                            consumer.seek(partition, getOffset(partition));
                            LOGGER.info("【重平衡seek】partition: {}, offset: {}.", partition.partition(), getOffset(partition));
                        } else {
                            LOGGER.info("【offset为空】partition: {}", partition.partition());
                        }
                    }
                } catch (Exception e) {
                    LOGGER.error("重平衡异常", e);
                }
                LOGGER.info("=============== 重平衡结束 ==============");
            }
        });

        return consumer;
    }

    public void consume() {
        LOGGER.info("【普通消费者】上线");
        AtomicInteger count = new AtomicInteger(0);
        try {
            while (true) {
                ConsumerRecords<String, String> records = consumer.poll(100);

                for (ConsumerRecord<String, String> record : records) {
                    int number = count.incrementAndGet();
                    LOGGER.info("【普通消费者】No.{} parition: {}, offset: {}, value: {}", number, record.partition(), record.offset(),record.value());
                }
                commitOffset();
            }
        } catch (Exception e) {
            LOGGER.error("消费异常", e);
        } finally {
            LOGGER.info("【普通消费者】下线");
        }
    }

    /**
     * ============================ 自定义offset， 可以放到数据库中进行维护 =================================
     */
    private Long getOffset(TopicPartition partition) {
        if (currentOffset.get(partition) == null) {
            return null;
        }
        return currentOffset.get(partition).offset();
    }

    private void commitOffset() {

        this.consumer.commitAsync((offsets, exception) -> {
            if (exception != null) {
                LOGGER.info("commit失败！！！！！！！！！！！！！！！！！");
            }
        });

        currentOffset.clear();
    }

    public static void main(String[] args) {
        new SimpleConsumer().consume();
    }
}

3.3 生产者

package com.fh.kafka.kafkahelper.producer;

import com.fh.kafka.kafkahelper.common.bean.KafkaConfig;
import org.apache.kafka.clients.producer.KafkaProducer;
import org.apache.kafka.clients.producer.ProducerRecord;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import java.util.ArrayList;
import java.util.List;

/**
 * 生产者
 */
public class GbdProducer {

    private static final Logger LOGGER = LoggerFactory.getLogger(GbdProducer.class);

    private static KafkaProducer producer = null;

    private static KafkaConfig kafkaConfig;

    static {
        kafkaConfig = new KafkaConfig();
    }

    private static void init() {
        if (producer == null) {
            producer = new KafkaProducer<String, String>(kafkaConfig.buildProducerProps());
        }
    }


    public static void send(String topic, String value) {

        init();

        try {
//            ProducerRecord<String, String> record = new ProducerRecord<>(topic, value);
//            producer.send(record);
            int v = Integer.parseInt(value);
            ProducerRecord<String, String> record = new ProducerRecord<>(topic, v % 3, "test", value);
            producer.send(record);
            LOGGER.info("发送消息: {}, partition: {}.", v, v % 3);

        } catch (Exception e) {
            LOGGER.error("发送消息异常", e);
        } finally {
            producer.close();
            producer = null;
        }

    }

    public static void send(String topic, List<String> values) {

        init();

        try {
            // 使用轮询方式

            for (int i = 0; i < values.size(); i++) {
                ProducerRecord<String, String> record = new ProducerRecord<>(topic, i % 3, "test", values.get(i));
                producer.send(record);
                LOGGER.info("发送消息: {}, partition: {}.", values.get(i), i % 3);
            }
        } catch (Exception e) {
            LOGGER.error("发送消息异常", e);
        } finally {
            producer.close();
            producer = null;
        }

    }

    public static void main(String[] args) {
        List<String> msgList = new ArrayList<>();
        for (int i = 0; i < 15; i++) {
            msgList.add(String.format("%d", i));
        }
        GbdProducer.send(kafkaConfig.getTopic(), msgList);
    }
}

4. 验证

4.1 创建topic

分区数设置为3  --partitions 3

.\bin\windows\kafka-topics.bat --zookeeper localhost:2181 --create --replication-factor 1 --partitions 3 --topic msg

4.2 查看Topic

.\bin\windows\kafka-topics.bat --zookeeper localhost:2181 --describe --topic msg

4.3 消费者消费分区查看

windows命令(linux跟换.bat为.sh)如下

kafka-consumer-groups.bat --bootstrap-server localhost:9092 --group jsGroup --describe

 可以看到3个消费者分别对应3个不同的分区

4.4 代码运行结果查看

4.4.1 单个消费者（并发为3）开始依次执行

 并发达到阈值时候消费者下线，并发减小后重新上线

4.4.2 两个消费者ConcurrentConsumer、SimpleConsumer一起消费

内容待整理：

参考内容: https://www.cnblogs.com/yaohaitao/p/12172867.html

pp_lan
关注
专栏目录
【Kafka】kafka 再均衡监听器 ConsumerRebalanceListener
九师兄
09-20 3144
新版本 consumer 默认把位移提交到 consumer offsets 中。其Kafka 也支持用户把位移提交到外部存储中，比如数据库中。若要实现这个功能，用户就必须使用 rebalance 监听器。使用 rebalance 监听器的前提是用户使用 consumer group。如果使用的是独立 consumer 或是直接手动分配分区，那么 rebalance 监听器是无效的。rebalance 监听器有一个主要的接口回调类，里面就两个方法和在开启新 一 轮rebalance前方法会被调用，而。
【Kafka】kafka命令kafka-console-consumer.sh
九师兄
12-13 5493
1.概述 kafka-console-consumer.sh 脚本是一个简易的消费者控制台。该 shell 脚本的功能通过调用 kafka.tools 包下的 ConsoleConsumer 类，并将提供的命令行参数全部传给该类实现。 注意：Kafka 从 2.2 版本开始将 kafka-topic.sh 脚本中的 −−zookeeper 参数标注为 “过时”，推荐使用 −−bootstrap-server 参数。若读者依旧使用的是 2.1 及以下版本，请将下述的 --bootstrap-server .
浅谈Kafka流控制与监控指标
weixin_59801183的博客
07-07 1953
Apache Kafka 是一个高度可扩展的、分布式的流处理平台，广泛应用于大数据和实时数据处理场景。为了确保 Kafka 集群的稳定性和性能，了解 Kafka 的流控制机制和监控指标至关重要。本文将深入详细阐述 Kafka 的流控制机制和监控指标，包括 Kafka 生产者、消费者和集群性能指标等。深入介绍如何设计和使用 Kafka 监控工具，以及如何进行故障排除。
Kafka-流量控制Quota功能
大叶子不小的博客
05-06 1600
https://shiyueqi.github.io/2017/04/27/Kafka-%E6%B5%81%E9%87%8F%E6%8E%A7%E5%88%B6Quota%E5%8A%9F%E8%83%BD/ 一、Quota 功能简介官方文档 http://kafka.apache.org/documentation/#design_quotas 二、Quota功能简介 Kafka从0.9版本开始增加流量控制功能–Quotas，并在broker中增加了以下的配置。 可以在broker的配置
kafka Java客户端之consumer 流量控制 以及 Rebalance解析
小灰狼与大白兔的博客
02-08 1万+
Consumer 流量控制 为了避免Kafka中的流量剧增导致过大的流量打到Consumer端将Consumer给压垮的情况，我们就需要针对Consumer进行限流。例如，当处理的数据量达到某个阈值时暂停消费，低于阈值时则恢复消费，这就可以让Consumer保持一定的速率去消费数据，从而避免流量剧增时将Consumer给压垮。大体思路如下： 在poll到数据之后，先去令牌桶中拿取令牌 如果获取到令牌，则继续业务处理 如果获取不到令牌，则调用pause方法暂停Consumer，等待令牌 当令牌桶中的令牌足够，
kafka rebalance ConsumerRebalanceListener
金溪的博客
11-04 1772
kafka在有新消费者加入或者撤出时，会触发rebalance操作，在subscribe订阅主题的时候，我们可以编写回掉函数，在触发rebalance操作之前和之后，提交相应偏移量和获取偏移量。 consumer.subscribe(Collections.singletonList(topic), new SaveOffsetOnRebalance(mulConsumer)); clas...
kafka-console-consumer:Kafka控制台使用者-从时间戳读取事件
03-30
Kafka游戏机消费者 控制台应用程序，用于从给定的时间戳读取事件。 要求 Java> = 8 建造 ./mvn install 用法示例 配置 您需要在与工具配置相同目录中的application.properties文件中进行特定设置，才能与kafka连接...
关于kafka-console-consumer.sh消费者的一些思考
weixin_43423377的博客
04-14 2798
(人物设定初步了解kafka的我) 我司现在有三台kafka服务器作为一个集群 需求是我写了一个监听器去监听活动失败的情况,如果活动失败则调用一个统计接口做数据统计 我需要从失败事件的随路数据中取一些数据,做一些判断. 现在我想从集群中看一下失败事件中的随路数据是否完整正确 于是,我xshell连接上了三台服务器并且运行以下命令 ./kafka-console-consumer.sh --bootstrap-server broker1IP:9092 --topic topicnam..
积分java源码-kafka-spark-consumer:用于SparkStreaming的高性能Kafka连接器。支持多主题获取、Kafk
06-06
积分java源码Kafka-Spark-Consumer 的 README 文件 注意：此 Kafka Spark Consumer 代码取自 Apache Storm 项目 () 的 Kafka spout，该项目最初由 wurstmeister () 创建。 原始 Storm Kafka Spout 代码已被修改以与 ...
spring-boot-kafka-consumer-example:Spring Boot Kafka使用者示例
05-18
带有Kafka Consumer实例的Spring Boot 本项目介绍如何将Spring Boot与Spring Kafka结合使用以使用Kafka主题中的JSON / String消息 启动Zookeeper bin/zookeeper-server-start.sh config/zookeeper.properties 启动...
kafka流量限制
热门推荐
黑曼巴
05-01 1万+
文章目录1.官网参考地址2.可以设置限制流量参数3.流量限制维度及组合4.如何设置流量5.限制用户流量阀值如何设置6.流量限制效果 1.官网参考地址 http://kafka.apache.org/21/documentation.html#design_quotas 2.可以设置限制流量参数 producer_byte_rate=1024 #单个broker入流量限制参数，单位字节 cons...
深入理解 Kafka 的 ConsumerRebalanceListener
m0_62153576的博客
08-03 946
是 Kafka 提供的一个回调接口，用户可以实现该接口来监听分区重新平衡（partition rebalance）事件。当消费者组中的分区分配发生变化时，Kafka 会触发重新平衡操作。：在重新平衡操作期间，当消费者需要放弃一些分区时调用。：在分区重新分配完成并且消费者开始获取数据之前调用，并且只有在调用方法时才会触发。通过本文的示例，我们可以看到在 Kafka 中的应用。它允许我们在分区重新平衡时执行一些自定义操作，从而更好地管理消费者组中的分区分配。这对于确保数据的一致性和可靠性至关重要。
【弄nèng - Kafka】应用篇（十七） —— Java Kafka 再均衡监听器ConsumerRebalanceListener
司马缸砸缸了
01-13 1537
文章目录一. 简介二. 实现2.1 引入依赖2.2 使用事例源码地址项目推荐 该篇博客是Kafka API的使用，ConsumerRebalanceListener 更多高级用法请看我的博客Kafka系列 参考： https://www.orchome.com/451 https://www.w3cschool.cn/apache_kafka/apache_kafka_workflow.html...
kafka的客户端限流（资源配额）
程序猿的樊笼
12-19 3439
本文说明的是Kafka的客户端（生产者、消费者）与broker之前的限流，不是kafka的broker间topic副本同步的限流。
Kafka权限认证与流量控制
YazIdris的博客
09-23 104
Kafka的权限认证功能允许管理员对访问Kafka集群的用户进行身份验证和授权。下面是一个示例，展示如何配置和使用Kafka的权限认证功能。Kafka的流量控制功能允许管理员限制特定用户或客户端对Kafka集群的访问速率。Kafka的流量控制功能允许管理员限制特定用户或客户端对Kafka集群的访问速率。管理员客户端使用管理员级别的凭证进行身份验证，然后根据定义的ACL规则对指定的主题进行授权或撤销授权。管理员客户端使用管理员级别的凭证进行身份验证，然后根据定义的ACL规则对指定的主题进行授权或撤销授权。
六、Kafka consumer及ConsumerRebalanceListener实现
qq_31473465的博客
09-06 1850
1. comsumer代码示例及ConsumerRebalanceListener实现 public class ConsumerMessage { private static final String TOPIC_NAME = "topic-07"; public static void main(String[] args) { Properties props = new Properties(); props.setProperty("boots
Kafka之Consumer Rebalance
jannal专栏
12-18 946
文章目录Kafka版本rebalancerebalance策略rebalance generationrebalance协议rebalance流程rebalance监听器 Kafka版本 kafka版本1.1.1，可能绝大部分也适用于kafka 0.10.x及以上版本。 rebalance ConsumerGroup(消费组)里的Consumer(消费者)共同读取topic(主题)的p...
深入理解Kafka的ConsumerRebalanceListener机制
最新发布
m0_62153576的博客
08-06 448
通过本文的分析和实例，我们可以看到在处理Kafka分区重新平衡时的重要性。正确实现此接口可以帮助我们更好地控制消费者在分区变化时的行为，从而提高应用程序的健壮性和灵活性。
kafka复习：（19）： ConsumerRebalanceListener的用法
amadeus_liu2的博客
08-25 220
【代码】kafka复习：（19）： ConsumerRebalanceListener的用法。
Kafka-console-consumer.sh 详细介绍
06-09
kafka-console-consumer.sh 是 Apache Kafka 提供的一个命令行工具，用于从 Kafka 消费者订阅的主题中读取消息并打印到控制台。它可以用来测试 Kafka 集群是否正常工作，检查主题中是否有消息，以及实时监控消息的流动情况。 kafka-console-consumer.sh 命令的用法如下： ```bash bin/kafka-console-consumer.sh --bootstrap-server <hostname>:<port> --topic <topic-name> [--from-beginning] ``` 其中，--bootstrap-server 参数指定 Kafka 集群的地址和端口；--topic 参数指定消费者订阅的主题名称；--from-beginning 参数可选，表示从主题的起始位置开始消费，如果不指定，则只消费最新的消息。 此外，kafka-console-consumer.sh 还支持一些其他的参数，例如可以将消息输出到文件或者指定消费者组等。更多详细信息可以通过执行 `bin/kafka-console-consumer.sh --help` 命令查看。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值