SpringBoot整合rabbitmq的使用

最新推荐文章于 2024-07-29 14:22:26 发布
最新推荐文章于 2024-07-29 14:22:26 发布
阅读量339 收藏 2
点赞数
分类专栏： Spring Could java Spring Boot 文章标签： rabbitmq java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_45324923/article/details/117927992
版权

建议看官网的Spring AMQP，需要快速入门可以看这篇文章
rabbitmq官网队列
https://www.rabbitmq.com/getstarted.html

配置就不写了，直接上SpringBoot使用rabbitmq，有人看在补配置

文章目录

rabbitmq常用的6种工作模式

1.简单模式
2.工作模式
3.发布/订阅模式（广播模式）
4.路由模式
5.主题模式
6.RPC模式
7.出版商确认模式（此篇文章没有该内容）

rabbitmq使用的常量

队列，交换机，路由都用一个类定义

package com.rabbit.demo.constant;

/**
 * @className: QueueConstant
 * @description: 队列常量
 * @createDate: 2021年06月15日 10:38:53
 * @author: ns
 */
public class QueueConstant {
    //简单队列
    public final static String SIMPLE_QUEUE = "simple_queue";
    //工作队列
    public final static String WORK_QUEUE = "work_queue";
	//发布交换机
    public final static String RELEASE_FANOUT_EXCHANGE = "release_fanout_exchange";
    //路由
    public final static String DIRECT = "direct";
}

队列控制层

因为是springboot集成rabbitmq就直接使用RabbitTemplate

package com.rabbit.demo.controller;

import com.rabbit.demo.constant.QueueConstant;
import org.springframework.amqp.rabbit.core.RabbitTemplate;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;

/**
 * @className: QueueController 
 * @description:
 * @createDate: 2021年05月28日 16:14:29
 * @author: ns
 */
@RestController
public class QueueController {

    @Autowired
    private RabbitTemplate rabbitTemplate;

    //简单队列
    @GetMapping("/simple/queue")
    public void simpleQueue(){
        System.out.println("简单队列发送");
        rabbitTemplate.convertAndSend(QueueConstant.WORK_QUEUE,"简单队列消费完成");
    }

	//工作队列
    @GetMapping("/work/queue")
    public void workQueue() {
        System.out.println("老板开始派发任务");
        for (int i = 0; i < 10; i++) {
            rabbitTemplate.convertAndSend(QueueConstant.WORK_QUEUE, "搬第" + i + "块砖");
        }
    }
	//发布订阅模式
    @GetMapping("/publish/subscribe/queue")
    public void publishSubscribe() {
        System.out.println("老板开始派发任务");
        for (int i = 0; i < 5; i++) {
            rabbitTemplate.convertAndSend(QueueConstant.RELEASE_FANOUT_EXCHANGE, "", "开始工作");
        }
    }
    //路由模式
    @GetMapping("/queue/route")
    public void routeMode() {
        System.out.println("程序开始运行");
        String[] strings = new String[]{"error", "info", "warring"};
        for (String string : strings) {
            rabbitTemplate.convertAndSend(QueueConstant.DIRECT, string, string);
        }
    }
     //主题模式
    @GetMapping("/queue/topic")
    public void topicQueue() {
        System.out.println("主题模式开始运行");
        String[] strings = {"quick.orange.rabbit", "lazy.orange.elephant", "quick.orange.fox",
                "lazy.brown.fox", "lazy.pink.rabbit", "quick.brown.fox"};
        for (String string : strings) {
            rabbitTemplate.convertAndSend(QueueConstant.TOPIC_EXCHANGE, string, string);
        }
    }

}

简单模式

作用：一对一发送接收，一个生产者，一个消费者
常用于异步处理业务
例如用户注册之后发送邮件，用户注册和邮件发送不用同时执行，可以使用rabbitmq将其分开异步执行，增加用户体验感

在这里插入图片描述

package com.rabbit.demo.consumer;

import com.rabbit.demo.constant.QueueConstant;
import org.springframework.amqp.rabbit.annotation.Queue;
import org.springframework.amqp.rabbit.annotation.RabbitListener;
import org.springframework.stereotype.Component;

/**
 * @className: SimpleQueueConsumer
 * @description:
 * @createDate: 2021年05月28日 16:05:22
 * @author: ns
 */
@Component
@RabbitListener(queuesToDeclare = @Queue(QueueConstant.SIMPLE_QUEUE))
public class SimpleQueueConsumer {
    //简单队列
    @RabbitHandler
    public void workQueues(String s){
        System.out.println("简单队列开始消费");
        System.out.println(s);
    }
}

工作模式

作用：多个队列处理任务，增加任务完成的效率
场景：当有一个任务，需要被自动尽快处理时，增加消费者数量处理
PS：一个消息只能被处理一次，即使有多个队列处理这个任务
在这里插入图片描述

当队列大于1个的时候，监听方法上需要写@RabbitHandler，不然发送的消息找不到处理的

搬砖工一号

package com.rabbit.demo.consumer;

import com.rabbit.demo.constant.QueueConstant;
import org.springframework.amqp.rabbit.annotation.Queue;
import org.springframework.amqp.rabbit.annotation.RabbitHandler;
import org.springframework.amqp.rabbit.annotation.RabbitListener;
import org.springframework.stereotype.Component;

/**
 * @className: WorkQueueConsumer
 * @description: 工作队列消费
 * @createDate: 2021年06月15日 16:47:18
 * @author: ns
 */
@Component
@RabbitListener(queuesToDeclare = @Queue(QueueConstant.WORK_QUEUE))
public class WorkQueueConsumer {

    @RabbitHandler
    public void String(String s) {
        System.out.println("搬砖工一号开始" + s);
    }
}

搬砖工二号

package com.rabbit.demo.consumer;

import com.rabbit.demo.constant.QueueConstant;
import org.springframework.amqp.rabbit.annotation.Queue;
import org.springframework.amqp.rabbit.annotation.RabbitHandler;
import org.springframework.amqp.rabbit.annotation.RabbitListener;
import org.springframework.stereotype.Component;
/**
 * @className: WorkQueueConsumer
 * @description: 工作队列消费
 * @createDate: 2021年06月15日 16:47:18
 * @author: ns
 */
@Component
@RabbitListener(queuesToDeclare = @Queue(QueueConstant.WORK_QUEUE))
class WorkQueueConsumer1 {

    @RabbitHandler
    public void String(String s) {
        System.out.println("搬砖工二号开始" + s);
    }
}

运行效果
在这里插入图片描述

发布/订阅模式（广播模式）

作用：将一条消息发送给交换机，然后交换机再发送给与其绑定的队列
应用场景：当新员工入职时，调用发邮件的队列和加入流程的队列
在这里插入图片描述
配置文件
AnonymousQueue匿名队列在断开连接后会自动删除
这里也可以为设置固定的队列名以供使用

package com.rabbit.demo.config;

import com.rabbit.demo.constant.QueueConstant;
import org.springframework.amqp.core.*;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

/**
 * @className: RabbitConfig
 * @description:
 * @createDate: 2021年06月15日 18:42:48
 * @author: ns
 */
@Configuration
public class RabbitConfig {

    /**
     * 创建匿名队列1
     */
    @Bean
    public Queue queue1() {
        return new AnonymousQueue();
    }

    /**
     * 创建匿名队列2
     */
    @Bean
    public Queue queue2() {
        return new AnonymousQueue();
    }

    /**
     * 创建广播交换机
     */
    @Bean
    public FanoutExchange fanoutExchange() {
        return new FanoutExchange(QueueConstant.RELEASE_FANOUT_EXCHANGE);
    }

    /**
     * 交换机与队列1绑定
     */
    @Bean
    public Binding bindingQueue1(Queue queue1, FanoutExchange fanoutExchange) {
        return BindingBuilder.bind(queue1).to(fanoutExchange);
    }

    /**
     * 交换机与队列2绑定
     */
    @Bean
    public Binding bindingQueue2(Queue queue2, FanoutExchange fanoutExchange) {
        return BindingBuilder.bind(queue2).to(fanoutExchange);
    }

}


package com.rabbit.demo.consumer;

import com.rabbit.demo.constant.QueueConstant;
import org.springframework.amqp.rabbit.annotation.Queue;
import org.springframework.amqp.rabbit.annotation.RabbitHandler;
import org.springframework.amqp.rabbit.annotation.RabbitListener;
import org.springframework.stereotype.Component;

/**
 * @className: PublishSubscribeConsumer
 * @description: 发布订阅
 * @createDate: 2021年06月16日 10:54:17
 * @author: ns
 */
@Component
public class PublishSubscribeConsumer {

    @RabbitHandler
    @RabbitListener(queues = "#{queue1.name}")
    public void consumer(String s) {
        System.out.println("前端" + s);
    }

    @RabbitHandler
    @RabbitListener(queues = "#{queue2.name}")
    public void consume1r(String s) {
        System.out.println("后端" + s);
    }
}

运行结果
在这里插入图片描述

路由模式

在这里插入图片描述
作用：路由模式用于区分执行，当达成某个条件时，可由对应消费者进行消费
场景：不同的日志进行不同的处理

路由模式配置文件

package com.rabbit.demo.config;

import com.rabbit.demo.constant.QueueConstant;
import org.springframework.amqp.core.*;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

/**
 * @className: RabbitDirectConfig
 * @description: 路由模式配置
 * @createDate: 2021年06月21日 16:17:49
 * @author: ns
 */
@Configuration
public class RabbitDirectConfig {

    /**
     * 创建路由交换机
     */
    @Bean
    public DirectExchange direct(){
        return new DirectExchange(QueueConstant.DIRECT);
    }

    /**
     * 创建匿名队列1
     */
    @Bean
    public Queue autoDeleteQueue1(){
        return new AnonymousQueue();
    }

    /**
     * 创建匿名队列2
     */
    @Bean
    public Queue autoDeleteQueue2(){
        return new AnonymousQueue();
    }

    /**
     * 绑定错误级别日志
     */
    @Bean
    public Binding binding1(DirectExchange direct,Queue autoDeleteQueue1){
        return BindingBuilder.bind(autoDeleteQueue1)
                .to(direct)
                .with("error");
    }

    /**
     * 绑定警告级别日志
     */
    @Bean
    public Binding binding2(DirectExchange direct,Queue autoDeleteQueue2){
        return BindingBuilder.bind(autoDeleteQueue2)
                .to(direct)
                .with("warring");
    }

    /**
     * 绑定显示级别日志
     */
    @Bean
    public Binding binding3(DirectExchange direct,Queue autoDeleteQueue2){
        return BindingBuilder.bind(autoDeleteQueue2)
                .to(direct)
                .with("info");
    }
	/**
     * 绑定错误级别日志
     */
    @Bean
    public Binding binding4(DirectExchange direct,Queue autoDeleteQueue2){
        return BindingBuilder.bind(autoDeleteQueue2)
                .to(direct)
                .with("error");
    }
}

路由模式消费者

package com.rabbit.demo.consumer;

import org.springframework.amqp.rabbit.annotation.RabbitListener;
import org.springframework.stereotype.Component;

/**
 * @className: DirectModeConsumer
 * @description: 路由模式消费者
 * @createDate: 2021年06月21日 16:25:50
 * @author: ns
 */
@Component
public class DirectModeConsumer {

    @RabbitListener(queues = "#{autoDeleteQueue1.name}")
    public void receive1(String s) {
        System.out.println(s + "开始处理报警");
    }

    @RabbitListener(queues = "#{autoDeleteQueue2.name}")
    public void receive2(String s) {
        System.out.println(s + "开始处理闲置不动");
    }

}
运行结果

在这里插入图片描述

主题模式

作用：主题模式相当于在路由模式的基础上增加了一个通配符的功能
当队列与“ # ”（散列）绑定键绑定时——它将接收所有消息，而不管路由键——就像在扇出交换中一样。
当绑定中不使用特殊字符“ * ”（星号）和“ # ”（散列）时，主题交换的行为就像直接交换一样。
详细请查看官网介绍
https://www.rabbitmq.com/tutorials/tutorial-five-spring-amqp.html
场景：需要通配路径时使用
在这里插入图片描述
主题模式配置文件

package com.rabbit.demo.config;

import com.rabbit.demo.constant.QueueConstant;
import org.springframework.amqp.core.*;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

/**
 * @className: RabbitTopicConfig
 * @description: 主题配置
 * @createDate: 2021年06月23日 15:35:21
 * @author: ns
 */
@Configuration
public class RabbitTopicConfig {

    /**
     * 主题交换机
     */
    @Bean
    public TopicExchange topicExchange() {
        return new TopicExchange(QueueConstant.TOPIC_EXCHANGE);
    }

    /**
     * 匿名队列1
     */
    @Bean
    public Queue topicQueue1() {
        return new AnonymousQueue();
    }

    /**
     * 匿名队列2
     */
    @Bean
    public Queue topicQueue2() {
        return new AnonymousQueue();
    }

    /** 
     * 绑定主题交换机与队列和路由关键字
     */
    @Bean
    public Binding binding1(TopicExchange topicExchange, Queue topicQueue1) {
        return BindingBuilder.bind(topicQueue1)
                .to(topicExchange)
                .with("*.orange.*");
    }

    /**
     * 绑定主题交换机与队列和路由关键字
     */
    @Bean
    public Binding binding2(TopicExchange topicExchange, Queue topicQueue2) {
        return BindingBuilder.bind(topicQueue2)
                .to(topicExchange)
                .with("*.*.rabbit");
    }

    /**
     * 绑定主题交换机与队列和路由关键字
     */
    @Bean
    public Binding binding3(TopicExchange topicExchange, Queue topicQueue2) {
        return BindingBuilder.bind(topicQueue2)
                .to(topicExchange)
                .with("lazy.#");
    }
}

主题模式消费者

package com.rabbit.demo.consumer;

import org.springframework.amqp.rabbit.annotation.RabbitListener;
import org.springframework.stereotype.Component;

/**
 * @className: TopicModeConsumer
 * @description: 主题模式消费者
 * @createDate: 2021年06月23日 15:59:39
 * @author: ns
 */
@Component
public class TopicModeConsumer {

    @RabbitListener(queues = "#{topicQueue1.name}")
    public void receive(String s) {
        System.out.println(s + "，属于：*.orange.*");
    }

    @RabbitListener(queues = "#{topicQueue2.name}")
    public void receive1(String s) {
        System.out.println(s + "，属于：lazy.#或*.*.rabbit");
    }
}

运行结果
在这里插入图片描述

RPC模式

作用：内部服务调用
优点：可以实现分布式事务
建议：使用Spring Cloud框架可以使用Openg Fegin进行内部的RPC调用
这里就不细讲了
在这里插入图片描述

此间彷徨
关注
  • 0
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
Springboot 整合RabbitMq ，用心看完这一篇就够了
默默不代表沉默
09-04 49万+
该篇文章内容较多，包括有rabbitMq相关的一些简单理论介绍，provider消息推送实例，consumer消息消费实例，Direct、Topic、Fanout的使用，消息回调、手动确认等。 （但是关于rabbitMq的安装，就不介绍了） 在安装完rabbitMq后，输入http://ip:15672/，是可以看到一个简单后台管理界面的。 在这个界面里面我们可以做些什么？ 可以手动创建............
Springboot整合RabbitMQ使用
WannaRunning的博客
03-16 101
引入AMQP依赖 <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-amqp</artifactId> </dependency> @EnableRabbit注解启动Rabbit相关配置 @Configuration @SpringBootApplication @EnableRabb
RabbitMQ fanout广播消息使用匿名队列
05-17 2079
场景 我们希望发送的消息被所有绑定到这个交换机的所有队列消费到，那么我们通常会用到fanout类型的交换机， 但我们又不想固定队列名称，那么就需要随机的队列名称，RabbitMQ中的AnonymousQueue就是解决这个问题的，通常，当您需要一个唯一命名的排他性自动删除队列时，建议您使用AnonymousQueue而不是broker定义的队列名称（使用“”作为队列名称会导致代理生成队列名称），默认情况下，队列名称以spring.gen-为前缀，后跟UUID的base64表示形式，例如：spring.g
【RabbitMQ实战】Springboot 整合RabbitMQ组件，多种编码示例，带你实践 看完这一篇就够了
qq_39666711的博客
06-26 768
该篇文章内容较多，包括有RabbitMQ一些理论介绍，provider消息推送实例，consumer消息消费实例，Direct、Topic、Fanout多种交换机的使用，同时简单介绍对消息回调、手动确认等。例如：随着人工智能的不断发展，机器学习这门技术也越来越重要，很多人都开启了学习机器学习，本文就介绍了机器学习的基础内容。这里面的每一种使用都包含实际编码示例，供大家理解，共同进步，如有不足。还请指教。
SpringBoot整合rabbitmq使用案例
weixin_43811057的博客
03-23 8419
rabbitmq可以将消息放入到head中或者放入body中然后发送。 1 、环境准备 1.1添加依赖 <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-amqp</artifactId> </dependency>
Springboot整合RabbitMQ并使用
秃头的博客
03-06 3639
创建交换机(Exchange)、队列(Queue)和建立绑定关系(Binding) `direct`：会将消息发送给路由键必须完全匹配的队列中。 `@RabbitListener`：可以标注在类和方法上 (监听哪些队列) `@RabbitHandler`：只能标注在方法上 (重载区别不同的消息) `fanout`：会将消息发送给所有绑定的队列中，不管路由键是否匹配。 `topic`：主体模式其实就是在路由模式的基础上，支持了对key的通配符匹配
springboot整合rabbitmq使用示例
weixin_41307800的博客
09-13 1010
一 消息队列四种模式 1 work模式 也称为工作模式，多劳多得，有能力的消费者能够消费更多的消息。 不需要交换机的支持，消息直接发送到队列即可。 1.1 示例 2 fanout模式 也称为广播模式，表如其意，消息一次发送可以经过多个队列被多个消费者共同消费。 需要交换机(图中的X)与队列进行绑定，消息发送到交换机，由交换机代理转发到与其绑定的消息队列。 2.1 示例 3 direct模式 带路由key的广播模式，需要交换机(图中的X)，队列以及路由key(图中的error、info等)进行绑
SpringBoot整合RabbitMQ实现消息延迟队列(含源码)
热门推荐
Venus's Blog
07-04 9万+
*** 商户订单号/*** 支付宝订单号//为true,则交换机处理消息到路由失败，则会返回给生产者 配置文件指定，则这里不需指定 rabbitTemplate . setMandatory(true);//开启强制消息投递（mandatory为设置为true），但消息未被路由至任何一个queue，则回退一条消息 rabbitTemplate . setReturnsCallback(returned -> {});
Springboot整合RabbitMq简单使用
XiaoXiao_Lin的博客
01-13 1073
@Autowired RabbitTemplate rabbitTemplate; @Autowired AmqpAdmin amqpAdmin; @Test void contextLoads() { rabbitTemplate.convertAndSend("amq.direct", "amq.direct", "消息内容"); } @Test void contextLoads1() { rabb.
SpringBoot整合rabbitMq使用方式
m0_64805182的博客
06-16 603
rabbitTemplate.convertAndSend(RabbitmqConfig.ITEM_TOPIC_EXCHANGE, "item.insert", "新增商品的消息~~");创建生产者：导入对应依赖后，使用rabbitTemplate，并调用convertAndSend来发送消息。编写配置类，使用@Bean注解在对应的方法上把方法的返回值（将队列，交换机等信息）交由spring管理。注解在消息处理方法上，指定监听的队列名称，并在方法参数中接收消息。// 处理接收到的消息。
SpringBoot整合RabbitMQ的快速使用教程
weixin_50348837的博客
05-28 1241
在分布式系统中，消息队列是一种重要的通信方式，它能够有效地将消息从一个应用程序传递到另一个应用程序。RabbitMQ是一款流行的开源消息队列系统，简单易用且功能强大。本文将介绍如何使用SpringBoot快速整合RabbitMQ，实现消息的发送和接收。。Fanout交换机会将接收到的所有消息广播到它知道的所有队列中。这种类型的交换机不考虑路由键，只是简单地将消息复制到所有绑定的队列中。适用于不需要选择性地发送消息给特定队列的情况，例如，广播系统通知或有多个服务需要消费同一份数据的场景。
SpringBoot整合RabbitMQ.zip
06-29
SpringBoot整合RabbitMQ的详细过程 **1.该篇博文首先讲述了交换机和队列之间的绑定关系** ①direct、②fanout、③topic **2.然后讲消息的回调** 四种情况下，确认触发哪个回调函数： ①消息推送到server，但是在...
springboot整合rabbitmq使用​
11-06
gitee仓库地址 https://gitee.com/ckl996/mq-demo 1.rabbitmq简单模式、工作模式、发布订阅模式 发布订阅模式： fanout广播模式 direct路由模式 topic主题订阅模式 资料内含docker部署mq文件及使用说明讲义
springboot整合rabbitmq使用死信队列
11-06
总的来说，Spring Boot整合RabbitMQ并使用死信队列是一种常见的消息处理策略，它能有效地处理异常消息，防止消息丢失，并为系统的健壮性提供保障。通过合理的配置和编程，我们可以构建出高效、可靠的分布式系统。
springBoot整合RabbitMQ案例
04-07
SpringBoot整合RabbitMQ是一个常见的后端开发任务，它涉及到分布式消息传递和Java应用程序的集成。RabbitMQ是一个开源的消息代理和队列服务器，而SpringBoot是基于Spring框架的简化版，提供了快速构建应用程序的方式...
Springboot整合RabbitMQ最简单demo
07-11
Springboot整合RabbitMQ最简单demo,适用于springcloud项目,作为消息总线适用,需要安装RabbitMQ,Mac linux可以使用命令行一键安装,在项目配置文件配置好端口即可(已默认配置),启动项目访问8080端口,参数见controller.
RabbitMQ+redis+Redisson分布式锁+seata实现订单服务
架构师小吴的博客
07-22 801
（相关解释直接在代码注释上了）
使用hutool工具判断字符串是否全部是字母(包括大小写)，java判断字符串是否全部是字母(包括大小写)
最新发布
qq_43700885的博客
07-29 279
1.导入hutool的maven依赖。2.复制一下代码执行。
golang 接口
m0_70982551的博客
07-24 1089
接口定义了一组方法，这些方法没有具体的实现。接口类型的变量可以存储任何实现了这些方法的类型的值。// 更多方法...在Go语言中，接口值是指存储了实现某个接口的具体类型值的变量。接口值由两部分组成：1.动态类型：这是接口值当前存储的实际类型。2.动态值：这是实际存储的值，该值必须实现了接口中定义的所有方法。
springboot 整合rabbitmq
09-07
- *1* [SpringBoot整合RabbitMQ](https://blog.csdn.net/K_kzj_K/article/details/106642250)[target="_blank" data-report-click={"spm":"1018.2226.3001.9630","extra":{"utm_source":"vip_chatgpt_common_search_...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值