SpringBoot 使用 RabbitMQ

于 2024-08-06 16:47:31 发布
阅读量613 收藏 16
点赞数 17
文章标签： java-rabbitmq spring boot rabbitmq
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/2302_82270778/article/details/140897982
版权

目录

1. 基于 SpringBoot 进行 RabbitMQ 的开发

1.1 工作队列模式

​编辑 2 Publish/Subscribe（发布订阅模式）

1.3 Routing（路由模式）

1.4 Topics（通配符模式）

2. 基于 SpringBoot + RabbitMQ 完成应用通信

2.1 创建项目

2.2 订单系统（生产者） 

2.3 物流系统（消费者）

2.4 启动服务，观察结果

2.5 发送消息格式为对象

1. 基于 SpringBoot 进行 RabbitMQ 的开发

1.1 工作队列模式

1）引入依赖

2）添加配置

spring:
  rabbitmq:
    host: 44.34.51.65
    port: 5672
    username: lk
    password: lk
    virtual-host: study

3）编写生产者代码

public class Constants {
    //工作队列模式
    public static final String WORK_QUEUE = "work.queue";
}

声明队列

@Configuration
public class RabbitMQConfig {
    //工作队列模式
    @Bean("workQueue")
    public Queue workQueue() {
        return QueueBuilder.durable(Constants.WORK_QUEUE).build();
    }
}
@RequestMapping("/producer")
@RestController
public class ProducerController {
    @Autowired
    private RabbitTemplate rabbitTemplate;

    @RequestMapping("/work")
    public String work() {
        for (int i = 0; i < 10; i++) {
            //使用内置交换机发送消息,routingKey 和队列名称保持一致
            rabbitTemplate.convertAndSend("", Constants.WORK_QUEUE,"hello queue.work" + i);
        }
        return "发送成功";
    }
}

生产者测试 

4）编写消费者代码

定义监听类

@Component
public class WorkListener {
    @RabbitListener(queues = Constants.WORK_QUEUE)
    public void queueListener1(Message message) {
        System.out.println("listener 1 [" + Constants.WORK_QUEUE + "] 接收到的消息:" + message);
    }
    @RabbitListener(queues = Constants.WORK_QUEUE)
    public void queueListener2(Message message) {
        System.out.println("listener 2 [" + Constants.WORK_QUEUE + "] 接收到的消息:" + message);
    }
}

@RabbitListener 是 Spring 框架中用于监听 RabbitMQ 队列的注解，通过使用这个注解，可以定义一个方法，以便从 RabbitMQ 队列中接收消息，该注解支持多种参数类型

1）String：返回消息的内容

2）Message：Spring AMQP 的 Message 类，返回原始的消息体以及消息的属性，如消息 ID、内容、队列信息等

3）Channel：RabbitMQ 的通道对象，可以用于进行更高级的操作，如手动确认消息

消费者测试

 2 Publish/Subscribe（发布订阅模式）

1）编写生产者代码

//发布订阅模式
public static final String FANOUT_QUEUE1 = "fanout.queue1";
public static final String FANOUT_QUEUE2 = "fanout.queue2";
public static final String FANOUT_EXCHANGE = "fanout.exchange";
//发布订阅模式
    @Bean("fanoutQueue1")
    public Queue fanoutQueue1() {
        return QueueBuilder.durable(Constants.FANOUT_QUEUE1).build();
    }
    @Bean("fanoutQueue2")
    public Queue fanoutQueue2() {
        return QueueBuilder.durable(Constants.FANOUT_QUEUE2).build();
    }
    @Bean("fanoutExchange")
    public FanoutExchange fanoutExchange() {
        return ExchangeBuilder.fanoutExchange(Constants.FANOUT_EXCHANGE).durable(true).build();
    }
    @Bean("fanoutQueueBinding1")
    public Binding fanoutQueueBinding1(@Qualifier("fanoutExchange") FanoutExchange fanoutExchange, @Qualifier("fanoutQueue1") Queue queue) {
        return BindingBuilder.bind(queue).to(fanoutExchange);
    }
    @Bean("fanoutQueueBinding2")
    public Binding fanoutQueueBinding2(@Qualifier("fanoutExchange") FanoutExchange fanoutExchange, @Qualifier("fanoutQueue2") Queue queue) {
        return BindingBuilder.bind(queue).to(fanoutExchange);
    }

声明两个队列和一个交换机，然后绑定队列和交换机

@RequestMapping("/fanout")
public String fanout() {
    rabbitTemplate.convertAndSend(Constants.FANOUT_EXCHANGE,"","hello queue.fanout");
    return "发送成功";
}

2）编写消费者代码

由于交换机和队列的绑定关系已经由生产者写完，所以消费者不需要再写

定义监听类

@Component
public class FanoutListener {
    @RabbitListener(queues = Constants.FANOUT_QUEUE1)
    public void queueListener1(String message) {
        System.out.println("队列[" + Constants.FANOUT_QUEUE1 + "] 接收到的消息:" + message);
    }
    @RabbitListener(queues = Constants.FANOUT_QUEUE2)
    public void queueListener2(String message) {
        System.out.println("队列[" + Constants.FANOUT_QUEUE2 + "] 接收到的消息:" + message);
    }
}

运行程序，观察结果

1.3 Routing（路由模式）

交换机类型为 Direct 时，会把消息交给指定 routing key 的队列

1）编写生产者代码

//路由模式
public static final String DIRECT_QUEUE1 = "direct.queue1";
public static final String DIRECT_QUEUE2 = "direct.queue2";
public static final String DIRECT_EXCHANGE = "direct.exchange";

声明队列，并和交换机绑定

//路由模式
    @Bean("directQueue1")
    public Queue directQueue1() {
        return QueueBuilder.durable(Constants.DIRECT_QUEUE1).build();
    }@Bean("directQueue2")
    public Queue directQueue2() {
        return QueueBuilder.durable(Constants.DIRECT_QUEUE2).build();
    }
    @Bean("directExchange")
    public DirectExchange directExchange() {
        return ExchangeBuilder.directExchange(Constants.DIRECT_EXCHANGE).durable(true).build();
    }
    @Bean("directQueueBinding1")
    public Binding directQueueBinding1(@Qualifier("directExchange") DirectExchange directExchange,@Qualifier("directQueue1") Queue queue) {
        return BindingBuilder.bind(queue).to(directExchange).with("orange");
    }
    @Bean("directQueueBinding2")
    public Binding directQueueBinding2(@Qualifier("directExchange") DirectExchange directExchange,@Qualifier("directQueue2") Queue queue) {
        return BindingBuilder.bind(queue).to(directExchange).with("black");
    }
    @Bean("directQueueBinding3")
    public Binding directQueueBinding3(@Qualifier("directExchange") DirectExchange directExchange,@Qualifier("directQueue2") Queue queue) {
        return BindingBuilder.bind(queue).to(directExchange).with("green");
    }
    @RequestMapping("/direct/{routingKey}")
    public String direct(@PathVariable("routingKey") String routingKey) {
        rabbitTemplate.convertAndSend(Constants.DIRECT_EXCHANGE,routingKey,"hello     queue.direct,my routingKey is :" + routingKey);
        return "发送成功";
    }

使用接口发送消息

2）编写消费者代码

定义监听类

@Component
public class DirectListener {
    @RabbitListener(queues = Constants.DIRECT_QUEUE1)
    public void queueListener1(String message) {
        System.out.println("队列 [" + Constants.DIRECT_QUEUE1 + "] 接收到消息:" + message);
    }
    @RabbitListener(queues = Constants.DIRECT_QUEUE2)
    public void queueListener2(String message) {
        System.out.println("队列 [" + Constants.DIRECT_QUEUE2 + "] 接收到消息:" + message);
    }
}

运行程序，观察结果

1.4 Topics（通配符模式）

1）编写生产者代码

//通配符模式
    public static final String TOPIC_QUEUE1 = "topic.queue1";
    public static final String TOPIC_QUEUE2 = "topic.queue2";
    public static final String TOPIC_EXCHANGE = "topic.exchange";

 声明队列和交换机，并绑定

//通配符模式
    @Bean("topicQueue1")
    public Queue topicQueue1() {
        return QueueBuilder.durable(Constants.TOPIC_QUEUE1).build();
    }
    @Bean("topicQueue2")
    public Queue topicQueue2() {
        return QueueBuilder.durable(Constants.TOPIC_QUEUE2).build();
    }
    @Bean("topicExchange")
    public TopicExchange topicExchange() {
        return ExchangeBuilder.topicExchange(Constants.TOPIC_EXCHANGE).durable(true).build();
    }
    @Bean("topicQueueBinding1")
    public Binding topicQueueBinding1(@Qualifier("topicExchange") TopicExchange topicExchange,@Qualifier("topicQueue1") Queue queue) {
        return BindingBuilder.bind(queue).to(topicExchange).with("*.orange.*");
    }
    @Bean("topicQueueBinding2")
    public Binding topicQueueBinding2(@Qualifier("topicExchange") TopicExchange topicExchange,@Qualifier("topicQueue2") Queue queue) {
        return BindingBuilder.bind(queue).to(topicExchange).with("*.*.rabbit");
    }@Bean("topicQueueBinding3")
    public Binding topicQueueBinding3(@Qualifier("topicExchange") TopicExchange topicExchange,@Qualifier("topicQueue2") Queue queue) {
        return BindingBuilder.bind(queue).to(topicExchange).with("lazy.#");
    }
@RequestMapping("/topic")
    public String topic(String routingKey) {
        rabbitTemplate.convertAndSend(Constants.TOPIC_EXCHANGE,routingKey,"hello queue.topic,my routingKey is :" + routingKey);
        return "发送成功";
    }

使用接口发送消息

 

2）编写消费者代码

@Component
public class TopicListener {
    @RabbitListener(queues = Constants.TOPIC_QUEUE1)
    public void queueListener1(String message) {
        System.out.println("队列[" + Constants.TOPIC_QUEUE1 + "] 接收到的消息:" + message);
    }
    @RabbitListener(queues = Constants.TOPIC_QUEUE2)
    public void queueListener2(String message) {
        System.out.println("队列[" + Constants.TOPIC_QUEUE2 + "] 接收到的消息:" + message);
    }
}

运行程序，观察结果

2. 基于 SpringBoot + RabbitMQ 完成应用通信

需求描述：

用户下单成功之后，通知物流系统，进行发货

订单系统作为一个生产者，物流系统作为一个消费者

2.1 创建项目

1）创建一个空的文件夹，将两个项目放在一起

2）在这个项目里面创建 Module

3）后续流程和创建 SpringBoot 项目一样

创建两个项目

logistics-service
order-service

2.2 订单系统（生产者） 

1）完善配置信息

spring:
  rabbitmq:
    host: 44.34.51.65
    port: 5672
    username: lk
    password: lk
    virtual-host: order

2）声明队列

@Configuration
public class RabbitConfig {
    @Bean("orderQueue")
    public Queue orderQueue() {
        return QueueBuilder.durable("order.create").build();
    }
}

3）编写下单接口，下单成功之后，发送订单消息

@RequestMapping("/order")
@RestController
public class OrderController {
    @Autowired
    private RabbitTemplate rabbitTemplate;
    @RequestMapping("/createOrder")
    public String createOrder() {
        //发送消息通知
        String orderID = UUID.randomUUID().toString();
        rabbitTemplate.convertAndSend("","order.create","下单成功,订单 ID:" + orderID);
        return "下单成功";
    }
}

4）启动服务，观察结果

2.3 物流系统（消费者）

1）完善配置信息

server:
  port: 9090
spring:
  rabbitmq:
    host: 44.34.51.65
    port: 5672
    username: lk
    password: lk
    virtual-host: order

2）监听队列

@Component
public class OrderListener {
    @RabbitListener(queues = "order.create")
    public void ListenerQueue(String message) {
        System.out.println("接收到消息:" + message);
    }
}

@RabbitListener(queues = "order.create") 可以加在类上，也可以加在方法上，加在类上，如果消息是 String 类型就会执行 String 类型的方法，如果是对象类型，就会执行对象类型的方法

@RabbitHandler 是一个方法级别的注解，当使用 @RabbitHandler 注解时，这个方法被调用处理特定的消息

@Component
public class OrderCreateListener {
    @RabbitHandler
    @RabbitListener(queues = "order.create")
    public void ListenerQueue(String message){
        System.out.println("接收到消息:"+ message);
    }
}

2.4 启动服务，观察结果

2.5 发送消息格式为对象

如果通过 RabbitTemplate 发送一个对象作为消息，需要对该对象进行序列化，Spring AMQP 推荐使用 JSON 序列化，Spring AMQP 提供了 Jackson2JsonMessageConverter 和 MappingJackson2MessageConverter 等转换器，需要把一个 MessageConverter 设置到 RabbitTemplate 中

@Configuration
public class RabbitConfig {
    @Bean("orderQueue")
    public Queue orderQueue() {
        return QueueBuilder.durable("order.create").build();
    }
    @Bean
    public Jackson2JsonMessageConverter jackson2JsonMessageConverter() {
        return new Jackson2JsonMessageConverter();
    }
    @Bean
    public RabbitTemplate rabbitTemplate(ConnectionFactory connectionFactory,Jackson2JsonMessageConverter jackson2JsonMessageConverter) {
        RabbitTemplate rabbitTemplate = new RabbitTemplate(connectionFactory);
        rabbitTemplate.setMessageConverter(jackson2JsonMessageConverter);
        return rabbitTemplate;
    }
}

 定义一个对象

@Data
public class OrderInfo {
    private String orderId;
    private String name;
}

生产者代码

@RequestMapping("/order")
@RestController
public class OrderController {
    @Autowired
    private RabbitTemplate rabbitTemplate;
    @RequestMapping("/createOrder2")
    public String createOrder2() {
        //发送消息通知
        OrderInfo orderInfo = new OrderInfo();
        orderInfo.setOrderId(UUID.randomUUID().toString());
        orderInfo.setName("商品" + new Random().nextInt(100));
        rabbitTemplate.convertAndSend("","order.create",orderInfo);
        return "下单成功";
    }
}

这里注入进来的 RabbitTemplate  就会使用刚才自己创建的对象，此时运行程序，观察结果

此时发送的就是对象了 

Lky strive
关注
  • 17
    点赞
  • 踩
  • 16
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
Springboot 整合RabbitMq ，用心看完这一篇就够了
默默不代表沉默
09-04 49万+
该篇文章内容较多，包括有rabbitMq相关的一些简单理论介绍，provider消息推送实例，consumer消息消费实例，Direct、Topic、Fanout的使用，消息回调、手动确认等。 （但是关于rabbitMq的安装，就不介绍了） 在安装完rabbitMq后，输入http://ip:15672/，是可以看到一个简单后台管理界面的。 在这个界面里面我们可以做些什么？ 可以手动创建............
SpringBoot 使用rabbitMQ
22333
05-07 1372
SpringBoot 整合 rabbitMQ application.yml设置 spring: rabbitmq: host: 47.115.50.193 username: admin password: admin 创建交换机，消息队列，并进行绑定 @Configuration public class RabbitMQConfig { private static final String TOPIC_NAME = "top_name"; private
SpringBoot使用RabbitMQ实现延迟队列
Funky_oaNiu的博客
06-03 604
实现延迟队列，先将消息发到指定了TTL时长的队列A中，队列A没有消费者，也就是说，队列A中的消息肯定会过期，等消息过期后，就会加入到队列B，也就是死信队列，B队列是有消费者在监听的，一旦收到消息，就进行后续的逻辑处理，从而达到延迟效果。如果消息的延迟时间设置较长，可能会导致堆积的延迟消息非常多，会带来较大的CPU开销，同时延迟消息的时间会存在误差。③死信队列：延迟队列上的消息过期后，会被自动转发到死信队列中，从而最终达到延迟的目的。因此，不建议设置延迟时间过长的延迟消息，如果时间过长，建议使用任务调度。
springboot使用rabbitmq
qq_25624815的博客
03-24 146
默认是true（与参数acknowledge-mode有关系）spring.rabbitmq.listener.simple.transaction-size: 指定一个事务处理的消息数量，最好是小于等于prefetch的数量.spring.rabbitmq.listener.simple.retry.initial-interval: 第一次和第二次尝试发布或传递消息之间的间隔。spring.rabbitmq.listener.simple.retry.max-interval: 最大重试时间间隔。
SpringBoot使用RabbitMQ的ACK机制
搬砖爱好者.的博客
02-25 2431
在使用MQ消息队列过程中，生产者发送消息到mq队列中，消费者监听这个队列，并拿取消息进行消费使用。但如果消费者因为在处理业务逻辑过程中，发生了非业务逻辑的异常(如断电、服务崩了等)这些，那么这条消息就没有完成消费，最后导致数据丢失。所以为了确保数据不会丢失，MQ支持自定义ACK消息确实机制。
springBoot使用RabbitMq6大模式详解
sora33的博客
07-03 1401
最简单最全的rabbitmq上手教程
springBoot使用rabbitmq并保证消息可靠性
卷心菜投手
01-04 2685
1、rabbitmq在springboot中使用 2、rabbitmq数据可靠性投递
SpringBoot基于RabbitMQ实现死信队列 (SpringBoot整合RabbitMQ实战篇)
莫等闲 白了少年头 空悲切
04-24 1934
消息超时的两种方式是？给队列设置ttl属性，进入队列后超过ttl时间的消息变为死信给消息设置ttl属性，队列接收到消息超过ttl时间后变为死信如何实现发送一个消息20秒后消费者才收到消息？给消息的目标队列指定死信交换机将消费者监听的队列绑定到死信交换机发送消息时给消息设置超时时间为20秒每一项技术深挖都是一个庞大的体系，学海无涯，共勉。
springboot 使用rabbitmq消息队列
刘富国的博客
02-27 717
目录 1.引入rabbitmq依赖 2.application.yml配置文件 3.消息接收端的三种实现 4.发送端的实现 1.引入rabbitmq依赖 &lt;!--rabbitmq--&gt; &lt;dependency&gt; &lt;groupId&gt;org.springframework.boot&lt;/......
SpringBoot使用RabbitMQ
LuckyCurve的博客
02-27 350
在SpringBoot下使用RabbitMQ 1.环境搭建： 在Spring初始化器里导入Message模块里面的Spring for RabbitMQ的starter和web模块即可 在配置文件application.yml中配置 spring: rabbitmq: host: www.luckycurve.cn username: ********** passw...
springboot使用rabbitmq工具类
03-29
springboot使用rabbitmq工具类,里面包含比较原生的方法,还有一套是我结合springboot框架写的一套方法,里面有两个方法,看情况使用,一般使用框架的方法比较好,因为框架方法时前辈们封装好经过检验的没有问题的方法,...
SpringBoot之RabbitMQ的使用方法
08-26
SpringBoot之RabbitMQ的使用方法 RabbitMQ是消息中间件的一种，消息中间件即分布式系统中完成消息的发送和接收的基础软件，消息中间件的工作过程可以用生产者消费者模型来表示。即，生产者不断的向消息队列发送信息...
SpringBoot整合RabbitMQ.zip
06-29
SpringBoot整合RabbitMQ的详细过程 **1.该篇博文首先讲述了交换机和队列之间的绑定关系** ①direct、②fanout、③topic **2.然后讲消息的回调** 四种情况下，确认触发哪个回调函数： ①消息推送到server，但是在...
springboot-rabbitMQ-websocket:springboot整合rabbitMQ和websocket，实现消息的发布和接收，并通过websocket实时推送数据到页面
05-27
在这个项目"springboot-rabbitMQ-websocket"中，我们将探讨如何将这三个技术整合起来，实现高效的数据发布和实时接收。 首先，Spring Boot整合RabbitMQ主要涉及以下几个步骤： 1. **添加依赖**：在项目中，我们...
springboot+rabbitmq
03-21
在本项目中，`springboot-rabbitmq`目录下包含了实现三种不同模式的代码： 1. 队列模式（Queue Mode）：在RabbitMQ中，队列是消息的接收者。生产者将消息发送到队列，而消费者从队列中接收和处理消息。队列模式是最...
Rabbitmq的几种工作模式
你我约定有三的博客
08-03 699
的交换机(具体交换机的类型和概念小伙伴们可以自行查阅下，这里主要讲工作模式)，生产者将消息发送给这个交换机，这个交换机把消息发送给每一个和其绑定的队列(注意。#号表示支持匹配多个词；*号表示只能匹配一个词，假如同一个队列与交换机直接设置的多个模糊的key都符合传入的，那么也只传送一次。的交换机不需要key所以生产者传递直接传""就好)(谁处理快，谁做的多)路由模式Routing。
Spring Boot 3.0新特性概述
心猿意码
08-06 310
接下来定义一个微服务接口，使用@HttpExchange注解来指定HTTP方法和路径。java深色版本581112}通过上面的实战，我们成功地使用Spring Boot 3.0构建了一个简单的微服务示例。Spring Boot 3.0引入的声明式HTTP客户端极大地简化了客户端和服务端之间的交互。在未来的工作中，我们还可以进一步探索Spring Cloud的其他组件，如服务发现、配置中心等，以实现更加复杂的微服务架构。
Spring Boot 整合 RestTemplate：详解与实战
最新发布
weixin_42564451的博客
08-06 540
本文详细讲解了 Spring Boot 整合 RestTemplate 的方法，包括依赖添加、实例创建、请求发送、响应处理以及一些高级用法。
Spring Boot相关知识
w75779的博客
08-06 560
Spring为企业级Java开发提供了一种相对简单的方法，通过依赖注入和面向切面编程，用简单的Java对象实现了EJB的功能。缺点：虽然Spring的组件代码是轻量级的，但他的配置却是重量级的（需要大量xml配置），除此之外，相关库的依赖、版本冲突也非常常见。Spring Boot Staters是一系列依赖关系的集合，因为它的存在，项目的依赖关系对我们来说变得更加简单了。YAML是一种人类可读的数据序列化语言，通常用于配置文件。优点：YAML文件具有结构化的特点，直观清晰，有层次感。
springboot 使用rabbitmq
08-26
要在Spring Boot中使用RabbitMQ，首先需要添加相应的依赖。在pom.xml文件中添加以下依赖： ```xml <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-amqp</artifactId> </dependency> ``` 接下来，你需要在application.properties（或application.yml）文件中配置RabbitMQ连接信息，例如： ```properties spring.rabbitmq.host=localhost spring.rabbitmq.port=5672 spring.rabbitmq.username=guest spring.rabbitmq.password=guest ``` 然后，你可以创建一个生产者和一个消费者来发送和接收消息。 对于生产者，你可以使用RabbitTemplate类发送消息。例如，创建一个名为`MessageProducer`的类，并注入`RabbitTemplate`： ```java import org.springframework.amqp.rabbit.core.RabbitTemplate; import org.springframework.beans.factory.annotation.Autowired; import org.springframework.stereotype.Component; @Component public class MessageProducer { private final RabbitTemplate rabbitTemplate; @Autowired public MessageProducer(RabbitTemplate rabbitTemplate) { this.rabbitTemplate = rabbitTemplate; } public void sendMessage(String message) { rabbitTemplate.convertAndSend("myExchange", "myRoutingKey", message); } } ``` 对于消费者，你可以创建一个消息处理器来处理接收到的消息。例如，创建一个名为`MessageConsumer`的类，并使用`@RabbitListener`注解指定监听的队列： ```java import org.springframework.amqp.rabbit.annotation.RabbitListener; import org.springframework.stereotype.Component; @Component public class MessageConsumer { @RabbitListener(queues = "myQueue") public void handleMessage(String message) { System.out.println("Received message: " + message); // 处理消息 } } ``` 需要注意的是，你还需要在启动类上添加`@EnableRabbit`注解来启用RabbitMQ相关功能。 这是一个简单的使用RabbitMQ的Spring Boot示例。根据你的需求，你可以进一步配置交换机和队列等属性，以及处理更复杂的消息场景。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值