RabbitMQ：第二章：Spring整合RabbitMQ（简单模式，广播模式，路由模式，通配符模式，消息可靠性投递，防止消息丢失

最新推荐文章于 2024-05-28 22:59:18 发布

2401_84046545

最新推荐文章于 2024-05-28 22:59:18 发布

阅读量546

点赞数 15

分类专栏：程序员文章标签： java-rabbitmq rabbitmq spring

本文链接：https://blog.csdn.net/2401_84046545/article/details/138480304

版权

程序员专栏收录该内容

477 篇文章 0 订阅

订阅专栏

<context:property-placeholder location=“classpath:rabbitmq.properties”/>

<rabbit:connection-factory id=“connectionFactory” host=“${rabbitmq.host}”

port=“${rabbitmq.port}”

username=“${rabbitmq.username}”

password=“${rabbitmq.password}”

virtual-host=“${rabbitmq.virtual-host}”/>

<rabbit:admin connection-factory=“connectionFactory”/>

<rabbit:queue id=“spring_queue” name=“spring_queue” auto-declare=“true”/>

<rabbit:queue id=“spring_fanout_queue_1” name=“spring_fanout_queue_1” auto-declare=“true”/>

<rabbit:queue id=“spring_fanout_queue_2” name=“spring_fanout_queue_2” auto-declare=“true”/>

<rabbit:fanout-exchange id=“spring_fanout_exchange” name=“spring_fanout_exchange” auto-declare=“true”>

rabbit:bindings

<rabbit:binding queue=“spring_fanout_queue_1” />

<rabbit:binding queue=“spring_fanout_queue_2”/>

</rabbit:bindings>

</rabbit:fanout-exchange>

<rabbit:queue id=“spring_direct_queue” name=“spring_direct_queue” auto-declare=“true”/>

<rabbit:direct-exchange name=“spring_direct_exchange” >

rabbit:bindings

<rabbit:binding queue=“spring_direct_queue” key=“direct”></rabbit:binding>

</rabbit:bindings>

</rabbit:direct-exchange>

<rabbit:queue id=“spring_topic_queue_one” name=“spring_topic_queue_one” auto-declare=“true”/>

<rabbit:queue id=“spring_topic_queue_two” name=“spring_topic_queue_two” auto-declare=“true”/>

<rabbit:queue id=“spring_topic_queue_three” name=“spring_topic_queue_three” auto-declare=“true”/>

<rabbit:topic-exchange id=“spring_topic_exchange” name=“spring_topic_exchange” auto-declare=“true”>

rabbit:bindings

<rabbit:binding pattern=“one.*” queue=“spring_topic_queue_one”/>

<rabbit:binding pattern=“two.#” queue=“spring_topic_queue_two”/>

<rabbit:binding pattern=“three.#” queue=“spring_topic_queue_three”/>

</rabbit:bindings>

</rabbit:topic-exchange>

<rabbit:template id=“rabbitTemplate” connection-factory=“connectionFactory”/>

4.rabbitmq.properties：

rabbitmq.host=110.42.239.246

rabbitmq.port=5672

rabbitmq.username=guest

rabbitmq.password=guest

rabbitmq.virtual-host=spring

说明：这里免费提供rabbitmq连接方式给大家使用学习

5.ProducerTest：

package com.sky.springrabbitmqprodule;

import org.junit.Test;

import org.junit.runner.RunWith;

import org.springframework.amqp.rabbit.core.RabbitTemplate;

import org.springframework.beans.factory.annotation.Autowired;

import org.springframework.test.context.ContextConfiguration;

import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;

@RunWith(SpringJUnit4ClassRunner.class)

@ContextConfiguration(locations = “classpath:spring-rabbitmq-producer.xml”)

public class ProducerTest {

@Autowired

private RabbitTemplate rabbitTemplate;

/**

简单模式发消息

@Test

public void testHelloWorld(){

rabbitTemplate.convertAndSend(“spring_queue”,“hello world spring…”);

}

/**

广播模式发消息

@Test

public void testFanout(){

rabbitTemplate.convertAndSend(“spring_fanout_exchange”,“”,“spring fanout…”);

}

/**

路由模式发消息

@Test

public void testDirect(){

rabbitTemplate.convertAndSend(“spring_direct_exchange”,“direct”,“spring Direct…”);

}

/**

通配符模式发消息

@Test

public void testTopics(){

rabbitTemplate.convertAndSend(“spring_topic_exchange”,“one.onekey”,“spring topic one…”);

rabbitTemplate.convertAndSend(“spring_topic_exchange”,“two.twokey.topic”,“spring topic two…”);

rabbitTemplate.convertAndSend(“spring_topic_exchange”,“three.threekey.topic”,“spring topic three…”);

}

2.消费者

1.项目架构图

在这里插入图片描述

代码如下（示例）：

2.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.apache.org/xsd/maven-4.0.0.xsd”>

4.0.0

com.sky

spring-rabbitmq-consumer

1.0-SNAPSHOT

org.springframework

spring-context

5.1.7.RELEASE

org.springframework.amqp

spring-rabbit

2.1.8.RELEASE

junit

4.12

org.springframework

spring-test

5.1.7.RELEASE

org.apache.maven.plugins

maven-compiler-plugin

3.8.0

1.8

3.spring-rabbitmq-consumer.xml

<?xml version="1.0" encoding="UTF-8"?>

<beans xmlns=“http://www.springframework.org/schema/beans”

xmlns:xsi=“http://www.w3.org/2001/XMLSchema-instance”

xmlns:context=“http://www.springframework.org/schema/context”

xmlns:rabbit=“http://www.springframework.org/schema/rabbit”

xsi:schemaLocation="http://www.springframework.org/schema/beans

http://www.springframework.org/schema/beans/spring-beans.xsd

http://www.springframework.org/schema/context

https://www.springframework.org/schema/context/spring-context.xsd

http://www.springframework.org/schema/rabbit

http://www.springframework.org/schema/rabbit/spring-rabbit.xsd">

<context:property-placeholder location=“classpath:rabbitmq.properties”/>

<rabbit:connection-factory id=“connectionFactory” host=“${rabbitmq.host}”

port=“${rabbitmq.port}”

username=“${rabbitmq.username}”

password=“${rabbitmq.password}”

virtual-host=“${rabbitmq.virtual-host}”/>

<rabbit:listener-container connection-factory=“connectionFactory” auto-declare=“true”>

<rabbit:listener ref=“topicListenerOne” queue-names=“spring_topic_queue_one”/>

<rabbit:listener ref=“topicListenerTwo” queue-names=“spring_topic_queue_two”/>

<rabbit:listener ref=“topicListenerThree” queue-names=“spring_topic_queue_three”/>

</rabbit:listener-container>

4.rabbitmq.properties

rabbitmq.host=110.42.239.246

rabbitmq.port=5672

rabbitmq.username=guest

rabbitmq.password=guest

rabbitmq.virtual-host=spring

说明：配置和生产者的一致

package com.sky.springrabbitmqconsumer.listener;

import org.springframework.amqp.core.Message;

import org.springframework.amqp.core.MessageListener;

public class TopicListenerThree implements MessageListener {

@Override

public void onMessage(Message message) {

//打印消息

System.out.println(new String(message.getBody()));

}

上面就是这个项目的所有代码了，下面就是Demo演示内容。

二、项目演示

====================================================================

演示简单模式：

消费者取消注释：

在这里插入图片描述消费者启动服务：

在这里插入图片描述生产者发送消息：

在这里插入图片描述消费者查看消息：

在这里插入图片描述

演示广播模式：

消费者取消注释：

在这里插入图片描述

消费者启动服务：

在这里插入图片描述

生产者发送消息：

在这里插入图片描述

消费者查看消息：

在这里插入图片描述

演示路由模式：

消费者取消注释：

在这里插入图片描述

消费者启动服务：

在这里插入图片描述

生产者发送消息：

在这里插入图片描述

消费者查看消息：

在这里插入图片描述

演示通配符模式：

消费者取消注释：

在这里插入图片描述

消费者启动服务：

在这里插入图片描述

生产者发送消息：

在这里插入图片描述

消费者查看消息：

在这里插入图片描述

三、消息可靠性投递

=======================================================================

消息可靠性实现需要保证以下几点：

持久化

exchange要持久化

queue要持久化

message要持久化

生产方确认Confirm
消费方确认Ack
Broker高可用

1.rabbitmq 整个消息投递的路径

producer—>rabbitmq broker—>exchange—>queue—>consumer

消息从producer 到 exchange 则会返回一个 confirmCallback 。
消息从exchange–>queue 投递失败则会返回一个 returnCallback 。

2.实现消息可靠性投递的步骤

生产者设置ConnectionFactory的publisher-confirms=“true” 开启确认模式。
生产者设置ConnectionFactory的publisher-returns=“true” 开启退回模式。
生产者使用rabbitTemplate.setConfirmCallback设置回调函数。当消息发送到exchange后回调confirm方法。在方法中判断ack，如果为true，则发送成功，如果为false，则发送失败，需要处理。
生产者使用rabbitTemplate.setReturnCallback设置退回函数，当消息从exchange路由到queue失败后，如果设置了rabbitTemplate.setMandatory(true)参数，则会将消息退回给producer。并执行回调函数returnedMessage。
消费者在rabbit:listener-container标签中设置acknowledge属性，设置ack方式 none：自动确认，manual：手动确认（none自动确认模式很危险，当生产者发送多条消息，消费者接收到一条信息时，会自动认为当前发送的消息已经签收了，这个时候消费者进行业务处理时出现了异常情况，也会认为消息已经正常签收处理了，而队列里面显示都被消费掉了。所以真实开发都会改为手动签收，可以防止消息丢失）
消费者如果在消费端没有出现异常，则调用channel.basicAck(deliveryTag,false);方法确认签收消息
消费者如果出现异常，则在catch中调用 basicNack或 basicReject，拒绝消息，让MQ重新发送消息。

3.具体实现可靠消息投递的代码

说明：基于上述Spring整合RabbitMQ的代码进行改动

生产者

第一处改动：设置确认模式和退回模式

在这里插入图片描述代码：

publisher-confirms=“true”

publisher-returns=“true”

第二处改动：声明队列和交互机的bean 在这里插入图片描述代码：

<rabbit:queue id=“test_queue_confirm” name=“test_queue_confirm”></rabbit:queue>

<rabbit:direct-exchange name=“test_exchange_confirm”>

rabbit:bindings

<rabbit:binding queue=“test_queue_confirm” key=“confirm”></rabbit:binding>

</rabbit:bindings>

</rabbit:direct-exchange>

第三处改动：编写Confirm测试方法

//测试Confirm 模式

@Test

public void testConfirm() {

//定义回调

rabbitTemplate.setConfirmCallback(new RabbitTemplate.ConfirmCallback() {

/**

@param correlationData 相关配置信息
@param ack exchange交换机是否成功收到了消息。true 成功，false代表失败
@param cause 失败原因

@Override

public void confirm(CorrelationData correlationData, boolean ack, String cause) {

System.out.println(“confirm方法被执行了…”);

//ack 为 true表示消息已经到达交换机

if (ack) {

//接收成功

System.out.println(“接收成功消息” + cause);

} else {

//如果没有投递到交换机中去就会接收失败，比如：将交换机名称写错

System.out.println(“接收失败消息” + cause);

//做一些处理，让消息再次发送。

}

});

//进行消息发送

rabbitTemplate.convertAndSend(“test_exchange_confirm”,“confirm”,“message Confirm…”);

//进行睡眠操作

try {

Thread.sleep(5000);

} catch (Exception e) {

e.printStackTrace();

}

第四处改动：编写Return测试方法

//测试 return模式

@Test

public void testReturn() {

//设置交换机处理失败消息的模式为true的时候，消息达到不了队列时，会将消息重新返回给生产者

rabbitTemplate.setMandatory(true);

//定义回调

rabbitTemplate.setReturnCallback(new RabbitTemplate.ReturnCallback() {

/**

@param message 消息对象
@param replyCode 错误码
@param replyText 错误信息
@param exchange 交换机
@param routingKey 路由键

@Override

public void returnedMessage(Message message, int replyCode, String replyText, String exchange, String routingKey) {

System.out.println(“return 执行了…”);

System.out.println(“message:”+message);

System.out.println(“replyCode:”+replyCode);

System.out.println(“replyText:”+replyText);

System.out.println(“exchange:”+exchange);

System.out.println(“routingKey:”+routingKey);

//处理业务

}

});

//进行消息发送

rabbitTemplate.convertAndSend(“test_exchange_confirm”,“confirm”,“message return…”);

//进行睡眠操作

try {

Thread.sleep(5000);

} catch (Exception e) {

e.printStackTrace();

}

消费者

第一处改动：

监听器：AckListener

package com.sky.springrabbitmqconsumer.listener;

import com.rabbitmq.client.Channel;

import org.springframework.amqp.core.Message;

import org.springframework.amqp.rabbit.listener.api.ChannelAwareMessageListener;

import org.springframework.stereotype.Component;

@Component

public class AckListener implements ChannelAwareMessageListener {

@Override

public void onMessage(Message message, Channel channel) throws Exception {

//1、获取消息的id

long deliveryTag = message.getMessageProperties().getDeliveryTag();

try {

//2、获取消息

System.out.println(“message:”+new String(message.getBody()));

//3、进行业务处理

System.out.println(“=进行业务处理”);

//模拟出现异常

int i = 5/0;

//4、进行消息签收

channel.basicAck(deliveryTag, true);

} catch (Exception e) {

//拒绝签收

第三个参数：requeue：重回队列。如果设置为true，则消息重新回到queue，broker会重新发送该消息给消费端

System.out.println(“=业务处理异常，消息重新回到queue，broker会重新发送该消息给消费端”);

channel.basicNack(deliveryTag, true, true);

}

第二处改动：

在这里插入图片描述原来是通过声明一个个的bean对象，现在改为了扫描某个包下面的类

<context:component-scan base-package=“com.sky.springrabbitmqconsumer.listener” />

第三处改动：

在这里插入图片描述在rabbit:listener-container标签中设置acknowledge属性改为手动确认，（限流设置：prefetch属性改为每次抓取2条消息，并且监听自定义的ackListener）

4.具体实现可靠消息投递的演示

正常发消息Demo演示

启动生产者Confirm模式：

在这里插入图片描述启动消费者：

在这里插入图片描述启动生产者Return模式：

在这里插入图片描述消费者的控制台就会不停的打印：

在这里插入图片描述

异常发消息Demo演示

生产者Confirm模式：

在这里插入图片描述生产者Return模式：

在这里插入图片描述

四、消息在消费端限流

========================================================================

1.限流示例图

在这里插入图片描述

2.实现步骤

在rabbit:listener-container中配置 prefetch属性设置消费端一次拉取多少消息
消费端的确认模式一定为手动确认:acknowledge=“manual”

3.具体实现消费端限流代码

消费者

第一处修改：监听器：QosListener

package com.sky.springrabbitmqconsumer.listener;

import com.rabbitmq.client.Channel;

import org.springframework.amqp.core.Message;

import org.springframework.amqp.rabbit.listener.api.ChannelAwareMessageListener;

import org.springframework.stereotype.Component;

@Component

public class QosListener implements ChannelAwareMessageListener {

@Override

public void onMessage(Message message, Channel channel) throws Exception {

//获取到的消息

System.out.println(new String(message.getBody()));

Thread.sleep(3000);

//处理业务逻辑

//进行消息的签收，第二个参数：true表示之前没签收的都给他签收掉

channel.basicAck(message.getMessageProperties().getDeliveryTag(),true);

}

第二处修改：

在这里插入图片描述

<rabbit:listener-container connection-factory=“connectionFactory”

auto-declare=“true”

acknowledge=“manual”

prefetch=“2”>

<rabbit:listener ref=“qosListener” queue-names=“test_queue_confirm”></rabbit:listener>

生成者

批量发送消息测试方法

//批量发送消息，让消费者每次拉去指定的数量

@Test

public void testQos(){

for (int i = 0; i < 10; i++) {

// 发送消息

rabbitTemplate.convertAndSend(“test_exchange_confirm”, “confirm”, “message confirm…”);

}

4.具体实现消费端限流Demo演示

启动消费者

在这里插入图片描述

启动生产者

在这里插入图片描述

查看消费者控制台日志

在这里插入图片描述说明：每隔3秒打印一条消息

异常情况，消费未进行签收

在这里插入图片描述重启消费者和生产者发消息，这个时候会看到，原本发送的十条消息，实际只有二条消息打印在消费者的控制台上面，因为prefetch属性配置了2，所以一次性拉取了二条。

在这里插入图片描述 <hr style=" border:solid; width:100px; height:1px;" color=#000000 size=1">

五、TTL

===================================================================

1.业务场景

在这里插入图片描述比如我们在下订单的时候，如果超过30分钟未支付，就取消这个订单，把当前商品的库存加回去。

2.定义

TTL 全称 Time To Live（存活时间/过期时间），当消息到达存活时间后，还没有被消费，会被自动清除。RabbitMQ可以对消息设置过期时间，也可以对整个队列（Queue）设置过期时间。

3.实现步骤

设置队列过期时间使用参数：x-message-ttl，单位：ms(毫秒)，会对整个队列消息统一过期。
设置消息过期时间使用参数：expiration。单位：ms(毫秒)，当该消息在队列头部时（消费时），会单独判断这一消息是否过期。
如果两者都进行了设置，以时间短的为准。

4.通过RabbitMQ管理控制台页面实现Demo

1.创建消息

在这里插入图片描述

2.创建交换机

在这里插入图片描述

3.将交换机和消息绑定

在这里插入图片描述

4.发送消息

在这里插入图片描述超过5秒没有消费者消费，就自动失效了。

5.通过代码实现TTL

添加ttl队列

<rabbit:queue name=“test_queue_ttl” id=“test_queue_ttl”>

rabbit:queue-arguments

</rabbit:queue-arguments>

</rabbit:queue>

<rabbit:topic-exchange name=“test_exchange_ttl” >

rabbit:bindings

<rabbit:binding pattern=“ttl.#” queue=“test_queue_ttl”></rabbit:binding>

</rabbit:bindings>

</rabbit:topic-exchange>

发送消息测试方法

//ttl测试

@Test

public void testTtl(){

for (int i = 0; i < 10; i++) {

// 发送消息

rabbitTemplate.convertAndSend(“test_exchange_confirm”, “ttl.test”, “message confirm…”);

}

启动测试方法

在这里插入图片描述等待10秒

在这里插入图片描述

六、死信队列

====================================================================

1.定义

死信队列，英文缩写：DLX 。Dead Letter Exchange（死信交换机），当消息成为Dead message后，可以被重新发送到另一个交换机，这个交换机就是DLX。

最后

自我介绍一下，小编13年上海交大毕业，曾经在小公司待过，也去过华为、OPPO等大厂，18年进入阿里一直到现在。

深知大多数Java工程师，想要提升技能，往往是自己摸索成长，自己不成体系的自学效果低效漫长且无助。

因此收集整理了一份《2024年Java开发全套学习资料》，初衷也很简单，就是希望能够帮助到想自学提升又不知道该从何学起的朋友，同时减轻大家的负担。

既有适合小白学习的零基础资料，也有适合3年以上经验的小伙伴深入学习提升的进阶课程，基本涵盖了95%以上Java开发知识点，不论你是刚入门Android开发的新手，还是希望在技术上不断提升的资深开发者，这些资料都将为你打开新的学习之门！

如果你觉得这些内容对你有帮助，需要这份全套学习资料的朋友可以戳我获取！！

由于文件比较大，这里只是将部分目录截图出来，每个节点里面都包含大厂面经、学习笔记、源码讲义、实战项目、讲解视频，并且会持续更新！
:bindings>

<rabbit:binding pattern=“ttl.#” queue=“test_queue_ttl”></rabbit:binding>

</rabbit:bindings>

</rabbit:topic-exchange>

发送消息测试方法

//ttl测试

@Test

public void testTtl(){

for (int i = 0; i < 10; i++) {

// 发送消息

rabbitTemplate.convertAndSend(“test_exchange_confirm”, “ttl.test”, “message confirm…”);

}

启动测试方法

在这里插入图片描述等待10秒

在这里插入图片描述

六、死信队列

====================================================================

1.定义

死信队列，英文缩写：DLX 。Dead Letter Exchange（死信交换机），当消息成为Dead message后，可以被重新发送到另一个交换机，这个交换机就是DLX。

最后

自我介绍一下，小编13年上海交大毕业，曾经在小公司待过，也去过华为、OPPO等大厂，18年进入阿里一直到现在。

深知大多数Java工程师，想要提升技能，往往是自己摸索成长，自己不成体系的自学效果低效漫长且无助。

[外链图片转存中…(img-qpfvEGtd-1714944095599)]

[外链图片转存中…(img-IeCQJOef-1714944095600)]

[外链图片转存中…(img-b7MR8zDH-1714944095600)]

如果你觉得这些内容对你有帮助，需要这份全套学习资料的朋友可以戳我获取！！

由于文件比较大，这里只是将部分目录截图出来，每个节点里面都包含大厂面经、学习笔记、源码讲义、实战项目、讲解视频，并且会持续更新！

2401_84046545

关注

15
点赞
踩
13

收藏

觉得还不错? 一键收藏
0
评论
RabbitMQ：第二章：Spring整合RabbitMQ（简单模式，广播模式，路由模式，通配符模式，消息可靠性投递，防止消息丢失

TTL 全称 Time To Live（存活时间/过期时间），当消息到达存活时间后，还没有被消费，会被自动清除。RabbitMQ可以对消息设置过期时间，也可以对整个队列（Queue）设置过期时间。自我介绍一下，小编13年上海交大毕业，曾经在小公司待过，也去过华为、OPPO等大厂，18年进入阿里一直到现在。深知大多数Java工程师，想要提升技能，往往是自己摸索成长，自己不成体系的自学效果低效漫长且无助。
复制链接

扫一扫