Spring Boot整合RabbitMQ

最新推荐文章于 2024-04-30 12:51:41 发布
最新推荐文章于 2024-04-30 12:51:41 发布
阅读量146 收藏
点赞数
分类专栏： 后端框架
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Nov17/article/details/114372334
版权

一、开发中的大概过程

  • 生产者工程：

    1. application.yml文件配置RabbitMQ相关信息；

    2. 在生产者工程中编写配置类，用于创建交换机和队列，并进行绑定

    3. 注入RabbitTemplate对象，通过RabbitTemplate对象发送消息到交换机

  • 消费者工程：

    1. application.yml文件配置RabbitMQ相关信息

    2. 创建消息处理类，用于接收队列中的消息并进行处理

二、添加依耐和相应配置

  • 生产者、消费者一样需要配置

  • 导入坐标

    <?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>
    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.1.4.RELEASE</version>
    </parent>
    <groupId>com.itheima</groupId>
    <artifactId>springboot-rabbitmq</artifactId>
    <version>1.0-SNAPSHOT</version>

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

  • 配置rabbitmq相关信息

    spring:
  rabbitmq:
    host: 127.0.0.1
    port: 5672
    username: nov17
    password: nov17
    virtual-host: testhost

    重点掌握后面的几种工作模式的特点以及使用方法

三、RabbitMQ工作模式

1）提前了解

  • 常用的交换机

    • DirectExchange：直连型交换机，根据消息携带的路由键，将消息转发给对应的队列

    • FanoutExchange：扇形交换机，接收到消息后会将消息转发到所有队列

    • TopicExchange：主题交换机，根据消息携带的路由键和交换机与队列绑定键的规则，将消息转发给对应的队列

  • 规则

    • #：匹配一个或多个词
    • *：匹配不多不少恰好1个词
2）简单模式 HelloWorld

  • 一个生产者、一个消费者，不需要设置交换机（使用默认的交换机）

  • 生产者代码：

    创建RabbitMQ队列配置类com.example.rabbitmq_producer.config;

    @Configuration
public class RabbitMQConfig {

    //队列名称
    public static final String SIMPLE_QUEUE = "simple_queue";

    //声明队列
    @Bean("simpleQueue")
    public Queue simpleQueue(){
        return QueueBuilder.durable(SIMPLE_QUEUE).build();
    }

}

  • 消费者代码：

    编写消息监听器com.example.rabbitmq_consumer.listener;

    @Component
public class MyListener {

	/**
     * 监听某个队列的消息
     * @param message 接收到的消息
     */
    @RabbitListener(queues = "simple_queue")
    public void printMsg(String msg) {
        System.out.println("消费者接收到的消息为：" + msg);
    }

}

  • 测试代码

    在生产者工程springboot-rabbitmq-producer中创建测试类，发送消息：

    @SpringBootTest
public class RabbitMQTest {

    @Autowired
    private RabbitTemplate rabbitTemplate;

    @Test
    public void test(){
        rabbitTemplate.convertAndSend(RabbitMQConfig.SIMPLE_QUEUE, "rabbitmq helloworld ...");
        System.out.println("消息发送成功");
    }

}
3）工作队列模式 Work Queue

  • 一个生产者、多个消费者（竞争关系），不需要设置交换机（使用默认的交换机）

  • 生产者代码：

    创建RabbitMQ队列配置类com.example.rabbitmq_producer.config;

    @Configuration
public class RabbitMQConfig {

    //队列名称
    public static final String WORK_QUEUE = "work_queue";

    //声明队列
    @Bean("workQueue")
    public Queue workQueue(){
        return QueueBuilder.durable(WORK_QUEUE).build();
    }

}

  • 消费者代码：

    编写消息监听器com.example.rabbitmq_consumer.listener;

    消费者1：

    @Component
public class MyListener {

	/**
     * 监听某个队列的消息
     * @param message 接收到的消息
     */
    @RabbitListener(queues = "work_queue")
    public void printMsg(String msg) {
        System.out.println("消费者1接收到的消息为：" + msg);
    }

}

  • 消费者2：

    @Component
public class MyListener {

	/**
     * 监听某个队列的消息
     * @param message 接收到的消息
     */
    @RabbitListener(queues = "work_queue")
    public void printMsg(String msg) {
        System.out.println("消费者2接收到的消息为：" + msg);
    }

}

  • 测试代码

    在生产者工程springboot-rabbitmq-producer中创建测试类，发送消息：

    @SpringBootTest
public class RabbitMQTest {

    @Autowired
    private RabbitTemplate rabbitTemplate;

    @Test
    public void test(){
        rabbitTemplate.convertAndSend(RabbitMQConfig.WORK_QUEUE, "rabbitmq work queue ...");
        System.out.println("消息发送成功");
    }

}
4）发布订阅模式 Publish/subscribe

  • 需要设置类型为fanout的交换机，并且交换机和队列进行绑定，当发送消息到交换机后，交换机会将消息发送到绑定的队列

  • 生产者代码

    创建RabbitMQ队列配置类com.example.rabbitmq_producer.config;

    @Configuration
public class RabbitMQConfig {

    //交换机名称
    public static final String ITEM_PS_EXCHANGE = "item_ps_exchange";
    //队列名称
    public static final String ITEM_QUEUE1 = "item_queue1";
    public static final String ITEM_QUEUE2 = "item_queue2";

    //声明交换机
    @Bean("itemPsExchange")
    public FanoutExchange PsExchange(){
        return ExchangeBuilder.fanoutExchange(ITEM_PS_EXCHANGE).build();
    }

    //声明队列
    @Bean("itemQueue1")
    public Queue itemQueue1(){
        return QueueBuilder.durable(ITEM_QUEUE1).build();
    }
    @Bean("itemQueue2")
    public Queue itemQueue2(){
        return QueueBuilder.durable(ITEM_QUEUE2).build();
    }

    //绑定队列和交换机
    @Bean
    public Binding itemQueueExchange1(@Qualifier("itemQueue1") Queue queue,
                                     @Qualifier("itemPsExchange") FanoutExchange exchange){
        return BindingBuilder.bind(queue).to(exchange);
    }
    @Bean
    public Binding itemQueueExchange2(@Qualifier("itemQueue2") Queue queue,
                                      @Qualifier("itemPsExchange") FanoutExchange exchange){
        return BindingBuilder.bind(queue).to(exchange);
    }

}

  • 消费者代码

    编写消息监听器com.example.rabbitmq_consumer.listener;

    消费者1：

    @Component
public class MyListener {

    @RabbitListener(queues = "item_queue1")
    public void printMsg(String msg) {
        System.out.println("消费者1接收到的消息为：" + msg);
    }

}

    消费者2：

    @Component
public class MyListener {

    @RabbitListener(queues = "item_queue2")
    public void printMsg(String msg) {
        System.out.println("消费者2接收到的消息为：" + msg);
    }

}

  • 测试代码

    在生产者工程springboot-rabbitmq-producer中创建测试类，发送消息：

    @SpringBootTest
public class RabbitMQTest {

    @Autowired
    private RabbitTemplate rabbitTemplate;

    @Test
    public void test(){
        rabbitTemplate.convertAndSend(RabbitMQConfig.ITEM_PS_EXCHANGE,"", "rabbitmq pub/sub ...");
        System.out.println("消息发送成功");
    }

}
5）路由模式 Routing

  • 需要设置类型为direct的交换机，交换机和队列进行绑定，并且指定routing key，当发送消息到交换机后，交换机会根据routing key将消息发送到对应的队列

  • 生产者代码：

    创建RabbitMQ队列配置类com.example.rabbitmq_producer.config;

    @Configuration
public class RabbitMQConfig {

    //交换机名称
    public static final String ITEM_ROUTING_EXCHANGE = "item_routing_exchange";
    //队列名称
    public static final String ITEM_QUEUE1 = "item_queue1";
    public static final String ITEM_QUEUE2 = "item_queue2";

    //声明交换机
    @Bean("itemPsExchange")
    public Exchange PsExchange(){
        return ExchangeBuilder.directExchange(ITEM_ROUTING_EXCHANGE).build();
    }

    //声明队列
    @Bean("itemQueue1")
    public Queue itemQueue1(){
        return QueueBuilder.durable(ITEM_QUEUE1).build();
    }
    @Bean("itemQueue2")
    public Queue itemQueue2(){
        return QueueBuilder.durable(ITEM_QUEUE2).build();
    }

    //绑定队列和交换机
    @Bean
    public Binding itemQueueExchange1(@Qualifier("itemQueue1") Queue queue,
                                     @Qualifier("itemPsExchange") Exchange exchange){
        return BindingBuilder.bind(queue).to(exchange).with("info").noargs();
    }
    @Bean
    public Binding itemQueueExchange2(@Qualifier("itemQueue2") Queue queue,
                                      @Qualifier("itemPsExchange") Exchange exchange){
        return BindingBuilder.bind(queue).to(exchange).with("error").noargs();
    }

}

  • 消费者代码：

    编写消息监听器com.example.rabbitmq_consumer.listener;

    消费者1：

    @Component
public class MyListener {

    @RabbitListener(queues = "item_queue1")
    public void printMsg(String msg) {
        System.out.println("消费者1接收到的消息为：" + msg);
    }

}

    消费者2：

    @Component
public class MyListener {

    @RabbitListener(queues = "item_queue2")
    public void printMsg(String msg) {
        System.out.println("消费者2接收到的消息为：" + msg);
    }

}

  • 测试代码：

    在生产者工程springboot-rabbitmq-producer中创建测试类，发送消息：

    @SpringBootTest
public class RabbitMQTest {

    @Autowired
    private RabbitTemplate rabbitTemplate;

    @Test
    public void test(){
        rabbitTemplate.convertAndSend(RabbitMQConfig.ITEM_ROUTING_EXCHANGE,"error", "rabbitmq routing ...");
        System.out.println("消息发送成功");
    }

}
6）通配符模式 Topic

  • 需要设置类型为topic的交换机，交换机和队列进行绑定，并且指定通配符方式的routing key，当发送消息到交换机后，交换机会根据routing key将消息发送到对应的队列

    Routingkey 一般都是有一个或多个单词组成，多个单词之间以”.”分割，例如： item.insert

    通配符规则：

    #：匹配一个或多个词

    *：匹配不多不少恰好1个词

  • 生产者代码：

    创建RabbitMQ队列配置类com.example.rabbitmq_producer.config;

    @Configuration
public class RabbitMQConfig {

    //交换机名称
    public static final String ITEM_TOPIC_EXCHANGE = "item_topic_exchange";
    //队列名称
    public static final String ITEM_QUEUE1 = "item_queue1";
    public static final String ITEM_QUEUE2 = "item_queue2";

    //声明交换机
    @Bean("itemPsExchange")
    public Exchange PsExchange(){
        return ExchangeBuilder.topicExchange(ITEM_TOPIC_EXCHANGE).build();
    }

    //声明队列
    @Bean("itemQueue1")
    public Queue itemQueue1(){
        return QueueBuilder.durable(ITEM_QUEUE1).build();
    }
    @Bean("itemQueue2")
    public Queue itemQueue2(){
        return QueueBuilder.durable(ITEM_QUEUE2).build();
    }

    //绑定队列和交换机
    @Bean
    public Binding itemQueueExchange1(@Qualifier("itemQueue1") Queue queue,
                                     @Qualifier("itemPsExchange") Exchange exchange){
        return BindingBuilder.bind(queue).to(exchange).with("info.#").noargs();
    }
    @Bean
    public Binding itemQueueExchange2(@Qualifier("itemQueue2") Queue queue,
                                      @Qualifier("itemPsExchange") Exchange exchange){
        return BindingBuilder.bind(queue).to(exchange).with("error.#").noargs();
    }

}

  • 消费者代码：

    编写消息监听器com.example.rabbitmq_consumer.listener;

    消费者1：

    @Component
public class MyListener {

    @RabbitListener(queues = "item_queue1")
    public void printMsg(String msg) {
        System.out.println("消费者1接收到的消息为：" + msg);
    }

}

    消费者2：

    @Component
public class MyListener {

    @RabbitListener(queues = "item_queue2")
    public void printMsg(String msg) {
        System.out.println("消费者2接收到的消息为：" + msg);
    }

}

  • 测试代码：

    在生产者工程springboot-rabbitmq-producer中创建测试类，发送消息：

    @SpringBootTest
public class RabbitMQTest {

    @Autowired
    private RabbitTemplate rabbitTemplate;

    @Test
    public void test(){
        rabbitTemplate.convertAndSend(RabbitMQConfig.ITEM_TOPIC_EXCHANGE,"info.select", "rabbitmq info.select ...");
        rabbitTemplate.convertAndSend(RabbitMQConfig.ITEM_TOPIC_EXCHANGE,"info.insert", "rabbitmq info.insert ...");
        rabbitTemplate.convertAndSend(RabbitMQConfig.ITEM_TOPIC_EXCHANGE,"error.delete", "rabbitmq error.delete ...");
        System.out.println("消息发送成功");
    }

}
清欢Nov17
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 3
    评论
专栏目录
Spring Boot 整合RabbitMQ
Java 技术专栏，从入门到精通，熟悉企业级开发
11-05 10万+
在业务活动期间，由于用户请求量短时间内剧增，可能导致系统压力过大甚至崩溃。通过消息队列实现请求的缓冲。在高并发场景下，系统可以将请求放入消息队列，然后异步处理这些请求，从而平滑系统的处理负载，确保系统的稳定性。
Spring Boot ： Spring Boot 整合 RabbitMQ
CHIKA2333的博客
08-09 460
RabbitMQ 是一个消息队列，说到消息队列，大家可能多多少少有听过，它主要的功能是用来实现应用服务的异步与解耦，同时也能起到削峰填谷、消息分发的作用。消息队列在比较主要的一个作用是用来做应用服务的解耦，消息从消息的生产者传递到消息队列，消费者从消息队列中获取消息并进行消费，生产者不需要管是谁在消费消息，消费者也无需关注消息是由谁来生产的。在分布式的系统中，消息队列也会被用在其他地方，比如分布式事务的支持，代表如阿里开源的 RocketMQ。当然，我们本篇文章的主角还是 RabbitMQ。
spring boot整合RabbitMQ
qq_55648724的博客
03-08 669
无
Spring Boot 整合rabbitmq
Dream_it_possible！的博客
03-04 1218
一、队列准备 1. 先进入到rabbitmq的管理页面，然后在管理页面新建一个虚拟主机，默认的虚拟主机为"/" ,不同的环境使用不同的虚拟主机，如开发环境可以设置为dev,生产环境可以设置为prod。 2. 在默认的虚拟主机下，新增一个队列rabbitmqtest 二、实现步骤 1. 添加rabbitmq依赖 ： ...
Spring Boot整合RabbitMQ详细教程
2401_84103936的博客
04-30 1163
笔者已经把面试题和答案整理成了面试专题文档//假如想一个消费者处理多个队列里面的信息可以如下设置：//设置最大的并发的消费者数量笔者已经把面试题和答案整理成了面试专题文档[外链图片转存中…(img-YrVM3PMb-1714452690743)][外链图片转存中…(img-HzjoMwqG-1714452690743)][外链图片转存中…(img-NwQsbI6W-1714452690744)][外链图片转存中…(img-1vfHO6gi-1714452690744)]
Spring Boot整合RabbitMQ教程
qq_42003636的博客
02-22 544
虽然并性已经提高的处理时间,但是,前面说过,邮件和短信对我正常的使用网站没有任何影响，客户端没有必要等着其发送完成才显示注册成功,应该是写入数据库后就返回.由此可以看出,引入消息队列后，用户的响应时间就等于写入数据库的时间+写入消息队列的时间(可以忽略不计),引入消息队列后处理后,响应时间是串行的3倍,是并行的2倍。zeroMq不支持，activeMq和rabbitMq都支持。(2)并行方式:将注册信息写入数据库后,发送邮件的同时,发送短信,以上三个任务完成后,返回给客户端,并行的方式能提高处理的时间。
Spring Boot 整合 RabbitMQ
MoYu's Blog
09-26 165
Spring Boot 整合 RabbitMQ 简介 在Spring项目中，可以使用Spring-Rabbit去操作RabbitMQ 尤其是在spring boot项目中只需要引入对应的amqp启动器依赖即可，方便的使用RabbitTemplate发送消息，使用注解接收消息。 一般在开发过程中： 生产者工程： application.yml文件配置RabbitMQ相关信息； 在生产者工程中编写配置类，用于创建交换机和队列，并进行绑定 注入RabbitTemplate对象，通过RabbitTemplate
Spring Boot 整合 RabbitMQ 实现
ttyy1112的专栏
09-30 1584
而RabbitAdmin Bean是在RabbitAutoConfiguration自动配置类中注册的，通过设置 spring.rabbitmq.dynamic 为false可以禁用该功能。下列代码创建类型为topic、名称为test_topic_exchange的exchange，当routingKey满足test.#时消息会被路由到 test_queue 队列。查看Consumer端日志，未回告原因是因为Consumer端没有处理test_queue队列中String类型消息的Handler。
Spring boot整合RabbitMQ
一个还在上学的程序缘
11-30 466
目录： 一、RabbitMQ简介   RabbitMQ安装不必我多说，linux和windows环境下都可以安装，我是在windows环境下进行安装的，安装RabbitMQ之前需要先安装Erlang，因为Rabbit MQ 是建立在Erlang OTP平台上，而且安装Erlang 时要注意安装的RabbityMQ 所依赖的Erlang版本。   RabbitMQ是实现了高级消息队列协议（AMQP）的开源消息代理软件（亦称面向消息的中间件）。RabbitMQ服务器是用Erlang语言编写的，而且支持跨平台。
spring boot整合RabbitMQ（Direct模式）
08-30
springboot集成RabbitMQ非常简单，如果只是简单的使用配置非常少，springboot提供了spring-boot-starter-amqp项目对消息各种...下面通过本文给大家介绍下spring boot整合RabbitMQ（Direct模式）,需要的朋友可以参考下
Spring Boot整合RabbitMQ开发实战详解
08-28
Spring Boot 整合 RabbitMQ 开发实战详解 首先，需要了解 RabbitMQ 中的一些基本概念，包括交换器（Exchange）、队列（Queue）和绑定（Binding）。交换器就像路由器，把消息发到交换器，然后交换器再根据路由键...
Spring Boot 整合 RabbitMQ 案例.zip
11-02
Spring Boot 整合 RabbitMQ 案例.zipSpring Boot 整合 RabbitMQ 案例.zipSpring Boot 整合 RabbitMQ 案例.zipSpring Boot 整合 RabbitMQ 案例.zipSpring Boot 整合 RabbitMQ 案例.zipSpring Boot 整合 RabbitMQ 案例...
Spring Boot整合RabbitMQ实例（Topic模式）
08-30
Spring Boot 整合 RabbitMQ 实例（Topic 模式） 本文主要介绍如何使用 Spring Boot 框架整合 RabbitMQ 实例，特别是 Topic Exchange 模式的使用。Topic Exchange 模式是一种基于通配符的消息路由机制，通过定义路由...
spring boot整合RabbitMQ实例详解（Fanout模式）
08-30
Spring Boot 整合 RabbitMQ 实例详解（Fanout 模式） Spring Boot 整合 RabbitMQ 是一种常见的消息队列解决方案，通过使用 RabbitMQ，可以实现消息的异步处理、队列处理和负载均衡等功能。在本文中，我们将详细介绍...
2024年公关服务行业分析报告.pptx
07-09
行业报告
惠州市建筑物矢量数据（Shp格式+带高度）.txt
最新发布
07-09
因文件较多，数据存放网盘，txt文件内包含下载链接及提取码，永久有效。失效会第一时间进行补充。
Matlab语言教程及案例
07-09
项目总结 本文详细介绍了Matlab的基础知识和一个完整的数据分析与可视化案例。内容包括： 1. **基本操作**：基本算术运算和矩阵操作。 2. **绘图**：二维和三维绘图。 3. **函数和脚本**：编写和运行Matlab函数和脚本。 4. **案例分析**：生成模拟数据，进行数据预处理、绘图和统计分析。 通过这个项目，读者可以掌握Matlab的基本使用方法，并了解如何在Matlab中进行数据分析和可视化。这对于初学者入门Matlab编程、提升数据处理和分析能力非常有帮助。希望本文能为读者提供有价值的参考，提升其Matlab编程和数据分析技能。
KB8825英文数据手册
07-09
三星KB8825英文数据手册
spring boot 整合rabbitmq
08-03
回答: Spring Boot整合RabbitMQ是相对容易的，因为Spring Boot封装了RabbitMQ的API，使得使用起来更加方便。RabbitMQ是一个消息队列中间件，用于实现应用程序之间的异步通信。它使用AMQP协议来进行消息传递。在...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值