Windows安装Kafka及Springboot整合

最新推荐文章于 2024-04-24 22:26:12 发布
最新推荐文章于 2024-04-24 22:26:12 发布
阅读量398 收藏 3
点赞数 3
分类专栏： ELK 文章标签： windows kafka spring boot
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/davidtio/article/details/131713186
版权

Windows安装Kafka及Springboot整合

Windows安装Kafka

一、安装Zookeeper

1、官网下载安装包

地址：http://zookeeper.apache.org/releases.html#download

选择任意一个版本
![[Pasted image 20230713223429.png]]

2、解压文件 进入conf目录 C:\myWork\dev_env\zookeeper\apache-zookeeper-3.8.0-bin\conf

**3、**复制"zoo_sample.cfg”文件并重命名为“zoo.cfg”

4、打开"zoo.cfg" 配置

	dataDir=C:\myWork\dev_env\zookeeper\apache-zookeeper-3.8.0-bin\data
	dataLogDir=C:\myWork\dev_env\zookeeper\apache-zookeeper-3.8.0-bin\log

在D:\codeapp\apache-zookeeper-3.7.0-bin目录下新建data文件和log文件

img

**5、添加系统变量 ：**ZOOKEEPER_HOME =C:\myWork\dev_env\zookeeper\apache-zookeeper-3.8.0-bin
在这里插入图片描述

在path变量下添加 %ZOOKEEPER_HOME%\bin
![[Pasted image 20230713223538.png]]

6、打开CMD 输入命令 zkServer 运行Zookeeper

img
启动成功 窗口保持运行

二、安装Kafka

1、进入官网下载安装包 http://kafka.apache.org/downloads
img

2、解压并进入config目录 C:\myWork\dev_env\kafka\kafka_2.12-3.1.0\config

3、打开server.properties编辑以下属性

注意分隔符是\\

4、打开zookeeper.properties文件编辑以下属性
在这里插入图片描述

5、进入Kafka主目录C:\myWork\dev_env\kafka\kafka_2.12-3.1.0 地址栏输入cmd回车打开cmd窗口，在cmd中输入命令

start bin\windows\kafka-server-start.bat config\server.properties

在这里插入图片描述

三、说明

2181：zookeper 、kafka和zookeeper的通信端口

9092：kakfa Producer和Consumer的端口

四、应用

1、创建topic

不要关闭以上两个cmd窗口 进入C:\myWork\dev_env\kafka\kafka_2.12-3.1.0 主目录 重新打开一个cmd窗口

输入以下命令创建一个topic

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

2、查看topic

./kafka-topics.bat --list   --bootstrap-server localhost:9092

在这里插入图片描述

3、新建生产者Producer

.\kafka-console-producer.bat --broker-list localhost:9092 --topic test

输入几段消息

在这里插入图片描述

4、新建消费者Consumer

.\kafka-console-consumer.bat --bootstrap-server localhost:9092 --topic test --from-beginning

刚才输入的消息也能够看得到
在这里插入图片描述

SpringBoot整合Kafka

一、新建springboot项目

![[Pasted image 20230713223823.png]]

二、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 https://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>
    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.6.7</version>
        <relativePath/> <!-- lookup parent from repository -->
    </parent>
    <groupId>com.dt</groupId>
    <artifactId>biz</artifactId>
    <version>0.0.1-SNAPSHOT</version>
    <name>SpringBootKafka</name>
    <description>SpringbootKafka3.1</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>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <scope>runtime</scope>
        </dependency>
        <dependency>
            <groupId>org.springframework.kafka</groupId>
            <artifactId>spring-kafka</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
        </dependency>
        <dependency>
            <groupId>org.springframework.kafka</groupId>
            <artifactId>spring-kafka-test</artifactId>
            <scope>test</scope>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-devtools</artifactId>
        </dependency>
    </dependencies>

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

</project>

三、application.yml 配置kafka

server:
  servlet:
    #应用访问地址
    context-path: /springboot-kafka
spring:
  #kafka配置
  kafka:
    #这里改为你的kafka服务器ip和端口号
    bootstrap-servers: 192.168.56.1:9092
    #=============== producer  =======================
    producer:
      #如果该值大于零时，表示启用重试失败的发送次数
      retries: 0
      #每当多个记录被发送到同一分区时，生产者将尝试将记录一起批量处理为更少的请求，默认值为16384(单位字节)
      batch-size: 16384
      #生产者可用于缓冲等待发送到服务器的记录的内存总字节数，默认值为3355443
      buffer-memory: 33554432
      #key的Serializer类，实现类实现了接口org.apache.kafka.common.serialization.Serializer
      key-serializer: org.apache.kafka.common.serialization.StringSerializer
      #value的Serializer类，实现类实现了接口org.apache.kafka.common.serialization.Serializer
      value-serializer: org.apache.kafka.common.serialization.StringSerializer
    #=============== consumer  =======================
    consumer:
      #用于标识此使用者所属的使用者组的唯一字符串
      group-id: dt-consumer-group
      #当Kafka中没有初始偏移量或者服务器上不再存在当前偏移量时该怎么办，默认值为latest，表示自动将偏移重置为最新的偏移量
      #可选的值为latest, earliest, none
      auto-offset-reset: earliest
      #消费者的偏移量将在后台定期提交，默认值为true
      enable-auto-commit: true
      #如果'enable-auto-commit'为true，则消费者偏移自动提交给Kafka的频率（以毫秒为单位），默认值为5000。
      auto-commit-interval: 100
      #密钥的反序列化器类，实现类实现了接口org.apache.kafka.common.serialization.Deserializer
      key-deserializer: org.apache.kafka.common.serialization.StringDeserializer
      #值的反序列化器类，实现类实现了接口org.apache.kafka.common.serialization.Deserializer
      value-deserializer: org.apache.kafka.common.serialization.StringDeserializer

四、KafkaUtil

package com.dt.biz.util;

import org.apache.kafka.clients.admin.*;
import org.apache.kafka.common.TopicPartitionInfo;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.kafka.core.KafkaTemplate;
import org.springframework.stereotype.Component;

import javax.annotation.PostConstruct;
import javax.annotation.Resource;
import java.util.*;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.atomic.AtomicReference;
import java.util.stream.Collectors;

/**
 * web方式使用，通过容器管理，由Srping管理对象
 */
@Component
public class KafkaUtils {
    @Value("${spring.kafka.bootstrap-servers}")
    private String springKafkaBootstrapServers;

    private AdminClient adminClient;

    @Resource
    private KafkaTemplate<String, Object> kafkaTemplate;

    /**
     * 初始化AdminClient
     * '@PostConstruct该注解被用来修饰一个非静态的void（）方法。
     * 被@PostConstruct修饰的方法会在服务器加载Servlet的时候运行，并且只会被服务器执行一次。
     * PostConstruct在构造函数之后执行，init（）方法之前执行。
     */
    @PostConstruct
    private void initAdminClient() {
        Map<String, Object> props = new HashMap<>(1);
        props.put(AdminClientConfig.BOOTSTRAP_SERVERS_CONFIG, springKafkaBootstrapServers);
        adminClient = KafkaAdminClient.create(props);
    }

    /**
     * 新增topic，支持批量
     */
    public void createTopic(Collection<NewTopic> newTopics) {
        adminClient.createTopics(newTopics);
    }

    /**
     * 删除topic，支持批量
     */
    public void deleteTopic(Collection<String> topics) {
        adminClient.deleteTopics(topics);
    }

    /**
     * 获取指定topic的信息
     */
    public String getTopicInfo(Collection<String> topics) {
        AtomicReference<String> info = new AtomicReference<>("");
        try {
            adminClient.describeTopics(topics).all().get().forEach((topic, description) -> {
                for (TopicPartitionInfo partition : description.partitions()) {
                    info.set(info + partition.toString() + "\n");
                }
            });
        } catch (InterruptedException | ExecutionException e) {
            e.printStackTrace();
        }
        return info.get();
    }

    /**
     * 获取全部topic
     */
    public List<String> getAllTopic() {
        try {
            List<String> list = adminClient.listTopics().listings().get().stream().map(TopicListing::name).collect(Collectors.toList());
            for (String s : list) {
                System.out.println(s);
            }
            return list;
        } catch (InterruptedException | ExecutionException e) {
            e.printStackTrace();
        }
        return new ArrayList<>();
    }

    /**
     * 往topic中发送消息
     */
    public void sendMessage(String topic, String message) {
        kafkaTemplate.send(topic, message);
    }
}

五、kafkaDemo （不用spring容器管理）

package com.dt.biz.demo;

import org.apache.kafka.clients.admin.*;
import org.apache.kafka.common.TopicPartitionInfo;
import org.springframework.kafka.core.KafkaTemplate;

import javax.annotation.Resource;
import java.util.*;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.atomic.AtomicReference;
import java.util.stream.Collectors;

/**
 * 不用spring容器管理
 */
public class KafkaDemo {
    private AdminClient adminClient;
    @Resource
    private KafkaTemplate<String,Object> kafkaTemplate;

    /**
     * 获得kafka操作句柄
     */
    private void initAdminClient() {
        Map<String, Object> props = new HashMap<>(1);
        props.put(AdminClientConfig.BOOTSTRAP_SERVERS_CONFIG, "192.168.56.1:9092");
        adminClient = KafkaAdminClient.create(props);
        System.out.println("adminClient " + adminClient);
    }

    /**
     * 新增topic，支持批量
     */
    public void createTopic(Collection<NewTopic> newTopics) {
        adminClient.createTopics(newTopics);
    }

    /**
     * 删除topic，支持批量
     */
    public void deleteTopic(Collection<String> topics) {
        adminClient.deleteTopics(topics);
    }

    /**
     * 获取指定topic的信息
     */
    public String getTopicInfo(Collection<String> topics) {
        AtomicReference<String> info = new AtomicReference<>("");
        try {
            adminClient.describeTopics(topics).all().get().forEach((topic, description) -> {
                for (TopicPartitionInfo partition : description.partitions()) {
                    info.set(info + partition.toString() + "\n");
                }
            });
        } catch (InterruptedException | ExecutionException e) {
            e.printStackTrace();
        }
        return info.get();
    }

    /**
     * 获取全部topic
     */
    public List<String> getAllTopic() {
        try {
            List<String> list = adminClient.listTopics().listings().get().stream().map(TopicListing::name).collect(Collectors.toList());
            return list;
        } catch (InterruptedException | ExecutionException e) {
            e.printStackTrace();
        }
        return new ArrayList<>();
    }

    /**
     * 往topic中发送消息
     * @param topic topicName
     * @param message 发送内容
     */
    public void sendMessage(String topic, String message) {
        kafkaTemplate.send(topic, message);
    }

    public static void main(String[] args) {
        KafkaDemo kafkaDemo = new KafkaDemo();
        //1.获得kafka句柄
        kafkaDemo.initAdminClient();
        //2.创建topic
        NewTopic newTopic = new NewTopic("test2", 1, Short.valueOf("1"));
        List<NewTopic> list2 = new ArrayList<NewTopic>();
        list2.add(newTopic);
        Collection<NewTopic> topics = new ArrayList<NewTopic>(list2);
        // kafkaDemo.createTopic(topics);

        //3.删除索引
        List<String> deleteTopicList = new ArrayList<String>();
        deleteTopicList.add("test");
        Collection<String> deleteCollection = deleteTopicList;
        //删除topic
        //kafkaDemo.deleteTopic(deleteCollection);
        //4.查询指定Topic
        String topicInfo = kafkaDemo.getTopicInfo(deleteTopicList);
        System.out.println("查询指定TopicInfo：" + topicInfo);

        //5.查询所有topic
        List<String> list = kafkaDemo.getAllTopic();
        for (String ss : list) {
            System.out.println("查询所有Topic：" + ss);
        }

        //6.往topic发送内容
//        kafkaDemo.sendMessage("test","kafkaDemo-t1");
    }

}

六、KafkaController

package com.dt.biz.controller;

import com.dt.biz.util.KafkaUtils;
import org.apache.kafka.clients.admin.NewTopic;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.kafka.annotation.KafkaListener;
import org.springframework.kafka.core.KafkaTemplate;
import org.springframework.web.bind.annotation.*;

import javax.annotation.Resource;
import java.util.ArrayList;
import java.util.Date;
import java.util.List;

/**
 * kafka控制器
 */
@RestController
@RequestMapping("/rest")
public class KafkaController {
    @Autowired
    private KafkaUtils KafkaUtils;

    private final static String TOPIC_NAME = "test";
    @Resource
    private KafkaTemplate<String, String> kafkaTemplate;

    @RequestMapping("/kafka/send")
    public void send() {
        Date date = new Date();
        System.out.println("发送时间：=================" + date);
        kafkaTemplate.send(TOPIC_NAME, "msg:" + date);
    }

    /**
     * 生产者往topic中发送消息demo
     *
     * @param topic
     * @param message
     */
    @PostMapping("kafka/message")
    public void sendMessage(String topic, String message) {
        KafkaUtils.sendMessage(topic, message);
    }

    /**
     * 消费者示例demo
     * <p>
     * 基于注解监听多个topic，消费topic中消息
     * （注意：如果监听的topic不存在则会自动创建）
     */
    @KafkaListener(topics = {"test"})
    public void consume(String message) {
        System.out.println("receive msg: " + message);
    }

    /**
     * 查询topic信息 (支持批量，这里就单个作为演示)
     */
    @PostMapping("/kafka/all")
    public void getAllTopics() {
        List<String> allTopics = KafkaUtils.getAllTopic();
        for (String s : allTopics) {
            System.out.println("getAllTopics:" + s);
        }
    }

    /*
     * 新增topic (支持批量，这里就单个作为演示)
     *
     * @param topic topic
     * @return ResponseVo
     */
    @PostMapping("/newTopic")
    public void add(String topic) {
        NewTopic newTopic = new NewTopic(topic, 1, (short) 1);
        List<NewTopic> list2 = new ArrayList<NewTopic>();
        list2.add(newTopic);
        KafkaUtils.createTopic(list2);
    }

    /**
     * 删除topic (支持批量，这里就单个作为演示)
     * (注意：如果topic正在被监听会给人感觉删除不掉（但其实是删除掉后又会被创建）)
     *
     * @param topic topic
     */
    @DeleteMapping("kafka/{topic}")
    public void delete(@PathVariable String topic) {
        List<String> deleteTopicList = new ArrayList<String>();
        deleteTopicList.add(topic);
        KafkaUtils.deleteTopic(deleteTopicList);
    }

}

七、项目gitee地址

https://gitee.com/DavidTio/springboot-kafka.git
David_Tio
关注
  • 3
    点赞
  • 踩
  • 3
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
SpringBoot Kafka 整合使用及安装教程
08-25
主要介绍了SpringBoot Kafka 整合使用及安装教程，本文图文并茂给大家介绍的非常详细，具有一定的参考借鉴价值 ,需要的朋友可以参考下
kafka在windows及linux下的安装使用以及kafka与springboot整合
a_sunny_a的博客
07-16 256
kafka在windows下的安装使用以及kafka与springboot整合 kafka服务端在windows下的安装及使用 到kafka下载网址下载最新版，最新版包含zookeeper 解压，zookeeper默认端口为2181，如需要修改可以在config/zookeeper.properties配置如： 当集群配置时slave(从服务器)可通过config/server.properties配置其zookeeper服务端的地址如： 启动zookeeper：zookeeper-server-st
Windows下载安装测试 Kafka ，并在SpringBoot上集成，一步到位简单Demo
Kashinhu的博客
11-01 131
Windows下载安装测试 Kafka ，并在SpringBoot上集成，试运行，一步到位简单Demo
kafak+zookeeper在windows安装，并在springboot项目中使用教程
weixin_41677422的博客
11-13 270
kafak+zookeeper在windows安装，并在springboot项目中使用教程大致分为四个步骤：一、安装zookeeper（资源协调，分配管理）二、安装Kafka三、安装kafka可视化工具kafka tool四、在springboot中使用Kafka 环境：jdk，maven，idea 大致分为四个步骤： 1.安装zookeeper 2.安装Kafka 3.安装kafka tool（kafka可视化工具） 4.在springboot中使用Kafk
SpringBoot整合Kafka
宋发元
09-25 1109
pom.xml引入依赖包 <!--kafka--> <dependency> <groupId>org.springframework.kafka</groupId> <artifactId>spring-kafka</artifactId> </dependency> application.yml引入配置信息 spring: kafka: bootstrap-servers: 你的Kafka
Springboot整合kafka
qq_35911118的博客
11-19 1423
首先在windows下启动kafka 启动方法如下: 首先下载kafka,zookeeper安装包 pom.xml <?xml version="1.0" encoding="UTF-8"?> 4.0.0 org.springframework.boot spring-boot-starter-parent 2.1.5.RELEASE com.cxy skafka 0.0.1-SNAPSHOT skafka Demo project for Spring Boot <proper
Windows环境下springboot集成kafka消息队列，生产者消费者，简单应用
greenapple222的博客
12-27 773
springboot中kafka生产者，消费者发送接收消息
SpringBoot：整合Kafka
燕双嘤
11-26 2919
虽然Kafka可作为消息组件使用，但它并不是单纯的消息组件，它被定位成“开源的分布式事件流平台（open-source distributed event strea ming platform）”，因此它和JMS实现或AMQP实现存在较大的差异。由于目前Kafka还依赖于ZooKeeper，因此在安装Kafka之前需要先安装，运行 ZooKeeper。
Spring boot集成kafka(windows)
m0_72167535的博客
12-31 1925
Spring boot集成kafka(windows)
springboot-kafka:springboot整合kafka实现消息的发送与消费学习
05-13
springboot-kafkaspringboot整合kafka实现消息的发送与消费学习csdn博客地址--
springboot整合kafka
06-23
springboot整合kafka的一个demo!附带window版本的zookeeper和kafka
springboot整合kafka相关讲解
04-14
Kafka目前主要作为一个分布式的发布订阅式的消息系统使用，下面简单介绍一下kafka的基本机制
Windows设置右键打开管理员CMD
轩辕霸天L
04-22 214
管理员CMD设置
c++:数据结构链表list的模拟实现
2301_76886465的博客
04-24 967
其实还有另一种解决方法,copy这个类,把这个类改成const版本的.但是这样会造成代码冗余.在调用上,我们假设有一个类A,里面有两个值a1和a2,我们用这个类来充当节点中的数据val。Ref是引用,Ptr是指针.这样子写是为了能生成多种引用T&,和T。这个类里面封装的是节点的指针,所以它唯一的成员变量就是Node。it->是调用it.operator->(),返回的是一个T。这个函数的功能和构造函数一样,写出来是为了后面进行复用.首先T是节点数据的类型,这个没问题.这里的模板有三个参数,为什么呢?
1 Java 泛型
qq_24907431的博客
04-23 1012
泛型，即“参数化类型”。一提到参数，最熟悉的就是定义方法时有形参，然后调用此方法时传递实参。那么参数化类型怎么理解呢？顾名思义，就是将类型由原来的具体的类型参数化，类似于方法中的变量参数，此时类型也定义成参数形式（可以称之为类型形参），然后在使用/调用时传入具体的类型（类型实参）。泛型的本质是为了参数化类型（在不创建新的类型的情况下，通过泛型指定的不同类型来控制形参具体限制的类型）。
使用C++实现尾插式循环链表结构
最新发布
AndrewYZWang的博客
04-24 431
总结起来，这段代码提供了一个简洁而实用的尾插式循环链表的实现，适用于需要高效进行顺序添加和按最近添加顺序删除元素的场景。用于创建新节点并将新节点插入到链表的尾部，即每次新增节点都会成为新的末尾节点。因此有必要实现一款属于自己的双向链表，这样在有需要的时候就能随时增加自己的特性，让链表更好的服务于其他模块。在使用C++实现链表时，我们需要实现两个主要的类：1. node节点类 ，2. 链接node节点的类。，该节点的前驱和后继均指向自身，形成一个空链表的“闭环”。，它作为链表中的实际节点实现。
【Effective Modern Cpp】条款9:优先考虑别名声明而非typedef
GouDanAndOcean的博客
04-24 200
是什么，这就是为什么编译器会坚持要求你在前面加上。将会是一个数据成员，不是一个类型，在。是否表示一个类型取决于。
centos7开启指定端口操作步骤
ithongchou的博客
04-24 322
【代码】centos7开启指定端口操作步骤。
kafka整合springboot
08-30
将Kafka与Spring Boot整合是一种常见的开发手段，可以通过导入Spring Boot整合Kafka的starter来实现。你可以在pom.xml文件中添加以下依赖坐标来导入该starter： ``` <dependency> <groupId>org.springframework.kafka</groupId> <artifactId>spring-kafka</artifactId> </dependency> ``` 需要注意的是，直接使用Kafka和使用Spring Boot整合Kafka两种方法虽然原理相同，但在配置、使用和理解上有一些区别。因此，不要混淆这两种方法。例如，在使用Spring Boot整合Kafka时，你可以通过同步监听来实现消息的接收，但这与Kafka本身的ack机制是两个独立的概念。 在完成依赖导入后，你可以创建一个测试类来演示如何使用生产者发送消息。首先，你需要创建一个KafkaTemplate对象，并在测试方法中使用它来发送消息。以下是一个示例代码： ``` @SpringBootTest public class KfKTest { @Autowired private KafkaTemplate<String, String> kafkaTemplate; @Test void pro_test(){ // 构造消息 User user = new User(); user.setName("张三"); user.setAge(20); kafkaTemplate.send("test", user.toString()); } } ``` 在这个示例中，我们使用了@Autowired注解来自动注入KafkaTemplate对象，并在测试方法中通过kafkaTemplate.send方法发送消息到名为"test"的主题。 这就是使用Kafka整合Spring Boot的基本步骤。你可以根据自己的需求进一步扩展和使用Kafka的其他功能。<span class="em">1</span><span class="em">2</span><span class="em">3</span> #### 引用[.reference_title] - *1* [SpringBoot整合Kafka](https://blog.csdn.net/m0_37294838/article/details/127253991)[target="_blank" data-report-click={"spm":"1018.2226.3001.9630","extra":{"utm_source":"vip_chatgpt_common_search_pc_result","utm_medium":"distribute.pc_search_result.none-task-cask-2~all~insert_cask~default-1-null.142^v93^chatsearchT3_2"}}] [.reference_item style="max-width: 50%"] - *2* *3* [知识点16--spring boot整合kafka](https://blog.csdn.net/dudadudadd/article/details/125344830)[target="_blank" data-report-click={"spm":"1018.2226.3001.9630","extra":{"utm_source":"vip_chatgpt_common_search_pc_result","utm_medium":"distribute.pc_search_result.none-task-cask-2~all~insert_cask~default-1-null.142^v93^chatsearchT3_2"}}] [.reference_item style="max-width: 50%"] [ .reference_list ]

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值