Kafka API的运用（Producer API）

最新推荐文章于 2022-01-28 14:56:40 发布
最新推荐文章于 2022-01-28 14:56:40 发布
阅读量384 收藏
点赞数
分类专栏： kafka 文章标签： kafka 大数据
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_48067943/article/details/108228557
版权

文章目录

四、Kafka API

1、Producer API

1.1 消息发送流程
  • Kafka 的 Producer 发送消息采用的是异步发送的方式。在消息发送的过程中，涉及到了两个线程——main线程和Sender线程，以及一个线程共享变量——RecordAccumulator。main 线程将消息发送给 RecordAccumulator，Sender 线程不断从 RecordAccumulator 中拉取消息发送到 Kafka broker。

在这里插入图片描述

在这里插入图片描述

顺序：监控器 —> 序列化器 —> 分区器

相关参数：

  • batch.size：只有数据积累到 batch.size 之后，sender 才会发送数据。
  • linger.ms：如果数据迟迟未达到 batch.size，sender 等待 linger.time 之后就会发送数据。
1.2 异步发送 API

1）导入依赖

<dependencies>
        <dependency>
            <groupId>org.apache.kafka</groupId>
            <artifactId>kafka-clients</artifactId>
            <version>2.4.1</version>
        </dependency>
        <dependency>
            <groupId>org.apache.logging.log4j</groupId>
            <artifactId>log4j-slf4j-impl</artifactId>
            <version>2.12.0</version>
        </dependency>
</dependencies>

2）添加log4j2配置文件（用于打印日志）

<?xml version="1.0" encoding="UTF-8"?>
<Configuration status="error" strict="true" name="XMLConfig">
    <Appenders>
        <!-- 类型名为Console，名称为必须属性 -->
        <Appender type="Console" name="STDOUT">
            <!-- 布局为PatternLayout的方式，
            输出样式为[INFO] [2018-01-22 17:34:01][org.test.Console]I'm here -->
            <Layout type="PatternLayout"
                    pattern="[%p] [%d{yyyy-MM-dd HH:mm:ss}][%c{10}]%m%n" />
        </Appender>

    </Appenders>

    <Loggers>
        <!-- 可加性为false -->
        <Logger name="test" level="info" additivity="false">
            <AppenderRef ref="STDOUT" />
        </Logger>

        <!-- root loggerConfig设置 -->
        <Root level="info">
            <AppenderRef ref="STDOUT" />
        </Root>
    </Loggers>

</Configuration>

3）编写代码

需要用到的类：

KafkaProducer：需要创建一个生产者对象，用来发送数据

ProducerConfig：获取所需的一系列配置参数

ProducerRecord：每条数据都要封装成一个ProducerRecord对象

  • kafka生产者的api最简单版本
public class MyProducer{
    public static void main(String[] args) {
        Properties properties = new Properties();
        properties.put("bootstrap.servers","hadoop105:9092");
        properties.put("key.serializer","org.apache.kafka.common.serialization.StringSerializer");
        properties.put("value.serializer","org.apache.kafka.common.serialization.StringSerializer");
        KafkaProducer<String, String> producer = new KafkaProducer<String,String>(properties);
        for (int i = 0; i < 10; i++) {
            producer.send(new ProducerRecord<String, String>("bajie", "--gaolaozhuangshuiyundong--" + i));

        }
        producer.close();

    }
}

[xiaoxq@hadoop105 kafka_2.11-2.4.1]$ bin/kafka-console-consumer.sh --bootstrap-server hadoop105:9092 --topic bajie
--gaolaozhuangshuiyundong--0
--gaolaozhuangshuiyundong--1
--gaolaozhuangshuiyundong--2
--gaolaozhuangshuiyundong--3
--gaolaozhuangshuiyundong--4
--gaolaozhuangshuiyundong--5
--gaolaozhuangshuiyundong--6
--gaolaozhuangshuiyundong--7
--gaolaozhuangshuiyundong--8
--gaolaozhuangshuiyundong--9

（1）不带回调函数的API

public class MyProducer2 {
    public static void main(String[] args) {
        //todo 创建生产者的配置对象
        Properties properties = new Properties();
        //1.设定集群
        properties.put(ProducerConfig.BOOTSTRAP_SERVERS_CONFIG,"hadoop105:9092");
        //2.设定ack等级
        properties.put(ProducerConfig.ACKS_CONFIG,"all");
        //3.设定重试的次数
        properties.put(ProducerConfig.RETRIES_CONFIG,"2");
        //4.设定batch的大小
        properties.put(ProducerConfig.BATCH_SIZE_CONFIG,"16384");
        //5.设定间隔时间
        properties.put(ProducerConfig.LINGER_MS_CONFIG,1);
        //6.设定缓冲区大小
        properties.put(ProducerConfig.BUFFER_MEMORY_CONFIG,"33554432");
        //7.设定key和value的序列化方式
        properties.put(ProducerConfig.KEY_SERIALIZER_CLASS_CONFIG,"org.apache.kafka.common.serialization.StringSerializer");
        properties.put(ProducerConfig.VALUE_SERIALIZER_CLASS_CONFIG,"org.apache.kafka.common.serialization.StringSerializer");
        //todo 创建生产者的对象
        KafkaProducer<String, String> producer = new KafkaProducer<>(properties);
        //发送数据
        for (int i = 0; i < 10; i++) {
            producer.send(new ProducerRecord<String, String>("bajie","gaolaozhuang---" + i));
        }
        //TODO 关闭生产者对象
        producer.close();
    }
}

[xiaoxq@hadoop105 kafka_2.11-2.4.1]$ bin/kafka-console-consumer.sh --bootstrap-server hadoop105:9092 --topic bajie

gaolaozhuang---0
gaolaozhuang---1
gaolaozhuang---2
gaolaozhuang---3
gaolaozhuang---4
gaolaozhuang---5
gaolaozhuang---6
gaolaozhuang---7
gaolaozhuang---8
gaolaozhuang---9

（2）带回调函数的API

  • 回调函数会在 producer 收到 ack 时调用，为异步调用，该方法有两个参数，分别是RecordMetadata和Exception，如果Exception为null，说明消息发送成功，如果Exception不为null，说明消息发送失败。
  • 注意：消息发送失败会自动重试，不需要我们在回调函数中手动重试。
public class MyProducer3 {
    public static void main(String[] args) {
        //todo 创建生产者的配置对象
        Properties properties = new Properties();
        //1.设定集群,broker-list
        properties.put(ProducerConfig.BOOTSTRAP_SERVERS_CONFIG,"hadoop105:9092");
        //2.设定ack等级
        properties.put(ProducerConfig.ACKS_CONFIG,"all");
        //3.设定重试的次数
        properties.put(ProducerConfig.RETRIES_CONFIG,"2");
        //4.设定batch的大小 16kb
        properties.put(ProducerConfig.BATCH_SIZE_CONFIG,"16384");
        //5.设定间隔时间 1ms
        properties.put(ProducerConfig.LINGER_MS_CONFIG,1);
        //6.设定缓冲区大小 32M
        properties.put(ProducerConfig.BUFFER_MEMORY_CONFIG,"33554432");
        //7.设定key和value的序列化方式
        properties.put(ProducerConfig.KEY_SERIALIZER_CLASS_CONFIG,"org.apache.kafka.common.serialization.StringSerializer");
        properties.put(ProducerConfig.VALUE_SERIALIZER_CLASS_CONFIG,"org.apache.kafka.common.serialization.StringSerializer");
        //todo 创建生产者的对象
        KafkaProducer<String, String> producer = new KafkaProducer<>(properties);
        //发送数据
        for (int i = 0; i < 10; i++) {
            //采用生产者对象发送数据
            producer.send(new ProducerRecord<String, String>("bajie","er shi xiong shi fu bei yao guai zhua zou le---" + i),new Callback() {

                @Override
                //这个回调函数 在ack正常返回的时候是返回metadata,如果不正常返回则返回异常
                public void onCompletion(RecordMetadata recordMetadata, Exception e) {
                    if (e==null){
                        System.out.println("topic:" + recordMetadata.topic()
                                            + "--partition:" + recordMetadata.partition()
                                            + "--offset:" + recordMetadata.offset() );
                    }
                }
            });


        }

        //TODO 关闭生产者对象
        //这个close会在关闭前将所有数据处理完再退出生产者.
        producer.close();
    }
}

控制台显示

topic:bajie--partition:1--offset:10
topic:bajie--partition:1--offset:11
topic:bajie--partition:1--offset:12
topic:bajie--partition:1--offset:13
topic:bajie--partition:1--offset:14
topic:bajie--partition:1--offset:15
topic:bajie--partition:1--offset:16
topic:bajie--partition:1--offset:17
topic:bajie--partition:1--offset:18
topic:bajie--partition:1--offset:19

主题中添加的内容

er shi xiong shi fu bei yao guai zhua zou le---0
er shi xiong shi fu bei yao guai zhua zou le---1
er shi xiong shi fu bei yao guai zhua zou le---2
er shi xiong shi fu bei yao guai zhua zou le---3
er shi xiong shi fu bei yao guai zhua zou le---4
er shi xiong shi fu bei yao guai zhua zou le---5
er shi xiong shi fu bei yao guai zhua zou le---6
er shi xiong shi fu bei yao guai zhua zou le---7
er shi xiong shi fu bei yao guai zhua zou le---8
er shi xiong shi fu bei yao guai zhua zou le---9
1.3 分区器

1） 默认的分区器 DefaultPartitioner

  • interceptors拦截器过滤 —–> serializer序列化器进行序列化方便数据的传输 —–> partitions分区

DefaultPartitioner分区实现：

  • 当指定了key，则采用固定的算法，每次都会计算出同一分区号，如果key不存在则计算出一个可用分区的的一个任意分区

2）自定义分区器

public class MyPartitioner implements Partitioner {
    @Override
    /**
     * 主要写分区逻辑
     * 有bajie 的就往0号分区
     * 没有bajie 的就往1号分区
     */
    public int partition(String s, Object o, byte[] bytes, Object o1, byte[] bytes1, Cluster cluster) {

        if (new String(bytes1).contains("bajie")){
            return 0;
        }else {
            return 1;
        }
    }
    @Override
    public void close() {

    }
    @Override
    public void configure(Map<String, ?> map) {

    }
}

编写partitionerProducer

public class PartitionerProducer {
    public static void main(String[] args) {
        //todo 创建生产者的配置对象
        Properties properties = new Properties();
        //1.设定集群,broker-list
        properties.put(ProducerConfig.BOOTSTRAP_SERVERS_CONFIG,"hadoop105:9092");
        //2.设定ack等级
        properties.put(ProducerConfig.ACKS_CONFIG,"all");
        //3.设定重试的次数
        properties.put(ProducerConfig.RETRIES_CONFIG,"2");
        //4.设定batch的大小 16kb
        properties.put(ProducerConfig.BATCH_SIZE_CONFIG,"16384");
        //5.设定间隔时间 1ms
        properties.put(ProducerConfig.LINGER_MS_CONFIG,1);
        //6.设定缓冲区大小 32M
        properties.put(ProducerConfig.BUFFER_MEMORY_CONFIG,"33554432");
        //7.设定分区器
        properties.put(ProducerConfig.PARTITIONER_CLASS_CONFIG,"partitioner.MyPartitioner");

        //8.设定key和value的序列化方式
        properties.put(ProducerConfig.KEY_SERIALIZER_CLASS_CONFIG,"org.apache.kafka.common.serialization.StringSerializer");
        properties.put(ProducerConfig.VALUE_SERIALIZER_CLASS_CONFIG,"org.apache.kafka.common.serialization.StringSerializer");
        //todo 创建生产者的对象
        KafkaProducer<String, String> producer = new KafkaProducer<>(properties);
        //发送数据
        for (int i = 0; i < 10; i++) {
            //采用生产者对象发送数据
            if (i<5){
                producer.send(new ProducerRecord<String, String>("bajie","er shi xiong shi bajie ---" + i),new Callback() {

                    @Override
                    //这个回调函数 在ack正常返回的时候是返回 metadata,如果不正常返回则返回异常
                    public void onCompletion(RecordMetadata recordMetadata, Exception e) {
                        if (e==null){
                            System.out.println("topic:" + recordMetadata.topic()
                                    + "--partition:" + recordMetadata.partition()
                                    + "--offset:" + recordMetadata.offset() );
                        }
                    }
                });
            }else{
                producer.send(new ProducerRecord<String, String>("bajie","da shi xiong shi wu kong ---" + i),new Callback() {

                    @Override
                    //这个回调函数 在ack正常返回的时候是返回 metadata,如果不正常返回则返回异常
                    public void onCompletion(RecordMetadata recordMetadata, Exception e) {
                        if (e==null){
                            System.out.println("topic:" + recordMetadata.topic()
                                    + "--partition:" + recordMetadata.partition()
                                    + "--offset:" + recordMetadata.offset() );
                        }
                    }
                });
            }
        }

        //TODO 关闭生产者对象
        //这个close会在关闭前将所有数据处理完再退出生产者.
        producer.close();
    }
}

执行后结果为

topic:bajie--partition:1--offset:25
topic:bajie--partition:1--offset:26
topic:bajie--partition:1--offset:27
topic:bajie--partition:1--offset:28
topic:bajie--partition:1--offset:29
topic:bajie--partition:0--offset:14
topic:bajie--partition:0--offset:15
topic:bajie--partition:0--offset:16
topic:bajie--partition:0--offset:17
topic:bajie--partition:0--offset:18
1.4 同步发送 API
  • 同步发送的意思就是，一条消息发送之后，会阻塞当前线程，直至返回ack。
  • 由于 send 方法返回的是一个 Future 对象，根据 Futrue 对象的特点，我们也可以实现同步发送的效果，只需在调用 Future 对象的 get 方法即可。

编写SyncProducer

public class SyncProducer {
    public static void main(String[] args) throws ExecutionException, InterruptedException {
        //todo 创建生产者的配置对象
        Properties properties = new Properties();
        //1.设定集群,broker-list
        properties.put(ProducerConfig.BOOTSTRAP_SERVERS_CONFIG,"hadoop105:9092");
        //2.设定ack等级
        properties.put(ProducerConfig.ACKS_CONFIG,"all");
        //3.设定重试的次数
        properties.put(ProducerConfig.RETRIES_CONFIG,"2");
        //4.设定batch的大小 16kb
        properties.put(ProducerConfig.BATCH_SIZE_CONFIG,"16384");
        //5.设定间隔时间 1ms
        properties.put(ProducerConfig.LINGER_MS_CONFIG,1);
        //6.设定缓冲区大小 32M
        properties.put(ProducerConfig.BUFFER_MEMORY_CONFIG,"33554432");
        //7.设定key和value的序列化方式
        properties.put(ProducerConfig.KEY_SERIALIZER_CLASS_CONFIG,"org.apache.kafka.common.serialization.StringSerializer");
        properties.put(ProducerConfig.VALUE_SERIALIZER_CLASS_CONFIG,"org.apache.kafka.common.serialization.StringSerializer");
        //todo 创建生产者的对象
        KafkaProducer<String, String> producer = new KafkaProducer<>(properties);
        //发送数据
        for (int i = 0; i < 10; i++) {
            //采用生产者对象发送数据
            Future<RecordMetadata> future = producer.send(new ProducerRecord<String, String>("bajie", "er shi xiong shi bajie ---" + i), new Callback() {

                @Override
                //这个回调函数 在ack正常返回的时候是返回 metadata,如果不正常返回则返回异常
                public void onCompletion(RecordMetadata recordMetadata, Exception e) {
                    if (e == null) {
                        System.out.println("topic:" + recordMetadata.topic()
                                + "--partition:" + recordMetadata.partition()
                                + "--offset:" + recordMetadata.offset());
                    }
                }
            });
            //System.out.println("消息已经发送了");
            future.get();
        }

        //TODO 关闭生产者对象
        //这个close会在关闭前将所有数据处理完再退出生产者.
        producer.close();
    }
}

执行后结果

opic:bajie--partition:0--offset:34
topic:bajie--partition:1--offset:35
topic:bajie--partition:0--offset:35
topic:bajie--partition:1--offset:36
topic:bajie--partition:0--offset:36
topic:bajie--partition:1--offset:37
topic:bajie--partition:0--offset:37
topic:bajie--partition:1--offset:38
topic:bajie--partition:0--offset:38
topic:bajie--partition:1--offset:39

当 //System.out.println("消息已经发送了");注释打开后执行结果
消息已经发送了
topic:bajie--partition:0--offset:39
消息已经发送了
topic:bajie--partition:1--offset:40
消息已经发送了
topic:bajie--partition:0--offset:40
消息已经发送了
topic:bajie--partition:1--offset:41
消息已经发送了
topic:bajie--partition:0--offset:41
消息已经发送了
topic:bajie--partition:1--offset:42
消息已经发送了
topic:bajie--partition:0--offset:42
消息已经发送了
topic:bajie--partition:1--offset:43
消息已经发送了
topic:bajie--partition:0--offset:43
消息已经发送了
topic:bajie--partition:1--offset:44
TANCHISE
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
四十五、Kafka生产者（Producer）API介绍
象在舞的技术专栏
03-05 2095
前几篇文章我们主要介绍了一些理论上的知识，下面我们来实操一下，本文主要讲解Kafka生产者的API。关注专栏《破茧成蝶——大数据篇》，查看更多相关的内容~ Kafka的Producer发送消息采用的是异步发送的方式。在消息发送的过程中，涉及到了两个线程——main线程和Sender线程，以及一个线程共享变量——RecordAccumulator。main线程将消息发送给RecordAccumulator，Sender线程不断从RecordAccumulator中拉取消息发送到Kafka broker。
Kafka之Producer API详解
zp17834994071的博客
08-20 1988
Kafka中如何创建生产者producer已经在前面给大家详细的讲解过，那么如何使用JAVA来创建并发送数据到topic中呢，今天就着重这一块说说。 先创建一个topic，拥有一个副本和一个分区 kafka-topics.sh --create --zookeeper localhost:2181 --replication-factor 1 --partitions 1 --topic test 示例： public class MyProducer { public static void ma
kafka Producer APIs （version:2.4.1）
只为成功找方法 不为失败找借口
11-15 1638
SKIP NAVIGATION LINKS OVERVIEW PACKAGE CLASS TREE DEPRECATED INDEX HELP PREVCLASS NEXTCLASS FRAMES NOFRAMES SUMMARY: NESTED| FIELD| CONSTR| METHOD DETAIL: FIELD| CONSTR| METHOD org.apache.kafka.clients.consumer Class Kaf...
2、java调用kafka api
05-29
在Java中调用Apache Kafka API是一项关键任务，特别是在构建分布式数据处理系统时。Apache Kafka是一个高性能、可扩展的消息队列（MQ），它提供实时的数据流处理能力。在Java应用程序中集成Kafka API可以让开发者...
快速学习-Kafka API
01-07
第 4 章 Kafka API 4.1 Producer API 4.1.1 消息发送流程 Kafka 的 Producer 发送消息采用的是异步发送的方式。在消息发送的过程中，涉及到了两个线程——main 线程和 Sender 线程，以及一个线程共享变量——...
kafka_producer.zip
06-18
在发送消息时，数据被编码为字节，因为Kafka API需要字节串作为输入。最后，`flush()`方法确保所有待发送的消息都被实际发送到Kafka集群。 在实际应用中，生产者可能还需要处理错误、重试策略、回调函数（用于确认...
kafka:Kafka api使用，
05-11
Kafka API 使用详解 Kafka 是一个高吞吐量、分布式的消息发布与订阅系统，由 LinkedIn 开发并随后捐赠给 Apache 软件基金会。它在大数据处理、实时流数据处理以及微服务架构中广泛应用。本篇文章将重点探讨如何在 ...
大数据kafka的api详细介绍和使用，包含kafka的安装部署
01-23
**Kafka API详解与使用** Kafka是一款由LinkedIn开发并贡献给Apache的开源分布式消息系统，主要用于处理实时数据流。其强大的性能、高吞吐量和可扩展性使其成为大数据领域的重要组件。本文将深入探讨Kafka的API，...
kafka 客户端之producer API发送消息以及简单源码分析
小灰狼与大白兔的博客
01-28 7919
背景：我使用docker-compose 搭建的kafka服务 kafka的简单介绍以及docker-compose部署单主机Kafka集群 Kafka API简单介绍 kafka除了用于管理和管理任务的命令行工具，Kafka还有5个用于Java和Scala的核心API 他们分别是 The Admin API : 用于管理和inspect topics, brokers和其他 Kafka 对象 The Producer API: 将事件流发布（写入）到一个或多个 Kafka topics The Cons
C语言：popen函数的使用
热门推荐
海月汐辰
03-25 2万+
C语言：popen函数的使用 一、利用system函数调用shell命令，只能获取到shell命令的返回值，而不能获取shell命令的输出结果，那如果想获取输出结果怎么办呢？用popen函数可以实现。 二、定义函数：FILE * popen(const char * command, const char...
kafka api的基本使用
weixin_30919571的博客
05-08 103
kafka API kafka Consumer提供两套Java API：高级Consumer API、和低级Consumer API。 高级Consumer API 优点： 高级API写起来简单，易用。 不需要自行去管理offset，API已经封装好了offset这块的东西，会通过zookeeper自行管理 不需要管理分区，副本等情况，系统自动管理 消费者断线后会自动根据上次记录在zookee...
python subprocess pipe_Python2.x subprocess.Popen的Broken pipe解决方法
weixin_33302571的博客
01-28 385
考虑如下代码：#!/usr/bin/env pythonp1 = Popen(["cat", "somebigfile"], stdout = PIPE)p2 = Popen(["head"], stdin = p1.stdout, stdout = PIPE)print p2.communicate()[0]会出现cat: write error: Broken pipe原因是在Unix-lik...
os.popen read()报编码错误_ACS800自动送钻编码器故障问题处理
weixin_39881958的博客
11-22 906
队上配套的送钻电机，ACS800-01型变频器，一上电即报ENCODER ERR(7301)故障，根据队上反馈，该问题已经存在了好几年了。由于考虑到送钻电机的悬停功能，为了电机控制更加精准，建议对编码器问题进行处理。根据队上的反馈，前面厂家人员上井时对编码器进行过检查，得到的答复是该类型的编码器已经停产，找不到货源，因此并未对该问题进行处理。变频器面板上出现该报警后，变频器仍旧可以运行，...
python中的subprocess.Popen（）使用
gotomic的专栏
08-17 7268
2010-03-30 17:45在收集snmp数据的过程中用到了subprocess这个模块，本来想用其他python里面关于snmp的库，还是觉得麻烦就直接调用snmpwalk来收集数据。 最开始想用subprocess.call（）这个函数，然而这个函数没有和其他进程通信的功能就放弃了 google了一下找到subprocess.Popen()这个函数，具体用法后面会贴一个别人写
Kafka实践（五）：KafkaProducer和KafkaConsumer的API使用
叶子叶来
08-19 8944
参考官网文档：http://kafka.apache.org/10/javadoc/index.html?org/apache/kafka/clients/producer/KafkaProducer.html Kafka的使用KafkaProducer类发送数据，kafka Producer是线程安全的，可以在多个线程之间共享生产者实例，其发送模型如下： 使用IDEA配置maven po...
Python调用os.popen控制台不输出stderr的方法
Ls4034的专栏
04-09 1万+
声明：这是个标题党，如果你执意想用os.popen做到控制台输出重定向，这篇文章中并没有答案，如果你对os.popen没有那么强烈的执念，请继续看 前段时间写代码使用os.popen时，遇到一个问题：执行的命令有可能会运行失败，虽然在代码中增加了异常处理，但是对于功能的要求是，不能在控制台打印出来报错信息，附上使用os.popen的情况： # -*- coding: utf-8 -*- im...
python：解决python中的编码问题
AIBAIKE的博客
02-11 399
python中的编码问题很让人头疼，python2和python3的处理方式不一样，这里只说python3的编码问题处理方法：utf8（输入） ——&gt; unicode（处理） ——&gt; （输出）utf8Python 里面处理的字符都是都是unicode 编码，因此解决编码问题的方法是把输入的文本（无论是什么编码）解码为（decode）unicode编码，然后输出时再编码（encode）成...
kafka2.4.1 api
最新发布
01-18
1. Producer API：用于向Kafka发送消息，将数据发送到Kafka集群的topic中。开发者可以通过API设置消息的键和值，以及指定使用的分区。 2. Consumer API：用于从Kafka读取消息，从指定的topic中消费数据。开发者可以...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值