Springboot集成rabbitmq——实现延迟队列

已于 2022-09-07 19:44:40 修改
阅读量3.4k 收藏 16
点赞数 1
分类专栏： springboo实战 文章标签： java-rabbitmq rabbitmq spring boot
于 2022-09-05 20:28:03 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/tang_seven/article/details/126711667
版权

目录

1.rabbitmq简介

2.延迟队列

3.Springboot集成rabbitmq

4.以死信队列形式实现

5.以插件形式实现

1.rabbitmq简介

 MQ(message queue)，从字面意思上看，本质是个队列，遵从先入先出的规则，只不过队列中存放的内容是 message 而已，是一种跨进程的通信机制，用于上下游传递消息。RabbitMq是开发中常用的一种消息中间件，由于实现服务之间的消息转发。使用了 MQ 之后，消息发送上游只需要依赖 MQ，不用依赖其他服务。

它主要基于四大核心概念：生产者、交换机、队列、消费者。其工作原理如下：

 简单来说，工作原理如下：

生产者——>生成消息——>建立连接——>交换机——>队列——>建立连接——>消费者

2.延迟队列

延时队列最重要的特性就体现在它的延时属性上，延时队列中的元素是希望在指定时间到了以后或之前取出和处理，简单来说，延时队列就是用来存放需要在指定时间被处理的元素的队列。

其可使用的应用场景如下：

  1. 订单在十分钟之内未支付则自动取消
  2. 新创建的店铺，如果在十天内都没有上传过商品，则自动发送消息提醒。
  3. 用户注册成功后，如果三天内没有登陆则进行短信提醒。

3.Springboot集成rabbitmq

关于springboot集成rabbitmq，首先我们需要导入相关依赖：

<dependencies>
    <!--RabbitMQ 依赖-->
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-amqp</artifactId>
    </dependency>
    <!--springboot 依赖-->
   <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter</artifactId>
    </dependency>
    <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>
    <!--RabbitMQ 测试依赖-->
    <dependency>
        <groupId>org.springframework.amqp</groupId>
        <artifactId>spring-rabbit-test</artifactId>
        <scope>test</scope>
    </dependency>
</dependencies>

编写配置文件，用以连接rabbitmq（此处使用application.yml形式）：

spring:
  rabbitmq:
    host: 127.0.0.1   #主机地址
    port: 5672    #端口号
    username: guest   #用户名   
    password: guest   #密码

然后，我们就可以在springboot项目中使用rabbitmq相关的包，或是使用 rabbitTemplate 来使用相关的方法。

4.以死信队列形式实现

死信，顾名思义就是无法被消费的消息。一般来说，producer 将消息投递到 broker 或者直接到queue 里了，consumer 从 queue 取出消息进行消费，但某些时候由于特定的原因导致queu 中的某些消息无法被消费，这样的消息如果没有后续的处理，就变成了死信，有死信自然就有了死信队列。

而由于TTL（生存时间）过期导致的死信，就是我们实现延迟队列的的方式。

我们需要声明如下形式的交互机和队列，以及对应的routing key，并进行绑定：

import org.springframework.amqp.core.*;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

import java.util.HashMap;
import java.util.Map;


@Configuration
public class TtlQueueConfig {
    //普通交换机及队列
    public static final String X_EXCHANGE = "X";
    public static final String QUEUE_A = "QA";
    public static final String QUEUE_B = "QB";
    //死信交换机及队列
    public static final String Y_DEAD_LETTER_EXCHANGE = "Y";
    public static final String DEAD_LETTER_QUEUE = "QD";
    //通用队列
    public static final String QUEUE_C = "QC";

    // 声明 xExchange
    @Bean("xExchange")
    public DirectExchange xExchange() {
        return new DirectExchange(X_EXCHANGE);
    }
    //声明队列 A ttl 为 10s 并绑定到对应的死信交换机
    @Bean("queueA")
    public Queue queueA() {
        Map<String, Object> args = new HashMap<>(3);
        //声明当前队列绑定的死信交换机
        args.put("x-dead-letter-exchange", Y_DEAD_LETTER_EXCHANGE);
        //声明当前队列的死信路由 key
        args.put("x-dead-letter-routing-key", "YD");
        //声明队列的 TTL
        args.put("x-message-ttl", 10000);
        return QueueBuilder.durable(QUEUE_A).withArguments(args).build();
    }

    // 声明队列 A 绑定 X 交换机
    @Bean
    public Binding queueaBindingX(@Qualifier("queueA") Queue queueA,
                                  @Qualifier("xExchange") DirectExchange xExchange) {
        return BindingBuilder.bind(queueA).to(xExchange).with("XA");
    }

    //声明队列 B ttl 为 40s 并绑定到对应的死信交换机
    @Bean("queueB")
    public Queue queueB() {
        Map<String, Object> args = new HashMap<>(3);
        //声明当前队列绑定的死信交换机
        args.put("x-dead-letter-exchange", Y_DEAD_LETTER_EXCHANGE);
        //声明当前队列的死信路由 key
        args.put("x-dead-letter-routing-key", "YD");
        //声明队列的 TTL
        args.put("x-message-ttl", 40000);
        return QueueBuilder.durable(QUEUE_B).withArguments(args).build();
    }

    //声明队列 B 绑定 X 交换机
    @Bean
    public Binding queuebBindingX(@Qualifier("queueB") Queue queue1B,
                                  @Qualifier("xExchange") DirectExchange xExchange) {
        return BindingBuilder.bind(queue1B).to(xExchange).with("XB");
    }
    //声明通用队列C 不设ttl，由消费者决定ttl
    @Bean("queueC")
    public Queue queueC() {
        Map<String, Object> args = new HashMap<>(3);
        //声明当前队列绑定的死信交换机
        args.put("x-dead-letter-exchange", Y_DEAD_LETTER_EXCHANGE);
        //声明当前队列的死信路由 key
        args.put("x-dead-letter-routing-key", "YD");
        return QueueBuilder.durable(QUEUE_C).withArguments(args).build();
    }
    // 声明队列 A 绑定 X 交换机
    @Bean
    public Binding queuecBindingX(@Qualifier("queueC") Queue queueC,
                                  @Qualifier("xExchange") DirectExchange xExchange) {
        return BindingBuilder.bind(queueC).to(xExchange).with("XC");
    }


    // 声明 死信队列交换机
    @Bean("yExchange")
    public DirectExchange yExchange() {
        return new DirectExchange(Y_DEAD_LETTER_EXCHANGE);
    }
    //声明死信队列 QD
    @Bean("queueD")
    public Queue queueD() {
        return new Queue(DEAD_LETTER_QUEUE,true);
    }
    //声明死信队列 QD 绑定关系
    @Bean
    public Binding deadLetterBindingQAD(@Qualifier("queueD") Queue queueD,
                                        @Qualifier("yExchange") DirectExchange yExchange) {
        return BindingBuilder.bind(queueD).to(yExchange).with("YD");
    }

}

 其中，QD为死信队列。当QA和QB队列中的消息，达到设定的TTL（10s和40s）后，将进入指定的死信队列QD。该方法下一个TTL指定一个队列

其中的QC作为通用的队列，即在消费者处指定消息对应的TTL，TTL过期后转入死信队列。使用该通用队列可以避免每增加一个新的时间需求，就要新增一个队列的问题。但该方法由于队列先进先出的性质，会导致一定的问题：

即先发出一个TTL为10s的消息a，进入队列；再马上发出一个TTL为2s的消息b，进入队列。由于队列的性质，会在消息a的TTL结束后，a进入2死信队列后，b才会进入死信队列。而不是根据TTL的时间，b比a先进入死信队列。

声明交换机、队列，并绑定成功后，编写死信队列消费者代码;

import com.rabbitmq.client.Channel;
import lombok.extern.slf4j.Slf4j;
import org.springframework.amqp.core.Message;
import org.springframework.amqp.rabbit.annotation.RabbitListener;
import org.springframework.stereotype.Component;

import java.io.IOException;
import java.util.Date;


@Slf4j
@Component
public class DeadLetterQueueConsumer {

    @RabbitListener(queues = "QD")
    public void receiveD(Message message, Channel channel) throws IOException {
        String msg = new String(message.getBody());
        log.info("当前时间：{},收到死信队列信息：{}", new Date().toString(), msg);
    }

}

 在controller中编写生产者代码，进行测试：

1.导入RabbitTemplate，以便使用rabbitmq相关方法。

    @Resource
    private RabbitTemplate rabbitTemplate;

 生产者代码，发消息给队列QA和QB：

    @GetMapping("/ttl/sendMsg/{message}")
    public void sendMsg(@PathVariable String message) {
        log.info("当前时间：{},发送一条信息给两个 TTL 队列:{}", new Date(), message);
        rabbitTemplate.convertAndSend("X", "XA", "消息来自 ttl 为 10S 的队列: " + message);
        rabbitTemplate.convertAndSend("X", "XB", "消息来自 ttl 为 40S 的队列: " + message);
    }

 结果如图：

 测试通用队列QC的效果：

    @GetMapping("/ttl/send/{message}/{ttlTime}")
    public void sendMsg(@PathVariable String message, @PathVariable String ttlTime) {
        rabbitTemplate.convertAndSend("X", "XC", message, correlationData -> {
            correlationData.getMessageProperties().setExpiration(ttlTime);
            return correlationData;
        });
        log.info("当前时间：{},发送一条时长{}毫秒 TTL 信息给队列 C:{}", new Date(), ttlTime, message);
    }

结果如图：

可以看到， 两条消息几乎同时到达死信队列，因为TTL为2s的消息由于被堵在TTL为10s的消息后导致。

5.以插件形式实现

上述问题可以通过插件解决，可去官网下载 (opens new window) rabbitmq_delayed_message_exchange 插件，放置到 RabbitMQ 的插件目录，并使用命令安装：rabbitmq-plugins enable rabbitmq_delayed_message_exchange

安装成功后，效果如图：

使用该插件后，延时队列的工作原理如图：

消息将不再存放在延时队列中，而是存放于延迟交换机中，由交换机进行分配。

声明交互机及队列代码如下：

import org.springframework.amqp.core.Binding;
import org.springframework.amqp.core.BindingBuilder;
import org.springframework.amqp.core.CustomExchange;
import org.springframework.amqp.core.Queue;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

import java.util.HashMap;
import java.util.Map;

@Configuration
public class DelayedQueueConfig {
    //延迟队列、交换机及路由名称
    public static final String DELAYED_QUEUE_NAME = "delayed.queue";
    public static final String DELAYED_EXCHANGE_NAME = "delayed.exchange";
    public static final String DELAYED_ROUTING_KEY = "delayed.routingkey";

    @Bean("delayedQueue")
    public Queue delayedQueue() {
        return new Queue(DELAYED_QUEUE_NAME);
    }

    //自定义交换机 我们在这里定义的是一个延迟交换机
    @Bean("delayedExchange")
    public CustomExchange delayedExchange() {
        Map<String, Object> args = new HashMap<>();
        //自定义交换机的类型，指定分发方式
        args.put("x-delayed-type", "direct");
        //此处type指定为延迟交换机
        return new CustomExchange(DELAYED_EXCHANGE_NAME, "x-delayed-message", true, false, args);
    }

    @Bean
    public Binding bindingDelayedQueue(@Qualifier("delayedQueue") Queue queue,
                                       @Qualifier("delayedExchange") CustomExchange delayedExchange) {
        return BindingBuilder.bind(queue).to(delayedExchange).with(DELAYED_ROUTING_KEY).noargs();
    }
}

 编写监听延迟队列代码：

import lombok.extern.slf4j.Slf4j;
import org.springframework.amqp.core.Message;
import org.springframework.amqp.rabbit.annotation.RabbitListener;
import org.springframework.stereotype.Component;
import java.util.Date;
import static com.seven.rabbitmq.config.DelayedQueueConfig.DELAYED_QUEUE_NAME;

@Slf4j
@Component
public class DelayQueueConsumer {

    @RabbitListener(queues = DELAYED_QUEUE_NAME)
    public void receiveDelayedQueue(Message message) {
        String msg = new String(message.getBody());
        log.info("当前时间：{},收到延时队列的消息：{}", new Date().toString(), msg);
    }
}

编写消费者代码：

    @GetMapping("/ttl/send/delay/{message}/{delayTime}")
    public void sendMsg(@PathVariable String message, @PathVariable Integer delayTime) {
        rabbitTemplate.convertAndSend(DELAYED_EXCHANGE_NAME, DELAYED_ROUTING_KEY, message,
                correlationData -> {
                    correlationData.getMessageProperties().setDelay(delayTime);
                    return correlationData;
                });
        log.info(" 当前时间：{}, 发送一条延迟{}毫秒的信息给队列delayed.queue:{}", new Date(), delayTime, message);
    }

测试结果：

可以看到，消息b在TTL过期后，由延迟交换机马上分发出去，不需等待TTL为10s的消息a过期，达到预设目的。

tang_seven
关注
  • 1
    点赞
  • 踩
  • 16
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
SpringBoot集成RabbitMQ的方法(死信队列)
08-26
主要介绍了SpringBoot集成RabbitMQ的方法(死信队列)，文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值，需要的朋友们下面随着小编来一起学习学习吧
SpringBoot使用RabbitMQ延时队列(小白必备)
08-25
主要介绍了SpringBoot使用RabbitMQ延时队列(小白必备)，详细的介绍延迟队列的使用场景及其如何使用，需要的小伙伴可以一起来了解一下
SpringBoot实现RabbitMQ延迟队列
sjhnanwang的专栏
03-25 387
rabbitmq延迟队列实现方式
SpringBoot之RabbitMQ实现两种延时队列（订单延迟取消）
AP0906424的博客
05-14 1805
最近在做电商项目时，订单需求要求用户在规定时间内（比如30分钟）完成支付，否则订单关闭，释放库存。要实现这个功能有很多种方法： 1、前端处理 前端js写一个倒计时，在规定时间内用户没有支付，则用户再次进入订单时触发订单关闭操作。倒计时参考：js倒计时 不过这种前端方法有一个弊端是必须进入当前倒计时页面才会触发。比如：用户退出倒计时页面，那么即使在规定的时间内没有支付也不会关闭订单释放库存；优点是简单容易实现。 2、后端处理 对于后端处理，可以写一个定时器去查询订单，但这样的会频繁查询，也不太理想。
SpringBoot系统搭建集成-016-RabbitMq延时队列
苍云烟
06-06 1034
延时队列即就是放置在该队列里面的消息是不需要立即消费的，而是等待一段时间之后取出消费。
RabbitMQ基础入门--SpringBoot + RabbitMQ 实现延时队列
wl921的博客
12-19 458
什么是QM 消息队列（Message Queue，简称MQ），从字面意思上看，本质是个队列，FIFO先入先出，只不过队列中存放的内容是message而已。其主要用途：不同进程Process/线程Thread之间通信。 什么是RabbitQM RabbitMQ是实现了高级消息队列协议（AMQP）的开源消息代理软件（亦称面向消息的中间件）。RabbitMQ服务器是用Erlang语言编写的，而集群和故障...
SpringBoot整合RabbitMQ实现消息延迟队列(含源码)
热门推荐
Venus's Blog
07-04 9万+
*** 商户订单号/*** 支付宝订单号//为true,则交换机处理消息到路由失败，则会返回给生产者 配置文件指定，则这里不需指定 rabbitTemplate . setMandatory(true);//开启强制消息投递（mandatory为设置为true），但消息未被路由至任何一个queue，则回退一条消息 rabbitTemplate . setReturnsCallback(returned -> {});
SpringBoot + RabbitMQ 做延时队列
qq_44680160的博客
12-19 876
SpringBoot + RabbitMQ 做延时队列
【RabbitMQ】Springboot实现延迟队列+死信队列
m0_64337991的博客
02-02 6782
目录 死信的概念 应用场景 死信的来源 延迟队列 延迟队列概念 延迟队列使用场景 springboot实现 代码架构图 配置类 生产者（在web界面输入消息） 消费者 结果 问题和新需求 延时队列优化 代码架构图 配置文件类代码 消息生产者代码 消费者 存在的问题 解决：安装延时队列插件 代码架构图 配置文件类代码 消息生产者代码 消费者 结果 总结 死信的概念 死信，顾名思义就是无法被消费的消息，字面意思可以这样理解 一般来说，生产者将消息..
springBoot之延时队列
weixin_47366919的博客
05-17 3787
1、创建延时队列 package com.example.demo.utils; import lombok.Data; import java.util.concurrent.DelayQueue; /** * 延时队列 * 需要保证队列单例 */ @Data public class DelayTaskQueue { private static class Holder{ static DelayQueue<DelayTask> instance = new
SpringBoot集成RabbitMQ延时队列，自定义延时时间Demo
09-16
该示例通过 rabbitmq_delayed_message_exchange 插件实现自定义延时时间的延时队列。 示例是纯净的，只引入了需要的架包 启动示例时，请确保MQ已经安装了延时插件(附件里带有插件及安装说明)以及示例的MQ相关的配置是否和你的环境一致 启动成功后访问 ip:port/mq/push(参数 msg 消息；delayTime 延时毫秒时间) 测试，在后端控制台中查看效果
如何使用SpringBoot与RabbitMQ结合实现延迟队列
02-25
何为延迟队列？顾名思义，延迟队列就是进入该队列的消息会被延迟消费的队列。而一般的队列，消息一旦入队了之后就会被消费者马上消费。延迟队列多用于需要延迟工作的场景。最常见的是以下两种场景：1.延迟消费。比如：用户生成订单之后，需要过一段时间校验订单的支付状态，如果订单仍未支付则需要及时地关闭订单。用户注册成功之后，需要过一段时间比如一周后校验用户的使用情况，如果发现用户活跃度较低，则发送邮件或者短信来提醒用户使用。2.延迟重试。比如消费者从队列里消费消息时失败了，但是想要延迟一段时间后自动重试。如果不使用延迟队列，那么我们只能通过一个轮询扫描程序去完成。这种方案既不优雅，也不方便做成统一的服务便于
Spring Boot与RabbitMQ结合实现延迟队列的示例
08-28
本篇文章主要介绍了Spring Boot与RabbitMQ结合实现延迟队列的示例，具有一定的参考价值，感兴趣的小伙伴们可以参考一下
RabbitMQ中的交换机类型
qq_64064246的博客
04-26 549
另一方面，知道如何处理消息，例如递交给某个特别队列、递交给所有队列、或是将消息丢弃。在Fanout模式中，一条消息，会被所有订阅的队列都消费。但是，在某些场景下，我们希望不同的消息被不同的队列消费。，因此如果没有任何队列与Exchange绑定，或者没有符合路由规则的队列，那么消息会丢失！不过队列一定要与交换机绑定。消息的发送方在 向 Exchange发送消息时，也必须指定消息的。Exchange不再把消息交给每一个绑定的队列，而是根据消息的。队列与交换机的绑定，不能是任意绑定了，而是要指定一个。
RabbitMQ（高级）笔记
程序员碎像的博客
04-26 359
（2）生产者确认 引入日志依赖 二、MQ持久化 （1）持久化介绍 发送100万条消息给队列，需要先在application.yml中取消生产者确认 没有持久化的测试用例，会出行阻塞的状态： 改为持久化后的测试用例： 使用auto自动模式 注意：创建的simple.queue需要Add Dead letter exchange，其他都跟之前创建的操作差不多 监听 测试用例 （3）取消订单
异步线程与RabbitMQ应该如何选择？
weixin_53390884的博客
04-23 351
异步线程是一种编程技术，它允许程序在执行长时间操作（如I/O操作、网络请求等）时，不阻塞主执行线程。这可以通过多线程或使用语言特性（如Python的。
RabbitMq总结
weixin_70202553的博客
04-26 377
消息的可靠性需要保证开启消息持久化，不然宕机消息就丢失了，首先是生产者发送消息的可靠性，mq要保证每一条消息都进行ack应答，而客户端收到了ack应答才继续发送，否则超时重试，当然需要设计接口的幂等性，对于消费者，要消费消息之后进行反馈，当mq收到反馈之后才删除消息。将消息发送到一个单独的事务队列，再从事务队列发送到消费者可消费的队列，若出现问题则回滚，若没有问题则删除事务队列中的消息。rabbitmq由消费者，生产者，交换机，队列，bindingkey组成，交换机存在三种，分别对应广播，单播，多播。
RabbitMQ Transport indicated EOF 总结
最新发布
jacke121的专栏
04-29 357
RabbitMQ Transport indicated EOF
什么是RabbitMQ，RabbitMQ基本概念，RabbitMQ的使用场景
小小鱼儿小小林的博客
04-25 436
RabbitMQ是一个开源的消息代理软件（也称为消息队列），它实现了高级消息队列协议（AMQP）。RabbitMQ提供了一种应用程序对应用程序之间的通信方法，基于消费-生产者模型，允许分布式系统中的组件进行异步通信。
springboot集成rabbitmq mqtt实现消息订阅和发送
06-10
Spring Boot集成RabbitMQ和MQTT可以使用Spring Boot的AMQP和Paho客户端库。以下是集成步骤： 1. 添加依赖 在pom.xml中添加以下依赖： ``` <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-amqp</artifactId> </dependency> <dependency> <groupId>org.eclipse.paho</groupId> <artifactId>org.eclipse.paho.client.mqttv3</artifactId> <version>1.2.0</version> </dependency> ``` 2. 配置RabbitMQ连接 在application.properties中配置RabbitMQ连接信息： ``` spring.rabbitmq.host=localhost spring.rabbitmq.port=5672 spring.rabbitmq.username=guest spring.rabbitmq.password=guest ``` 3. 创建RabbitMQ消息接收者 创建一个类来接收RabbitMQ消息。在该类中，使用@RabbitListener注解标记方法，指定队列名称和消息处理方法。 ``` @Component public class RabbitMQReceiver { @RabbitListener(queues = "test") public void receive(String message) { // 处理消息 } } ``` 4. 创建MQTT消息接收者 创建一个类来接收MQTT消息。在该类中，实现MqttCallback接口，重写messageArrived方法来处理接收到的消息。 ``` @Component public class MQTTReceiver implements MqttCallback { @Override public void connectionLost(Throwable throwable) { // 连接丢失 } @Override public void messageArrived(String topic, MqttMessage mqttMessage) throws Exception { // 处理消息 } @Override public void deliveryComplete(IMqttDeliveryToken iMqttDeliveryToken) { // 消息发送完成 } } ``` 5. 创建RabbitMQ消息发送者 创建一个类来发送RabbitMQ消息。在该类中，注入AmqpTemplate并调用convertAndSend方法来发送消息到指定队列。 ``` @Component public class RabbitMQSender { @Autowired private AmqpTemplate amqpTemplate; public void send(String message) { amqpTemplate.convertAndSend("test", message); } } ``` 6. 创建MQTT消息发送者 创建一个类来发送MQTT消息。在该类中，注入MqttClient并调用connect、publish和disconnect方法来发送消息。 ``` @Component public class MQTTSender { @Autowired private MqttClient mqttClient; @Autowired private MqttConnectOptions mqttConnectOptions; public void send(String topic, String message) throws MqttException { MqttMessage mqttMessage = new MqttMessage(message.getBytes()); mqttClient.connect(mqttConnectOptions); mqttClient.publish(topic, mqttMessage); mqttClient.disconnect(); } } ``` 以上是在Spring Boot中集成RabbitMQ和MQTT实现消息订阅和发送的基本步骤。需要注意的是，AMQP和MQTT是不同的消息协议，需要根据实际情况选择使用哪个协议。另外，需要确保网络通畅，否则可能会出现消息丢失等问题。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值