RabbitMQ配合springboot基本使用

最新推荐文章于 2024-07-22 19:12:28 发布
最新推荐文章于 2024-07-22 19:12:28 发布
阅读量2.1k 收藏
点赞数
分类专栏： RabbitMQ 文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_43960044/article/details/124013635
版权

RabbitMQ几种模式

一、普通模式（一个发送一个接收）

配置类

@Configuration
public class RabbitMQConfigFanout {
    public static final String TEST_QUEUE = "test_queue";
    /**
     * Bean注解放到方法上，1、自动执行当前方法，将方法返回值放到ioc容器中
     * 2、方法中有参数会在ioc容器中寻找同类型的参数注入到方法中
     * <p>
     * 生成消息队列queue
     *
     * @return
     */
    @Bean
    public Queue queue() {
        return new Queue(TEST_QUEUE, true);
    }
}

发送、接收方法

	@Autowired
    private RabbitTemplate rabbitTemplate;

    /**
     * 测试发送消息
     *
     * @param msg
     */
    public void send(Object msg) {
        log.info("发送消息:" + msg);
        rabbitTemplate.convertAndSend(RabbitMQConfigFanout.TEST_QUEUE, msg);
    }

	/**
     * 测试接收queue队列消息
     */
    @RabbitListener(queues = RabbitMQConfigFanout.TEST_QUEUE)
    public void receive(Object msg) {
        log.info("接收消息：" + msg);
    }

二、fanout（路由模式）

发送这发送消息给exchange，exchange再发送给所有接收者。所有接收者都能接收。

import org.springframework.amqp.core.Binding;
import org.springframework.amqp.core.BindingBuilder;
import org.springframework.amqp.core.FanoutExchange;
import org.springframework.amqp.core.Queue;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

@Configuration
public class RabbitMQConfigFanout {
    public static final String FANOUT_QUEUE01 = "fanout_queue01";
    public static final String FANOUT_QUEUE02 = "fanout_queue02";
    public static final String FANOUT_EXCHANGE = "fanout_exchange";

    /**
     * 测试路由模式
     * 生成消息队列queue_fanout01
     *
     * @return
     */
    @Bean
    public Queue queue01() {
        return new Queue(FANOUT_QUEUE01);
    }

    /**
     * 测试路由模式
     * 生成消息队列queue_fanout02
     *
     * @return
     */
    @Bean
    public Queue queue02() {
        return new Queue(FANOUT_QUEUE02);
    }

    /**
     * 测试路由模式
     * 生成交换机
     *
     * @return
     */
    @Bean
    public FanoutExchange fanoutExchange() {
        return new FanoutExchange(FANOUT_EXCHANGE);
    }

    /**
     * 绑定交换机，将queue_fanout01与fanout_exchange绑定
     *
     * @return
     */
    @Bean
    public Binding binding01() {
        return BindingBuilder.bind(queue01()).to(fanoutExchange());
    }

    /**
     * 绑定交换机，将queue_fanout02与fanout_exchange绑定
     *
     * @return
     */
    @Bean
    public Binding binding02() {
        return BindingBuilder.bind(queue02()).to(fanoutExchange());
    }

}

发送、接收方法

    /**
     * 测试发送消息
     * 向fanout_exchange交换机发送消息
     *
     * @param msg
     */
    public void sendFanOut(String msg) {
        log.info("fanOut发送消息：" + msg);
        rabbitTemplate.convertAndSend(RabbitMQConfigFanout.FANOUT_EXCHANGE, "", msg);
    }

	/**
     * 测试接收queue_fanout01消息
     * 在路由模式下
     */
    @RabbitListener(queues = RabbitMQConfigFanout.FANOUT_QUEUE01)
    public void receiveFanout01(Object msg) {
        log.info("接收queue_fanout01队列消息：" + msg);
    }

    @RabbitListener(queues = RabbitMQConfigFanout.FANOUT_QUEUE02)
    public void receiveFanout02(Object msg) {
        log.info("接收queue_fanout02队列消息：" + msg);
    }

三、direct方法

  1. 发送消息给exchange时带上routingKey，指明接收者
  2. 与routingKey相匹配者接收消息

配置


@Configuration
public class RabbitMQConfigDirect {

    public static final String QUEUE_DIRECT01 = "queue_direct01";
    public static final String QUEUE_DIRECT02 = "queue_direct02";
    public static final String DIRECT_EXCHANGE = "direct_exchange";
    public static final String ROUTING_KEY01 = "queue.red";
    public static final String ROUTING_KEY02 = "queue.green";

    @Bean
    public Queue queueDirect01() {
        return new Queue(QUEUE_DIRECT01);
    }

    @Bean
    public Queue queueDirect02() {
        return new Queue(QUEUE_DIRECT02);
    }

    @Bean
    public DirectExchange directExchange() {
        return new DirectExchange(DIRECT_EXCHANGE);
    }

    @Bean
    public Binding bindingDirect01() {
        return BindingBuilder.bind(queueDirect01()).to(directExchange()).with(ROUTING_KEY01);
    }

    @Bean
    public Binding bindingDirect02() {
        return BindingBuilder.bind(queueDirect02()).to(directExchange()).with(ROUTING_KEY02);
    }

}

发送、接收方法


    /**
     * direct模式下向ROUTING_KEY01测试发送消息
     *
     * @param msg
     */
    public void sendDirect01(Object msg) {
        log.info("direct模式下向发送" + RabbitMQConfigDirect.ROUTING_KEY01 + "消息：" + msg);
        rabbitTemplate.convertAndSend(RabbitMQConfigDirect.DIRECT_EXCHANGE, RabbitMQConfigDirect.ROUTING_KEY01, msg);
    }

    public void sendDirect02(Object msg) {
        log.info("direct模式下向发送" + RabbitMQConfigDirect.ROUTING_KEY02 + "消息：" + msg);
        rabbitTemplate.convertAndSend(RabbitMQConfigDirect.DIRECT_EXCHANGE, RabbitMQConfigDirect.ROUTING_KEY02, msg);
    }


    /**
     * 测试direct模式下接收消息
     */
    @RabbitListener(queues = RabbitMQConfigDirect.QUEUE_DIRECT01)
    public void receiveDirect01(Object msg) {
        log.info("direct模式下接收" + RabbitMQConfigDirect.ROUTING_KEY01 + "消息：" + msg);
    }

    @RabbitListener(queues = RabbitMQConfigDirect.QUEUE_DIRECT02)
    public void receiveDirect02(Object msg) throws InterruptedException {
        // Thread.sleep(10000);
        log.info("direct模式下接收" + RabbitMQConfigDirect.ROUTING_KEY02 + "消息：" + msg);
    }

四、topic方式

  1. *匹配一个单词
  2. # 匹配0个或多个单词
  3. 根据匹配规则接收消息（一个消息可能被多个接收）
  4. 绑定使用 BindingBuilder.bind(queueTopic02()).to(topicExchange()).with(ROUTING_KEY02);

@Configuration
public class RabbitMQConfigTopic {

    public static final String TOPIC_QUEUE01 = "topic_queue01";
    public static final String TOPIC_QUEUE02 = "topic_queue02";
    public static final String TOPIC_EXCHANGE = "topic_exchange";
    // * 匹配一个单词，# 匹配0个或多个单词
    public static final String ROUTING_KEY01 = "queue.topic.*";
    public static final String ROUTING_KEY02 = "queue.topic.#.test";

    @Bean
    public Queue queueTopic01() {
        return new Queue(TOPIC_QUEUE01);
    }

    @Bean
    public Queue queueTopic02() {
        return new Queue(TOPIC_QUEUE02);
    }

    @Bean
    public TopicExchange topicExchange() {
        return new TopicExchange(TOPIC_EXCHANGE);
    }

    @Bean
    public Binding topicBinding01() {
        return BindingBuilder.bind(queueTopic01()).to(topicExchange()).with(ROUTING_KEY01);
    }

    @Bean
    public Binding topicBinding02() {
        return BindingBuilder.bind(queueTopic02()).to(topicExchange()).with(ROUTING_KEY02);
    }

}

发送、接收方法


    /**
     * topic模式下发送消息，指定模糊匹配，匹配不同的routing key
     *
     * @param msg
     */
    public void sendTopic01(Object msg) {
        log.info("topic模式下向 queue.topic.test 发送消息：" + msg);
        rabbitTemplate.convertAndSend(RabbitMQConfigTopic.TOPIC_EXCHANGE, "queue.topic.test", msg);
    }

    public void sendTopic02(Object msg) {
        log.info("topic模式下向 queue.topic.test.test 发送消息：" + msg);
        rabbitTemplate.convertAndSend(RabbitMQConfigTopic.TOPIC_EXCHANGE, "queue.topic.test.test", msg);
    }

    /**
     * 测试topic模式下接收消息
     */
    @RabbitListener(queues = RabbitMQConfigTopic.TOPIC_QUEUE01)
    public void receiveTopic01(Object msg) {
        log.info("topic模式下接收" + RabbitMQConfigTopic.ROUTING_KEY01 + "消息：" + msg);
    }

    @RabbitListener(queues = RabbitMQConfigTopic.TOPIC_QUEUE02)
    public void receiveTopic02(Object msg) {
        log.info("topic模式下接收" + RabbitMQConfigTopic.ROUTING_KEY02 + "消息：" + msg);
    }

五、header方式

  1. 配置绑定exchange时带上map，使用whereAll、whereAny进行匹配，前者匹配所有map，后者匹配一个即可接收消息
  2. 发送消息时带上Message，在MessageProperties中设置header值

@Configuration
public class RabbitMQConfigHeader {

    public static final String QUEUE_HEADER01 = "queue_header01";
    public static final String QUEUE_HEADER02 = "queue_header02";
    public static final String HEADER_EXCHANGE = "queue_exchange";

    @Bean
    public Queue queueHeader01() {
        return new Queue(QUEUE_HEADER01);
    }

    @Bean
    public Queue queueHeader02() {
        return new Queue(QUEUE_HEADER02);
    }

    @Bean
    public HeadersExchange headersExchange() {
        return new HeadersExchange(HEADER_EXCHANGE);
    }

    @Bean
    public Binding headerBinding01() {
        Map<String, Object> map = new HashMap<>();
        map.put("color", "red");
        map.put("speed", "low");
        return BindingBuilder.bind(queueHeader01()).to(headersExchange()).whereAll(map).match();
    }

    @Bean
    public Binding headerBinding02() {
        Map<String, Object> map = new HashMap<>();
        map.put("color", "red");
        map.put("speed", "high");
        return BindingBuilder.bind(queueHeader02()).to(headersExchange()).whereAny(map).match();
    }
}

发送、接收消息


    /**
     * header模式下发送消息测试
     *
     * @param msg
     */
    public void sendHeader01(String msg) {
        log.info("header模式下向" + RabbitMQConfigHeader.QUEUE_HEADER01 + "发送消息：" + msg);
        MessageProperties messageProperties = new MessageProperties();
        messageProperties.setHeader("color", "red");
        messageProperties.setHeader("speed", "low");
        Message message = new Message(msg.getBytes(), messageProperties);
        rabbitTemplate.send(RabbitMQConfigHeader.HEADER_EXCHANGE, "", message);
    }

    public void sendHeader02(String msg) {
        log.info("header模式下向" + RabbitMQConfigHeader.QUEUE_HEADER02 + "发送消息：" + msg);
        MessageProperties messageProperties = new MessageProperties();
        messageProperties.setHeader("color", "red");
        messageProperties.setHeader("speed", "high");
        Message message = new Message(msg.getBytes(), messageProperties);
        rabbitTemplate.send(RabbitMQConfigHeader.HEADER_EXCHANGE, "", message);
    }
noobmantest
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
springboot整合RabbitMQ
05-04
SpringBoot 整合 RabbitMQ 的过程涉及到多个关键知识点，这些知识点包括了消息中间件的基本概念、SpringBoot 的集成方式、RabbitMQ 的配置与使用，以及相关工具的配合。以下是对这些内容的详细阐述。 首先，...
Rabbitmq基本使用以及与springboot集成简单示例
gitcat的博客
10-28 3398
Rabbitmq基本使用以及与springboot集成简单示例，rabbitmq基本概念，常见问题。
springboot使用rabbitmq死信队列和延时队列配合一起使用
weixin_42169734的博客
09-01 501
【代码】springboot使用rabbitmq死信队列和延时队列配合一起使用。
SpringBoot中如何使用RabbitMq
最新发布
shenzhenNBA的专栏
07-22 590
RabbitMQ 是一个开源的消息中间件，基于 AMQP（高级消息队列协议）实现。 它由 Erlang 语言开发，并且支持多种编程语言，包括 Java、Python、Ruby、PHP 和 C# 等，
SpringBoot整合RabbitMQ
K_kzj_K的博客
06-09 4643
该篇文章内容较多，包括有rabbitMq相关的一些简单理论介绍，provider消息推送实例，consumer消息消费实例，Direct、Topic、Fanout的使用，消息回调、手动确认等。 （但是关于rabbitMq的安装，就不介绍了） 在安装完rabbitMq后，输入http://ip:15672/，是可以看到一个简单后台管理界面的。 在这个界面里面我们可以做些什么？ 可以手动创建虚拟host，创建用户，分配权限，创建交换机，创建队列等等，还有查看队列消息，消费效率，推送效率等等。 以上..
SpringBoot整合RabbitMQ ——Fanout模式
祝我飞黄腾达
03-22 1853
模拟用户下订单，将订单信息封装，通过MQ进行消息分发。 假设我们有一个订单系统，用户进行下单支付，下单成功后，根据业务处理一般都会消息通知用户相关信息。例如通过邮件+手机+qq 等方式进行消息推送支付成功信息。 ▎生产者 Producer 完整的项目结构如下： 1. 创建SpringBoot 项目 2. 勾选引入web、RabbitMQ依赖 3. 配置文件配置rabbit参数 注意：如果是连接本地，Spring...
Spring Boot整合RabbitMQ之发布与订阅模式（fanout）
cssweb_sh的博客
06-09 3067
Spring Boot整合RabbitMQ之发布与订阅模式
SpringBoot整合RabbitMQ基础学习Exchange源码
03-03
首先，让我们了解SpringBoot整合RabbitMQ的基本步骤： 1. **添加依赖**：在`pom.xml`文件中引入RabbitMQ的Spring Boot Starter依赖： ```xml <groupId>org.springframework.boot <artifactId>spring-boot-...
基于springboot商城系统
04-02
本文将涵盖SpringBoot的基本概念、商城系统的关键组件以及实现细节。 SpringBoot是由Pivotal团队开发的，旨在简化Spring应用的初始搭建以及开发过程。它预设了许多默认配置，使得开发者能够快速启动项目，同时保持...
springboot-demo
12-26
SpringBoot 是一个由 Pivotal 团队创建的框架，旨在简化 Spring 应用程序的初始搭建以及开发过程。...通过学习和实践这个 demo，开发者能够快速掌握 SpringBoot 的基本用法，并在此基础上构建更复杂的项目。
7.Spring Boot中使用RabbitMQ
相互学习 共同进步
05-22 563
/ 构建一个新的持久的、非自动删除的与提供的名称的交换机// 构建一个新的交换。给定一个名称、持久性标志、自动删除标志// 构建一个新的交换。给定一个名称、持久性标志和自动删除标志和参数属性描述name交换机名称durable持久性。声明一个持久耐用的交换机（在服务器重新启动仍然有效），那么它是持久的。默认true，即持久autoDelete自动删除。ture：如果服务器在不再使用时删除交换。默认false，即不自动删除arguments用于声明交换机的参数。
在SpringBoot中对RabbitMQ三种使用方式
有趣的灵魂万里挑一,好看的皮囊你又没有
07-08 4775
在SpringBoot三种创建RabbitMQ的队列和消息的方式
Springboot下RabbitMq的简单使用
weixin_49923835的博客
05-27 1594
相关依赖 <parent> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-parent</artifactId> <version>2.4.13</version> <relativePath/> </parent>
SpringBoot集成RabbitMQ-Fanout模式
My_Java_yon的博客
06-21 762
刚开始进入公司的时候，我们公司的架构还比较单一，就采用一种单体结构，而单体结构的话它是把所以的业务都堆积在一个项目里面，但是随着公司业务不断发展和推进，我们公司的负责人就开始把项目进行分裂，变成了一个分布式的架构，就把系统进行了一个拆分，在拆分......
Spring Boot 中使用 RabbitMQ
good7ob的博客
07-31 1755
通过本文的介绍，你已经学习了如何在 Spring Boot 中使用 RabbitMQ 实现异步消息的发送和接收。你了解了如何配置 RabbitMQ 连接信息，并使用 Spring Boot 提供的和注解进行消息的发送和接收。通过实际的案例，我们展示了如何使用 RabbitMQ 实现任务队列，以邮件发送服务为例。你学习了如何创建消息发送者和消息接收者，并使用队列来实现任务的异步处理。使用 RabbitMQ 可以帮助我们实现解耦和异步处理，提高系统的可靠性和性能。
rabbitmq在spring boot中的使用
kitahiragawa的博客
03-29 320
spring boot自动配置了rabbitmq的连接工厂、template等等，使用起来非常方便。
06-RabbitMQ之SpringBoot使用
qq_39234967的博客
08-11 305
由于SpringBoot官方支持RabbitMQ，所以RabbitMQ与SpringBoot的集成是非常简单的。不过SpringBoot集成RabbitMQ的方式是按照Spring的一套统一的MQ模型创建的，因此SpringBoot集成插件中对于生产者、消息、消费者等重要的对象模型，与RabbitMQ原生的各个组件有对应关系，但是并不完全相同。...
mq的面试题 20200908
yuzepeng11的博客
09-08 429
1、如何使用 ActiveMQ 解决分布式事务？ 在互联网应用中，基本都会有用户注册的功能。在注册的同时，我们会做出如下操作： 1. 收集用户录入信息，保存到数据库 2. 向用户的手机或邮箱发送验证码 等等… 如果是传统的集中式架构，实现这个功能非常简单：开启一个本地事务，往本地数据库中插入一条用户数据，发送 验证码，提交事物。 但是在分布式架构中，用户和发送验证码是两个独立的服务，它们都有各自的数据库，那么就不能通过本地事物 保证操作的原子性...
rabbitmq配合springboot示例
04-04
这里是一个简单的rabbitmq和springboot配合的示例： 1. 首先，我们需要在pom.xml中添加以下依赖： ```xml <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-amqp</artifactId> </dependency> ``` 2. 接下来，我们需要在application.properties中添加rabbitmq的配置： ```properties spring.rabbitmq.host=localhost spring.rabbitmq.port=5672 spring.rabbitmq.username=guest spring.rabbitmq.password=guest ``` 3. 然后，在我们的代码中，我们可以定义一个队列和一个交换机： ```java @Configuration public class RabbitConfig { public static final String QUEUE_NAME = "test.queue"; public static final String EXCHANGE_NAME = "test.exchange"; public static final String ROUTING_KEY = "test.routingKey"; @Bean public Queue queue() { return new Queue(QUEUE_NAME, true); } @Bean public DirectExchange exchange() { return new DirectExchange(EXCHANGE_NAME); } @Bean public Binding binding(Queue queue, DirectExchange exchange) { return BindingBuilder.bind(queue).to(exchange).with(ROUTING_KEY); } } ``` 4. 然后，我们可以编写一个生产者来发送消息到队列中： ```java @Component public class RabbitProducer { @Autowired private AmqpTemplate amqpTemplate; public void send(String message) { amqpTemplate.convertAndSend(RabbitConfig.EXCHANGE_NAME, RabbitConfig.ROUTING_KEY, message); } } ``` 5. 最后，我们可以编写一个消费者来处理队列中的消息： ```java @Component @RabbitListener(queues = RabbitConfig.QUEUE_NAME) public class RabbitConsumer { @RabbitHandler public void receive(String message) { System.out.println("Received message: " + message); } } ``` 这样，我们就完成了rabbitmq和springboot的配合示例，当我们发送一个消息到队列中时，消费者就会接收到这条消息。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值