SpringBoot整合RabbitMQ及多模式简单实现

最新推荐文章于 2024-05-08 22:19:23 发布
最新推荐文章于 2024-05-08 22:19:23 发布
阅读量398 收藏 1
点赞数
分类专栏： # JavaWeb
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/u014086799/article/details/106148212
版权

SpringBoot整合RabbitMQ及多模式简单实现

本文摘录自：

https://blog.csdn.net/weixin_38305440/article/details/104807062

依赖：

starter添加依赖：

Spring for RabbitMQ

配置文件：

application.yml

spring:
  rabbitmq:
    host: 192.168.64.140
    username: admin
    password: admin

简单模式

Bean

@SpringBootApplication
public class Main {
	public static void main(String[] args) {
		SpringApplication.run(Main.class, args);
	}

	@Bean
	public Queue task_queue() {
		/*
		 * 可用以下形式: 
		 * new Queue("helloworld") - 持久,非排他,非自动删除
		 * new Queue("helloworld",false,false,false,null)
		 */
		return new Queue("helloworld",false);
	}
}

生产者

AmqpTemplate是rabbitmq客户端API的一个封装工具,提供了简便的方法来执行消息操作.

AmqpTemplate由自动配置类自动创建

@Component
public class SimpleSender {
	@Autowired
	AmqpTemplate t;
	
	public void send() {
		// 这里向 helloworld 队列发送消息
		t.convertAndSend("helloworld", "Hello world!! "+System.currentTimeMillis());
		System.out.println("消息已发送");
	}
}

消费者

通过@RabbitListener从指定的队列接收消息

使用@RebbitHandler注解的方法来处理消息

@Component
@RabbitListener(queues = "helloworld")
public class SimpleReceiver {
	@RabbitHandler
	public void receive(String msg) {
		System.out.println("收到: "+msg);
	}
}

@RabbitListener注解可以直接加在方法上，这样@RabbitHandler就可以不加了

同时也可以在@RabbitListener上定义队列属性：

@RabbitListener(queuesToDeclare = @Queue(name = "helloworld",durable = "false"))

工作模式

在主程序中创建名为task_queue的持久队列

@SpringBootApplication
public class Main {
	public static void main(String[] args) {
		SpringApplication.run(Main.class, args);
	}
	@Bean
	public Queue task_queue() {
		// 这个构造方法创建的队列参数为: 持久,非排他,非自动删除
		return new Queue("task_queue");
	}
}

生产者

@Component
public class WorkSender {
	@Autowired
	AmqpTemplate t;
	
	public void send() {
		while (true) {
			System.out.print("输入:");
			String s = new Scanner(System.in).nextLine();
			//spring 默认将消息的 DeliveryMode 设置为 PERSISTENT 持久化,
			t.convertAndSend("task_queue", s);
		}
	}
}

SpringBoot默认消息是持久化消息，如果需要非持久消息，还需要用MessagePostProcessor进行配置：

	//如果需要设置消息为非持久化,可以取得消息的属性对象,修改它的deliveryMode属性
	t.convertAndSend("task_queue", (Object) s, new MessagePostProcessor() {
		@Override
		public Message postProcessMessage(Message message) throws AmqpException {
			MessageProperties props = message.getMessageProperties();
			props.setDeliveryMode(MessageDeliveryMode.NON_PERSISTENT);
			return message;
		}
	});

消费者

@Component
public class WorkReceiver1 {
	@RabbitListener(queues="task_queue")
	public void receive1(String s) throws Exception {
		System.out.println("receiver1 - 收到: "+s);
		for (int i = 0; i < s.length(); i++) {
			if (s.charAt(i) == '.') {
				Thread.sleep(1000);
			}
		}
	}
	
	@RabbitListener(queues="task_queue")
	public void receive2(String s) throws Exception {
		System.out.println("receiver2 - 收到: "+s);
		for (int i = 0; i < s.length(); i++) {
			if (s.charAt(i) == '.') {
				Thread.sleep(1000);
			}
		}
	}
}

ACK设置

SpringBoot封装了3个模式：

NONE：不做任何操作，rabbitmq发送消息即删除，不管处理结果如何

AUTO（默认）：在方法处理完成后，SpringBoot会自动发送回执

MANUAL：需要手写回执

spring:
  rabbitmq:
    listener:
      simple:
        # acknowledgeMode: NONE # rabbitmq的自动确认
        acknowledgeMode: AUTO # rabbitmq的手动确认, springboot会自动发送确认回执 (默认)
        # acknowledgeMode: MANUAL # rabbitmq的手动确认, springboot不发送回执, 必须自己编码发送回执

MANUAL模式的手动执行确认操作：

	@RabbitListener(queues="task_queue")
	public void receive1(String s, Channel c, @Header(name=AmqpHeaders.DELIVERY_TAG) long tag) throws Exception {
		System.out.println("receiver1 - 收到: "+s);
		for (int i = 0; i < s.length(); i++) {
			if (s.charAt(i) == '.') {
				Thread.sleep(1000);
			}
		}
		// 手动发送确认回执
		c.basicAck(tag, false);
	}

消息抓取数量

在工作模式中，为了合理分发消息，避免阻塞，需要把qos设置为1

spring:
  rabbitmq:
    listener:
      simple:
        prefetch: 1 # qos=1, 默认250

发布和订阅模式

@SpringBootApplication
public class Main {
	public static void main(String[] args) {
		SpringApplication.run(Main.class, args);
	}
	@Bean
	public FanoutExchange fanoutExchange() {
		return new FanoutExchange("logs");
	}
}

生产者

生产者向指定的交换机 logs 发送数据.

不需要指定队列名或路由键, 即使指定也无效, 因为 fanout 交换机会向所有绑定的队列发送数据, 而不是有选择的发送.

@Component
public class Publisher {
	@Autowired
	AmqpTemplate t;
	public void send() {
		while (true) {
			System.out.print("输入:");
			String s = new Scanner(System.in).nextLine();
			// 指定向 logs 交换机发送, 不指定队列名或路由键
			t.convertAndSend("logs","",s);
		}
	}
}

消费者

消费者需要执行以下操作:

  1. 定义随机队列(随机命名,非持久,排他,自动删除)
  2. 定义交换机(可以省略, 已在主程序中定义)
  3. 将队列绑定到交换机

spring boot 通过注解完成以上操作:

@RabbitListener(bindings = @QueueBinding( //这里进行绑定设置
	value = @Queue, //这里定义随机队列,默认属性: 随机命名,非持久,排他,自动删除
	exchange = @Exchange(name = "logs", declare = "false") //指定 logs 交换机,因为主程序中已经定义,这里不进行定义
))

@Component
public class Subscriber {
	@RabbitListener(bindings = @QueueBinding(value = @Queue, exchange = @Exchange(name = "logs", declare = "false")))
	public void receive1(String s) throws Exception {
		System.out.println("receiver1 - 收到: "+s);
	}
	@RabbitListener(bindings = @QueueBinding(value = @Queue, exchange = @Exchange(name = "logs", declare = "false")))
	public void receive2(String s) throws Exception {
		System.out.println("receiver2 - 收到: "+s);
	}
}

路由模式

与发布和订阅模式代码类似, 只是做以下三点调整:

  1. 使用 direct 交换机
  2. 队列和交换机绑定时, 设置绑定键
  3. 发送消息时, 指定路由键
@SpringBootApplication
public class Main {
	public static void main(String[] args) {
		SpringApplication.run(Main.class, args);
	}
	@Bean
	public DirectExchange fanoutExchange() {
		return new DirectExchange("direct_logs");
	}
}

生产者

@Component
public class RouteSender {
	@Autowired
	AmqpTemplate t;
	
	public void send() {
		while (true) {
			System.out.print("输入消息:");
			String s = new Scanner(System.in).nextLine();
			System.out.print("输入路由键:");
			String key = new Scanner(System.in).nextLine();
			// 第二个参数指定路由键
			t.convertAndSend("direct_logs",key,s);
		}
	}
}

消费者

@Component
public class RouteReceiver {
	@RabbitListener(bindings = @QueueBinding(value = @Queue,exchange = @Exchange(name = "direct_logs", declare = "false"),key = {"error"}))
	public void receive1(String s) throws Exception {
		System.out.println("receiver1 - 收到: "+s);
	}
	@RabbitListener(bindings = @QueueBinding(value = @Queue, exchange = @Exchange(name = "direct_logs", declare = "false"),key = {"error","info","warning"}))
	public void receive2(String s) throws Exception {
		System.out.println("receiver2 - 收到: "+s);
	}
}

主题模式

@SpringBootApplication
public class Main {
	public static void main(String[] args) {
		SpringApplication.run(Main.class, args);
	}
	@Bean
	public TopicExchange fanoutExchange() {
		return new TopicExchange("topic_logs");
	}
}

生产者

@Component
public class TopicSender {
	@Autowired
	AmqpTemplate t;
	
	public void send() {
		while (true) {
			System.out.print("输入消息:");
			String s = new Scanner(System.in).nextLine();
			System.out.print("输入路由键:");
			String key = new Scanner(System.in).nextLine();
			
			t.convertAndSend("topic_logs",key,s);
		}
	}
}

消费者

@Component
public class TopicReceiver {
	@RabbitListener(bindings = @QueueBinding(value = @Queue,exchange = @Exchange(name = "topic_logs", declare = "false"),key = {"*.orange.*"}))
	public void receive1(String s) throws Exception {
		System.out.println("receiver1 - 收到: "+s);
	}
	@RabbitListener(bindings = @QueueBinding(value = @Queue, exchange = @Exchange(name = "topic_logs", declare = "false"),key = {"*.*.rabbit","lazy.#"}))
	public void receive2(String s) throws Exception {
		System.out.println("receiver2 - 收到: "+s);
	}
}

RPC异步调用

@SpringBootApplication
public class Main {
	public static void main(String[] args) {
		SpringApplication.run(Main.class, args);
	}
	@Bean
	public Queue sendQueue() {
		return new Queue("rpc_queue",false);
	}
	@Bean
	public Queue rndQueue() {
		return new Queue(UUID.randomUUID().toString(), false);
	}
}

服务端

从rpc_queue接收调用数据, 执行运算求斐波那契数,并返回计算结果.
@Rabbitlistener注解对于具有返回值的方法:

  • 会自动获取 replyTo 属性
  • 自动获取 correlationId 属性
  • 向 replyTo 属性指定的队列发送计算结果, 并携带 correlationId 属性
@Component
public class RpcServer {
	@RabbitListener(queues = "rpc_queue")
	public long getFbnq(int n) {
		return f(n);
	}
	private long f(int n) {
		if (n==1 || n==2) {
			return 1;
		}
		return f(n-1) + f(n-2);
	}
}

客户端

使用 SPEL 表达式获取随机队列名: "#{rndQueue.name}"

发送调用数据时, 携带随机队列名和correlationId

从随机队列接收调用结果, 并获取correlationId

@Component
public class RpcClient {
	@Autowired
	AmqpTemplate t;
	
	@Value("#{rndQueue.name}")
	String rndQueue;
	
	public void send(int n) {
		// 发送调用信息时, 通过前置消息处理器, 对消息属性进行设置, 添加返回队列名和关联id
		t.convertAndSend("rpc_queue", (Object)n, new MessagePostProcessor() {
			@Override
			public Message postProcessMessage(Message message) throws AmqpException {
				MessageProperties p = message.getMessageProperties();
				p.setReplyTo(rndQueue);
				p.setCorrelationId(UUID.randomUUID().toString());
				return message;
			}
		});
	}
	
	//从随机队列接收计算结果
	@RabbitListener(queues = "#{rndQueue.name}")
	public void receive(long r, @Header(name=AmqpHeaders.CORRELATION_ID) String correlationId) {
		System.out.println("\n\n"+correlationId+" - 收到: "+r);
	}
}
紫宇寰
关注
专栏目录
【SpringBoot】43、SpringBoot中整合RabbitMQ实现延时队列（延时插件篇）
Asurplus
02-21 21万+
一、介绍 1、什么是延时队列？ 延时队列即就是放置在该队列里面的消息是不需要立即消费的，而是等待一段时间之后取出消费 2、适用场景 （1）商城订单超时未支付，取消订单 （2）使用权限到期前十分钟提醒用户 （3）收益项目，投入后一段时间后产生收益 二、实现方式 从以上场景中，我们可以看出，延时队列的主要功能就是在指定的时间之后做指定的事情，那么，我们思考有哪些工具我们可以使用？ 1、Redis 监听过期 Key 可以参考我的博客【SpringBoot】三十五、SpringBoot整合Redis监听Ke
SpringBoot 整合 RabbitMQ 并使用发布订阅模式
include_hcj的博客
08-19 1130
我们可以使用 RabbitMQ 的发布订阅模式，实现：用户发布动态，其“粉丝”收到其发布动态的消息用户下订单，库存模块、支付模块等收到消息并处理等等。
详解Spring Boot 配置多个RabbitMQ
08-30
本篇文章主要介绍了Spring Boot 配置多个RabbitMQ，小编觉得挺不错的，现在分享给大家，也给大家做个参考。一起跟随小编过来看看吧
SpringBoot之简单整合RabbitMq
一叶知秋hwb的博客
04-13 223
一、RabbitMq基本概念 1.1、什么是RabbitMq？ AMQP，即Advanced Message Queuing Protocol，高级消息队列协议，是应用层协议的一个开放标准，为面向消息的中间件设计。消息中间件主要用于组件之间的解耦，消息的发送者无需知道消息使用者的存在，反之亦然。 AMQP的主要特征是面向消息、队列、路由（包括点对点和发布/订阅）、可靠性、安全。 ...
SpringBoot简单整合RabbitMQ
m0_64686550的博客
03-05 202
springboot简单整合RabbitMQ，并简单学习原生RabbitMQ代码
【RabbitMQ】SpringBoot集成RabbitMQ项目实战：简单队列模式、三种交换机模式（Fanout模式，Direct模式，Topic模式））
Zhou_LC的博客
01-07 1803
文章目录1 本文背景2 具体步骤3 测试结果 1 本文背景 近期在做一个电商秒杀项目，在服务优化的阶段用到了 RabbitMQ 这个消息中间件，让秒杀请求不再瞬时冲击秒杀接口，而是利用消息中间件来让请求如队列般排队而来。 2 具体步骤 下面是最基础的一种 SpringBoot 集成 RabbitMQ 简单队列模式的方式：添加 pom 依赖、 yml 配置、配置类、消息发送者、消息接收者 1、添加 pom 依赖，这里需要添加 amqp，amqp 是一个提供统一消息服务的应用层标准高级消息队列协议，是应用层协议
SpringBoot集成多个RabbitMq（多个MQ链接）
zwtwbb的专栏
12-16 1985
##2023年12月16日 20:25:36 项目中使用RabbitMQ作为应用间信息互通，本次梳理下关于MQ的使用。 1、引入依赖 <!-- 引入依赖，使用v2.5.6版本 --> <dependencies> <dependency> <groupId>org.springframework.boo...
【RabbitMQ教程】springboot整合rabbitmq(topic模式)
qq_43783527的博客
10-09 2624
为了方便测试，我直接把生产者代码放工程测试类：发送routing key是"topic.sms.email"的消息，那么mq-rabbitmq-consumer下那些监听的（与交换机(topic.exchange)绑定，并且订阅的routingkey中匹配了"topic.sms.email"规则的） 队列就会收到消息。创建两个工程 mq-rabbitmq-producer和mq-rabbitmq-consumer，分别配置1、2、3（第三步本例消费者用注解形式，可以不用配）搭建SpringBoot环境。
springBoot整合RabbitMQ案例
04-07
SpringBoot整合RabbitMQ是一个常见的后端开发任务，它涉及到分布式消息传递和Java应用程序的集成。RabbitMQ是一个开源的消息代理和队列服务器，而SpringBoot是基于Spring框架的简化版，提供了快速构建应用程序的方式...
springboot整合rabbitmq，开启手工确认。保证消息100%投递
09-16
在Spring Boot应用中整合RabbitMQ，以确保消息100%投递，是一个关键的实践，特别是对于那些需要高可靠性和数据一致性的系统。RabbitMQ是一个流行的开源消息代理，它遵循Advanced Message Queuing Protocol (AMQP)...
SpringBoot与RabbitMQ整合和对五种队列模式的实现源码
06-21
SpringBoot与RabbitMQ整合和对五种队列模式的实现源码。可以参考博文：https://blog.csdn.net/qq_29914837/article/details/93144255
SpringBoot 整合 RabbitMQ 消息队列
Jaemon
12-30 629
SpringBoot 整合 RabbitMQ 消息队列
SpringBoot 连接多个Rabbitmq数据源
守正出奇
06-05 3898
SpringBoot 连接多个Rabbitmq数据源前言一、单个RabbitMq数据源二、多个RabbitMQ数据源2.1 增加配置信息2.2 代码实现三、RabbitMQ的optional queue arguments 和 policies3.1 optional queue agruments3.2 policies 前言 最近工作上需要在一个项目里面使用两个RabbitMq作为数据源，记录一下大概的实现过程，加深影响。 一、单个RabbitMq数据源 一般情况下，都是依赖单个RabbitMQ作..
SpringBoot整合RabbitMQ的实现
Ouyzc的博客
01-07 581
之前写过JMS的相关文章进行介绍和实现，实现是采用最简单的ActiveMQ。如果业务和服务架构较为简单，ActiveMQ已经足够了，但随着业务量的增长和服务架构越来越复杂，采用了分布式架构，那么ActiveMQ就会显得不够稳定和灵活了。那么就必须要寻求更加灵活的消息中间件了。RabbitMQ是不二的选择。   一.RabbitMQ的简单介绍 跟ActiveMQ类似，RabbitMQ也是消息中...
Spring Boot RabbitMQ多数据源配置
weixin_46993901的博客
09-06 719
在构建复杂的应用程序时，经常需要与多个数据源进行交互。这可能包括连接多个数据库、消息队列或其他数据存储系统。RabbitMQ 是一个流行的消息队列系统，它通过消息队列实现了应用程序之间的松耦合，适用于异步任务处理、解耦、削峰填谷等场景。本篇博客将介绍如何在 Spring Boot 中配置和管理多个 RabbitMQ 数据源，以满足不同的应用需求，并提供示例代码首先，在 文件中添加 RabbitMQ 的 Spring Boot Starter 依赖，以便引入 RabbitMQ 相关的库和功能。 2. 抽象类
spring boot rabbtimq rpc 模式
偶是一只小小鸟~
08-13 322
使用Spring Boot 与Rabbitmq 实现rpc 调用 定义接口 首先定义一个公用的接口 public interface RemoteLoginInterface { SecurityUserDetails remoteLoginUser(String username); } Client 端 配置 AmqpProxyFactoryBean 对象代理. 使用Sprin...
SpringBoot集成RabbitMQ配置多数据源
qq_26432153的博客
03-07 965
SpringBoot集成rabbitmq，并配置多个rabbitmq数据源，并测试
spingboot + rabbitmq Rpc模式
weixin_43866295的博客
01-31 588
spingboot + rabbitmq Rpc模式 配置类 @Configuration public class RabbitMqConfig6 { @Bean public Queue queueR() { return new Queue("queueR"); } } 发送消息 - 生产者 @Service public class RabbitMqService6 {...
springboot整合rabbitmq的不同工作模式理解
最新发布
weixin_43975276的博客
05-08 900
前提是已经安装并启动了rabbitmq，并且项目已经引入rabbitmq，完成了配置。不同模式所需参数不同，生产者可以根据参数不同使用重载的convertAndSend方法。而消费者均是直接监听某个队列。不同的交换机是实现不同工作模式的关键组件.每种交换机类型都有其特定的路由和分发策略。一些概念queue:队列这是最基本的模式，包含一个生产者和一个消费者和一个队列bean。生产者发送消息到指定队列，消费者从该队列中接收消息。如下图：生产者P往queue发送消息，消费者C消费queue里的消息。
SpringBoot整合RabbitMQ实现延迟队列实战
"本文将介绍如何使用SpringBoot与RabbitMQ结合实现延迟队列，包括延迟队列的概念、应用场景以及具体实现方式，涉及到RabbitMQ的Time-To-Live Extensions和Dead Letter Exchanges特性。" 在分布式系统中，延迟队列是...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值