Kafka提交偏移量的五种方式

最新推荐文章于 2025-03-16 07:01:03 发布
最新推荐文章于 2025-03-16 07:01:03 发布
阅读量1.1w 收藏 51
点赞数 10
分类专栏： kafka 大数据 文章标签： kafka offset 偏移量
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/qq_35689573/article/details/86711265
版权
探讨Kafka消费者偏移量的五种管理方式：自动提交、提交当前偏移量、异步提交、同步异步组合提交及提交特定偏移量，分析其优缺点并附实践案例。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

讨论偏移量我们首先要知道如何查看偏移量及消费者目前消费的偏移量

./kafka-consumer-groups.sh --describe --bootstrap-server 192.168.153.128:9092 --group ConsumerGroup3

Consumer group 'ConsumerGroup3' has no active members：可以看到我们这个消费者组现在是没有消费者的

test_topic这个topic其他分区没有消息，只有分区2有消费记录：

CURRENT-OFFSET：目前已被消费者消费的消息偏移量

LOG-END-OFFSET：消息最大偏移量

LAG：消息堆积的条数

1、自动提交方式

这种提交方式有两个很重要的参数：

enable.auto.commit=true（是否开启自动提交，true or false）

auto.commit.interval.ms=5000（提交偏移量的时间间隔，默认5000ms）

每隔5秒，消费者会自动把从poll方法接收到的最大偏移量提交上去。自动提交是在轮询中进行，消费者每次轮询时都会检查是否提交该偏移量。可是这种情况会发生重复消费和丢失消息的情况。

重复消费：如果我们设auto.commit.interval.ms=60000，16:34首次提交偏移量62，此时又拉取了2条消息，此时分区2对应的消费者宕机，发生了分区再均衡，（分区的所有权从一个消费者转到另一个消费者被称为再均衡。一般新增消费者，消费者关闭或改变分区数都会发生再均衡）分区2的消息由另一个消费者消费，新的消费者会读取16:34提交的那个偏移量，这样就会发生重复消费了，我们来实践一下：

我们开两个消费端consumer1和consumer2：

private static final String TOPIC_NAME = "test_topic";

    public static void main(String[] args) {
        Properties props = new Properties();
        props.put("bootstrap.servers",
                "192.168.153.128:9092,192.168.153.128:9093,192.168.153.128:9094");
        props.put("group.id", "ConsumerGroup3");
        /* 是否自动确认offset */
        props.put("enable.auto.commit", "true");
        /* 自动确认offset的时间间隔 */
        props.put("auto.commit.interval.ms", "60000");
        props.put("session.timeout.ms", "30000");
//        props.put("auto.offset.reset", "earliest");
        props.put("auto.offset.reset", "latest");

        // 序列化类
        props.put("key.deserializer", "org.apache.kafka.common.serialization.StringDeserializer");
        props.put("value.deserializer", "org.apache.kafka.common.serialization.StringDeserializer");
        
        KafkaConsumer<String, String> consumer = new KafkaConsumer<String, String>(props);
        consumer.subscribe(Collections.singletonList(TOPIC_NAME));

        try {
            for (; ; ) {
                ConsumerRecords<String, String> records = consumer.poll(Duration.ofMillis(100));
                for (ConsumerRecord<String, String> record : records)
                    System.out.printf("消费消息：topic=%s, partition=%d, offset=%d, key=%s, value=%s\n",
                            record.topic(), record.partition(), record.offset(), record.key(), record.value());
            }
        } finally {
            consumer.close();
        }
    }

生产者：

        producer = new KafkaProducer<>(props);
        for (int i = 0; i < 2; i++) {
	        ProducerRecord<String, String> record = new ProducerRecord<>(TOPIC_NAME, 2,
	                "key01", "连衣裙" + i);
	        try {
	            RecordMetadata result = producer.send(record).get();
	            System.out.printf("同步发送：%s，分区：%d，offset：%d\n", result.topic(),
	                    result.partition(), result.offset());
	        } catch (Exception e) {
	            e.printStackTrace();
	        }
        }

生产者生产了2条数据：

同步发送：test_topic，分区：2，offset：62
同步发送：test_topic，分区：2，offset：63

consumer2消费的消息

2019-01-31 17:02:17 消费消息：topic=test_topic, partition=2, offset=62, key=key01, value=连衣裙0
2019-01-31 17:02:17 消费消息：topic=test_topic, partition=2, offset=63, key=key01, value=连衣裙1

此时我们关闭consumer2，去服务器执行./kafka-consumer-groups.sh --describe --bootstrap-server 192.168.153.128:9092 --group ConsumerGroup3

我们再看consumer1消费的消息

2019-01-31 17:02:50 消费消息：topic=test_topic, partition=2, offset=62, key=key01, value=连衣裙0
2019-01-31 17:02:50 消费消息：topic=test_topic, partition=2, offset=63, key=key01, value=连衣裙1

可以看到发生了重复消费。

丢失消息：消费者一次poll100条新消息，并且提交了偏移量，此时消费者还没处理完，就宕机了，又发生了再均衡，由另一个消费者消费该分区的消息，新的消费者会读取旧消费者最后一次提交的偏移量，此时就会发生消息丢失了。我们来实践一下：

生产者：

      for (int i = 0; i < 10; i++) {
	        ProducerRecord<String, String> record = new ProducerRecord<>(TOPIC_NAME, 2,
	                "key01", "连衣裙" + i);
	        try {
	            RecordMetadata result = producer.send(record).get();
	            System.out.printf("同步发送：%s，分区：%d，offset：%d\n", result.topic(),
	                    result.partition(), result.offset());
	        } catch (Exception e) {
	            e.printStackTrace();
	        }
        }

生产10条消息：

同步发送：test_topic，分区：2，offset：208
同步发送：test_topic，分区：2，offset：209
同步发送：test_topic，分区：2，offset：210
同步发送：test_topic，分区：2，offset：211
同步发送：test_topic，分区：2，offset：212
同步发送：test_topic，分区：2，offset：213
同步发送：test_topic，分区：2，offset：214
同步发送：test_topic，分区：2，offset：215
同步发送：test_topic，分区：2，offset：216
同步发送：test_topic，分区：2，offset：217

consumer2：

for (; ; ) {
    ConsumerRecords<String, String> records = consumer.poll(Duration.ofMillis(100));
    if (!records.isEmpty()){
       System.out.println("consumer2消费了这批消息！");
    }
    for (ConsumerRecord<String, String> record : records){
        new Thread(new Runnable() {
			@Override
			public void run() {
				try {
					Thread.sleep(60000);//用阻塞来模拟数据处理过程所消耗的时间
				} catch (InterruptedException e) {
					e.printStackTrace();
			    }
			System.out.printf(DateUtil.getDate() + " 消费消息：topic=%s, partition=%d, offset=%d, key=%s, value=%s\n",
					                record.topic(), record.partition(), record.offset(), record.key(), record.value());
	        }
	   }).start();
    }
}
consumer2消费了这批消息！
consumer2消费了这批消息！
consumer2消费了这批消息！
consumer2消费了这批消息！
consumer2消费了这批消息！
consumer2消费了这批消息！

可见consumer2已经接收到了这批消息但并未进行逻辑处理，因为提交偏移量的周期时间比处理数据的时间小，所以已经提交了偏移量，此时我们关闭consumer2，再发送10条消息

同步发送：test_topic，分区：2，offset：218
同步发送：test_topic，分区：2，offset：219
同步发送：test_topic，分区：2，offset：220
同步发送：test_topic，分区：2，offset：221
同步发送：test_topic，分区：2，offset：222
同步发送：test_topic，分区：2，offset：223
同步发送：test_topic，分区：2，offset：224
同步发送：test_topic，分区：2，offset：225
同步发送：test_topic，分区：2，offset：226
同步发送：test_topic，分区：2，offset：227

我们看一下consumer1

for (; ; ) {
    ConsumerRecords<String, String> records = consumer.poll(Duration.ofMillis(100));
    if (!records.isEmpty()){
        System.out.println("consumer1消费了这批消息！");
    }
    for (ConsumerRecord<String, String> record : records){
        new Thread(new Runnable() {
			@Override
			public void run() {
				try {
					Thread.sleep(60000);//用阻塞来模拟数据处理过程所消耗的时间
				} catch (InterruptedException e) {
					e.printStackTrace();
				}
				System.out.printf(DateUtil.getDate() + " 消费消息：topic=%s, partition=%d, offset=%d, key=%s, value=%s\n",
					                record.topic(), record.partition(), record.offset(), record.key(), record.value());
			}
		}).start();
    }
}
consumer1消费了这批消息！
consumer1消费了这批消息！
consumer1消费了这批消息！
consumer1消费了这批消息！
consumer1消费了这批消息！
consumer1消费了这批消息！
2019-02-32 09:27:13 消费消息：topic=test_topic, partition=2, offset=220, key=key01, value=连衣裙2
2019-02-32 09:27:13 消费消息：topic=test_topic, partition=2, offset=218, key=key01, value=连衣裙0
2019-02-32 09:27:13 消费消息：topic=test_topic, partition=2, offset=219, key=key01, value=连衣裙1
2019-02-32 09:27:13 消费消息：topic=test_topic, partition=2, offset=221, key=key01, value=连衣裙3
2019-02-32 09:27:13 消费消息：topic=test_topic, partition=2, offset=222, key=key01, value=连衣裙4
2019-02-32 09:27:13 消费消息：topic=test_topic, partition=2, offset=223, key=key01, value=连衣裙5
2019-02-32 09:27:13 消费消息：topic=test_topic, partition=2, offset=225, key=key01, value=连衣裙7
2019-02-32 09:27:13 消费消息：topic=test_topic, partition=2, offset=224, key=key01, value=连衣裙6
2019-02-32 09:27:13 消费消息：topic=test_topic, partition=2, offset=227, key=key01, value=连衣裙9
2019-02-32 09:27:13 消费消息：topic=test_topic, partition=2, offset=226, key=key01, value=连衣裙8

其实我们不看consumer1可能也知道208到217之间的那10条消息其实已经丢失了。consumer1是从220开始消费的。

由此我们知道自动提交的方式是有弊端的，如果你是同步处理数据，再均衡时很容易发生消息重复，如果你是异步处理数据，则易发生数据丢失，这都是我们不想看到的。

2、提交当前偏移量

enable.auto.commit=false，用commitSync()提交由poll方法返回的最新偏移量，如果提交成功马上返回，提交失败则抛出异常。

for (; ; ) {
    ConsumerRecords<String, String> records = consumer.poll(Duration.ofMillis(100));
    if (!records.isEmpty()){
        System.out.println("consumer1消费了这批消息！");
    }
    for (ConsumerRecord<String, String> record : records){
		System.out.printf(DateUtil.getDate() + " 消费消息：topic=%s, partition=%d, offset=%d, key=%s, value=%s\n",
			                record.topic(), record.partition(), record.offset(), record.key(), record.value());
    }
    consumer.commitSync();
}

3、异步提交

手动提交不足之处在于提交请求后，broker响应之前应用程序会一直阻塞。这样就会限制应用程序的吞吐量。虽然可以通过降低提交频率来提升吞吐量，但一旦发生再均衡，会增加重复消息的数量。

for (; ; ) {
    ConsumerRecords<String, String> records = consumer.poll(Duration.ofMillis(100));
    if (!records.isEmpty()){
       System.out.println("consumer1消费了这批消息！");
    }
    for (ConsumerRecord<String, String> record : records){
	    System.out.printf(DateUtil.getDate() + " 消费消息：topic=%s, partition=%d, offset=%d, key=%s, value=%s\n",
			                record.topic(), record.partition(), record.offset(), record.key(), record.value());
    }
    consumer.commitAsync();
}

异步提交还可以有回调

for (; ; ) {
    ConsumerRecords<String, String> records = consumer.poll(Duration.ofMillis(100));
    if (records.isEmpty()){
       continue;
    }
    for (ConsumerRecord<String, String> record : records){
		System.out.printf(DateUtil.getDate() + " 消费消息：topic=%s, partition=%d, offset=%d, key=%s, value=%s\n",
			                record.topic(), record.partition(), record.offset(), record.key(), record.value());
    }
    consumer.commitAsync(new OffsetCommitCallback() {
					
		@Override
		public void onComplete(Map<TopicPartition, OffsetAndMetadata> offsets, Exception e)       
        {
			if (e != null) {
				System.out.println(offsets.toString());
				System.out.println(e.toString());
			}
		}
	});
}

4、同步异步组合提交

如果提交失败发生在关闭消费者或者再均衡前的最后一次提交，那么就要确保提交能够成功。这个时候就需要使用同步异步组合提交。

try {
    for (; ; ) {
       ConsumerRecords<String, String> records = consumer.poll(Duration.ofMillis(100));
       if (records.isEmpty()){
           continue;
       }
       for (ConsumerRecord<String, String> record : records){
		   System.out.printf(DateUtil.getDate() + " 消费消息：topic=%s, partition=%d, offset=%d, key=%s, value=%s\n",
			                record.topic(), record.partition(), record.offset(), record.key(), record.value());
       }
       consumer.commitAsync();
    }
} finally {
   try{
      consumer.commitSync();
   } finally{
      consumer.close();
   }
}

5、提交特定偏移量

如果想要在批次中间提交偏移量，消费者API允许在调用commitSync和commitAsync时传递希望提交的分区和偏移量。

Map<TopicPartition, OffsetAndMetadata> currentOffsets = new HashMap<TopicPartition, OffsetAndMetadata>();
int count = 0; 		
try {
    for (; ; ) {
        ConsumerRecords<String, String> records = consumer.poll(Duration.ofMillis(100));
        if (records.isEmpty()){
           continue;
        }
        for (ConsumerRecord<String, String> record : records){
			System.out.printf(DateUtil.getDate() + " 消费消息：topic=%s, partition=%d, offset=%d, key=%s, value=%s\n",
			                record.topic(), record.partition(), record.offset(), record.key(), record.value());
			currentOffsets.put(new TopicPartition(record.topic(), record.partition()), new OffsetAndMetadata(record.offset(), "no metadata"));
			if (count%1000==0) {
				consumer.commitAsync(currentOffsets, null);
			}
			count++;
        }
    }
} finally {
    try{
        consumer.commitSync();
    } finally{
        consumer.close();
    }
}

参考文献的文章写得很好，大家可以去看看。

参考文献：https://blog.youkuaiyun.com/ljheee/article/details/81605754

Kafka消费者提交偏移量的几种方式
DeoSql的博客
09-22 341
在Kafka中，消费者需要跟踪已经消费的消息的偏移量，以确保数据的一致性和正确性。下面将介绍几种常见的方式来提交Kafka消费者的偏移量。在Kafka中，消费者需要跟踪已经消费的消息的偏移量，以确保数据的一致性和正确性。下面将介绍几种常见的方式来提交Kafka消费者的偏移量。方法异步提交偏移量，并通过回调函数处理提交结果。方法异步提交偏移量，并通过回调函数处理提交结果。与手动同步提交偏移量不同，手动异步提交偏移量不会阻塞消费者线程。与手动同步提交偏移量不同，手动异步提交偏移量不会阻塞消费者线程。
Kafka消费者的偏移量记录和管理方式
DeoSql的博客
09-17 213
Kafka的消费者是用于读取和处理发布到Kafka主题的消息的应用程序。手动提交偏移量方式提供了更高的灵活性和精确控制，适用于对消息处理具有严格要求的场景。在自动提交模式下，Kafka消费者会定期自动提交偏移量，无需开发者显式地进行提交。在手动提交模式下，消费者负责跟踪和管理自己的偏移量，并在处理完消息后显式地提交偏移量。这种方式给予了消费者更大的灵活性和精确控制，但也需要开发者自行管理和处理偏移量的提交。在消费消息时，无需手动提交偏移量，消费者会自动定期提交。在上面的示例中，创建Kafka消费者时通过。
Kafka - 偏移量提交
热门推荐
用时间去蜕变
04-23 1万+
Kafka - 偏移量提交 一、偏移量提交 消费者提交偏移量的主要是消费者往一个名为_consumer_offset的特殊主题发送消息，消息中包含每个分区的偏移量。 如果消费者一直运行，偏移量的提交并不会产生任何影响。但是如果有消费者发生崩溃，或者有新的消费者加入消费者群组的时候，会触发 Kafka 的再均衡。这使得 Kafka 完成再均衡之后，每个消费者可能被会分到新分区中。为了能...
Kafka-提交偏移量（offset）
weixin_41227335的博客
01-17 3408
1.自动提交： 1.属性enable.auto.commit -&amp;gt; true 2.属性auto.commit.interval.ms -&amp;gt;5000 默认提交时间间隔为5s 3.消费者会自动将poll()方法接收到的消息的最大偏移量提交上去 2.手动提交偏移量（分为两种） 1.同步的提交 2，异步的提交 3.同步方式提交偏移量 4.异步方式提交偏移量 ...
Kafka 中的偏移量是什么？它解决了哪些问题？
郑龙飞
03-16 538
在 Kafka 中，偏移量（offset）是为分区中的每条记录（消息）分配的唯一标识符。每条新消息都会被追加到日志中，Kafka 会为其分配下一个连续的偏移量。• 如果消费者在处理分区 0 的偏移量 3 后失败，下一个消费者（或重启后）将从偏移量 4 继续。：每次处理完一条支付记录后，消费者提交最后成功处理的消息的偏移量。在分区主题中，消费者可以独立管理偏移量，实现可扩展的并行处理。如果消费者失败，另一个消费者可以从最后提交的偏移量继续处理。• 一个支付消费者在处理分区 0 的偏移量 4 后崩溃。
kafka权威指南 第四章 第5节：提交和偏移量 [复制链接]
lppl010_的专栏
06-17 498
http://www.aboutyun.com/thread-22089-1-1.html本帖最后由 feilong 于 2017-6-30 08:16 编辑问题导读1.什么是一次提交（commit）？2.什么是偏移量（offset）？3.消费者如何提交偏移量？4.KafkaConsumer API 提供的提交偏移量的方法有哪些？5.commitSync()方法如何使用？当我们调用poll()时，...
Kafka消费者 之 如何提交消息的偏移量
CREATE_17的博客
07-07 713
每一个成功人士的背后，必定曾经做出过勇敢而又孤独的决定。放弃不难，但坚持很酷~前言由于消费者模块的知识涉及太多，所以决定先按模块来整理知识，最后再进行知识模块汇总。一、概述在新消费者客户...
Kafka-消费者-偏移量的提交方式
qq_38304392的博客
04-06 315
Kafka-消费者-偏移量的提交方式 每次调用poll()方法，它总是返回由生产者写入Kafka但还没有被消费者读取过的记录，可以追踪到哪些记录是被群组里的哪个消费者读取的。 更新分区当前位置的操作叫做提交。 消费者往一个叫做 _consumer_offset的特殊主题发送消息，消息里包含每个分区的偏移量。如果消费者一直处于运行状态，那么偏移量就没有什么用处。不过，如果消费者发生崩溃或者有新的消...
java kafka设置偏移量_kafka消费者偏移量提交
weixin_39616071的博客
03-02 2050
自动提交当前偏移量如果客户端属性enable.auto.commit被设为true,那么每过5s,消费者会自动把从poll()方法接收到的最大偏移量提交上去,提交时间间隔由auto.commit.interval.ms控制,默认为5s假设我们使用默认的5s提交时间间隔,在上次提交的3s之后发生了再均衡,在均衡后消费者会从最后一次提交的位置开始读取消息,这时候偏移量已经落后的3s,因此这3s内的消息...
【大数据学习 | kafka】kafka的偏移量管理
2301_80912559的博客
11-05 2280
一般我们都会选择异步提交方式，他们的功能都是将拉取到的一整批数据的最大偏移量直接提交到__consumer_offsets中，但是同步方式会很浪费资源，异步方式虽然不能保证稳定性但是我们的偏移量是一直递增存储的，所以偶尔提交不成功一个两个不影响我们的使用。但是我们不能随意的指定消费者消费数据的位置，因为在启动消费者的时候，一个组中会存在多个消费者，每个人拿到的对应分区是不同的，所以我们需要知道这个消费者能够获取的分区是哪个，然后再指定相应的断点位置。
Kafka——Consumer提交偏移量
困而学之，学思并重
03-30 700
Kafka提交偏移量的方式： 自动提交 手动提交——同步 手动提交——异步 自动提交 package test.kafka import java.util.Properties import org.apache.kafka.common.serialization.StringSerializer class kafkaProperities { private val KF...
kafka手动提交偏移量
qq_44665283的博客
06-29 1454
生产者提交数据的时候 开启事务 /** * Description: * 生产者提交数据的时候 开启事务 */ package com.doit.kafka.day02 import java.util.Properties import org.apache.kafka.clients.producer.{KafkaProducer, ProducerRecord} import org.apache.kafka.common.serialization.StringSerializer
Kafka-消费者提交偏移量
zc0565的博客
10-30 1514
偏移量的作用，一个消费者组消费一个主题的过程中，如果有消费者发生崩溃或者有新的消费者加入群组，就会触发再均衡，完成再均衡后，每个消费者可能会分配到新的分区，为了能够继续之前的消息读取，消费者需要一个记录上一次读取到的位置的偏移量，之后从这个偏移量指定的位置开始读取。 在新版 Kafka 中，消费者提交偏移量是通过向 __consumer_offset 特殊主题发送包含每个分区的偏移量来实现的。 K...
深入解析Kafka消费者——提交和偏移量
weixin_34323858的博客
08-12 1284
KafkaConsumer(消费者)每次调用 poll()方法，它总是返回由生产者写入 Kafka但还没有被消费者读取过的记录， 我们因 此可以追踪到哪些记录是被群组里的哪个消费者读取的。之前已经讨论过， Kafka 不会像其他 JMS 队列那样需要得到消费者的确认，这是 Kafka 的一个独特之处。相反，消...
分布式消息系统：Kafka（五）偏移量
强子的博客
09-01 1万+
5、偏移量提交 5.1 偏移量 （1）新旧版本偏移量的变化 　　在Kafka0.9版本之前消费者保存的偏移量是在zookeeper中/consumers/GROUP.ID/offsets/TOPIC.NAME/PARTITION.ID。新版消费者不在保存偏移量到zookeeper中，而是保存在Kafka的一个内部主题中“consumer_offsets”，该主题默认有50个分区，每个分区...
Kafka-偏移量（含消费者事务）
喻师傅的学习笔记
05-18 1477
Kafka偏移量
SaprkStreaming整合kafka（获取偏移量和异步提交偏移量）
weixin_43648241的博客
08-28 445
package cn._51doit.spark.day13 import org.apache.kafka.clients.consumer.ConsumerRecord import org.apache.kafka.common.serialization.StringDeserializer import org.apache.spark.SparkConf import org.apache.spark.streaming.dstream.{DStream, InputDStream, Rece
kafka消费者提交偏移量的方式对比同步、自动、异步、组合提交等、基本代码实现、以及他们导致的问题
一点光辉的博客
05-09 4028
1 基本概念 提交：消费者消费完消息之后，更新自己消费那个消息的操作 _consumer_offset：消费者消费完消息之后，会往_consumer_offset主题发送消息，_consumer_offset保存每个分区的偏移量 分区再均衡：消费者的数量发生变化，或者主题分区数量发生变化，会修改消费者对应的分区关系，叫做分区再均衡：保证kafka高可用和伸缩性；缺点：在均衡期间，消费者无法读取消息，群组短时间不可用 2 提交方式 2.1 自动提交 1）如果提交的...
卑微打工人！docker创建容器端口
m0_56530263的博客
07-13 184
二、回顾整理阿里面试题 基本就这样了，还有一些零星的问题想不起来了，答案也整理出来了。 自我介绍 JVM如何加载一个类的过程，双亲委派模型中有哪些方法？ HashMap如何实现的？ HashMap和ConcurrentHashMap区别， Concurrent HashMap 线程安全hashtable吗， ConcurrentHashMap如何保证 线程安全？ HashMap和HashTable 区别，HashTable线程安全吗？ 进程间通信有哪几种方式 JVM分为哪些区，每一个区干吗的？ JVM如
springboot集成kafka手动提交偏移量
最新发布
03-17
手动提交偏移量通常涉及到消费者的配置参数，比如enable.auto.commit设置为false，然后使用不同的提交方式，如同步或异步提交。 接下来，我需要考虑如何具体在代码中实现手动提交。可能涉及到使用AckMode.MANUAL或...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值