SpringBoot2＞04 - 集成RabbitMQ

已于 2024-02-19 09:54:07 修改
阅读量449 收藏 1
点赞数
分类专栏： SpringBoot系列二 文章标签： rabbitmq 分布式
于 2019-01-19 11:41:58 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/cp026la/article/details/86550541
版权

消息中间件：

ActiveMQ，RabbitMQ，Kafka等都是常见的消息中间件，安全性从高到低，速度从低到高，Kafka在大数据中使用较多，RabbitMQ在银行系统中使用较多。主要应用在异步解耦、消息缓冲等场景中。

RabbitMQ简介：

由Erlang语言开发，实现AMQP(Advanced Message Queuing Protocol)的一种消息中间件。支持多种客户端，例如：Python、Ruby、.NET、Java、JMS、C、PHP等。

个人学习总结：
链接：【springboot、springcloud、docker 等，学习目录】

结构：

来自百度百科：

提到消息中间件，我们常听到的是：消息生产者、消费者、队列。如图，RabbitMQ多了一个Exchange交换器，Exchange位于消息生产者和队列之间。

相关名词：

  • Producer： 消息生产者，图中最左边。将消息发送到Exchange中。

  • Consumer：消息消费者，图中最右边。订阅队列中的消息。

  • RabbitMQ Server：传输服务，维护着生产者到消费者之间的线路，保证消息按照指定的方式传输。

  • Exchange：交换器，将接收到的producer消息路由到指定队列(一或多个)。具有direct、fanout、topic、headers四种类型，每种类型对应不同的路由规则

  • Queue：队列，用于存放Exchange路由过来的消息，consumer从队列中订阅消息。

  • RoutingKey：路由规则，生产者发送消息到Exchange时指定，Exchange根据路由规则将消息发送到哪一个Queue中存储。

direct、fanout、topic 初步了解：

1、direct ：直接模式，最简单的使用，一个消息只会有一个消费者。不需要 routingKey 规则匹配。

2、fanout：分列模式，将消息一次发给多个队列。不需要 routingKey 规则匹配。

3、topic：订阅模式，交换机中的消息根据匹配规则路由到对应的队列中。

集成RabbitMQ：

1、docker安装RabbitMQ：

# 1、获取镜像
docker pull rabbitmq:management
# 2、创建容器
docker run ‐di ‐‐name=tensquare_rabbitmq ‐p 5671:5617 ‐p 5672:5672 ‐p 4369:4369 ‐p 15671:15671 ‐p 15672:15672 ‐p 25672:25672 rabbitmq:management

监视画面：http://192.168.25.133:15672默认用户名、密码：guest

2、pom依赖：

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

3、application配置：

# 工程的端口
server:
  port: 8099

spring:
  rabbitmq:
    host: 192.168.25.133
    # mq 的端口
    port: 5672
    username: guest
    password: guest

直接模式(Direct)：

1、队列配置：

@Configuration
public class DirectConfig {
    @Bean
    public Queue helloQueue(){
        return new Queue("hello");
    }
}

亦可在15672监视画面中配置队列。

2、Producer：

    @Autowired
    private RabbitTemplate rabbitTemplate;
    /**
     * 直接模式  最简单的使用
     * 一个消息只会有一个消费者，
     */
    @Test
    public void testSend(){
        // 多个消费者只有一个消费者接收到消息
        rabbitTemplate.convertAndSend("hello","直接模式测试");

        // 多个接收者  均匀的分布到消费者中
        /*for (int i = 0; i < 10; i++) {
            rabbitTemplate.convertAndSend("hello","直接模式测试 ：" + i);
        }*/
    }

3、consumer：

@Component
@RabbitListener(queues = "hello")
public class DirectCcustomer01 {
    @RabbitHandler
    public void showMessage(String message){
        System.out.println("DirectCcustomer01 >>>hello>>>接收到消息："+message);
    }
}
@Component
@RabbitListener(queues = "hello")
public class DirectCcustomer02 {
    @RabbitHandler
    public void showMessage(String message){
        System.out.println("DirectCcustomer02 >>>hello>>>接收到消息："+message);
    }
}

4、测试：

  • 发送一次：多个消费者只有一个消费者可以接收。

  • 发送多次：多个消费者均匀消费。

分列模式(Fanout):

1、队列配置：此处定义了三个队列测试，生产中根据实际需求定义。

@Configuration
public class FanoutConfig {

    /*********************** 定义队列 start ************************/
    @Bean
    public Queue fanoutA() {
        return new Queue("fanout.a");
    }

    @Bean
    public Queue fanoutB() {
        return new Queue("fanout.b");
    }

    @Bean
    public Queue fanoutC() {
        return new Queue("fanout.c");
    }
    /*********************** 定义队列 end ************************/

    /**
     * 分列式 交换器
     * 名称：fanoutExchange
     */
    @Bean
    FanoutExchange fanoutExchange() {
        return new FanoutExchange("fanoutExchange");
    }

    /****************** 队列绑定交换机 start ********************/

    // fanoutA 与 fanoutExchange 绑定
    @Bean
    public Binding bindingExchangeWithA() {
        return BindingBuilder.bind(fanoutA()).to(fanoutExchange());
    }

    // fanoutB 与 fanoutExchange 绑定
    @Bean
    public Binding bindingExchangeWithB() {
        return BindingBuilder.bind(fanoutB()).to(fanoutExchange());
    }

    // fanoutC 与f anoutExchange 绑定
    @Bean
    public Binding bindingExchangeWithC() {
        return BindingBuilder.bind(fanoutC()).to(fanoutExchange());
    }

    /****************** 队列绑定交换机 end ********************/
}

2、Producer：

   /**
     * 分列模式 -- 将消息一次发给多个队列
     * 不需要 routingKey 规则匹配  直接模式的加强版
     */
    @Test
    public void testSendFanout(){
        rabbitTemplate.convertAndSend("fanoutExchange","", "分列模式发送的消息");
    }

3、consumer：对应三个消费者

​@Component
@RabbitListener(queues = "fanout.a")
public class FanoutConsumerA {
    @RabbitHandler
    public void showMessage(String message){
        System.out.println(">>>FanoutConsumerA >>>fanout.a>>>接收到消息："+message);
    }
}
@Component
@RabbitListener(queues = "fanout.b")
public class FanoutConsumerB {
    @RabbitHandler
    public void showMessage(String message){
        System.out.println(">>>FanoutConsumerB >>>fanout.b>>>接收到消息："+message);
    }
}
@Component
@RabbitListener(queues = "fanout.c")
public class FanoutConsumerC {
    @RabbitHandler
    public void showMessage(String message){
        System.out.println(">>>FanoutConsumerC >>>fanout.c>>>接收到消息："+message);
    }
}

4、测试：

发送一次消息，FanoutConsumerA 、B、C都可以接收到消息。

订阅模式(Topic)：

1、队列配置：

/**
 * @Auther: xf
 * @Date: 2019/1/3 18:46
 * @Description: 主题模式
 *
 * 任何发送到Topic Exchange的消息都会被转发到所有关心RouteKey中指定话题的Queue上
 * RouteKey：匹配规则，使每个消息队列只关心自己匹配的消息
 */
@Configuration
public class TopicConfig {

    /*********************** 定义队列 start ************************/
    @Bean
    public Queue topiocA() {
        return new Queue("topic.a");
    }

    @Bean
    public Queue topicB() {
        return new Queue("topic.b");
    }

    @Bean
    public Queue topicC() {
        return new Queue("topic.c");
    }
    /*********************** 定义队列 end ************************/


    /**
     * 主题模式 交换器
     * 名称：topicExchange
     */
    @Bean
    TopicExchange topicExchange() {
        return new TopicExchange("topicExchange");
    }

    /****************** 队列绑定交换机 start ********************/

    /**
     * topicA 与 topicExchange 绑定
     * routingKey : topic.coolron
     * 只会接收包含topic.msg的消息
     */
    @Bean
    public Binding bindingTopicExchangeWithA() {
        return BindingBuilder.bind(topiocA()).to(topicExchange()).with("topic.coolron");
    }

    /**
     * topicB 与 topicExchange 绑定
     * routingKey : topic.#
     * 只会接收 topic 开头的信息 topic、topic.AA、topic.AA.BB、topic.AA.BB.CC
     * # 匹配0个、一个或多个词
     */
    @Bean
    public Binding bindingTopicExchangeWithB() {
        return BindingBuilder.bind(topicB()).to(topicExchange()).with("topic.#");
    }

    /**
     * topicC 与 topicExchange 绑定
     * routingKey : topic.*
     * 只能接收类似 topic.AA、topic.BB、topic.CC 的消息
     * * 匹配一个词
     */
    @Bean
    public Binding bindingTopicExchangeWithC() {
        return BindingBuilder.bind(topicC()).to(topicExchange()).with("topic.*");
    }
    /****************** 队列绑定交换机 end ********************/
}

注意："#"代表0个、一个或多个词、"*"代表一个词，"."分隔。

2、Producer：

    /**
     * 主题模式
     */
    @Test
    public void testSendTopic1(){
        // 根据TopicConfig 中 RoutingKey 的配置 ，队列 topic.a、b、c 都可以匹配到
        rabbitTemplate.convertAndSend("topicExchange","topic.coolron","主题模式");
    }

    @Test
    public void testSendTopic2(){
        // 根据TopicConfig 中 RoutingKey 的配置 ，队列 topic.b 可以匹配到 topic.#
        rabbitTemplate.convertAndSend("topicExchange","topic.cool.ron","主题模式");
    }

    @Test
    public void testSendTopic3(){
        // 根据TopicConfig 中 RoutingKey 的配置 ，队列 topic.b、c 可以匹配到 topic.# topic.*
        rabbitTemplate.convertAndSend("topicExchange","topic.ron","主题模式");
    }

    @Test
    public void testSendTopic4(){
        // 根据TopicConfig 中 RoutingKey 的配置 ，队列 topic.b、c 可以匹配到 topic.# topic.*，“” 代表一个词
        rabbitTemplate.convertAndSend("topicExchange","topic.","主题模式");
    }

    @Test
    public void testSendTopic5(){
        // 根据TopicConfig 中 RoutingKey 的配置 ，队列 topic.b 可以匹配到 topic.# 
        rabbitTemplate.convertAndSend("topicExchange","topic","主题模式");
    }

3、consumer：

/**
 * @Auther: xf
 * @Date: 2019/1/3 22:46
 * @Description: 主题模式 消费者 A
 */
​@Component
@RabbitListener(queues = "topic.a")
public class TopicCustomerA {
    @RabbitHandler
    public void showMessage(String message){
        System.out.println("TopicCustomerA>>>topic.a>>>接收到消息："+message);
    }
}
@Component
@RabbitListener(queues = "topic.b")
public class TopicCustomerB {
    @RabbitHandler
    public void showMessage(String message){
        System.out.println("TopicCustomerB>>>topic.b>>>接收到消息："+message);
    }
}
@Component
@RabbitListener(queues = "topic.c")
public class TopicCustomerC {
    @RabbitHandler
    public void showMessage(String message){
        System.out.println("TopicCustomerC>>>topic.c>>>接收到消息：" + message);
    }
}

4、测试结果：

  • testSendTopic1（topic.coolron）：三个consumer都可以订阅到消息。规则：topic.coolron、topic.#、topic.*。

  • testSendTopic2（topic.cool.ron）：只有TopicCustomerB订阅到消息。规则：topic.#。

  • testSendTopic3（topic.ron）：TopicCustomerB、C订阅到消息。规则：topic.#、topic.*。

  • testSendTopic4（topic.）：队列 B、C可以订阅到消息，“” 代表一个词 。规则topic.#  topic.*。

  • testSendTopic5（topic）：队列 B 可以订阅到消息。规则：topic.#。

总结：

1、一条消息，直接模式只能一个消费者订阅、分列模式可多个消费者订阅、topic模式根据路由规则匹配订阅。
2、Exchange位于producer和queue之间。
3、Exchange根据匹配规则将消息路由到对应的Queue中存储。
4、routingKey，"#"代表0个、一个或多个、"*"代表一个词。上文中"topic."会匹配到B、C，因为“”代表一个词。“topic”只会匹配到B。

代码地址：

springboot-account2: 公众号 - Gitee.com

个人微信公众号，谢谢支持！

cp026la
关注
专栏目录
30. SpringBoot2.x最佳实践之RabbitMQ集成
极客星云-CSDN博客
04-29 303
SpringBoot2.x最佳实践之RabbitMQ集成
【SpringBoot】43、SpringBoot中整合RabbitMQ实现延时队列（延时插件篇）
热门推荐
Asurplus
02-21 21万+
一、介绍 1、什么是延时队列？ 延时队列即就是放置在该队列里面的消息是不需要立即消费的，而是等待一段时间之后取出消费 2、适用场景 （1）商城订单超时未支付，取消订单 （2）使用权限到期前十分钟提醒用户 （3）收益项目，投入后一段时间后产生收益 二、实现方式 从以上场景中，我们可以看出，延时队列的主要功能就是在指定的时间之后做指定的事情，那么，我们思考有哪些工具我们可以使用？ 1、Redis 监听过期 Key 可以参考我的博客【SpringBoot】三十五、SpringBoot整合Redis监听Ke
SpringBoot+RabbitMQ
一名系统架构师的征途
08-08 3692
RabbitMQ 即一个消息队列，主要是用来实现应用程序的异步和解耦，同时也能起到消息缓冲，消息分发的作用。消息中间件在互联网公司的使用中越来越多，刚才还看到新闻阿里将RocketMQ捐献给了apache，当然了今天的主角还是讲RabbitMQ。消息中间件最主要的作用是解耦，中间件最标准的用法是生产者生产消息传送到队列，消费者从队列中拿取消息并处理，生产者不用关心是谁来消费，消费者不用关心谁在生产...
SpringBoot教程（十五） | SpringBoot集成RabbitMq（基础版）
最新发布
qq_20236937的博客
07-24 1090
SpringBoot集成RabbitMq（基础版）
springboot2整合rabbitmq
qq_41842356的博客
09-25 387
方法得
springBoot2.x快速集成RabbitMQ
qq_15458763的博客
11-24 2021
文章目录一、公共部分-MQ配置集成二、生产者1、生产者-公共父类2、自定义队列1的子类三、消费者1、监听队列 主要分为三大部分：MQ配置集成，生产者，消费者。 一、公共部分-MQ配置集成 申明队列、绑定队列的操作，无论是在消费者端和生产者端写都可以的，只要写了这部分操作的代码所在的服务先启动，就会去MQ服务端创建了。 建议不知道哪个服务先启动，就两个服务都写也没有问题，幂等的，不会得复创建。 package com.epay.fsc.ucms.rbhs.provider.configuration; im
【三】SpringBoot2集成RabbitMQ
laichj的博客
04-02 653
官方文档参考：https://docs.spring.io/spring-boot/docs/current/reference/html/spring-boot-features.html#boot-features-messaging 1 添加 依赖 pom.xml <dependency> <groupId>org.springframework....
springboot-integrate-rabbitmq:springboot-集成-rabbitmq
03-16
在"springboot-integrate-rabbitmq-main"这个项目中，你可能会找到以下文件和目录结构： - `src/main/java`: 包含主要的Java源代码，如配置类、消息生产者和服务、消息消费者等。 - `src/main/resources`: 存放配置...
SpringBoot-Mysql-Redis-RabbitMQ-Shiro:SpringBoot项目，单数据源版 集成 Mysql + Redis + RabbitMQ + Shiro
05-14
SpringBoot-Mysql-Redis-RabbitMQ-Shiro 主要的架构：Spring Boot Mybatis Druid Pagehelper Redis Shiro RabbitMQ Freemarker poi 等等。 运行环境： maven jdk1.8 访问路径： 初始账号：admin 密码: 123456 注释...
springboot集成各种技能 activiti security-cas-sso rabbitmq
10-13
springboot-activiti springboot-actuator springboot-elasticsearch springboot-flowable springboot-rabbitmq springboot-security-oauth2-sso springboot-shiro ... 各种集成 纯手写 java 开发者可以看一下
springboot-rabbitmq-retry-queues:该存储库对该博客文章https中引入的RabbitMQ的非阻塞重试队列解决方案进行了概括
03-20
本存储库`springboot-rabbitmq-retry-queues`主要关注的是如何在Spring Boot应用中实现RabbitMQ的非阻塞重试队列解决方案，这是一个针对处理消息处理失败时的策略，可以避免因单个任务失败而导致整个系统的阻塞。...
Spring rabbitmq集成
11-24
Spring rabbitmq开发技术，rabbitmq主要配置由fectory- connect ，template声明，exchange交换器，queue队列,，，监听
SpringBoot2整合RabbitMQ入门
冷兮Coding
05-09 1107
一、消息队列概述 1. 消息服务中两个重要概念： 消息代理（message broker）和 目的地（Destination） 当消息发送者发出消息以后，将由消息代理接管，消息代理保证消息传递到指定目的地。 2. 消息队列主要有两种形式的目的地 1. 队列（queue）: 点对点消息通信（point-to-point） 2. 主题（topic）: 发布（publish）/ 订阅（subscribe）消息通信 点对点式 消息发送者发送消息，消息代理将其放入一个队列中，消息接收者从队列中获取消息内容，消息读
Springboot2.x整合RabbitMQ
竹林幽深
02-10 301
1、RabbitMQ介绍 可参照RabbitMQ笔记 2、接入配置 pom依赖 <!--amqp依赖--> <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-amqp</artif...
SpringBoot2.x 集成 RabbitMQ
RtxTitanV的博客
05-30 1221
本文主要对SpringBoot2.x集成RabbitMQ进行简单总结，其中SpringBoot使用的2.4.5版本。
SpringBoot 2.0 | SpringBoot 集成 RabbitMQ
个人博客
05-01 689
一、RabbitMQ 使用场景 RabbitMQ 是一个消息中间件，最主要的作用：信息的缓冲区，应用场景如下: 1、系统集成与分布式系统的设计 各种子系统通过消息来对接，这种解决方案也逐步发展成一种架构风格，即“通过消息传递的架构”。 例：现在医院有两个科“看病科”和“住院科”在之前他们之间是没有任何关系的，如果你在“看病课”看完病后注册的信息和资料，到住院科后还得重新注册一遍？那现在要改革，你看...
rabbitmq集成
qq_33228316的博客
03-26 69
1.maven配置&lt;dependency&gt; &lt;groupId&gt;com.rabbitmq&lt;/groupId&gt; &lt;artifactId&gt;amqp-client&lt;/artifactId&gt; &lt;version&gt;3.5.1&lt;/version&gt; &lt;/dependency&
2 Spring boot整合rabbitMQ
qq_44798321的博客
08-05 177
一、大概步骤 spring boot项目中只需要引入对应的amqp启动器依赖即可，方便的使用RabbitTemplate发送消息，使用注解接收消息。 一般在开发过程中： 生产者工程： 1. application.yml文件配置RabbitMQ相关信息； 2. 在生产者工程中编写配置类，用于创建交换机和队列，并进行绑定 3. 注入RabbitTemplate对象，通过RabbitTemplate对象发送消息到交换机 消费者工程： 1. application.yml文件配置RabbitMQ相关信息 2.
RabbitMQ 深度理解 SpringBoot2与RabbitMQ整合
m0_62866284的博客
09-21 290
RabbitMQ 深度理解 SpringBoot2与RabbitMQ整合
springboot rabbitmq使用 springboot rabbitmq使用 springboot集成rabbitmq一对多
07-09
Spring Boot集成RabbitMQ可以通过以下步骤完成： 1. 添加Maven依赖：在pom.xml文件中添加RabbitMQ的Spring Boot Starter依赖。 ```xml <dependency> <groupId>org.springframework.boot</groupId> <artifactId>...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值