学习使用springBoot整合RabbitMq实现5种模式列队

最新推荐文章于 2022-08-11 15:01:14 发布
最新推荐文章于 2022-08-11 15:01:14 发布
阅读量1.7k 收藏 2
点赞数 1
分类专栏： javaee框架 文章标签： rabbitmq spring boot java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_45826772/article/details/121351714
版权

使用SpringBoot整合RabbitMq实现5种模式列队:

目录

简单列队

广播列队

订阅列队

主题列队

Headers列队
学习使用rabbitmq（mac系统）在这里呦!!!

1.创建测试接口（测试只用这一个接口)

@RestController
@RequestMapping("/")
public class test{
  	@Autowired
    private MQSender mQSender;

    @GetMapping("/test/{msg}")
    @ResponseBody
    public String test(@PathVariable("msg") Object msg){
       	mQSender.send(msg);
        return String.valueOf(msg);
    }
}

2.编写配置文件:

spring:   
  rabbitmq:
      username: guestweb
      password: 123456
      port: 15672
      host: 127.0.0.1
      virtual-host: /
      listener:
        simple:
          #消费者最小数量
          concurrency: 10
          #消费者最大数量
          max-concurrency: 10
          #限制消费者每次只处理一条消息，处理完再继续下一条消息
          prefetch: 1
          #启动时是否默认启动容器，默认true
          auto-startup: true
          #被拒绝时重新进入队列
          default-requeue-rejected: true
      # 配置模版
      template:
        retry:
          #发布重试，默认false
          enabled: true
          #重试时间 默认1000ms
          initial-interval: 1000
          #重试最大次数，默认3次
          max-attempts: 3
          #重试最大间隔时间，默认10000ms
          max-interval: 10000
          #重试间隔的乘数。比如配2.0 第一次等10s，第二次等20s，第三次等40s
          multiplier: 1.0

3.简单列队:

3.1:编写Config
/**
 * 创建普通消息列队
 * @author haoruijie
 */
@Configuration
public class RabbitMqConfig {
  	//列队
    public static final String MAIL_QUEUE_NAME = "queue";
 
    @Bean
    public Queue queue(){
        //配置队列名  并设置消息持久化
        return new Queue(MAIL_QUEUE_NAME,true);
    }
}
3.2:编写简单列队生产者和消费者：
@Service
@Slf4j
public class MQSender {
    @Autowired
    private RabbitTemplate rabbitTemplate;
		
  	//生产者
    public void send(Object msg){
        log.info("==========>>>>>>>>>>发送消息:"+msg);
        rabbitTemplate.convertAndSend("queue",msg);
    }
		//消费者
    @RabbitListener(queues = "queue")
    public void receiver(Object msg){
        log.info("============>>>>>>>>>接收消息:"+msg);
    }
}

4.广播列队
（消息会分发到绑定此交换机的queue上）

4.1:编写Config
@Configuration
public class RabbitmqConfig {
    private static final String QUEUE01= "queue01";
    private static final String QUEUE02= "queue02";
    private static final String EXCHANGE_NAME = "fanout_exchange"//交换机
  	@Bean
    public Queue queue1(){
      return new Queue(QUEUE01);
    }
  
  	@Bean
    public Queue queue2(){
      return new Queue(QUEUE02);
    }
  
  	@Bean
  	public FanoutExchange fanoutExchange(){
        return new FanoutExchange(EXCHANGE_NAME);
    }
  
  	@Bean
  	public Binding binding01(){
      return BindingBuilder.bind(queue1()).to(fanoutExchange());
    }
  
  	@Bean
  	public Binding binding02(){
      return BindingBuilder.bind(queue2()).to(fanoutExchange());
    }
}
4.2:编写工作列队生产者和消费者
@Service
@Slf4j
public class MQSender {
    @Autowired
    private RabbitTemplate rabbitTemplate;
		
  	//生产者
    public void send(Object msg){
        log.info("==========>>>>>>>>>>发送消息:"+msg);
      	//没有绑定路由键 需要填写路由键为空
        rabbitTemplate.convertAndSend("fanout_exchange","",msg);
    }
		//消费者01
    @RabbitListener(queues = "queue01")
    public void receiver01(Object msg){
        log.info("============>>>>>>>>>queue01接收消息:"+msg);
    }
  	//消费者02
    @RabbitListener(queues = "queue02")
    public void receiver02(Object msg){
        log.info("============>>>>>>>>>queue02接收消息:"+msg);
    }
}

5.创建订阅列队

5.1:编写Config
@Configuration
public class RabbitmqConfig {
    private static final String QUEUE01= "queue01";
    private static final String QUEUE02= "queue02";
 	private static final String EXCHANGE_NAME = "direct_exchange"//交换机
    //路由键
    private static final String ROUTINGKEY01 = "queue.red";
    private static final String ROUTINGKEY02 = "queue.pink";
  
    @Bean
    public Queue queue01(){
        return new Queue(QUEUE01);
    }
    @Bean
    public Queue queue02(){
        return new Queue(QUEUE02);
    }
    @Bean
    public DirectExchange directExchange(){
        return new DirectExchange(EXCHANGE_NAME);
    }

    @Bean
    public Binding binding1(){
      	//将列队01绑定到交换机上为给他设置路由键
        return BindingBuilder.bind(queue01()).to(directExchange()).with(ROUTINGKEY01);
    }
    @Bean
    public Binding binding2(){
        return BindingBuilder.bind(queue02()).to(directExchange()).with(ROUTINGKEY02);
    }
}
5.2:编写订阅列队生产者和消费者
@Service
@Slf4j
public class MQSender {
    @Autowired
    private RabbitTemplate rabbitTemplate;
		
  	//生产者
    public void send(Object msg){
        log.info("==========>>>>>>>>>>发送消息:"+msg);
        rabbitTemplate.convertAndSend("direct_exchange","queue.red",msg);
      	rabbitTemplate.convertAndSend("direct_exchange","queue.pink",msg);
    }
		//消费者01
    @RabbitListener(queues = "queue01")
    public void receiver01(Object msg){
        log.info("============>>>>>>>>>queue01接收消息:"+msg+"路由键名为：queue.red");
    }
  	//消费者02
    @RabbitListener(queues = "queue02")
    public void receiver02(Object msg){
        log.info("============>>>>>>>>>queue02接收消息:"+msg+"路由键名为：queue.pink");
    }
}

6.主题列队(使用最多的模式)

（与订阅列队相似，但是对路由键加模糊查找）通配符:*匹配.之前之后的一个字符、#匹配.之前之后的一个或多个字符和空字符。

6.1:编写Config:
@Configuration
public class RabbitmqConfig {
    private static final String QUEUE01= "queue01";
    private static final String QUEUE02= "queue02";
 	private static final String EXCHANGE_NAME = "topic_exchange"//交换机
    //主题路由键
    private static final String ROUTINGKEY01 = "*.red.*";
    private static final String ROUTINGKEY02 = "#.red.*";
  
    @Bean
    public Queue queue01(){
        return new Queue(QUEUE01);
    }
    @Bean
    public Queue queue02(){
        return new Queue(QUEUE02);
    }
    @Bean
    public TopicExchange topicExchange(){
        return new TopicExchange(EXCHANGE_NAME);
    }

    @Bean
    public Binding binding1(){
        return BindingBuilder.bind(queue01()).to(directExchange()).with(ROUTINGKEY01);
    }
    @Bean
    public Binding binding2(){
        return BindingBuilder.bind(queue02()).to(directExchange()).with(ROUTINGKEY02);
    }
}
6.2:编写主题列队生产者和消费者
@Service
@Slf4j
public class MQSender {
    @Autowired
    private RabbitTemplate rabbitTemplate;
		
  	//生产者
    public void send(Object msg){
        log.info("==========>>>>>>>>>>发送消息:"+msg);
        rabbitTemplate.convertAndSend("topic_exchange","queue.red.demo",msg);
      	rabbitTemplate.convertAndSend("topic_exchange","test.queue.red.demo",msg);
    }
		//消费者01
    @RabbitListener(queues = "queue01")
    public void receiver01(Object msg){
        log.info("============>>>>>>>>>queue01接收消息:"+msg+"主题路由键名为：*.red.*");
    }
  	//消费者02
    @RabbitListener(queues = "queue02")
    public void receiver02(Object msg){
        log.info("============>>>>>>>>>queue02接收消息:"+msg+"主题路由键名为：#.red.*");
    }
}

7.Headers模式(性能较低基本上不会使用)

7.1:编写Config
@Configuration
public class RabbitMqConfig {
	private static final String QUEUE01= "queue01";
    private static final String QUEUE02= "queue02";
 	private static final String EXCHANGE_NAME = "headersExchange"//交换机
    //主题路由键
    private static final String ROUTINGKEY01 = "*.red.*";
    private static final String ROUTINGKEY02 = "#.red.*";
	@Bean
	public Queue queue01() {
		return new Queue(QUEUE01);
	}
	@Bean
	public Queue queue02() {
		return new Queue(QUEUE02);
	}

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

	@Bean
	public Binding binding01(){
		Map<String,Object> map = new HashMap<>();
		map.put("queueName","queue01");
		map.put("bindType","whereAll");
		return BindingBuilder.bind(queue01()).to(headersExchange()).whereAll(map).match();
	}

	@Bean
	public Binding binding02(){

		Map<String,Object> map = new HashMap<>();
		map.put("queueName","queue02");
		map.put("bindType","whereAny");
		return BindingBuilder.bind(queue02()).to(headersExchange()).whereAny(map).match();
	}
}
7.2:编写Headers模式生产者和消费者
@Service
@Slf4j
public class MQSender {
	@Autowired
	private RabbitTemplate rabbitTemplate;

	public void send(Object msg){
		MessageProperties messageProperties = new MessageProperties();
		messageProperties.setHeader("queueName","queue01");
		messageProperties.setHeader("bindType","whereAll");
    messageProperties.setHeader("queueName","queue02");
		messageProperties.setHeader("bindType","whereAll");
		Message message = new Message(msg, messageProperties);
		rabbitTemplate.send("headersExchange",null,message);
	}
  
  @RabbitListener(queues = "queue01")
	public void receiver01(byte[] msg){
		log.info("============>>>>>>>>>queue01接收消息:"+new String(msg);
	}
	@RabbitListener(queues = "queue02")
	public void receiver02(byte[] msg){
    	log.info("============>>>>>>>>>queue02接收消息:"+new String(msg);
	}
}
科杰智能制造
关注
专栏目录
【SpringBoot】43、SpringBoot中整合RabbitMQ实现延时队列（延时插件篇）
Asurplus
02-21 21万+
一、介绍 1、什么是延时队列？ 延时队列即就是放置在该队列里面的消息是不需要立即消费的，而是等待一段时间之后取出消费 2、适用场景 （1）商城订单超时未支付，取消订单 （2）使用权限到期前十分钟提醒用户 （3）收益项目，投入后一段时间后产生收益 二、实现方式 从以上场景中，我们可以看出，延时队列的主要功能就是在指定的时间之后做指定的事情，那么，我们思考有哪些工具我们可以使用？ 1、Redis 监听过期 Key 可以参考我的博客【SpringBoot】三十五、SpringBoot整合Redis监听Ke
SpringBoot整合RabbitMQ实现延时队列
PGL2009的博客
12-12 2271
组件的版本 SpringBoot : V2.5.5 RabbitMQ: 3.9.9 延时队列 延时队列的典型应用场景，例如购买火车票，下单占座后20分钟内未支付的订单会被强制取消，避免在余票紧张的情况下，车票一直被占用，其他人无法购买。还有电商平台，客户下单后，订单进入购物车，如果购物车内的订单超过特定时间未支付，则会失效，回滚库存。 RabbitMQ实现延时队列 利用 RabbitMQ 做延时队列是比较常见的一种方式，而实际上RabbitMQ 自身并没有直接支持提供延迟队列功能，而是通过 RabbitMQ
springBoot集成RabbitMq 五种工作模式
qq_46859110的博客
10-06 690
RabbitMQ提供了6种模式：简单模式，work模式，Publish/Subscribe发布与订阅模式，Routing路由模式，Topics主题模式 导入依赖 <dependencies> <!-- junit--> <dependency> <groupId>org.springframework.boot</groupId> <artifact
分布式专题｜进入BAT必备之Springboot 集成 RabbitMQ的五种工作模式
热门推荐
11-14 2万+
分布式专题｜进入BAT必备之Springboot 集成 RabbitMQ的五种工作模式
SpringBoot整合RabbitMQ：5种模式实战
沮丧的南瓜
07-31 3353
一、环境准备 1、pom依赖 <!-- 父工程依赖 --> <parent> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-parent</artifactId> <version>2.3.6.RELEASE</version> </pa
SpringBoot整合五种RabbitMQ模式
qq_45782349的博客
04-18 264
1 搭建初始环境 1.1 引入依赖 <dependency> <groupId>org.springframework.amqp</groupId> <artifactId>spring-rabbit-test</artifactId> <scope>test</scope> </dependency> 1.2 配置配置文件 spring: application: name: spri
03RabbitMq-SpringBoot整合RabbitMq五种模式
niannujiao6的博客
02-08 1231
一、Fanout模式 生产者 1.导入amqp协议依赖 <!--rabbitmq--> <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-amqp</artifactId> </dependency>
SpringBoot整合RabbitMQ.zip
06-29
SpringBoot整合RabbitMQ的详细过程 **1.该篇博文首先讲述了交换机和队列之间的绑定关系** ①direct、②fanout、③topic **2.然后讲消息的回调** 四种情况下，确认触发哪个回调函数： ①消息推送到server，但是在...
Springboot整合RabbitMQ最简单demo
07-11
Springboot整合RabbitMQ最简单demo,适用于springcloud项目,作为消息总线适用,需要安装RabbitMQ,Mac linux可以使用命令行一键安装,在项目配置文件配置好端口即可(已默认配置),启动项目访问8080端口,参数见controller.
springBoot整合RabbitMQ案例
04-07
SpringBoot整合RabbitMQ是一个常见的后端开发任务，它涉及到分布式消息传递和Java应用程序的集成。RabbitMQ是一个开源的消息代理和队列服务器，而SpringBoot是基于Spring框架的简化版，提供了快速构建应用程序的方式...
SpringBoot与RabbitMQ整合和对五种队列模式的实现源码
06-21
SpringBoot与RabbitMQ整合和对五种队列模式的实现源码。可以参考博文：https://blog.csdn.net/qq_29914837/article/details/93144255
SpringBoot 集成 RabbitMq 实现五种常用消息模型
wxw1997a的博客
08-09 565
一个简单的 Demo ，实现五种消息模型，快速上手
springboot几种开发模式_springboot整合rabbitmq的五种模式
weixin_39682301的博客
12-20 427
SpringBoot-RabbitMQ本案例为springboot整合rabbitmq的五种工作模式。springboot不需要在启动类前加@EnableRabbit和新建ConnectionFactory(),因为可以在yml里配置rabbitmq的选项。本案例开启的消息确认机制,持久化了交换机,队列以及消息,消费者端开启了手动ACK,保证非极端情况下消息的可靠性。配置简单,doem中有详细的注...
springboot整合rabbitmq的五种模式示例
not only a 程序员的博客
06-19 8122
springboot整合rabbitmq RabbitMQ提供了6种消息模型，但是第6种其实是RPC，并不是MQ，因此不予学习。那么也就剩下5种。 1.基本消息模型：生产者–>队列–>一个消费者 2.work消息模型：生产者–>队列–>多个消费者共同消费 3.订阅模型-Fanout：广播，将消息交给所有绑定到交换机的队列，每个消费者都可以收到同一条消息 4.订阅模型-Di...
spring boot整合rabbitmq(5种)
cxxx45的博客
06-19 217
原文：https://blog.csdn.net/qq_38762237/article/details/89433506 依赖 ​ org.springframework.boot ​ spring-boot-starter-amqp application.yml spring: rabbitmq: ​ host: 127.0.0.1 ​ username: tel...
SpringBoot+RabbitMQ_动态的队列名称
雪小白
10-23 3487
目录 一、前言 二、集成MQ 2.1 pom文件引入jar 2.2 ymal文件配置MQ 2.3 编写生产者 2.4 编写消费者 一、前言 在做项目中，服务之间需要通讯，原本使用的http请求，但是并发量上来后，速度就不是很理想，所以决定用MQ消息队列来解决这个问题。 举例：一个服务要将客户发过来的消息进行分类，是水果的调用处理水果的服务器，是蔬菜的调用处理蔬菜的服务器，也就是每台服务器要处理自己队列里的消息。 二、集成MQ 2.1 pom文件引入jar &lt...
SpringBoot+RabbitMQ实现消息队列的各种模式
wuqihawubito的博客
07-21 341
文章目录依赖：配置文件：简单模式：工作队列模式;发布订阅模式路由Routing模式通配符模式 依赖： <dependencies> <!--RabbitMQ 依赖--> <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-amqp&
Rabbitmq之整合Springboot，普通队列以及死信队列demo实例，队列优化以及插件实现延迟队列
花&败
05-21 389
1、引入pom.xml依赖 <?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.a
RabbitMQ消息队列(三)：SpringBoot整合之工作模式
fatestranger的博客
08-11 362
Work Queues 与简单模式相比，多了一个或一些消费端，多个消费端共同消费同一个队列中的消息。应用场景：对于 任务过重或任务较多情况使用工作队列可以提高任务处理的速度。
SpringBoot整合RabbitMQ实现延迟队列实战
"本文将介绍如何使用SpringBoot与RabbitMQ结合实现延迟队列，包括延迟队列的概念、应用场景以及具体实现方式，涉及到RabbitMQ的Time-To-Live Extensions和Dead Letter Exchanges特性。" 在分布式系统中，延迟队列是...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

科杰智能制造

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值