SpringBoot ~ 整合AMQP（RabbitMQ）

最新推荐文章于 2024-02-17 19:09:01 发布
置顶 最新推荐文章于 2024-02-17 19:09:01 发布
阅读量592 收藏
点赞数 22
分类专栏： SpringBoot
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_39743981/article/details/106616494
版权

  1. 添加pom依赖

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

  2. application.properties配置

    spring.rabbitmq.host=***.***.***.***
spring.rabbitmq.port=5762
spring.rabbitmq.username=admin
spring.rabbitmq.password=***

  3. 在RabbitMQ中所有的消息生产者提交的消息都会交由Exchange进行再分配，Exchange会根据不同的策略将消息分发到不同的Queue中。RabbitMQ提供了4种不同策略，分别是Direct、Fanout、Topic、Header，4种策略中前三种使用率较高

    • Direct

      DirectExchange的路由策略是将消息队列绑定到一个DirectExchange上，但一条消息到达DirectExchange时会被转发到与该条消息routing key相同的Queue上

      • DirectExchange的配置如下：

        /**
 * @author wsyjlly
 * @create 2019.07.17 - 21:33
 **/
@Configuration
public class RabbitDirectConfig {
    public final static String DIRECTNAME = "ysw-direct";
    @Bean
    Queue queue1(){
        return new Queue("queue-direct1");
    }

    @Bean

    Queue queue2(){
        return new Queue("queue-direct2");
    }

    @Bean
    Queue queue3(){
        return new Queue("queue-direct3");
    }

    @Bean
    DirectExchange directExchange(){
        return new DirectExchange(DIRECTNAME,true,false);
    }

    @Bean
    Binding binding1(){
        return BindingBuilder.bind(queue1()).to(directExchange()).with("direct1");
    }

    @Bean
    Binding binding2(){
        return BindingBuilder.bind(queue2()).to(directExchange()).with("direct2");
    }
}

        DirectExchange和Binding两个Bean的配置可以省略掉，即如果使用DirectExchange，只配置一个Queue的实例即可

      • 配置消费者

        /**
 * @author wsyjlly
 * @create 2019.07.17 - 21:42
 **/
@Component
public class DirectReceiver {
    Logger logger= LoggerFactory.getLogger(getClass());

    @RabbitListener(queues = "queue-direct1")
    public void directHandler1(String msg){
        logger.info("\033[30;4m"+"queue-direct1:"+msg+"\033[0m");
    }

    @RabbitListener(queues = "queue-direct2")
    public void directHandler2(String msg){
        logger.info("\033[30;4m"+"queue-direct2:"+msg+"\033[0m");
    }

    @RabbitListener(queues = "queue-direct3")
    public void directHandler3(String msg){
        logger.info("\033[30;4m"+"queue-direct3:"+msg+"\033[0m");
    }
}

        通过@RabbitListener注解指定一个方法是一个消费者方法，方法参数就是所接收的消息。

      • 消息发送

        通过注入RabbitTemplate对象来进行消息发送，在这里我通过定时任务使其自定发送，须开启定时任务，详细操作可查看<SpringBoot定时任务@Schedule>一节

        /**
 * @author wsyjlly
 * @create 2019.07.18 - 1:13
 **/
@Component
public class RabbitmqSchedule {
    @Autowired
    RabbitTemplate rabbitTemplate;
    Logger logger = LoggerFactory.getLogger(getClass());

    @Scheduled(fixedDelay = 5000,initialDelay = 3000)
    public void direct(){
        String message = "direct-task";
        logger.info("\033[30;4m"+message+"\033[0m");
        rabbitTemplate.convertAndSend("ysw-direct","direct1",message);
        rabbitTemplate.convertAndSend("ysw-direct","direct2",message);
        rabbitTemplate.convertAndSend("queue-direct3",message);
    }
}

    • Fanout

      FanoutExchange的数据交换策略是把所有到达FanoutExchange的消息转发给所有与他绑定的Queue，在这种策略中，routingkey将不起作用。

      • FanoutExchange的配置方式如下：

        /**
 * @author wsyjlly
 * @create 2019.07.17 - 21:33
 **/
@Configuration
public class RabbitFanoutConfig {
    public final static String FANOUTNAME = "ysw-fanout";

    @Bean
    Queue queue4(){
        return new Queue("queue-fanout1");
    }

    @Bean
    Queue queue5(){
        return new Queue("queue-fanout2");
    }

    @Bean
    Queue queue6(){
        return new Queue("queue-fanout3");
    }

    @Bean
    FanoutExchange fanoutExchange(){
        return new FanoutExchange(FANOUTNAME,true,false);
    }

    @Bean
    Binding binding4(){
        return BindingBuilder.bind(queue4()).to(fanoutExchange());
    }

    @Bean
    Binding binding5(){
        return BindingBuilder.bind(queue5()).to(fanoutExchange());
    }

    @Bean
    Binding binding6(){
        return BindingBuilder.bind(queue6()).to(fanoutExchange());
    }
}

      • 配置消费者

        /**
 * @author wsyjlly
 * @create 2019.07.17 - 21:42
 **/
@Component
public class FanoutReceiver {
    Logger logger= LoggerFactory.getLogger(getClass());

    @RabbitListener(queues = "queue-fanout1")
    public void fanoutHandler1(String msg){
        logger.info("\033[31;4m"+"queue-fanout1:"+msg+"\033[0m");
    }

    @RabbitListener(queues = "queue-fanout2")
    public void fanoutHandler2(String msg){
        logger.info("\033[31;4m"+"queue-fanout2:"+msg+"\033[0m");
    }

    @RabbitListener(queues = "queue-fanout3")
    public void fanoutHandler3(String msg){
        logger.info("\033[31;4m"+"queue-fanout3:"+msg+"\033[0m");
    }
}

      • 消息发送

        /**
 * @author wsyjlly
 * @create 2019.07.18 - 1:13
 **/
@Component
public class RabbitmqSchedule {
    @Autowired
    RabbitTemplate rabbitTemplate;
    Logger logger = LoggerFactory.getLogger(getClass());

    Scheduled(fixedDelay = 5000,initialDelay = 4000)
    public void fanout(){
        String message = "fanout-task";
        logger.info("\033[31;4m"+message+"\033[0m");
        rabbitTemplate.convertAndSend("ysw-fanout",null,message);
    }
}

    • Topic

      TopicExchange是比较复杂也比较灵活的一种路由策略，在TopicExchange中，Queue通过routingkey绑定到TopicExchange上，当消息发送到TopicExchange后，TopicExchange根据消息的routingkey将消息路由到一个或多个Queue上。

      • TopicExchange配置如下：

        /**
 * @author wsyjlly
 * @create 2019.07.17 - 21:33
 **/
@Configuration
public class RabbitTopicConfig {
    public final static String TOPIC_NAME = "ysw-topic";
    @Bean
    Queue queue7(){
        return new Queue("queue-topic1");
    }

    @Bean
    Queue queue8(){
        return new Queue("queue-topic2");
    }

    @Bean
    Queue queue9(){
        return new Queue("queue-topic3");
    }

    @Bean
    TopicExchange topicExchange(){
        return new TopicExchange(TOPIC_NAME,true,false);
    }

    @Bean
    Binding binding7(){
         /*
         * 匹配规则
         * 绑定键binding key也必须是这种形式。以特定路由键发送的消息将会发送到所有绑定键与之匹配的队列中。但绑定键有两种特殊的情况：
         * 绑定键binding key也必须是这种形式。以特定路由键发送的消息将会发送到所有绑定键与之匹配的队列中。但绑定键有两种特殊的情况：
         * ①*（星号）仅代表一个单词
         * ②#（井号）代表任意个单词
         **/
        return BindingBuilder.bind(queue7()).to(topicExchange()).with("#.topic1");
    }

    @Bean
    Binding binding8(){
        return BindingBuilder.bind(queue8()).to(topicExchange()).with("topic2.#");
    }

    @Bean
    Binding binding9(){
        return BindingBuilder.bind(queue9()).to(topicExchange()).with("#.topic3.*");
    }
}

      • 配置消费者

        /**
 * @author wsyjlly
 * @create 2019.07.17 - 21:42
 **/
@Component
public class TopicReceiver {
    Logger logger= LoggerFactory.getLogger(getClass());

    @RabbitListener(queues = "queue-topic1")
    public void topicHandler1(String msg){
        logger.info("\033[32;4m"+"queue-topic1:"+msg+"\033[0m");
    }

    @RabbitListener(queues = "queue-topic2")
    public void topicHandler2(String msg){
        logger.info("\033[32;4m"+"queue-topic2:"+msg+"\033[0m");
    }

    @RabbitListener(queues = "queue-topic3")
    public void topicHandler3(String msg){
        logger.info("\033[32;4m"+"queue-topic3:"+msg+"\033[0m");
    }
}

      • 消息发送

        /**
 * @author wsyjlly
 * @create 2019.07.18 - 1:13
 **/
@Component
public class RabbitmqSchedule {
    @Autowired
    RabbitTemplate rabbitTemplate;
    Logger logger = LoggerFactory.getLogger(getClass());

    @Scheduled(cron = "0-30/6 * * * * ?")
    public void topic(){
        String message = "topic-task";
        int i = 0;
        logger.info("\033[32;4m"+message+"\033[0m");
        rabbitTemplate.convertAndSend(RabbitTopicConfig.TOPIC_NAME,
        "topic1.news",message + 1);//topic1
        rabbitTemplate.convertAndSend(RabbitTopicConfig.TOPIC_NAME,
        "topic1.salary",message + 2);//topic1
        rabbitTemplate.convertAndSend(RabbitTopicConfig.TOPIC_NAME,
        "topic2.news",message + 3);//topic2
        rabbitTemplate.convertAndSend(RabbitTopicConfig.TOPIC_NAME,
        "topic2.item",message + 4);//topic2
        rabbitTemplate.convertAndSend(RabbitTopicConfig.TOPIC_NAME,
        "topic2.sth.topic1",message + 5);//topic2&topic1
        rabbitTemplate.convertAndSend(RabbitTopicConfig.TOPIC_NAME,
        "topic1.sth.topic2",message + 6);//topic2&topic1
        rabbitTemplate.convertAndSend(RabbitTopicConfig.TOPIC_NAME,
        "topic3",message + 7);//topic3
        rabbitTemplate.convertAndSend(RabbitTopicConfig.TOPIC_NAME,
        "topic3.news",message + 8);//topic3
        rabbitTemplate.convertAndSend(RabbitTopicConfig.TOPIC_NAME,
        "topic1.topic3",message + 9); //topic1&topic3
        rabbitTemplate.convertAndSend(RabbitTopicConfig.TOPIC_NAME,
        "topic2.topic3",message + 10);//topic2&topic3
        rabbitTemplate.convertAndSend(RabbitTopicConfig.TOPIC_NAME,
        "topic3.topic1",message + 11);//topic3&topic1
        rabbitTemplate.convertAndSend(RabbitTopicConfig.TOPIC_NAME,
        "topic2.topic3.topic1",message + 12);//topic1&topic2&topic3
    }
}

    • Header

      HeaderExchange是一种较少使用的路由策略，HeaderExchange会根据消息的Header将消息路由到不同的Queue上，这种策略也和routingkey无关。

      • HeaderExchange配置如下：

        /**
 * @author wsyjlly
 * @create 2019.07.17 - 21:33
 **/
@Configuration
public class RabbitHeaderConfig {
    public final static String HEADER_NAME = "ysw-header";
    @Bean
    Queue queue10(){
        return new Queue("queue-header1");
    }

    @Bean

    Queue queue11(){
        return new Queue("queue-header2");
    }

    @Bean
    Queue queue12(){
        return new Queue("queue-header3");
    }

    @Bean
    HeadersExchange headersExchange(){
        return new HeadersExchange(HEADER_NAME,true,false);
    }

    @Bean
    Binding binding10(){
        Map<String,Object> map = new HashMap<>();
        map.put("age", "18");
        map.put("name", "ysw");
        return BindingBuilder.bind(queue10()).to(headersExchange()).whereAny(map).match();
    }

    @Bean
    Binding binding11(){
        Map<String,Object> map = new HashMap<>();
        map.put("name", "ysw");
        return BindingBuilder.bind(queue11()).to(headersExchange()).where("age").exists();
    }

    @Bean
    Binding binding12(){
        Map<String,Object> map = new HashMap<>();
        map.put("age", "18");
        map.put("name", "ysw");
        return BindingBuilder.bind(queue12()).to(headersExchange()).whereAll(map).match();
    }
}

        Binding配置注释：whereAny表示消息的Header中只要有一个Header匹配上map中的key/value，就把该消息路由到名为“queue-header1”的Queue上；whereAll方法表示消息的所有Header都要匹配，才将消息路由到名为“queue-header2”的Queue上；where表示只要消息的header中包含age，无论age值为多少，都将消息路由到名为“queue-header2”的Queue上。

      • 配置消费者

        /**
 * @author wsyjlly
 * @create 2019.07.17 - 21:42
 **/
@Component
public class HeaderReceiver {
    Logger logger= LoggerFactory.getLogger(getClass());

    @RabbitListener(queues = "queue-header1")
    public void headerHandler1(byte[] msg){
        logger.info("\033[33;4m"+"queue-header1:"+new String(msg,0,msg.length)+"\033[0m");
    }

    @RabbitListener(queues = "queue-header2")
    public void headerHandler2(byte[] msg){
        logger.info("\033[33;4m"+"queue-header2:"+new String(msg,0,msg.length)+"\033[0m");
    }

    @RabbitListener(queues = "queue-header3")
    public void headerHandler3(byte[] msg){
        logger.info("\033[33;4m"+"queue-header3:"+new String(msg,0,msg.length)+"\033[0m");
    }
}

      • 消息发送

        /**
 * @author wsyjlly
 * @create 2019.07.18 - 1:13
 **/
@Component
public class RabbitmqSchedule {
    @Autowired
    RabbitTemplate rabbitTemplate;
    Logger logger = LoggerFactory.getLogger(getClass());

    @Scheduled(cron = "0-30/3 * * * * ?")
    public void header(){
        String message = "header-task";
        logger.info("\033[33;4m"+message+"\033[0m");

        Message message1 = MessageBuilder.withBody("name=name".getBytes())
        .setHeader("name", "aaa").build();
        Message message2 = MessageBuilder.withBody("name=ysw".getBytes())
        .setHeader("name", "ysw").build();
        Message message3 = MessageBuilder.withBody("age=19".getBytes())
        .setHeader("age", "19").build();
        Message message4 = MessageBuilder.withBody("age=18".getBytes())
        .setHeader("age", "18").build();
        Message message5 = MessageBuilder.withBody("name=ysw&age=18".getBytes())
        .setHeader("name", "ysw").setHeader("age","18").build();
        Message message6 = MessageBuilder.withBody("name=ysw&age=19".getBytes())
        .setHeader("name", "ysw").setHeader("age","19").build();
        Message message7 = MessageBuilder.withBody("name=aaa&age=18".getBytes())
        .setHeader("name", "aaa").setHeader("age","18").build();

        rabbitTemplate.convertAndSend(RabbitHeaderConfig.HEADER_NAME,
        null,message1);
        rabbitTemplate.convertAndSend(RabbitHeaderConfig.HEADER_NAME,
        null,message2);
        rabbitTemplate.convertAndSend(RabbitHeaderConfig.HEADER_NAME,
        null,message3);
        rabbitTemplate.convertAndSend(RabbitHeaderConfig.HEADER_NAME,
        null,message4);
        rabbitTemplate.convertAndSend(RabbitHeaderConfig.HEADER_NAME,
        null,message5);
        rabbitTemplate.convertAndSend(RabbitHeaderConfig.HEADER_NAME,
        null,message6);
        rabbitTemplate.convertAndSend(RabbitHeaderConfig.HEADER_NAME,
        null,message7);
    }
}
ꦿ๑簡單點๑
关注
专栏目录
【SpringBoot】43、SpringBoot中整合RabbitMQ实现延时队列（延时插件篇）
Asurplus
02-21 21万+
一、介绍 1、什么是延时队列？ 延时队列即就是放置在该队列里面的消息是不需要立即消费的，而是等待一段时间之后取出消费 2、适用场景 （1）商城订单超时未支付，取消订单 （2）使用权限到期前十分钟提醒用户 （3）收益项目，投入后一段时间后产生收益 二、实现方式 从以上场景中，我们可以看出，延时队列的主要功能就是在指定的时间之后做指定的事情，那么，我们思考有哪些工具我们可以使用？ 1、Redis 监听过期 Key 可以参考我的博客【SpringBoot】三十五、SpringBoot整合Redis监听Ke
Springboot整合RabbitMQ
SSL 的博客
01-24 1446
RabbitMQ的安装以及Springboot整合案例
SpringBoot: 整合消息服务之AMQP
手写我对你的温柔
03-20 3822
AMQP AMQP:Advanced Message Queuing Protocol高级消息队列协议。 其是一个线路层的协议规范，不是API规范(e.g: JMS) 所以它是天然跨平台的。按照规范的格式发送数据，任何平台都可以通过AMQP进行消息交互。 主流的StormMQ,RabbitMQ都实现了AMQP RabbitMQ的安装： 安装指南:安装指南[推荐访问我这个链接，下面的...
spring-boot 集成 rabbitmq
热门推荐
zl
01-11 1万+
之前说了集成activemq，那就再说说集成另一个很火的mq，兔子。 本文示例主要参看官方的demo https://github.com/spring-projects/spring-boot/tree/master/spring-boot-samples/spring-boot-sample-amqp https://github.com/spring-projects/spring
Spring Boot 整合 AMQP
圣人男的博客
02-28 2748
RabbitMQ 安装https://blog.csdn.net/kangguang/article/details/104551284 一.添加依赖 <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-w...
springboot整合rabbitMq
shuaigg001的博客
07-24 168
1.rabbitmq的五种队列模式 简单队列 工作队列 发布、订阅 路由 主题 rpc等 1.常用的交换机 因为消费者是从队列获取消息的，队列是绑定交换机的，所以对应的消息推送、接受模式有一下几种 Direct Exchange 路由模式是发布/订阅模式的一种特殊情况。 路由模式的交换机类型为“direct”。 绑定队列到交换机时指定 key，即路由键，一个队列可以指定多个路由键。 生产者发送消息时需要指定路由键，这时，消息只会发送到绑定的key的对应队列中。 直连型交换机，根据
SpringBoot AMQP
大漠知秋的加油站
07-07 7678
SpringBoot 已经提供了对 AMQP 协议完全支持的 依赖，引入此依赖即可快速方便的在 SpringBoot 中使用 RabbitMQ。参考：Spring AMQP。 声明式实现（推荐） 注意，以上配置再启动 SpringBoot 并不会立马创建交换机、队列、绑定，SpringBoot AMQP 有懒加载，需要等到使用 时才会创建。什么是使用 呢？ 再比如监听了队列 死信队列机制 死信队列需要在创建 Queue 时指定对应属性： RabbitTemplate 是 SpringBoo
SpringBoot+redis+RabbitMq整合实例
07-13
RabbitMQ是基于AMQP（Advanced Message Queuing Protocol）的消息中间件，用于解耦生产者和消费者，使得系统可以异步处理任务，提高系统的可扩展性和容错性。在Spring Boot中，Spring AMQP提供了与RabbitMQ的集成，...
springboot+redis整合rabbitmq
04-21
接着，`springboot+rabbitmq`的整合则涉及到Spring AMQP（Advanced Message Queuing Protocol）框架。在Spring Boot项目中，同样需要添加`spring-boot-starter-amqp`依赖来引入RabbitMQ支持。在配置文件中，我们需要...
spring boot整合RabbitMQ（Direct模式）
08-30
springboot集成RabbitMQ非常简单，如果只是简单的使用配置非常少，springboot提供了spring-boot-starter-amqp项目对消息各种支持。下面通过本文给大家介绍下spring boot整合RabbitMQ（Direct模式）,需要的朋友可以...
SpringBoot 简易Rabbit amqp消息处理
baidu_41741410的博客
08-19 741
    SpringBoot 简易Rabbit 消息处理   Rabbit这里不做介绍，可以百度找找相关内容。 三种常用的交换器：direct、fanout、topic direct：点对点消息，严格按照路由键绑定的消息队列一对一的单发消息 fanout： 不管路由键是什么，给所有绑定的消息队列全发消息 topic：给符合路由键绑定的多个消息队列多发消息。如 *.news，#.news...
SpringBoot整合AMQP
lwd2307997664的博客
05-03 1301
SpringBoot整合AMQP 文章目录SpringBoot整合AMQP前言一、JMS、AMQP概念以及区别二、RabbitMQ简介三、互联网大厂为什么选择RabbitMQ四、RabbitMQ的一些核心概念五、RabbitMQ的部署安装 前言 消息队列（Message Queue）是一种进程间或者线程间的异步通信方式。使用消息队列，消息生产者会将消息保存在消息队列中，知道消息消费者来取走它。实现服务的解耦合，并提高系统的可靠性和扩展性。 目前常用的开源消息队列有很多，RabbitMQ、ActiveMQ、
SpringBoot 使用 Amqp
qq_51767561的博客
10-22 1312
springboot 集成 amqp
【开发篇】十九、SpringBoot整合RabbitMQ（SpringAMQP）
llg___的博客
05-30 1771
可以看到，消费者2处理消息慢（代码里用处理一次休眠的旧来模拟），但它从队列里拿的消息却和消费者1一样，因此导致消费总时间过长。prefetch默认无限，这里改为1，即 每次只能获取一条消息，处理完成才能获取下一个消息。重启，这次同样生产50条消息，消费总时间变短了，可以看到消费者2处理的慢，取的也慢。和基本模型不一样，WorkQueue模型，即工作队列，有多个消费者。可以提高消息处理速度，避免队列消息堆积。启动消费服务，可以看到队列创建并且绑定到了交换机，以后交换机有消息，和交换机绑定的队列都能收到一份！
Spring Boot Messaging Chapter 5 AMQP with Spring Boot
https://gitee.com/micai-code
08-09 505
摘要：本章讨论高级消息队列协议(AMQP)，它是一种不可知的消息协议。您将学习如何使用Spring AMQP模块，它将与RabbitMQ代理通信。RabbitMQ是全球最常用的代理之一，这是因为它易于安装和使用。最好的部分是它是开源的。 AMQP来自金融业，由摩根大通(JPMorgan Chase)于2003年创建。随后，更多的公司围绕它展开工作，以增强这种新的消息传递方式。Rabbit技术通过...
SpringBoot(十) 消息AMQP(RabbitMQ)
zengdongwen的博客
04-10 278
#1、概述 1.在大多应用中，我们系统之间需要进行异步通信，即异步消息。 2.异步消息中两个重要概念： 消息代理（message broker）和目的地（destination） 当消息发送者发送消息以后，将由消息代理接管，消息代理保证消息传递到指定目的地。 3.异步消息主要有两种形式的目的地 1.队列（queue）：点对点消息通信（point-to-point） 2.主题（topic）：发...
Spring Boot对AMQP的支持
最新发布
听海边涛声
02-17 898
Spring Boot对AMQP的支持
SpringBoot2.x系列教程62--SpringBoot整合消息队列之AMQP协议
qfchenjunbo的博客
08-12 184
一. AMQP 协议概述 AMQP的全称为Advanced Message Queuing Protocl,即高级消息队列协议,它是应用层协议的一个开放标准,为面向消息的中间件而设计.该协议主要用于制定基于队列进行消息传递的开放标准. 消息中间件主要用于组件之间的解耦,消息的发送者无需知道消息使用者的存在,反之亦然.AMQP的主要特征是面向消息、队列、路由(包括点对点和发布/订阅)、可靠性、安全. 二. AMQP 协议的核心概念 虚拟主机vhost; 连接Connection; 信道Channe
Spring Boot 2.X - Spring Boot整合AMQP之RabbitMQ
XUDC的程序人生
04-17 4190
文章目录Spring Boot 2.X - Spring Boot整合AMQP之RabbitMQRabbitMQ简介简介MessagePublisherExchangeQueueBindingConnectionChannelConsumerVirtual HostBroker引入依赖编写配置编写接口启用Rabbit注解消息监听消息测试 Spring Boot 2.X - Spring Boot整...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

ꦿ๑簡單點๑

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值