SpringBoot+ActiveMQ-点对点队列模式（消费端）

最新推荐文章于 2023-09-11 12:00:00 发布
最新推荐文章于 2023-09-11 12:00:00 发布
阅读量769 收藏
点赞数
分类专栏： SpringBoot+Demo 文章标签： spring boot java-activemq activemq activemq持久化 activemq点对点模式 Powered by 金山文档
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/myyhtw/article/details/128765361
版权

ActiveMQ消息中间件的点对点模式point to point 消息队列

生产端案例(配合消费端测试)：SpringBoot+ActiveMQ生产端

ActiveMQ版本：apache-activemq-5.16.5

SpringBoot集成ActiveMQ消费端的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">
    <modelVersion>4.0.0</modelVersion>
    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.0.5.RELEASE</version>
        <relativePath/> <!-- lookup parent from repository -->
    </parent>

    <groupId>boot.example.queue.customer</groupId>
    <artifactId>boot-example-queue-demo-customer-2.0.5</artifactId>
    <version>0.0.1-SNAPSHOT</version>
    <name>boot-example-queue-demo-customer-2.0.5</name>
    <description>Demo project for Spring Boot</description>

    <properties>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
        <project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>
        <java.version>1.8</java.version>
    </properties>

    <dependencies>
        <dependency>
            <groupId>boot.example.demo.entity</groupId>
            <artifactId>boot-example-demo-entity-2.0.5</artifactId>
            <version>0.0.1-SNAPSHOT</version>
        </dependency>

        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>

        <!-- activeMQ依赖组件 -->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-activemq</artifactId>
            <exclusions>
                <exclusion>
                    <groupId>org.slf4j</groupId>
                    <artifactId>slf4j-log4j12</artifactId>
                </exclusion>
            </exclusions>
        </dependency>
        <!-- spring.activemq.pool.enabled=true -->
        <dependency>
            <groupId>org.apache.activemq</groupId>
            <artifactId>activemq-pool</artifactId>
            <version>5.16.5</version>
        </dependency>
        <dependency>
            <groupId>io.springfox</groupId>
            <artifactId>springfox-swagger2</artifactId>
            <version>2.9.2</version>
        </dependency>
        <dependency>
            <groupId>com.github.xiaoymin</groupId>
            <artifactId>swagger-bootstrap-ui</artifactId>
            <version>1.9.2</version>
        </dependency>
    </dependencies>

    <build>
        <plugins>
            <!-- 打包成一个可执行jar -->
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
                <executions>
                    <execution>
                        <goals>
                            <goal>repackage</goal>
                        </goals>
                    </execution>
                </executions>
            </plugin>
        </plugins>
    </build>

</project>

application.properties


server.port=8042


spring.activemq.broker-url=tcp://127.0.0.1:61616
spring.activemq.user=admin
spring.activemq.password=admin
spring.activemq.in-memory=false
spring.activemq.packages.trust-all=true
spring.activemq.pool.enabled=true
spring.activemq.pool.max-connections=6
spring.activemq.pool.idle-timeout=30000
spring.activemq.pool.expire-timeout=0
spring.jms.pub-sub-domain=false

启动类AppQueueCustomer

package boot.example.queue.customer;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.jms.annotation.EnableJms;

/**
 * 蚂蚁舞
 */
@SpringBootApplication
/**
 * 启动消息队列
 */
@EnableJms
public class AppQueueCustomer {
    public static void main( String[] args ) {
        SpringApplication.run(AppQueueCustomer.class, args);
        System.out.println( "Hello World!" );
    }
    

}

配置一个queue ActiveMQQueueConfig

package boot.example.queue.customer.config;

import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.jms.config.DefaultJmsListenerContainerFactory;
import org.springframework.jms.config.JmsListenerContainerFactory;

import javax.jms.ConnectionFactory;

/**
 * 蚂蚁舞
 */
@Configuration
public class ActiveMQQueueConfig {

    // queue模式的ListenerContainer
    @Bean
    public JmsListenerContainerFactory<?> jmsListenerContainerQueue(ConnectionFactory activeMQConnectionFactory) {
        DefaultJmsListenerContainerFactory bean = new DefaultJmsListenerContainerFactory();
        bean.setConnectionFactory(activeMQConnectionFactory);
        //  启用queue 不启用topic
        bean.setPubSubDomain(false);
        return bean;
    }


}

消息消费端的queue

ActiveMQConstant

package boot.example.queue.customer.config;

/**
 *  蚂蚁舞
 */

import boot.example.queue.entity.BootProvider;

import java.util.LinkedList;
import java.util.List;


public class ActiveMQConstant {

    //  默认queue
    public static final String defaultQueue = "myw_queue";

    //  指定queue
    public static final String stringQueue = "stringQueue";

    //  指定list<String>
    public static final String stringListQueue = "stringListQueue";

    //  指定Object
    public static final String objQueue = "objQueue";

    //  指定List<Object>
    public static final String objListQueue = "objListQueue";

    //  简单存储默认queue消费端收到的消息
    public static List<String> defaultList = new LinkedList<>();

    public static List<String> stringQueueList = new LinkedList<>();

    public static List<List<String>> stringListQueueList = new LinkedList<>();

    public static List<BootProvider> objQueueList = new LinkedList<>();

    public static List<List<BootProvider>> objListQueueList = new LinkedList<>();


}

DefaultQueueConsumerService

package boot.example.queue.customer.service;

import boot.example.queue.customer.config.ActiveMQConstant;
import org.springframework.jms.annotation.JmsListener;
import org.springframework.stereotype.Service;
import javax.jms.JMSException;
import javax.jms.TextMessage;

/**
 *  蚂蚁舞
 */
@Service
public class DefaultQueueConsumerService {

    @JmsListener(destination = ActiveMQConstant.defaultQueue)
    public void message(TextMessage textMessage) throws JMSException {
        if(textMessage == null || textMessage.getText() == null){
            return;
        }
        System.out.println("默认消费者:"+textMessage.getText());
        ActiveMQConstant.defaultList.add(textMessage.getText());
    }


}

AQueueConsumerService

package boot.example.queue.customer.service;

import boot.example.queue.customer.config.ActiveMQConstant;
import boot.example.queue.entity.BootProvider;
import org.springframework.jms.annotation.JmsListener;
import org.springframework.stereotype.Service;

import javax.jms.ObjectMessage;
import java.util.List;

/**
 * 蚂蚁舞
 */
@Service
public class AQueueConsumerService {

    @JmsListener(destination = ActiveMQConstant.stringQueue, containerFactory = "jmsListenerContainerQueue")
    public void receiveStringQueue(String msg) {
        if(msg == null){return;}
        System.out.println("A接收到消息...." + msg);
        ActiveMQConstant.stringQueueList.add(msg);
    }

    @JmsListener(destination = ActiveMQConstant.stringListQueue, containerFactory = "jmsListenerContainerQueue")
    public void receiveStringListQueue(List<String> list) {
        if(list.isEmpty()){return;}
        System.out.println("A接收到集合队列消息...." + list);
        ActiveMQConstant.stringListQueueList.add(list);
    }

    @JmsListener(destination = ActiveMQConstant.objQueue, containerFactory = "jmsListenerContainerQueue")
    public void receiveObjQueue(ObjectMessage objectMessage) throws Exception {
        if(objectMessage == null || objectMessage.getObject() == null){return;}
        System.out.println("A接收到对象队列消息...." + objectMessage.getObject());
        BootProvider bootProvider = (BootProvider) objectMessage.getObject();
        ActiveMQConstant.objQueueList.add(bootProvider);
    }

    @SuppressWarnings("unchecked")
    @JmsListener(destination = ActiveMQConstant.objListQueue, containerFactory = "jmsListenerContainerQueue")
    public void receiveObjListQueue(ObjectMessage objectMessage) throws Exception {
        if(objectMessage == null || objectMessage.getObject() == null){return;}
        System.out.println("A接收到的对象队列消息..." + objectMessage.getObject());
        List<BootProvider> list = (List<BootProvider>) objectMessage.getObject();
        ActiveMQConstant.objListQueueList.add(list);
    }


}

BQueueConsumerService

package boot.example.queue.customer.service;

import boot.example.queue.customer.config.ActiveMQConstant;
import boot.example.queue.entity.BootProvider;
import org.springframework.jms.annotation.JmsListener;
import org.springframework.stereotype.Service;

import javax.jms.JMSException;
import javax.jms.ObjectMessage;
import javax.jms.TextMessage;
import java.util.List;

/**
 *  蚂蚁舞
 */
@Service
public class BQueueConsumerService {

    @JmsListener(destination = ActiveMQConstant.stringQueue, containerFactory = "jmsListenerContainerQueue")
    public void receiveStringQueue(TextMessage textMessage) throws JMSException {
        if(textMessage == null || textMessage.getText() == null){return;}
        System.out.println("B接收到消息...." + textMessage.getText());
        ActiveMQConstant.stringQueueList.add(textMessage.getText());
    }

    @JmsListener(destination = ActiveMQConstant.stringListQueue, containerFactory = "jmsListenerContainerQueue")
    public void receiveStringListQueue(List<String> list) {
        if(list.isEmpty()){return;}
        System.out.println("B接收到集合队列消息...." + list);
        ActiveMQConstant.stringListQueueList.add(list);
    }

    @JmsListener(destination = ActiveMQConstant.objQueue, containerFactory = "jmsListenerContainerQueue")
    public void receiveObjQueue(ObjectMessage objectMessage) throws Exception {
        if(objectMessage == null || objectMessage.getObject() == null){return;}
        System.out.println("B接收到对象队列消息...." + objectMessage.getObject());
        BootProvider bootProvider = (BootProvider) objectMessage.getObject();
        ActiveMQConstant.objQueueList.add(bootProvider);
    }

    @SuppressWarnings("unchecked")
    @JmsListener(destination = ActiveMQConstant.objListQueue, containerFactory = "jmsListenerContainerQueue")
    public void receiveObjListQueue(ObjectMessage objectMessage) throws Exception {
        if(objectMessage == null || objectMessage.getObject() == null){return;}
        System.out.println("B接收到的对象队列消息..." + objectMessage.getObject());
        List<BootProvider> list = (List<BootProvider>) objectMessage.getObject();
        ActiveMQConstant.objListQueueList.add(list);
    }
    
    


}

SwaggerConfig UI使用

package boot.example.queue.customer.config;

import com.google.common.base.Predicates;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import springfox.documentation.builders.ApiInfoBuilder;
import springfox.documentation.builders.PathSelectors;
import springfox.documentation.builders.RequestHandlerSelectors;
import springfox.documentation.service.ApiInfo;
import springfox.documentation.spi.DocumentationType;
import springfox.documentation.spring.web.plugins.Docket;
import springfox.documentation.swagger2.annotations.EnableSwagger2;

/**
 *  蚂蚁舞
 */
@Configuration
@EnableSwagger2
public class SwaggerConfig {

    @Bean
    public Docket createRestApi(){
        return new Docket(DocumentationType.SWAGGER_2).apiInfo(apiInfo()).select()
                .apis(RequestHandlerSelectors.any()).paths(PathSelectors.any())
                .paths(Predicates.not(PathSelectors.regex("/error.*")))
                .paths(PathSelectors.regex("/.*"))
                .build().apiInfo(apiInfo());
    }

    private ApiInfo apiInfo(){
        return new ApiInfoBuilder()
                .title("demo")
                .description("demo接口")
                .version("0.01")
                .build();
    }

    /**
     * http://localhost:XXXX/doc.html  地址和端口根据实际项目查看
     */


}

BootDefaultQueueCustomerController

package boot.example.queue.customer.controller;

import boot.example.queue.customer.config.ActiveMQConstant;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

import java.util.List;

/**
 * 蚂蚁舞
 */
@RestController
@RequestMapping(value="/customer")
public class BootDefaultQueueCustomerController {

    @GetMapping(value="/myw_queue")
    public List<String> myw_queue() {
        return ActiveMQConstant.defaultList;
    }

}

BootQueueCustomerController

package boot.example.queue.customer.controller;

import boot.example.queue.customer.config.ActiveMQConstant;
import boot.example.queue.entity.BootProvider;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

import java.util.List;

/**
 * 蚂蚁舞
 */
@RestController
@RequestMapping(value="/customer")
public class BootQueueCustomerController {

    @GetMapping(value="/stringQueue")
    public List<String> stringQueue() {
        return ActiveMQConstant.stringQueueList;
    }

    @GetMapping(value="/stringListQueue")
    public List<List<String>> stringListQueue() {
        return ActiveMQConstant.stringListQueueList;
    }

    @GetMapping(value="/objQueueList")
    public List<BootProvider> objQueueList() {
        return ActiveMQConstant.objQueueList;
    }

    @GetMapping(value="/objListQueueList")
    public List<List<BootProvider>> objListQueueList() {
        return ActiveMQConstant.objListQueueList;
    }


}

测试使用的对象BootProvider

package boot.example.queue.entity;

import java.io.Serializable;
import java.util.Date;

/**
 *  用在activeMq消息，必须保证package一致，不然序列化后反序列化要出错
 *  蚂蚁舞
 */
public class BootProvider implements Serializable {

    private int id;

    private String name;

    private Date date = new Date();

    public BootProvider() {
    }

    public BootProvider(int id, String name) {
        this.id = id;
        this.name = name;
    }

    public int getId() {
        return id;
    }

    public void setId(int id) {
        this.id = id;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public Date getDate() {
        return date;
    }

    public void setDate(Date date) {
        this.date = date;
    }

    @Override
    public String toString() {
        return "BootProvider{" +
                "id=" + id +
                ", name='" + name + '\'' +
                ", date=" + date +
                '}';
    }
}

结构目录

├─boot-example-demo-entity-2.0.5
│  │  pom.xml
│  │  
│  ├─src
│  │  └─main
│  │      └─java
│  │          └─boot
│  │              └─example
│  │                  └─queue
│  │                      └─entity
│  │                              BootProvider.java
├─boot-example-queue-demo-customer-2.0.5
│  │  pom.xml
│  │  
│  ├─src
│  │  ├─main
│  │  │  ├─java
│  │  │  │  └─boot
│  │  │  │      └─example
│  │  │  │          └─queue
│  │  │  │              └─customer
│  │  │  │                  │  AppQueueCustomer.java
│  │  │  │                  │  
│  │  │  │                  ├─config
│  │  │  │                  │      ActiveMQConstant.java
│  │  │  │                  │      ActiveMQQueueConfig.java
│  │  │  │                  │      SwaggerConfig.java
│  │  │  │                  │      
│  │  │  │                  ├─controller
│  │  │  │                  │      BootDefaultQueueCustomerController.java
│  │  │  │                  │      BootQueueCustomerController.java
│  │  │  │                  │      
│  │  │  │                  └─service
│  │  │  │                          AQueueConsumerService.java
│  │  │  │                          BQueueConsumerService.java
│  │  │  │                          DefaultQueueConsumerService.java
│  │  │  │                          
│  │  │  └─resources
│  │  │          application.properties
│  │  │          
│  │  └─test
│  │      └─java
│  │          └─boot
│  │              └─example
│  │                  └─queue
│  │                      └─customer
│  │                              AppQueueCustomerTest.java
│  │

启动后访问（ActiveMQ必须提前启动）

http://localhost:8042/doc.html

现在进行测试，在生产端程序发送数据，可以看到消费端收到了数据并临时保存在列表里

还可以使用List<String> 或者 List<Object> 或者直接java对象

测试下对象

消费端接收的数据

另外可以在控制台看到

A和B两个接收监听都收到了数据，看着像是轮询消费的，ActiveMQ支持存在多个消费者，但是对一个消费者而言，只会有一个消费者可以消费，其他的消费者便不能消费此消息

还有ActiveMQ默认开启持久化的，数据在安装目录的data目录下面

源码案例地址: SpringBoot+ActiveMQ源码案例

蚂蚁舞
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Springboot+ActiveMq
09-02
ActiveMQ提供高可靠的消息传递，支持多种消息模型，包括点对点和发布/订阅。 ### 3. Springboot整合ActiveMQ #### 3.1 添加依赖 在Springboot项目中，我们需要在`pom.xml`文件中添加ActiveMQ的依赖。例如，如果...
消息队列学习(springboot+kafka+activemq)
06-28
启动应用即可测试，可帮助快速了解kafka、activemq 两者在 Queue topic producer consumer 使用异同点，demo仅仅是最简化代码，演示通信和使用，无法对两者的集群模式进行测试，如果有对集群模式有兴趣，可自行扩展...
SpringBoot整合ActiveMQ[超详细版]
最新发布
wang20000102的博客
09-11 3197
SpringBoot整合ActiveMQ消息队列（Message Queue）是一种进程间或者线程间的异步通信方式。使用消息队列，消息生产者会将消息保存在消息队列中，SpringBoot整合ActiveMQ 知道消息消费者来取走它。实现服务的解耦合，并提高系统的可靠性和扩展性。目前常用的开源消息队列有很多。SpringBoot整合ActiveMQ 也就是常说的消息中间件。本篇文章以Apache ActiveMQ为例，实战整合ActiveMQ的队列模式和广播模式两种以及兼容两种的实战。
4. springboot集成activemq-消息的消费者
weixin_39563769的博客
10-25 519
springboot集成activemq，消费消息
springboot整合activeMq，支持多个MQ
eternal_tc的博客
04-08 1258
创建activeMq连接工厂，通过@Bean注入。使用@JmsListener进行监听消费数据。@Qualifier指定Bean发送数据。 支持配置多个Mq,创建不同的Bean即可，案例使用了三个MQ。以第三个说明，其他两个一样的模式。
SpringBoot整合ActiveMq
qq_35220073的博客
06-10 2054
消息队列，是基础数据结构中“先进先出”的一种数据结构。指把要传输的数据（消息）放在队列中，用队列机制来实现消息传递——生产者产生消息并把消息放入队列，然后由消费者去处理。消费者可以到指定队列拉取消息，或者订阅相应的队列，由MQ服务端给其推送消息。
Springboot 整合 activemq （生产者——消费者）
野的博客
06-07 2979
1.添加pom文件 <!-- ActiveMQ的启动器 --> <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-activemq</artifactId> </depend...
SpringBoot整合ActiveMQ消息队列和双向队列、点对点与发布订阅
10-16
SpringBoot整合ActiveMQ消息队列和双向队列、点对点与发布订阅，可以参考我的博客文章进行学习https://blog.csdn.net/sujin_/article/details/82956386
springboot整合activemq 消费者 ACK手动确认 &消息重发
08-20
springboot整合 activeMq 消费者 消费接收消息 包含队列模式点对点发 以及 主题模式一对多 这是消费者的demo consumer 。 里面有消息重发机制，手动确认ACK模式。 配合 producer 生产者demo使用。
SpringBoot整合ActiveMQ：实现生产者-消费者
缘来阁
03-27 751
整合ActiveMQ 基础 引入依赖 <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-activemq</artifactId> </dependency> <depen...
实战Spring4+ActiveMQ整合实现消息队列(生产者+消费者)
chamabo4215的博客
07-15 447
引言: 最近公司做了一个以信息安全为主的项目，其中有一个业务需求就是，项目定时监控操作用户的行为，对于一些违规操作严重的行为，以发送邮件(FoxMail)的形式进行邮件告警，可能是多人，也可能是一个人，第一次是以单人的形式，,直接在业务层需要告警的地方发送邮件即可，可是后边需求变更了，对于某些告警邮件可能会发送多人，这其中可能就会有阻塞发邮件的可能，直到把所有邮件发送完毕后再继续做下边的业务，领导...
1.1-ActiveMQ队列（Queue）模式下消息生产与消费
sql2008help的博客
02-27 292
ActiveMQ队列模式下消息生产与消费 消息生产者 package service.queue; import org.apache.activemq.ActiveMQConnectionFactory; import javax.jms.Connection; import javax.jms.DeliveryMode; import javax.jms.Destination; import javax.jms.JMSException; import javax.jms.MessageProdu
实力干货！SpringBoot JMS(ActiveMQ) 使用实践
热门推荐
qiangcuo6087的博客
01-12 4万+
摘要: 本文介绍ActiveMQ在SpringBoot中的使用，其中配置都基于注解 ActiveMQ 1. 下载windows办的activeMQ后，在以下目录可以启动： spring 2. 启动后会有以下提示 spring 3. 所以我们可以通过http://localhost:8161访问管理页面，通过tcp://localhost:6161
SpringBoot项目整合RabbitMQ
weixin_52721608的博客
09-06 718
消息队列（Message Queue）是分布式系统中常用的组件，它允许不同的应用程序之间通过发送和接收消息进行通信。Spring Boot提供了简单且强大的方式来整合消息队列，其中包括RabbitMQ、ActiveMQ、Kafka等多种消息队列实现。本文将以RabbitMQ为例，详细介绍如何使用Spring Boot来整合消息队列。通过以上步骤，我们成功地实现了Spring Boot与RabbitMQ的整合。我们配置了RabbitMQ连接信息，创建了消息生产者和消费者，然后进行了简单的测试。
springboot--ActiveMQ--消息队列
杨不易呀
07-30 312
ActiveMQ远程消息队列 一、我们创建springboot项目工程 二、创建完毕我们简单介绍 activeMQ 1.概述 消息中间件可以理解成就是一个服务软件,保存信息的容器,比如生活中的快递云柜. 我们把数据放到消息中间件当中, 然后通知对应的服务进行获取 消息中间件是在消息的传输过程中保存信息的容器 2.消息中间件应用场景 1. 使用消息服务器当做大的队列使用, 先进先出, 来...
ActiveMq(二) - 点对点模式
weixin_30564785的博客
04-15 122
1、概念 JMS有两种消息通信模型，点对点模型(point to point)(p2p)和发布/订阅模型(pub/sub),ActiveMq实现了JMS接口，同样，ActiveMq也实现了这两种模型。 点对点模型规定了一个消息只能有一个接收者，而发布/订阅模型允许一个消息可以有多个消息接收者 点对点模型 当一个消息生产者产生一个消息时，会把消息放入一个队列(Queue)中，然后消息消费者从Queu...
SpringBoot集成ActiveMQ
清风ai明月的专栏
09-03 2249
springboot集成activemq
springboot 配置多个activemq
weixin_45131680的博客
08-17 348
【代码】springboot 配置多个activemq。
springboot +activemq实现
07-08
Spring Boot与ActiveMQ的集成可以实现消息队列的功能。以下是实现步骤： 1. 配置ActiveMQ依赖：在项目的pom.xml文件中添加ActiveMQ的依赖。 ```xml <groupId>org.springframework.boot <artifactId>spring-boot...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值