Kafka的高级消费者与低级消费者

kafka消费旧高级消费,新高级消费代码 kafak 0.9API 旧高级消费 新高级消费,指定offset消费,并且持续监控offset 立即下载
Kafka的高级消费者与低级消费者

          在Kafka实战章节,我们写的例子都是Kafka的高级消费实例,可以看到在消息消费者的程序中,我们只需要指定zookeeper、及消费群组的groupId即可实现从消息队列中消费消息,屏蔽了大量的底层细节:如消息的偏移量等信息都不在程序中维护。Kafka的高级消费实例,满足以下几点规则:

(1)同一个消费群组中,如果线程数大于Topic分区数,那么一些线程永远接收不到消息;

(2)同一个消费群组中,如果线程数小于Topic分区数,部分线程将从多个分区接收消息;

(3)对于从多个分区接收消息的线程,消费每个分区内的消息是有序的,但消费多个分区之间的消息是无序的;

        明白了Kafka的高级消费实例的过程之后,如果我们想进一步控制一个消费者消费哪个分区怎么办呢?比如多次读取同一个消息。答案是使用低级消费者实例,即在程序中指定Topic的Partition的Leader broker,并在程序中跟踪消息的偏移量offset值。其步骤大致如下:

(1)指定消费Topic Partition的Leader broker及备份broker;

(2)构造并发送请求数据;

(3)处理leader broker的变更;

        实例如下:

[java]  view plain  copy
  1. import kafka.api.FetchRequest;  
  2. import kafka.api.FetchRequestBuilder;  
  3. import kafka.api.PartitionOffsetRequestInfo;  
  4. import kafka.common.ErrorMapping;  
  5. import kafka.common.TopicAndPartition;  
  6. import kafka.javaapi.*;  
  7. import kafka.javaapi.consumer.SimpleConsumer;  
  8. import kafka.message.MessageAndOffset;  
  9.   
  10. import java.nio.ByteBuffer;  
  11. import java.util.ArrayList;  
  12. import java.util.Collections;  
  13. import java.util.HashMap;  
  14. import java.util.List;  
  15. import java.util.Map;  
  16.   
  17. public class SimpleConsumerDemo {  
  18.     private List<String> m_replicaBrokers = new ArrayList<>();  
  19.   
  20.     public SimpleConsumerDemo(){  
  21.         m_replicaBrokers = new ArrayList<>();  
  22.     }  
  23.   
  24.     public void run(long a_maxReads, String a_topic, int a_partition, List<String> a_seedBrokers, int a_port) throws Exception {  
  25.         // find the meta data about the topic and partition we are interested in  
  26.         //  
  27.         PartitionMetadata metadata = findLeader(a_seedBrokers, a_port, a_topic, a_partition);  
  28.         if (metadata == null) {  
  29.             System.out.println("Can't find metadata for Topic and Partition. Exiting");  
  30.             return;  
  31.         }  
  32.         if (metadata.leader() == null) {  
  33.             System.out.println("Can't find Leader for Topic and Partition. Exiting");  
  34.             return;  
  35.         }  
  36.         String leadBroker = metadata.leader().host();  
  37.         String clientName = "Client_" + a_topic + "_" + a_partition;  
  38.   
  39.         SimpleConsumer consumer = new SimpleConsumer(leadBroker, a_port, 100000, 64 * 1024, clientName);  
  40.         long readOffset = getLastOffset(consumer,a_topic, a_partition, kafka.api.OffsetRequest.EarliestTime(), clientName);  
  41.   
  42.         int numErrors = 0;  
  43.         while (a_maxReads > 0) {  
  44.             if (consumer == null) {  
  45.                 consumer = new SimpleConsumer(leadBroker, a_port, 100000, 64 * 1024, clientName);  
  46.             }  
  47.             FetchRequest req = new FetchRequestBuilder()  
  48.                     .clientId(clientName)  
  49.                     .addFetch(a_topic, a_partition, readOffset, 100000) // Note: this fetchSize of 100000 might need to be increased if large batches are written to Kafka  
  50.                     .build();  
  51.             FetchResponse fetchResponse = consumer.fetch(req);  
  52.   
  53.             if (fetchResponse.hasError()) {  
  54.                 numErrors++;  
  55.                 // Something went wrong!  
  56.                 short code = fetchResponse.errorCode(a_topic, a_partition);  
  57.                 System.out.println("Error fetching data from the Broker:" + leadBroker + " Reason: " + code);  
  58.                 if (numErrors > 5) break;  
  59.                 if (code == ErrorMapping.OffsetOutOfRangeCode())  {  
  60.                     // We asked for an invalid offset. For simple case ask for the last element to reset  
  61.                     readOffset = getLastOffset(consumer,a_topic, a_partition, kafka.api.OffsetRequest.LatestTime(), clientName);  
  62.                     continue;  
  63.                 }  
  64.                 consumer.close();  
  65.                 consumer = null;  
  66.                 leadBroker = findNewLeader(leadBroker, a_topic, a_partition, a_port);  
  67.                 continue;  
  68.             }  
  69.             numErrors = 0;  
  70.   
  71.             long numRead = 0;  
  72.             for (MessageAndOffset messageAndOffset : fetchResponse.messageSet(a_topic, a_partition)) {  
  73.                 long currentOffset = messageAndOffset.offset();  
  74.                 if (currentOffset < readOffset) {  
  75.                     System.out.println("Found an old offset: " + currentOffset + " Expecting: " + readOffset);  
  76.                     continue;  
  77.                 }  
  78.                 readOffset = messageAndOffset.nextOffset();  
  79.                 ByteBuffer payload = messageAndOffset.message().payload();  
  80.   
  81.                 byte[] bytes = new byte[payload.limit()];  
  82.                 payload.get(bytes);  
  83.                 System.out.println(String.valueOf(messageAndOffset.offset()) + ": " + new String(bytes, "UTF-8"));  
  84.                 numRead++;  
  85.                 a_maxReads--;  
  86.             }  
  87.   
  88.             if (numRead == 0) {  
  89.                 try {  
  90.                     Thread.sleep(1000);  
  91.                 } catch (InterruptedException ie) {  
  92.                 }  
  93.             }  
  94.         }  
  95.         if (consumer != null) consumer.close();  
  96.     }  
  97.   
  98.     public static long getLastOffset(SimpleConsumer consumer, String topic, int partition,  
  99.                                      long whichTime, String clientName) {  
  100.         TopicAndPartition topicAndPartition = new TopicAndPartition(topic, partition);  
  101.         Map<TopicAndPartition, PartitionOffsetRequestInfo> requestInfo = new HashMap<TopicAndPartition, PartitionOffsetRequestInfo>();  
  102.         requestInfo.put(topicAndPartition, new PartitionOffsetRequestInfo(whichTime, 1));  
  103.         kafka.javaapi.OffsetRequest request = new kafka.javaapi.OffsetRequest(  
  104.                 requestInfo, kafka.api.OffsetRequest.CurrentVersion(), clientName);  
  105.         OffsetResponse response = consumer.getOffsetsBefore(request);  
  106.   
  107.         if (response.hasError()) {  
  108.             System.out.println("Error fetching data Offset Data the Broker. Reason: " + response.errorCode(topic, partition) );  
  109.             return 0;  
  110.         }  
  111.         long[] offsets = response.offsets(topic, partition);  
  112.         return offsets[0];  
  113.     }  
  114.   
  115.     private String findNewLeader(String a_oldLeader, String a_topic, int a_partition, int a_port) throws Exception {  
  116.         for (int i = 0; i < 3; i++) {  
  117.             boolean goToSleep = false;  
  118.             PartitionMetadata metadata = findLeader(m_replicaBrokers, a_port, a_topic, a_partition);  
  119.             if (metadata == null) {  
  120.                 goToSleep = true;  
  121.             } else if (metadata.leader() == null) {  
  122.                 goToSleep = true;  
  123.             } else if (a_oldLeader.equalsIgnoreCase(metadata.leader().host()) && i == 0) {  
  124.                 // first time through if the leader hasn't changed give ZooKeeper a second to recover  
  125.                 // second time, assume the broker did recover before failover, or it was a non-Broker issue  
  126.                 //  
  127.                 goToSleep = true;  
  128.             } else {  
  129.                 return metadata.leader().host();  
  130.             }  
  131.             if (goToSleep) {  
  132.                 try {  
  133.                     Thread.sleep(1000);  
  134.                 } catch (InterruptedException ie) {  
  135.                 }  
  136.             }  
  137.         }  
  138.         System.out.println("Unable to find new leader after Broker failure. Exiting");  
  139.         throw new Exception("Unable to find new leader after Broker failure. Exiting");  
  140.     }  
  141.   
  142.     private PartitionMetadata findLeader(List<String> a_seedBrokers, int a_port, String a_topic, int a_partition) {  
  143.         PartitionMetadata returnMetaData = null;  
  144.         loop:  
  145.         for (String seed : a_seedBrokers) {  
  146.             SimpleConsumer consumer = null;  
  147.             try {  
  148.                 consumer = new SimpleConsumer(seed, a_port, 100000, 64 * 1024, "leaderLookup");  
  149.                 List<String> topics = Collections.singletonList(a_topic);  
  150.                 TopicMetadataRequest req = new TopicMetadataRequest(topics);  
  151.                 kafka.javaapi.TopicMetadataResponse resp = consumer.send(req);  
  152.   
  153.                 List<TopicMetadata> metaData = resp.topicsMetadata();  
  154.                 for (TopicMetadata item : metaData) {  
  155.                     for (PartitionMetadata part : item.partitionsMetadata()) {  
  156.                         if (part.partitionId() == a_partition) {  
  157.                             returnMetaData = part;  
  158.                             break loop;  
  159.                         }  
  160.                     }  
  161.                 }  
  162.             } catch (Exception e) {  
  163.                 System.out.println("Error communicating with Broker [" + seed + "] to find Leader for [" + a_topic  
  164.                         + ", " + a_partition + "] Reason: " + e);  
  165.             } finally {  
  166.                 if (consumer != null) consumer.close();  
  167.             }  
  168.         }  
  169.         if (returnMetaData != null) {  
  170.             m_replicaBrokers.clear();  
  171.             for (kafka.cluster.Broker replica : returnMetaData.replicas()) {  
  172.                 m_replicaBrokers.add(replica.host());  
  173.             }  
  174.         }  
  175.         return returnMetaData;  
  176.     }  
  177.   
  178.     public static void main(String args[]) {  
  179.         SimpleConsumerDemo example = new SimpleConsumerDemo();  
  180.         long maxReads = Long.parseLong(args[0]);  
  181.         String topic = args[1];  
  182.         int partition = Integer.parseInt(args[2]);  
  183.         List<String> seeds = new ArrayList<>();  
  184.         seeds.add(args[3]);  
  185.         int port = Integer.parseInt(args[4]);  
  186.         try {  
  187.             example.run(maxReads, topic, partition, seeds, port);  
  188.         } catch (Exception e) {  
  189.             System.out.println("Oops:" + e);  
  190.             e.printStackTrace();  
  191.         }  
  192.     }  
  193. }  

参考资料:

1、https://cwiki.apache.org/confluence/display/KAFKA/Index

2、http://www.nohup.cc/article/195/

3、http://blog.youkuaiyun.com/honglei915/article/details/37563647

4、http://orchome.com/11

配置Kafka生产者与消费者所需jar包_高版本 Kafka是一种高吞吐量的分布式发布订阅消息系统,通过生产者与消费者进行消息传递。 包里包括:kafka_2.11-0.11.0.0.jar、kafka-clients-0.11.0.0.jar、scala-library-2.11.1.jar(最后一个是关联jar) 注:0.11以后版本与0.9以下版本服务器不匹配,请下载适合的jar包。 立即下载

相关推荐

kafka生产者和消费者的javaAPI的示例代码

主要介绍了kafka生产者和消费者的javaAPI的示例代码,小编觉得挺不错的,现在分享给大家,也给大家做个参考。一起跟随小编过来看看吧

kafka Streams

1. Kafka 高级消费者 高阶消费者是一把双刃剑,一方面简化了编程,一方面也由于编程者参与的功能过少, 可控内容过少而造成很多问题。 (1) 自动负载均衡 高阶消费者为了简化编程,封装了一系列 API,这套 API 会均匀地将分区分配给消费者 线程,消费者消费哪个分区不由消费者决定,而是由高阶 API 决定,如果有消费者线程挂 掉了,高阶 API 会检测到,进而进行重新分...

程序员学习圈 2034

ModelSim 2020.4破解失败?手把手教你解决‘Unable to checkout viewer license‘报错(附环境变量配置)

本文针对ModelSim 2020.4启动时遇到的‘Unable to checkout viewer license’报错,提供了从理解许可证机制到分步修复的完整指南。文章深入解析了viewer license与图形用户界面(GUI)的关系,并详细说明了通过生成有效许可证文件、精准配置系统环境变量及替换关键文件来解决图形界面启动失败的问题,帮助用户彻底修复并理解其背后的逻辑。

k6l7m8n9的博客 1003

Kafka消费者的偏移量和高级/简单消费者

Kafka消费者的偏移量和高级/简单消费者 提交和偏移量 提交:更新分区的当前位置称为提交,当前版本(0.10.1.1)用topic ___consumer_offsets 保存提交的偏移量 偏移量:消费者在Kafka追踪到消息在分区里的位置 消费者在崩溃或者有新的消费者加入群组,就会触发再均衡。这是需要读取最后一次偏移量,然后从偏移量指定的地方继续处理。提交的偏移量小于真实的偏移量,消息...

jyj019的博客 4840

iOS 取证窍门:为什么要先从 Recovery 恢复模式开始?

未记录的 DFU 代表“设备固件升级”。与专为普通用户设计的恢复模式不同,DFU 模式从来都不是为公众设计的。Apple 知识库中的任何地方都没有关于 DFU 的文档。进入 DFU 的方法主要是通过按下、按住和释放按钮的复杂操作序列,并具有精确的时间限制。在多个步骤中的任何一个步骤中,如果时间错误,都会导致重新启动设备,而不是将其切换到 DFU。另外,设备屏幕上也没有 DFU 模式的指示。如果设备成功切换到 DFU,显示屏将保持黑色。即使对于专家来说,进入 DFU 模式也可能很困难。恢复模式是最容易解释的。

2302_82041293的博客 1198

主流 AI 插件 之一的 Copilot 介绍

Copilot 是微软推出的一款人工智能助手,旨在通过自然语言交互帮助您提升工作效率和创造力,覆盖多平台,提供智能问答、内容生成、代码辅助等功能。其核心定位为“日常 AI 伴侣”,旨在通过自然语言交互提升工作与生活效率。

u014695938的博客 6938

Kafka技术内幕:消费者(高级和低级API)和 协调者

概述生产者发送消息时在客户端就按照节点和Partition进行分组,属于同一个目标节点的多个Partition会作为同一个请求传送到服务端,作为目标节点的服务端也可以处理来自不同生产者客户端的请求。如果从网络层通信来看,客户端和服务端都会使用队列的方式确保顺序地客户端发送请求,服务端接收请求,服务端发送响应,客户端接收响应。从存储层来看,生产者会将消息分发到不同节点的不同Partition上,服务...

lvlei19911108的博客 195

5.4 GTT BO的内存分配分析

本文分析了AMD GPU驱动中的GTT技术实现。GTT作为GPU页表,负责管理主机内存与GPU虚拟地址的映射,支持大容量内存访问和统一寻址。文章详细介绍了GTT的核心数据结构amdgpu_gtt_mgr、初始化流程,以及BO(Buffer Object)创建时GTT区间的分配与释放机制。GTT管理通过TTM框架实现分层设计,提供内存统计、兼容性检查等接口,并支持动态迁移、多进程隔离等高级特性。该机制为AMD GPU提供了高效灵活的内存管理基础。

图形/计算GPU的驱动与虚拟化技术分享园地 3741

Kafka工作流程-高级消费者和低级消费者

版权声明:本文为博主原创文章,遵循 CC 4.0 BY-SA 版权协议,转载请附上原文出处链接和本声明。 本文链接:https://blog.youkuaiyun.com/Luomingkui1109/article/details/82784695 1. Kafka 高级消费者 高阶消费者是一把双刃剑,一方面简化了编程,一方面也由于编程者参与的功能过少, 可控内容过少而造成很多问题。 (1) 自...

moliyiran的专栏 1068

动力学约束下的运动规划算法——Kinodynamic RRT*算法

动力学约束下的运动规划算法——Kinodynamic RRT*算法

慕羽★的博客 6755

YOLOv8 智能交通违章检测 - 机动车道占用(违停/非机动车占道)详解

本文提出基于YOLOv8的智能交通违章检测方案,主要针对机动车道占用问题。系统整合目标检测、目标跟踪和ROI区域判定,实现两种典型场景检测:违章停车(静止超时)和非机动车/行人占道。详细介绍了系统架构、配置文件设计、核心逻辑实现及可视化模块,包括ROI区域管理、状态跟踪和违章判定算法。针对实际应用中的堵车误判、非机动车误报等问题,提出了密度检测、轨迹分析和自适应阈值等优化策略。该方案计算量适中,适合边缘设备部署,并建议配套开发ROI标定工具和证据链保存功能。

u010117029的博客 238

Kafka高级API和低级API

Kafka消费过程分析 kafka提供了两套consumer API:高级Consumer API和低级API。 1高级API 1)高级API优点 高级API写起来简单 不需要去自行去管理offset,系统通过zookeeper自行管理 不需要管理分区,副本等情况,系统自动管理 消费者断线会自动根据上一次记录在zookeeper中的offset去接着获取数据(默认设置1分钟更新一下zookeeper中存的的offset) 可以使用group来区分对同一个topic的不同程序访问分...

u011250186的博客 1007

把 sy-* 带进 ABAP CDS:ABAP 7.50 里的环境信息新姿势($session 与 @Environment.systemField 实战)

摘要:ABAP 7.50在CDS视图中引入两种获取环境信息的方式:1)直接使用$session会话变量读取用户、客户端和系统语言;2)通过@Environment.systemField注解参数,由Open SQL自动注入系统字段。$session方式简单但依赖Open SQL访问路径,非ABAP环境下可能失效;注解参数方案更工程化,依赖关系明确且支持测试。建议ABAP体系内优先使用$session,对外接口采用参数化方案。两种方式各有适用场景,正确选择可避免潜在风险。(148字)

2007 年 ~ 2025 年,深耕 SAP 技术 18 年 156

Kafka快速入门系列(8) | Kafka的消费过程分析

  本篇博主带来的是producer(生产者)的数据可靠性保证。 目录1. 高级API1.高级API优点2.高级API缺点1. 低级API1.低级 API 优点2.低级API缺点3. 消费者组4. 消费方式5. 分区分配策略1. roundrobin2. range   kafka提供了两套consumer API:高级Consumer API和低级Consumer API。 1. 高级API ...

不温卜火 6559

流程图详解Transformer最核心的多头注意力机制,QKV流向清晰明了

本文详细讲解了Transformer模型中的多头注意力机制(Multi-head Attention)。通过类比多人评估同一事物的不同视角,说明多头机制能综合多个注意力权重获得更有效的输出。文章逐步推导了多头注意力的计算过程:将输入矩阵X(4×512维)分别与8组Q、K、V权重矩阵相乘,得到8组head(每组4×64维),拼接后经Wo矩阵变换恢复为4×512维输出。整个过程涉及37个待训练参数矩阵(1个Wo、8组Wq/Wk/Wv)。该机制通过并行计算多个注意力头,能更全面捕捉输入特征间的复杂关系。

人工智能研究所的博客 267

WINCC7.3破解文件

WINCC7.3硬件够破解文件,有需要的下载!WINCC7.3硬件够破解文件,有需要的下载!

Kafka消费者详解

Kafka采用消费组保证了“一个分区只可被消费组中的一个消费者所消费” 消费者组再平衡实现故障容错 一旦有消费者加入或退出消费组,导致消费组成员列表发生变化,消费组中所有的消费者就要执行再平衡(rebalance) 工作。如果订阅主题的分区有变化,所有的消费者也都要再平衡。 由于消费者消费消息的最小单元是分区,因此每个分区都应该记录消费进度,而且消费进度应该面向消费组级别。 消费者除了需...

qq_43193797的博客 946

大中型超市收银系统(可直接运行)

光步前台收银系统系统功能:商品销售、商品退货、挂单、收银员权限、会员销售、单品取消、整单取消、商品查询、脱机销售、脱机数据上传,基本资料下载,开钱箱、小票打印、收款结算,支持多币种付款方式(现金、储值卡、礼券、微信等),支持多种促销。运行环境:.net 4.0登陆信息用户名:1001 密码:123456内置商品信息,商品编码可输入00001000 - 00010000,测试效果相关功能键F5 结算 F9挂单 F11商品查询 F8退货 Insert单品取消 Del整单取消 F12开钱箱F2 会员 Ctrl+Z退出系统 Home 锁屏 相关源码待公开

source - kafka 高级API和低级API

高级 API produce package com.sinoiov.kafka.test; import kafka.javaapi.producer.Producer; import kafka.producer.KeyedMessage; import kafka.producer.ProducerConfig; import kafka.serializer.StringEn...

tianyeshiye 610

Outlook Express 6 (OE6) for Win7/Win8/Win10

英文版 Outlook Express6.0, 兼容Win7/Win10/WinXP,解压就可用。

C# WinForm 基于DirectShow.dll编写的程序,可边预览边保存视频,音频和图片

基于微软的DirectShow.dll的二次开发1.自动识别连接的摄像头跟麦克风且可以对其进行选择(默认选中第一个)2.可录制wmv和avi两种格式的视频并且都带有音频,avi可以录制的分辨率和帧数进行选择,wmv默认进行了淸晰度优化如不喜欢可去除代码中有相关提示3.可在预览点开之后进行拍照,也可边录制视频边拍照4.添加了视频和音频的压缩功能(酌情使用)这次二次开发发现C#对DirectShow的相关信息太少,这次做完也不敢藏私共享出来,还望大家指正

kafka 高级API和低级API

高级 API produce package com.sinoiov.kafka.test; import kafka.javaapi.producer.Producer; import kafka.producer.KeyedMessage; import kafka.producer.ProducerConfig; import kafka.serializer.StringEnc

摩西YF拉比 7201

消息队列之Kafka 消费过程分析(五)

1.1Kafka消费过程分析 kafka提供了两套consumer API:高级Consumer API和低级API。 1.1.1 消费模型 消息由生产者发布到Kafka集群后,会被消费者消费。消息的消费模型有两种:推送模型(push)和拉取模型(pull)。 基于推送模型(push)的消息系统,由消息代理记录消费者的消费状态。消息代理在将消息推送到消费者后,标记这条消息为已消费,但这种方式无法很好地保证消息被处理。比如,消息代理把消息发送出去后,当消费进程挂掉或者由于网络原因没有收到这条消息时,就有可能造

鱼的博客 578

kafka 二 集群架构 幂等性 生产者写入分区策略、消费者组再均衡消费者规则、副本机制、低级 api、高级 api、Kafka-eagl监控工具、分区的leader 与follower

【kafka可视化工具】kafka-eagle在windows环境的下载、安装、启动与访问_kafka eagle下载_No8g攻城狮的博客-优快云博客。如果ack响应失败,生产者重试,再次发送消息,kafka会根据pid和 sequence number 是否保存同一条消息。0、1、2 节点 三个 副本 0挂掉 0的领导会在 1 or 2 上马上出现领导,实现保证分区全在。生产者 发送到分区,kafka 保存到分区,返回一个ack ,若果失败,生产者会重新发送。

银河系天城知识宝库_技术专家蒋浩宇 528

kafka工作流程分析-消费过程分析

Kafka 消费过程分析 kafka 提供了两套 consumer API:高级 Consumer API 和低级 API。 3.3.1 高级 API 1)高级 API 优点高级 API 写起来简单 不需要自行去管理 offset,系统通过 zookeeper 自行管理。 不需要管理分区,副本等情况,.系统自动管理。 消费者断线会自动根据上一次记录在 zookeeper 中的 offset 去接着获取数据(默认设置1 分钟更新一下 zookeeper 中存offset) 可以使用 group 来区分对同一个

小哇 724

简单搞定Kafka:消费过程分析

高级API 1)高级API优点 高级API 写起来简单 不需要去自行去管理offset,系统通过zookeeper自行管理 不需要管理分区,副本等情况,系统自动管理 消费者断线会自动根据上一次记录在zookeeper中的offset去接着获取数据(默认设置1分钟更新一下zookeeper中存的的offset) 可以使用group来区分对同一个topic 的不同程序访问分离开来(不同的group记录不同的offset,这样不同程序读取同一个topic才不会因为offset互相影响) 2)高级AP

github_36444580的博客 224
上一篇: Kafka使用进阶——消费者
下一篇: kafka消费者低级实例
王树民
博客等级 码龄10年 912粉丝 560原创
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明:

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

余额充值