【Kafka】2.在SpringBoot中使用官方原生java版Kafka客户端

最新推荐文章于 2024-09-11 00:18:33 发布
最新推荐文章于 2024-09-11 00:18:33 发布
阅读量1.2k 收藏 1
点赞数 1
分类专栏： Kafka SpringBoot 文章标签： java kafka spring boot
本文为博主原创文章，未经博主允许，不得以任何方式转载或者演绎，如需转载请联系博主
本文链接：https://blog.csdn.net/crezfikbd/article/details/132252889
版权

目 录

在开始之前，需要先做点准备工作，用 IDEA 新建一个 Maven 项目，取名 kafka-study，然后删掉它的 src 目录，接着在 pom.xml 里面引入下面的依赖。这个项目的作用是作为整个工程的父项目，后面的项目都在此基础上新建 module 即可。

这里用到的环境信息如下：

  • JDK1.8
  • SpringBoot2.7.1
  • IDEA
  • Maven3.6.3
<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>
    <packaging>pom</packaging>

    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.7.1</version>
        <relativePath/>
    </parent>

    <groupId>org.yuhuofei</groupId>
    <artifactId>kafka-study</artifactId>
    <version>1.0-SNAPSHOT</version>

    <name>kafka-study</name>
    <description>Study project for Kafka</description>
    <properties>
        <java.version>1.8</java.version>
    </properties>
    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>

        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
        </dependency>
    </dependencies>

    <build>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
            </plugin>
        </plugins>
    </build>
</project>

1. 新建一个消息生产者

使用 IDEA 在 kafka-study 的基础上新建一个 Maven 类型的 module ，命名为 producer-01，直至完成。接着，我们改造这个 module ，把它变成我们想要的消息生产者。

1、在 java 目录下，新建一个包 com.yuhuofei ，然后再创建一个启动类 ProducerApplication.java ，内容如下:

package com.yuhuofei;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

@SpringBootApplication
public class ProducerApplication {

    public static void main(String[] args) {
        SpringApplication.run(ProducerApplication.class, args);
    }

}

2、在 resources 目录下，新建配置文件 application.properties ，内容如下：

server.port=8080
server.servlet.context-path=/producer-01
#Kafka配置
topic.name=my-kafka-topic

3、在自己的 pom.xml 文件中，引入 Kafka 客户端的依赖。这里需要注意的是，由于我们在上一篇博客里安装的是 kafka_2.11-2.2.1 版本的服务端，所以引入的 Kafka 客户端的版本最好对应，也选择 2.2.1 版本的。

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <parent>
        <artifactId>kafka-study</artifactId>
        <groupId>org.yuhuofei</groupId>
        <version>1.0-SNAPSHOT</version>
    </parent>
    <modelVersion>4.0.0</modelVersion>

    <artifactId>producer-01</artifactId>

    <dependencies>
        <!--官方原生的java版kafka客户端依赖-->
        <dependency>
            <groupId>org.apache.kafka</groupId>
            <artifactId>kafka-clients</artifactId>
            <version>2.2.1</version>
        </dependency>
        <!--fastjson依赖-->
        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>fastjson</artifactId>
            <version>2.0.11.graal</version>
        </dependency>
    </dependencies>

</project>

4、由于 Kafka 进行消息的发布或者消费是需要有 Topic 的，因此我们需要要创建一个 Topic。在 zookeeper 和 Kafka 服务端都启动的情况下，打开 D:\Kafka\kafka_2.11-2.2.1\bin\windows 文件夹，在地址栏输入 cmd，打开控制台，然后用下面的命令创建、查看、删除 topic 。

如下图所示，我已经创建了一个名字为 my-kafka-topic 的 topic ，这个 topic 的分区为 1，副本也是 1。

# 创建topic
kafka-topics.bat --create --zookeeper 127.0.0.1:2181 --replication-factor 1 --partitions 1 --topic my-kafka-topic
# 查询topic列表
kafka-topics.bat --zookeeper 127.0.0.1:2181 --list					
# 删除topic
kafka-topics.bat --delete --zookeeper 127.0.0.1:2181 --topic my-kafka-topic
# 查询某个topic信息
kafka-topics.bat --describe --zookeeper localhost:2181 --topic my-kafka-topic
#kafka查看topic数据内容
kafka-console-consumer.bat --bootstrap-server localhost:9092 --topic my-kafka-topic --from-beginning

在这里插入图片描述

5、实现生产者发送消息

  • controller层
package com.yuhuofei.controller;

import com.yuhuofei.service.ProducerInterface;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

import javax.annotation.Resource;

/**
 * @Description
 * @ClassName ProducerController
 * @Author yuhuofei
 * @Date 2023/8/13 16:38
 * @Version 1.0
 */
@RequestMapping("/info")
@RestController
public class ProducerController {

    @Resource
    private ProducerInterface producerInterface;

    @GetMapping("/create-message")
    public void createTopic() {
        producerInterface.createMessage();
    }
}
  • service层
package com.yuhuofei.service;

/**
 * @Description
 * @InterfaceName ProducerController
 * @Author yuhuofei
 * @Date 2023/8/13 16:39
 * @Version 1.0
 */
public interface ProducerInterface {

    void createMessage();
}
  • serviceImpl层
package com.yuhuofei.service.impl;

import com.alibaba.fastjson.JSON;
import com.alibaba.fastjson.JSONObject;
import com.yuhuofei.service.ProducerInterface;
import org.apache.kafka.clients.producer.Producer;
import org.apache.kafka.clients.producer.ProducerRecord;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.stereotype.Service;

import javax.annotation.Resource;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.Future;

/**
 * @Description
 * @ClassName ProducerInterfaceImpl
 * @Author yuhuofei
 * @Date 2023/8/13 16:39
 * @Version 1.0
 */
@Service
public class ProducerInterfaceImpl implements ProducerInterface {

    @Value("${topic.name}")
    private String topicName;

    @Resource
    private Producer producer;

    @Override
    public void createMessage() {
        //创建测试数据
        JSONObject jsonObject = new JSONObject();
        jsonObject.put("word", "这是生产者生产的测试消息");
        String jsonString = JSON.toJSONString(jsonObject);
        //使用kafka发送消息
        ProducerRecord<String, String> producerRecord = new ProducerRecord<>(topicName, jsonString);
        producer.send(producerRecord);
    }
}
  • 客户端配置类
package com.yuhuofei.config;

import org.apache.kafka.clients.producer.KafkaProducer;
import org.apache.kafka.clients.producer.Producer;
import org.apache.kafka.clients.producer.ProducerConfig;
import org.apache.kafka.common.serialization.StringSerializer;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

import java.util.Properties;

/**
 * @Description 配置生产者客户端参数
 * @ClassName KafkaProperties
 * @Author yuhuofei
 * @Date 2023/8/13 22:18
 * @Version 1.0
 */
@Configuration
public class KafkaConfig {

    @Bean("producer")
    public Producer<String, String> getKafkaProducer() {
        Properties properties = new Properties();
        //配置Kafka的服务端IP和端口
        properties.put(ProducerConfig.BOOTSTRAP_SERVERS_CONFIG, "127.0.0.1:9092");
        //指定key使用的序列化类
        properties.put(ProducerConfig.KEY_SERIALIZER_CLASS_CONFIG, StringSerializer.class.getName());
        //指定value使用的序列化类
        properties.put(ProducerConfig.VALUE_SERIALIZER_CLASS_CONFIG, StringSerializer.class.getName());
        return new KafkaProducer<>(properties);
    }
}

6、启动服务，调用接口 http://localhost:8080/producer-01/info/create-message ，然后在控制台用命令查看一下消息是否写入，如下图所见，虽然是乱码，但是已经可以看出消息成功写入到 Kafka

在这里插入图片描述
到这里，消息生产者的创建暂时告一段落。

2. 新建一个消息消费者

和前面建立生产者类似的步骤，只是文件信息和名字不一样，这里步骤就不重复了，直接给出相关的配置和类。这个消费者，取名 consumer-01 。

  • pom.xml文件
<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <parent>
        <artifactId>kafka-study</artifactId>
        <groupId>org.yuhuofei</groupId>
        <version>1.0-SNAPSHOT</version>
    </parent>
    <modelVersion>4.0.0</modelVersion>

    <artifactId>consumer-01</artifactId>

    <dependencies>
        <!--官方原生的java版kafka客户端依赖-->
        <dependency>
            <groupId>org.apache.kafka</groupId>
            <artifactId>kafka-clients</artifactId>
            <version>2.2.1</version>
        </dependency>
        <!--fastjson依赖-->
        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>fastjson</artifactId>
            <version>2.0.11.graal</version>
        </dependency>
    </dependencies>
</project>
  • properties文件
server.port=8081
server.servlet.context-path=/consumer-01
#Kafka配置
topic.name=my-kafka-topic
  • 启动类 ConsumerApplication.java
package com.yuhuofei;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

@SpringBootApplication
public class ConsumerApplication {

    public static void main(String[] args) {
        SpringApplication.run(ConsumerApplication.class, args);
    }

}
  • 控制层ConsumerController.java
package com.yuhuofei.controller;

import com.yuhuofei.service.ConsumerInterface;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

import javax.annotation.Resource;

/**
 * @Description
 * @ClassName ConsumerController
 * @Author yuhuofei
 * @Date 2023/8/14 0:19
 * @Version 1.0
 */
@RestController
@RequestMapping("/consumer")
public class ConsumerController {

    @Resource
    private ConsumerInterface consumerInterface;

    @GetMapping("/getData")
    public void getData() {
        consumerInterface.getData();
    }
}
  • service层
package com.yuhuofei.service;

/**
 * @Description
 * @ClassName ConsumerInterface
 * @Author yuhuofei
 * @Date 2023/8/14 0:20
 * @Version 1.0
 */
public interface ConsumerInterface {
    void getData();
}
  • serviceImpl层
package com.yuhuofei.service.impl;

import com.yuhuofei.service.ConsumerInterface;
import org.apache.kafka.clients.consumer.Consumer;
import org.apache.kafka.clients.consumer.ConsumerRecord;
import org.apache.kafka.clients.consumer.ConsumerRecords;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.stereotype.Service;

import javax.annotation.Resource;
import java.time.Duration;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Collections;
import java.util.List;

/**
 * @Description
 * @ClassName ConsumerInterfaceImpl
 * @Author yuhuofei
 * @Date 2023/8/14 0:20
 * @Version 1.0
 */
@Service
public class ConsumerInterfaceImpl implements ConsumerInterface {

    @Value("${topic.name}")
    private String topicName;

    @Resource
    private Consumer consumer;

    @Override
    public void getData() {
        Collection<String> topics = Collections.singletonList(topicName);
        consumer.subscribe(topics);
        List<String> result = new ArrayList<>();
        while (true) {
            ConsumerRecords<String, String> consumerRecords = consumer.poll(Duration.ofMillis(1000));
            for (ConsumerRecord consumerRecord : consumerRecords) {
                //从ConsumerRecord中获取消费数据
                String res = (String) consumerRecord.value();
                System.out.println("从Kafka中消费的原始数据: " + res);
                result.add(res);
                System.out.println(result);
            }
        }
    }
}
  • config配置类
package com.yuhuofei.config;

import org.apache.kafka.clients.consumer.Consumer;
import org.apache.kafka.clients.consumer.ConsumerConfig;
import org.apache.kafka.clients.consumer.KafkaConsumer;
import org.apache.kafka.common.serialization.StringDeserializer;
import org.apache.kafka.common.serialization.StringSerializer;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

import java.util.Properties;

/**
 * @Description 配置消费者参数
 * @ClassName KafkaConsumerConfig
 * @Author yuhuofei
 * @Date 2023/8/14 0:08
 * @Version 1.0
 */
@Configuration
public class KafkaConsumerConfig {

    @Bean("consumer")
    public Consumer<String, String> getKafkaConsumer() {
        Properties properties = new Properties();
        //配置Kafka的服务端IP和端口
        properties.put(ConsumerConfig.BOOTSTRAP_SERVERS_CONFIG, "127.0.0.1:9092");
        //指定key使用的序列化类
        properties.put(ConsumerConfig.KEY_DESERIALIZER_CLASS_CONFIG, StringDeserializer.class.getName());
        //指定value使用的序列化类
        properties.put(ConsumerConfig.VALUE_DESERIALIZER_CLASS_CONFIG, StringDeserializer.class.getName());
        //指定消费者组
        properties.put(ConsumerConfig.GROUP_ID_CONFIG, "consumer-01-group");
        properties.put(ConsumerConfig.ENABLE_AUTO_COMMIT_CONFIG,true);
        properties.put(ConsumerConfig.AUTO_COMMIT_INTERVAL_MS_CONFIG,100);
        properties.put(ConsumerConfig.AUTO_OFFSET_RESET_CONFIG,"latest");
        return new KafkaConsumer<>(properties);
    }
}

最终整个项目目录如下图所示。

在这里插入图片描述

3. 测 试

1、检查 zookeeper 和 Kafka 服务端是否是启动的，没启动就先启动。

2、接着，启动消费者服务，然后调用一下接口 http://localhost:8081/consumer-01/consumer/getData ，这么做的目的启动一个线程，监听 topic 。

3、最后，启动生产者服务，调用接口 http://localhost:8080/producer-01/info/create-message ，向 Kafka 服务器写数据。

结果如下所示：

控制台看到的所有消息记录
这是所有发送的记录
生产者发送一条消息
在这里插入图片描述
消费者监听到一条消息并接收
在这里插入图片描述

在 SpringBoot 中，使用官方原生 java 版 Kafka 客户端的入门介绍到这里结束，还有更多使用方式，等待挖掘。

yuhuofei2021
关注
专栏目录
Spring Boot+Kafka实战生产级Kafka消费组
AI天才研究院
08-06 2600
Kafka是一个开源分布式消息系统，最初由LinkedIn开发，之后成为Apache项目的一部分。Kafka主要用于大数据实时流处理，具有低延迟、高吞吐量等特点。本文将会从基本概念、术语说明、原理及应用场景三个方面对Kafka进行详细介绍。Kafka作为一个分布式系统，需要配合Zookeeper实现主备、容错等功能。因此在实际中部署Kafka集群至少需要2台服务器，其中一台为zookeeper服务器。
【kafka专栏】Spring kafka消息发送事务处理
字母哥博客
07-09 988
在《幂等与事务处理的》的文章中，我们已经为大家介绍使用apache kafka原生API 如何保证：数据被发送Exactly One，发送一次并且只发送一次，不重发不漏发。幂等性的设置仍然很简单，只需要将生产者客户端参数设置为true即可。 本文主要为大家介绍下在SpringBoot环境下结合Spring kafka如何实现幂等性和事务的处理。我们看下面的一段代码，使用向kafka发送数据，但是发送数据之后方法内部抛出了异常。假如我们的代码含义是下面的这样的订单支付未成功，可能用户余额不足，抛出异常。但是向
如何在Java中使用Kafka
微赚开发者技术分享博客
07-03 1865
本文详细介绍了如何在Java中使用Kafka，包括创建生产者和消费者的基本步骤，以及一些高级配置与优化建议。通过本文的学习，相信大家能够掌握基本的Kafka使用方法，并能在实际项目中应用。本文将详细介绍如何在Java中使用Kafka，并通过示例代码展示如何实现生产者和消费者。大家好，我是免费搭建查券返利机器人省钱赚佣金就用微赚淘客系统3.0的小编，也是冬天不穿秋裤，天冷也要风度的程序猿！在实际应用中，可以根据需要调整Kafka生产者和消费者的配置，以提高性能和可靠性。在Maven项目中，可以在。
Kafka客户端核心参数详解
最新发布
qq_45061342的博客
09-11 2354
Kafka提供了两套客户端API，HighLevel API和LowLevel API。 HighLevel API封装了kafka的运行细节，使用起来比较简单，是企业开发过程中最常用的客户端API。 而LowLevel API则需要客户端自己管理Kafka的运行细节，Partition，Offset这些数据都由客户端自行管理。这层API功能更灵活，但是使用起来非常复杂，也更容易出错。只在极少数对性能要求非常极致的场景才会偶尔使用。重点是HighLeve API 。
Kafka的Java客户端
HRX98的博客
03-04 1654
Kafka的Java客户端-demo版 0. 订单类 package com.hao.entity; public class Order { private Long orderId; private int count; public Order(Long orderId, int count) { this.orderId = orderId; this.count = count; } public Order() {
kafka java 客户端
Pichairen
01-17 2047
参考：kafka——AdminClient API - 简书 1、AdminClient API <dependencies> <dependency> <groupId>org.apache.kafka</groupId> <artifactId>kafka-clients</artifactId> <version>2.7
Kafka 处理器客户端介绍
weixin_33889245的博客
06-01 141
【编者按】本文作者为 Bill Bejeck，主要介绍如何有效利用新的 Apache Kafka 客户端来满足数据处理需求。文章系国内 ITOM 管理平台 OneAPM 编译呈现，以下为正文。 如果你使用的系统需要传输大量数据，就算你没用过 Kafka，很有可能已经听说过它了。从较高层面来说，Kafka 是一个对错误零容忍、分布式的发布订...
Kafka Java 客户端使用
shpunishment的博客
06-13 375
文章目录1. 常用配置2. kafka-clients2.1 生产者2.2 消费者2.3 多线程 1. 常用配置 生产者 配置 描述 类型 默认值 bootstrap.servers 用于建立与kafka集群的连接，仅影响用于初始化的hosts，来发现全部的servers。格式：host1:port1,host2:port2,…，数量尽量不止一个，以防其中一个down了。 list acks 生产者要求Leader在确认请求完成之前已收到的确认数。acks = 0：如果设置为零，那么生
kafka的java客户端-生产者
拒绝熬夜啊的博客
06-29 1449
kafka的java客户端-生产者
springboot 1.5.2 集成kafka的简单例子
08-28
SpringBoot 1.5.2 集成 Kafka 的简单例子 SpringBoot 1.5.2 版本发布...通过以上步骤，可以轻松地实现 SpringBoot 1.5.2 版本中的 Kafka 集成，使用 Spring Kafka 来发送和消费消息，提高系统的可扩展性和可靠性。
spring-kafka源码分析-01
kafka_zsxq的博客
12-03 441
前言 对于Java web服务通常都会使用spring-boot作为web基础框架，今天就从spring的角度分析一下kafka是如何注入到spring容器中并且如何使用的。本文主要针对spring-kafka.2.5.5.RELEASE版本进行分析，不涉及kafka-clients原理讲解。 了解Springframework Bean的生命周期： spring容器从全局的角度来看就是管理web系统运行过程中所需要的对象，其中bean的生命周期就是系统运行所依赖对象的 创建过程->初
kafka 客户端
12-11
kafka消息队列 监控界面 内含分区选择，topic选择，消息查看发送。操作简便。直接启动jar即可。
kafka客户端
09-04
1/kafka是一个分布式的消息缓存系统 2/kafka集群中的服务器都叫做broker 3/kafka有两类客户端，一类叫producer（消息生产者），一类叫做consumer（消息消费者），客户端和broker服务器之间采用tcp协议连接 4/kafka中不同业务系统的消息可以通过topic进行区分，而且每一个消息topic都会被分区，以分担消息读写的负载 5/每一个分区都可以有多个副本，以防止数据的丢失 6/某一个分区中的数据如果需要更新，都必须通过该分区所有副本中的leader来更新 7/消费者可以分组，比如有两个消费者组A和B，共同消费一个topic：order_info,A和B所消费的消息不会重复 比如 order_info 中有100个消息，每个消息有一个id,编号从0-99，那么，如果A组消费0-49号，B组就消费50-99号 8/消费者在具体消费某个topic中的消息时，可以指定起始偏移量 每个partition只能同一个group中的同一个consumer消费，但多个Consumer Group可同时消费同一个partition。 n个topic可以被n个Consumer Group消费，每个Consumer Group有多个Consumer消费同一个topic Topic在逻辑上可以被认为是一个queue，每条消费都必须指定它的Topic，可以简单理解为必须指明把这条消息放进哪个queue里。为了使得Kafka的吞吐率可以线性提高，物理上把Topic分成一个或多个Partition，每个Partition在物理上对应一个文件夹，该文件夹下存储这个Partition的所有消息和索引文件。若创建topic1和topic2两个topic，且分别有13个和19个分区 Kafka的设计理念之一就是同时提供离线处理和实时处理。根据这一特性，可以使用Storm这种实时流处理系统对消息进行实时在线处理，同时使用Hadoop这种批处理系统进行离线处理，还可以同时将数据实时备份到另一个数据中心，只需要保证这三个操作所使用的Consumer属于不同的Consumer Group即可。
Kafka使用Java客户端进行访问的示例代码
08-29
本篇文章主要介绍了Kafka使用Java客户端进行访问的示例代码，小编觉得挺不错的，现在分享给大家，也给大家做个参考。一起跟随小编过来看看吧
【云原生】springboot 整合 OpenTelemetry
congge
01-14 1万+
springboot 整合 OpenTelemetry
apache kafka系列之客户端开发-java
热门推荐
李志涛的专栏
07-15 2万+
kafka客户端开发,如果进行多线程并行消费数据。
kafka的java客户端_Kafka使用Java客户端进行访问-Go语言中文社区
weixin_42149153的博客
02-21 116
本文环境如下：操作系统：CentOS 6 64位JDK版本：1.8.0_171 64位Kafka版本：kafka_2.12-2.1.11. maven依赖包org.apache.kafkakafka_2.122.1.12. 生产者代码import org.apache.kafka.clients.producer.KafkaProducer;import org.apache.kafka.clie...
kafka之java客户端实战
weixin_43134177的博客
01-13 1518
Producer可选的属性都可以由ProducerConfig类管理。比如ProducerConfig.BOOTSTRAP_SERVERS_CONFIG属性，显然就是指发送者要将消息发到哪个Kafka集群上。这是每个Producer必选的属性。在ProducerConfig中，对于大部分比较重要的属性，都配置了对应的DOC属性进行描述。Kafka的消息是一个Key-Value结构的消息。其中，key和value都可以是任意对象类型。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值