Spring Boot 整合RabbitMQ 配置文件方式

最新推荐文章于 2024-04-22 13:48:39 发布
最新推荐文章于 2024-04-22 13:48:39 发布
阅读量899 收藏 1
点赞数 2
分类专栏： RabbitMQ 文章标签： rabbitmq java 消息队列 spring boot
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_46759279/article/details/115333201
版权
1. 初始化配置
1.1 引入依赖
<!--spring整合RabbitMQ-->
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-amqp</artifactId>
</dependency>
<!--spring-web-->
<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>
<dependency>
    <groupId>org.springframework.amqp</groupId>
    <artifactId>spring-rabbit-test</artifactId>
    <scope>test</scope>
</dependency>
1.2 连接RabbitMQ配置文件
server:
  port: 8082
spring:
  rabbitmq:
    port: 5672
    host: 192.168.200.100
    username: admin
    password: admin
2. Fanout模式
2.1 创建配置文件

创建交换机和队列并进行绑定

此配置文件放到生产端或消费端都可以

/**
 * @author: mingan.xie
 * @since: 2021/3/22
 * @history: 1.2021/3/22 created by xma
 */
@Configuration
public class RabbitMQConfigFanout {

    // 1: 声明交换机
    @Bean
    public FanoutExchange fanoutExchange(){
        return new FanoutExchange("fanout_order_product");
    }

    // 2: 声明队列
    // durable:是否持久化,默认是false,持久化队列：会被存储在磁盘上，当消息代理重启时仍然存在，暂存队列：当前连接有效
    // exclusive:默认也是false，只能被当前创建的连接使用，而且当连接关闭后队列即被删除。此参考优先级高于durable
    // autoDelete:是否自动删除，当没有生产者或者消费者使用此队列，该队列会自动删除。
    @Bean
    public Queue duanxinQueue(){
        return new Queue("duanxin.fanout.queue", true, false, false);
    }

    @Bean
    public Queue emailQueue(){
        return new Queue("email.fanout.queue", true, false, false);
    }

    @Bean
    public Queue smsQueue(){
        return new Queue("sms.fanout.queue", true, false, false);
    }

    // 3: 绑定对用关系
    @Bean
    public Binding smsBinding(){
        return BindingBuilder.bind(smsQueue()).to(fanoutExchange());
    }

    @Bean
    public Binding emailBinding(){
        return BindingBuilder.bind(emailQueue()).to(fanoutExchange());
    }

    @Bean
    public Binding duanxinBinding(){
        return BindingBuilder.bind(duanxinQueue()).to(fanoutExchange());
    }
}
2.2 创建生产者
@Component
public class ProductFanout {

    @Resource
    private RabbitTemplate rabbitTemplate;

    public void makerOrderFanout(){
        // 参数1: 交换机名称
        String exchangeName = "fanout_order_product";
        // 参数2: direct 和 topic 模式下的路由key / 无交换机模式下的路由名称
        String routingKey = "";
        // 参数3: 消息体
        String orderId = UUID.randomUUID().toString();

        rabbitTemplate.convertAndSend(exchangeName, routingKey, orderId);
    }
}
2.3 创建消费者

短信消费者

@Component
@RabbitListener(queues = {"duanxin.fanout.queue"})
public class FanoutDuanxinConsumer {

    @RabbitHandler
    public void reviceMessage(String message){
        System.out.println("fanout Duanxin 接收到了消息：" + message);
    }

}

Email消费者

@Component
@RabbitListener(queues = {"email.fanout.queue"})
public class FanoutEmailConsumer {

    @RabbitHandler
    public void reviceMessage(String message){
        System.out.println("fanout Email 接收到了消息：" + message);
    }
}

Sms消费者

@Component
@RabbitListener(queues = {"sms.fanout.queue"})
public class FanoutSmsConsumer {

    @RabbitHandler
    public void reviceMessage(String message){
        System.out.println("fanout Sms 接收到了消息：" + message);
    }

}
2.4 调用测试类
@SpringBootTest
class SpringBootRabbitmqProducerApplicationTests {

    @Resource
    private ProductFanout productFanout;

    @Test
    void contextLoads1() {
        productFanout.makerOrderFanout();
    }
}
3. Direct模式
3.1 创建配置文件

创建交换机和队列并进行绑定

此配置文件放到生产端或消费端都可以

/**
 * @author: mingan.xie
 * @since: 2021/3/22
 * @history: 1.2021/3/22 created by xma
 */
@Configuration
public class RabbitMQConfigDirect {

    // 1: 声明交换机
    @Bean
    public DirectExchange directExchange(){
        return new DirectExchange("direct_order_product");
    }

    // 2: 声明队列
    // durable:是否持久化,默认是false,持久化队列：会被存储在磁盘上，当消息代理重启时仍然存在，暂存队列：当前连接有效
    // exclusive:默认也是false，只能被当前创建的连接使用，而且当连接关闭后队列即被删除。此参考优先级高于durable
    // autoDelete:是否自动删除，当没有生产者或者消费者使用此队列，该队列会自动删除。
    @Bean
    public Queue directduanxinQueue(){
        return new Queue("duanxin.direct.queue", true, false, false);
    }

    @Bean
    public Queue directemailQueue(){
        return new Queue("email.direct.queue", true, false, false);
    }

    @Bean
    public Queue directsmsQueue(){
        return new Queue("sms.direct.queue", true, false, false);
    }

    // 3: 绑定对用关系
    // with(): 绑定对应的路由key  *:一个字符  #: 一个或多个字符
    @Bean
    public Binding directsmsBinding(){
        return BindingBuilder.bind(directsmsQueue()).to(directExchange()).with("sms");
    }

    @Bean
    public Binding directemailBinding(){
        return BindingBuilder.bind(directemailQueue()).to(directExchange()).with("email");
    }

    @Bean
    public Binding directduanxinBinding(){
        return BindingBuilder.bind(directduanxinQueue()).to(directExchange()).with("duanxin");
    }
}
3.2 创建生产者
@Component
public class ProductFanout {

    @Resource
    private RabbitTemplate rabbitTemplate;

    public void makerOrderDirect(){
        // 参数1: 交换机名称
        String exchangeName = "direct_order_product";
        // 参数2: direct 和 topic 模式下的路由key / 无交换机模式下的路由名称

        // 参数3: 消息体
        String orderId = UUID.randomUUID().toString();

        rabbitTemplate.convertAndSend(exchangeName, "sms", orderId);
        rabbitTemplate.convertAndSend(exchangeName, "email", orderId);
        System.out.println("路由key: sms, email");
    }
}
3.3 创建消费者

短信消费者

@Component
@RabbitListener(queues = {"duanxin.direct.queue"})
public class DirectDuanxinConsumer {

    @RabbitHandler
    public void reviceMessage(String message){
        System.out.println("direct Duanxin 接收到了消息：" + message);
    }

}

Email消费者

@Component
@RabbitListener(queues = {"email.direct.queue"})
public class DirectEmailConsumer {

    @RabbitHandler
    public void reviceMessage(String message){
        System.out.println("direct Email 接收到了消息：" + message);
    }
}

Sms消费者

@Component
@RabbitListener(queues = {"sms.direct.queue"})
public class DirectSmsConsumer {

    @RabbitHandler
    public void reviceMessage(String message){
        System.out.println("direct Sms 接收到了消息：" + message);
    }

}
3.4 调用测试类
@SpringBootTest
class SpringBootRabbitmqProducerApplicationTests {

    @Resource
    private ProductFanout productFanout;

    @Test
    void contextLoads2() {
        productFanout.makerOrderDirect();
    }
}
4. Topic模式
4.1 创建配置文件

创建交换机和队列并进行绑定

此配置文件放到生产端或消费端都可以

/**
 * @author: mingan.xie
 * @since: 2021/3/22
 * @history: 1.2021/3/22 created by xma
 */
@Configuration
public class RabbitMQConfigTopic {

    // 1: 声明交换机
    @Bean
    public TopicExchange topicExchange(){
        return new TopicExchange("topic_order_product");
    }

    // 2: 声明队列
    // durable:是否持久化,默认是false,持久化队列：会被存储在磁盘上，当消息代理重启时仍然存在，暂存队列：当前连接有效
    // exclusive:默认也是false，只能被当前创建的连接使用，而且当连接关闭后队列即被删除。此参考优先级高于durable
    // autoDelete:是否自动删除，当没有生产者或者消费者使用此队列，该队列会自动删除。
    @Bean
    public Queue topicduanxinQueue(){
        return new Queue("duanxin.topic.queue", true, false, false);
    }

    @Bean
    public Queue topicemailQueue(){
        return new Queue("email.topic.queue", true, false, false);
    }

    @Bean
    public Queue topicsmsQueue(){
        return new Queue("sms.topic.queue", true, false, false);
    }

    // 3: 绑定对用关系
    // with(): 绑定对应的路由key  *:一个字符  #: 一个或多个字符
    @Bean
    public Binding topicsmsBinding(){
        return BindingBuilder.bind(topicsmsQueue()).to(topicExchange()).with("*.topic.#");
    }

    @Bean
    public Binding topicemailBinding(){
        return BindingBuilder.bind(topicemailQueue()).to(topicExchange()).with("#.topic.#");
    }

    @Bean
    public Binding topicduanxinBinding(){
        return BindingBuilder.bind(topicduanxinQueue()).to(topicExchange()).with("com.#");
    }
}
4.2 创建生产者
@Component
public class ProductFanout {

    @Resource
    private RabbitTemplate rabbitTemplate;

    public void makerOrderTopic(){
        // 参数1: 交换机名称
        String exchangeName = "topic_order_product";
        // 参数2: direct 和 topic 模式下的路由key / 无交换机模式下的路由名称
        String routingKey = "com.xxx.topic";
        // 参数3: 消息体
        String orderId = UUID.randomUUID().toString();

        rabbitTemplate.convertAndSend(exchangeName, routingKey, orderId);
        System.out.println("路由key:" + routingKey);
    }
}
4.3 创建消费者

短信消费者

@Component
@RabbitListener(queues = {"duanxin.topic.queue"})
public class TopicDuanxinConsumer {

    @RabbitHandler
    public void reviceMessage(String message){
        System.out.println("topic Duanxin 接收到了消息：" + message);
    }

}

Email消费者

@Component
@RabbitListener(queues = {"email.topic.queue"})
public class TopicEmailConsumer {

    @RabbitHandler
    public void reviceMessage(String message){
        System.out.println("topic Email 接收到了消息：" + message);
    }
}

Sms消费者

@Component
@RabbitListener(queues = {"sms.topic.queue"})
public class TopicSmsConsumer {

    @RabbitHandler
    public void reviceMessage(String message){
        System.out.println("topic Sms 接收到了消息：" + message);
    }

}
4.4 调用测试类
@SpringBootTest
class SpringBootRabbitmqProducerApplicationTests {

    @Resource
    private ProductFanout productFanout;

    @Test
    void contextLoads3() {
        productFanout.makerOrderTopic();
    }
}
5. 设置消息过期时间
5.1 设置队列整体消息过期时间

创建配置文件

/**
 * @author: mingan.xie
 * @since: 2021/3/22
 * @history: 1.2021/3/22 created by xma
 */
@Configuration
public class RabbitMQConfigTTL {

    // 1: 声明交换机
    @Bean
    public TopicExchange ttlTopicExchange(){
        return new TopicExchange("ttl_topic_order_product");
    }

    // 2: 声明队列
    // durable:是否持久化,默认是false,持久化队列：会被存储在磁盘上，当消息代理重启时仍然存在，暂存队列：当前连接有效
    // exclusive:默认也是false，只能被当前创建的连接使用，而且当连接关闭后队列即被删除。此参考优先级高于durable
    // autoDelete:是否自动删除，当没有生产者或者消费者使用此队列，该队列会自动删除。
    @Bean
    public Queue ttlTopicduanxinQueue(){
        HashMap<String, Object> args = new HashMap<>();
        // 给队列设置消息过期时间：毫秒值
        args.put("x-message-ttl", 5000);
        return new Queue("ttl.duanxin.topic.queue", true, false, false, args);
    }

    // 3: 绑定对用关系
    @Bean
    public Binding ttlTopicsmsBinding(){

        return BindingBuilder.bind(ttlTopicduanxinQueue()).to(ttlTopicExchange()).with("ttl");
    }
}

创建生产者

@Component
public class ProductFanout {

    @Resource
    private RabbitTemplate rabbitTemplate;
    
    public void makerOrderTopicTtl(){
        // 参数1: 交换机名称
        String exchangeName = "ttl_topic_order_product";
        // 参数2: direct 和 topic 模式下的路由key / 无交换机模式下的路由名称
        String routingKey = "ttl";
        // 参数3: 消息体
        String orderId = UUID.randomUUID().toString();

        rabbitTemplate.convertAndSend(exchangeName, routingKey, orderId);
        System.out.println("路由key:" + routingKey);
    }
}

调用测试类

@SpringBootTest
class SpringBootRabbitmqProducerApplicationTests {

    @Resource
    private ProductFanout productFanout;

    @Test
    void contextLoads4() {
        productFanout.makerOrderTopicTtl();
    }
}
5.2 设置单个发送消息的过期时间

创建配置文件

/**
 * @author: mingan.xie
 * @since: 2021/3/22
 * @history: 1.2021/3/22 created by xma
 */
@Configuration
public class RabbitMQConfigTTL {

    // 1: 声明交换机
    @Bean
    public TopicExchange ttlTopicExchange(){
        return new TopicExchange("ttl_topic_order_product");
    }

    @Bean
    public Queue ttlMessageTopicduanxinQueue(){
        return new Queue("ttl.message.duanxin.topic.queue", true);
    }

    @Bean
    public Binding ttlMessageTopicsmsBinding(){
        return BindingBuilder.bind(ttlMessageTopicduanxinQueue()).to(ttlTopicExchange()).with("ttl.message");
    }
}

创建生产者

@Component
public class ProductFanout {

    @Resource
    private RabbitTemplate rabbitTemplate;
    
    public void makerOrderTopicTtlMessage(){
        String exchangeName = "ttl_topic_order_product";
        // 参数1: 交换机名称
        // 参数2: direct 和 topic 模式下的路由key / 无交换机模式下的路由名称
        String routingKey = "ttl.message";
        // 参数3: 消息体
        String orderId = UUID.randomUUID().toString();
        MessagePostProcessor messagePostProcessor = message -> {
            // 设置过期时间
            message.getMessageProperties().setExpiration("5000");
            message.getMessageProperties().setContentEncoding("UTF-8");
            return message;
        };

        rabbitTemplate.convertAndSend(exchangeName, routingKey, orderId, messagePostProcessor);
        System.out.println("路由key:" + routingKey);
    }
}

调用测试类

@SpringBootTest
class SpringBootRabbitmqProducerApplicationTests {

    @Resource
    private ProductFanout productFanout;

    @Test
    void contextLoads5() {
        productFanout.makerOrderTopicTtlMessage();
    }
}
6. 死信队列

由于某些原因导致队列中某些消息无法被消费，这些消息就会被放到死信对类中

产生死信的几种方式：

​ 消息被拒绝

​ 消息TTL过期

​ 队列达到最大长度

6.1 创建死信队列
/**
 * @author: mingan.xie
 * @since: 2021/3/22
 * @history: 1.2021/3/22 created by xma
 */
@Configuration
public class RabbitMQConfigDead {

    // 1: 声明交换机
    @Bean
    public TopicExchange deadTopicExchange(){
        return new TopicExchange("dead_topic_order_product");
    }

    // 2: 声明队列
    // durable:是否持久化,默认是false,持久化队列：会被存储在磁盘上，当消息代理重启时仍然存在，暂存队列：当前连接有效
    // exclusive:默认也是false，只能被当前创建的连接使用，而且当连接关闭后队列即被删除。此参考优先级高于durable
    // autoDelete:是否自动删除，当没有生产者或者消费者使用此队列，该队列会自动删除。
    @Bean
    public Queue deadTopicduanxinQueue(){
        return new Queue("dead.duanxin.topic.queue", true);
    }

    // 3: 绑定对用关系
    @Bean
    public Binding deadTopicsmsBinding(){
        return BindingBuilder.bind(deadTopicduanxinQueue()).to(deadTopicExchange()).with("dead");
    }

}
6.2 创建普通队列并绑定死信队列
/**
 * @author: mingan.xie
 * @since: 2021/3/22
 * @history: 1.2021/3/22 created by xma
 */
@Configuration
public class RabbitMQConfigTTL {

    // 1: 声明交换机
    @Bean
    public TopicExchange ttlTopicExchange(){
        return new TopicExchange("ttl_topic_order_product");
    }

    // 2: 声明队列
    // durable:是否持久化,默认是false,持久化队列：会被存储在磁盘上，当消息代理重启时仍然存在，暂存队列：当前连接有效
    // exclusive:默认也是false，只能被当前创建的连接使用，而且当连接关闭后队列即被删除。此参考优先级高于durable
    // autoDelete:是否自动删除，当没有生产者或者消费者使用此队列，该队列会自动删除。
    @Bean
    public Queue ttlTopicduanxinQueue(){
        HashMap<String, Object> args = new HashMap<>();
        // 给队列设置消息过期时间：毫秒值
        args.put("x-message-ttl", 5000);
        // 设置队列最大长度
        args.put("x-max-length", 5);
        // 设置死信队列交换机名称
        // 当消息在一个队列中变成死信后,它能就发送到另一个交换机中，这个交换机就是DLX，绑定DLX的队列被称之为死信队列
        // 编程死信队列的原因：消息被拒绝，消息过期，队列达到最大长度
        args.put("x-dead-letter-exchange", "dead_topic_order_product");
        // 设置死信队列路由key
        args.put("x-dead-letter-routing-key", "dead");
        return new Queue("ttl.duanxin.topic.queue", true, false, false, args);
    }

    // 3: 绑定对用关系
    @Bean
    public Binding ttlTopicsmsBinding(){

        return BindingBuilder.bind(ttlTopicduanxinQueue()).to(ttlTopicExchange()).with("ttl");
    }

}
6.3 创建生产者
@Component
public class ProductFanout {

    @Resource
    private RabbitTemplate rabbitTemplate;
    public void makerOrderTopicTtl(){
        // 参数1: 交换机名称
        String exchangeName = "ttl_topic_order_product";
        // 参数2: direct 和 topic 模式下的路由key / 无交换机模式下的路由名称
        String routingKey = "ttl";
        // 参数3: 消息体
        String orderId = UUID.randomUUID().toString();

        rabbitTemplate.convertAndSend(exchangeName, routingKey, orderId);
        System.out.println("路由key:" + routingKey);
    }
}
6.4 调用测试类
@SpringBootTest
class SpringBootRabbitmqProducerApplicationTests {

    @Resource
    private ProductFanout productFanout;

    @Test
    void contextLoads4() {
        for (int i = 0; i < 10; i++) {
            productFanout.makerOrderTopicTtl();
        }
    }
}

设置类队列的最大长度为5，超过队列长度的消息都会被放到死信队列中

在这里插入图片描述

设置类队列消息过期时间为5秒，5秒过后消息未被消费，也会被放到死信队列中

在这里插入图片描述

7. 总结
Pole丶逐
关注
  • 2
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 3
    评论
专栏目录
1 SpringBoot整合RabbitMQ-整合配置篇-源码数据库
09-04
1 SpringBoot整合RabbitMQ实战系列教程-整合配置篇-源码数据库
spring boot整合RabbitMQ实例详解（Fanout模式）
08-30
使用 Spring Boot 整合 RabbitMQ，需要添加 RabbitMQ 依赖项到 Maven 或 Gradle 配置文件中。然后，可以创建一个配置类，用于定义队列、交换器和绑定关系。例如： ```java @Configuration public class ...
【rabbitmq】springboot整合rabbitmq
Think_and_work的博客
03-10 1689
源码地址 https://gitee.com/shen-chuhao/walker.git 前提 安装rabbitmq 可以参考以前的文章进行安装 使用docker-compose安装rabbitmq windows安装rabbitMq 概念 生产者 这里主要是指生产信息的一方 消费者 消费信息的一方 队列 用来存储信息的存储结构 交换机 这个主要用于决定消息推送和消息接收的模式 主要有以下几种交换机： Direct Exchange 直连交换机 Fanout Exchange 扇形交换机 Topic E
RabbitMQ Spring Boot 配置与使用指南
最新发布
Yaml4的博客
04-22 1448
目录1.yaml配置如下2.引入pom依赖如下2.1 引入项目resources下libs中的jar包依赖如下2.2引入maven私服依赖如下3.启动类配置如下4.项目中测试发送消息如下5.项目中消费消息代码示例6.mq管理后台交换机队列创建及路由绑定关系如下Spring Boot集成RabbitMQ入口: RabbitMQ实现消息队列生产者与消费者rps中的每一个都可以按照Sping官方的RabbitAutoConfiguration自动装配的RabbitProperties的样式来配置，做到了实现配置多
SpringBoot 整合 RabbitMQ
Qynwang的博客
04-29 556
在生产者端编写测试代码，也就是在 Producer 项目中编写测试代码。2. 配置 application.yml。2. 配置 application.yml。所在项目为 Producer。所在项目为 Consumer。1. 添加maven依赖。
SpringbBoot集成单机RabbitMq 最佳实践
wuyuecai的博客
01-08 151
SpringbBoot集成RabbitMq 以及消息的可靠投递 可靠消费
rabbitmq-spring-boot-start配置使用手册
qq_34905631的博客
03-13 1533
rabbitmq-spring-boot-start配置使用手册。
详解Spring Boot 配置多个RabbitMQ
08-30
Spring Boot 配置多个 RabbitMQ Spring Boot 是一个流行的 Java 框架，用于快速构建生产级别的应用程序。RabbitMQ 是一个消息队列中间件，用于实现异步消息处理和队列管理。配置多个 RabbitMQ 实例是为了提高系统的...
spring-boot-rabbitmq-demo.zip
03-09
spring boot和rabbitMQ最佳实践 1、JSON序列化与反序列化 要实现消息跨平台，需要配置消息JSON序列化（配置见代码实现），就可以实现不同语言之间互相发送/接收消息，还可以直接用RabbitMQ控制台发送消息。 2、...
SpringCloudStream整合RabbitMq
09-04
**SpringCloudStream与RabbitMQ整合详解** SpringCloudStream是一个框架，它允许应用程序以声明式方式定义输入和输出绑定，从而简化与消息中间件的集成。在这个场景中，我们将讨论如何将SpringCloudStream与...
Spring Boot (5) 整合 RabbitMQ
08-17
总结一下，Spring Boot整合RabbitMQ的关键步骤包括： 1. 添加RabbitMQ的依赖。 2. 配置RabbitMQ的连接信息。 3. 定义交换机、队列和绑定。 4. 创建发送和接收消息的服务类。 这只是一个基本的示例，实际使用时，你...
SpringBoot整合RabbitMq
jl935418600的博客
06-23 197
SpringBoot整合RabbitMq 参考博客：https://blog.csdn.net/qq_33547169/article/details/78124294 1.介绍 1.1 RabbitMQ MQ全称为Message Queue，即消息队列， RabbitMQ是由erlang语言开发，基于AMQP（Advanced Message Queue 高级消息队列协议）协议实现的消息队列，它...
springboot整合rabbitmq
qq_38151401的博客
12-08 428
目录 一、配置文件 1、pom.xml 2、application.yml 二、创建好了交换器、消息等并关联了 三、测试单播 1、发送消息 2、接收消息 3、自定义MessageConverter 四、测试广播 五、监听消息队列 1、@EnableRabbit开启基于注解的rabbitmq模式 2、@RabbitListener监听消息队列 3、运行结果 六、A...
SpringBoot中配置RabbitMQ
目标检测专栏持续更新中，改进YOLO系列通用，适用v5、v7、v8、所有博客均是团队原创博客，所有文章禁止转载，违者必究。
04-26 3081
RabbitMQ介绍与原理见：消息队列之 RabbitMQ RabbitMQ安装见：RabbitMQ安装 依赖： <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-amqp</artifactId> </dependency> 在Spring Boot中配置RabbitMQ比较简单，首先配置yml
4、Springboot整合RabbitMQ
yisuyanyu的博客
04-30 261
1、首先创建两个工程，一个生产者，一个消费者。 2、首先解决pom.xml的依赖，两个工程pom.xml都放入 <!--rabbitmq--> <dependency> <groupId>org.springframework.boot</groupId> <...
史上最全 RabbitMQ入门教程，从零开始带你深入♂学习（十三）——ttl延迟队列
爱分享的板栗老哥
08-17 422
RabbitMQ（十三）——ttl延迟队列 延迟队列简介 延时队列,队列内部是有序的，最重要的特性就体现在它的延时属性上，延时队列中的元素是希望 在指定时间到了以后或之前取出和处理，简单来说，延时队列就是用来存放需要在指定时间被处理的 元素的队列。 使用场景 1.订单在十分钟之内未支付则自动取消 2.新创建的店铺，如果在十天内都没有上传过商品，则自动发送消息提醒。 3.用户注册成功后，如果三天内没有登陆则进行短信提醒。 4.用户发起退款，如果三天内没有得到处理则通知相关运营人员。 5.预定会议后，需要在
Springboot 整合RabbitMq ，用心看完这一篇就够了(1)
m0_56169789的博客
03-18 966
小编利用空余时间整理了一份《MySQL性能调优手册》，初衷也很简单，就是希望能够帮助到大家，减轻大家的负担和节省时间。关于这个，给大家看一份学习大纲（PDF）文件，每一个分支里面会有详细的介绍。这里都是以图片形式展示介绍，如要下载原文件以及更多的性能调优笔记（MySQL+Tomcat+JVM）！return map;到这里，我们其实已经掌握了怎么去使用消息消费的手动确认了。但是这个场景往往不够！
RabbitMQ配置、使用、Spring整合、SpringBoot整合
qq_52043717的博客
04-15 808
1、RabbitMQ中的一些概念 1、JMS 是 JavaEE 13大规范中的一种，规定了java客户端与消息队列通信的一套API接口，是一个 Java 平台中关于面向消息中间件的API。类比jdbc，jdbc是java程序与数据库通信的一套API接口。 为什么要指定规范？有了规范，大家都遵循规范去实现，虽然底层实现不同，但使用起来都统一，就好像什么牌子的安卓手机都用type-c接口。 RabbitMQ官方是没有遵循JMS接口规范实现，没写提供JMS的实现包，但是在开源社区有人写了JMS的实现类。 AMQ
spring boot整合rabbitmq
08-24
Spring Boot与RabbitMQ的整合可以通过使用Spring AMQP实现。下面是一个简单的步骤： 1. 添加依赖：在`pom.xml`文件中添加以下依赖关系： ```xml <groupId>org.springframework.boot <artifactId>spring-boot-...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值