黑马RabbitMQ高级学习笔记

最新推荐文章于 2025-04-09 22:01:02 发布

pan_h1995

最新推荐文章于 2025-04-09 22:01:02 发布

阅读量1.9k

点赞数 4

分类专栏：笔记

本文链接：https://blog.youkuaiyun.com/pan_h1995/article/details/115348252

版权

RabbitMQ高级内容介绍

RabbitMQ高级特性

消息可靠性投递
Consumer ACK
消费端限流
TTL
死信队列
延迟队列
日志与监控
消息可靠性分析与追踪
管理

RabbitMQ应用问题

消息可靠请保障
消息幂等性处理

RabbitMQ集群搭建

RabbitMQ高可用集群

1、RabbitMQ高级特性

1.1、消息的可靠投递

1、定义

在使用RabbitMQ的时候，作为消息发送方希望杜绝任何消息丢失或投递失败场景。RabbitMQ为我们提供了两种方式用来控制消息的投递可靠性模式。

confirm 确认模式
return退回模式

rabbitMQ整个消息投递的路径为：
pruducer —>rabbitMQ broker ---->exchange------>queue ----> consumer

消息从producer到exchange则会返回一个confirmCallback。
消息从exchange–>queue投递失败则会返回一个returnCallback。
我们将利用这两个callback控制消息的可靠性投递。

2、生产者端代码实现

1）新建spring工程rabbitmq-producer-spring

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">
    <modelVersion>4.0.0</modelVersion>

    <groupId>org.example</groupId>
    <artifactId>rabbitmq-producer-spring</artifactId>
    <version>1.0-SNAPSHOT</version>

    <properties>
        <maven.compiler.source>8</maven.compiler.source>
        <maven.compiler.target>8</maven.compiler.target>
    </properties>

    <dependencies>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-context</artifactId>
            <version>5.1.7.RELEASE</version>
        </dependency>

        <dependency>
            <groupId>org.springframework.amqp</groupId>
            <artifactId>spring-rabbit</artifactId>
            <version>2.1.8.RELEASE</version>
        </dependency>

        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.12</version>
        </dependency>

        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-test</artifactId>
            <version>5.1.7.RELEASE</version>
        </dependency>
    </dependencies>

    <build>
        <plugins>
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-compiler-plugin</artifactId>
                <version>3.8.0</version>
                <configuration>
                    <source>1.8</source>
                    <target>1.8</target>
                </configuration>
            </plugin>
        </plugins>
    </build>
</project>

3）配置rabbitmq相关信息

rabbitmq.properties


rabbitmq.host=172.16.98.133
rabbitmq.port=5672
rabbitmq.username=heima
rabbitmq.password=heima
rabbitmq.virtual-host=/itcast

4）spring配置文件，定义队列和交换机

spring-rabbitmq-producer.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"/>

    <!-- 定义rabbitmq connectionFactory -->
    <rabbit:connection-factory id="connectionFactory" host="${rabbitmq.host}"
                               port="${rabbitmq.port}"
                               username="${rabbitmq.username}"
                               password="${rabbitmq.password}"
                               virtual-host="${rabbitmq.virtual-host}"
                               publisher-confirms="true"
                               publisher-returns="true"
    />
    <!--定义管理交换机、队列-->
    <rabbit:admin connection-factory="connectionFactory" />

    <!--定义rabbitMqTemplate对象操作可以在代码中方便发送消息-->
    <rabbit:template id="rabbitTemplate" connection-factory="connectionFactory"/>

    <!--消息可靠性投递生产端-->
    <rabbit:queue id="test_queue_confirm" name="queue_confirm_test"></rabbit:queue>
    <rabbit:direct-exchange name="exchange_confirm_test">
        <rabbit:bindings>
            <rabbit:binding queue="queue_confirm_test" key="confirm"></rabbit:binding>
        </rabbit:bindings>
    </rabbit:direct-exchange>


</beans>

5）编写测试类进行测试

ProducerTest.java



import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.amqp.core.Message;
import org.springframework.amqp.rabbit.connection.CorrelationData;
import org.springframework.amqp.rabbit.core.RabbitTemplate;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.Configuration;
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;

    /*
    确认模式：
        步骤：
            1、确认模式开启：ConnectionFactory中开启，publisher-confirms="true"
            2、在rabbitTamplate中定义ConfirmCallback回调函数

    */

    @Test
    public void testConfirm(){
   
        //2、定义回调
        rabbitTemplate.setConfirmCallback(new RabbitTemplate.ConfirmCallback() {
   
            /***
             *
             * @param correlationData 相关配置信息，在convertAncSend中参数配置信息
             * @param ack exchange交换机，是否成功收到了消息。true成功，false代表失败
             * @param cause 失败原因
             */
            @Override
            public void confirm(CorrelationData correlationData, boolean ack, String cause) {
   
                System.out.println("confirm方法被执行了...");
                if(ack){
   
                    //接收成功
                    System.out.println("接收成功："+cause);
                }else{
   
                    //接收失败
                    System.out.println("接收失败消息："+cause);
                    //做一些处理，让消息再次发送
                }
            }
        });

        //3、发送消息
        rabbitTemplate.convertAndSend("exchange_confirm_test111","confirm","message confirm...");
    }


    /**
     * 回退模式：当消息发送给exchange后，exchange路由到Queue失败时，才会执行returnCallback
     *  步骤：
     *      1、开启回退模式：也是在ConnectionFactory中开启，publisher-returns="true"
     *      2、设置ReturnCallback
     *      3、设置Exchange处理消息的模式：
     *          ①如果消息没有路由到Queue，则丢弃消息（默认）
     *          ②如果消息没有路由到Queue，返回给消息发送方ReturnCallback
     *
     */
    @Test
    public void testReturn(){
   
        //设置交换机处理失败消息的模式
        //不设置该项的话，默认将消息丢弃，也不会触发回调
        rabbitTemplate.setMandatory(true);

        //设置ReturnCallback
        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);
                System.out.println(replyCode);
                System.out.println(replyText);
                System.out.println(exchange);
                System.out.println(routingKey);
            }
        });

        //3、发送消息
        rabbitTemplate.convertAndSend("exchange_confirm_test","confirm111","message confirm...");
    }
}

6）测试结果

确认模式测试结果：提示没有该交换机
退回模式测试结果：
注：当没有设置交换机处理失败消息的模式，为默认模式，会将消息丢弃，也不会进行调用回调函数。

小结：

设置ConnectionFactory的publisher-confirms=“true” 开启确认模式。

使用rabbitTemplate.setConfirmCallback设置回调函数。当消息发送到exchange后回调confirm方法。在方法中判断ack，如果为true，则发送成功，如果为false，则发送失败，需要处理。

设置ConnectionFactory的publisher-returns=“true” 开启回退模式。

使用rabbitTemplate.setReturnCallback设置退回函数。当消息从exchange路由到queue失败后，如果设置rabbitTemplate.setMandatory(true)参数，则会将消息退回给producer。并执行回调函数returnedMessage。

在RabbitMQ中也提供了事务机制，但是性能较差，此处不作讲解。
使用channel下列方法，完成事务控制
- txSelect()，用于将当前channel设置成transaction模式
- txCommit()，用于提交事务
- txRollback()，用于回滚事务

1.2、Consumer Ack

1、定义

ack指Acknowledge，确认。表示消费端收到消息后的确认方式。
有三种确认方式：

自动确认：acknowledge = "none"
手动确认：acknowledge = "manual"
根据异常情况确认：acknowledge = "auto"，（这种方式使用麻烦，不作讲解）

其中自动确认是指，当消息一旦被Consumer接收到，则自动确认收到，并将相应message从RabbitMQ的消息缓存中移除。
但在实际业务处理中，很可能消息接收到，业务处理出现异常，那么该消息就会丢失。
如果设置了手动确认方式，则需要在业务处理成功后，调用channel.basicAck()，手动签收，如果出现异常，则调用channel.basicNack()方法，让其自动重新发送消息。

2、消费端代码实现

1）新建`rabbitmq-consumer-spring`工程

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="