RabbitMQ - 笔记

已于 2022-07-23 18:03:50 修改
阅读量251 收藏
点赞数
分类专栏： 微服务 文章标签： rabbitmq 分布式 java
于 2022-06-08 14:42:54 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/ZHHX666/article/details/125120610
版权

文章目录

1. MQ的基本概念

1.1 MQ概述

MQ (Message Queue) 消息队列，是在消息的传输过程中保存消息的容器。多用于分布式系统之间进行通信。

在这里插入图片描述

1.2 MQ的优势和劣势

优势：

  • 应用解耦
  • 异步提速
  • 削峰填谷

劣势：

  • 系统可用性降低
  • 系统复杂度提高
  • 一致性问题

1.3 MQ的优势

  1. 应用解耦

在这里插入图片描述
直接调用，如果新增子系统需要修改主系统的代码。耦合度高、不利于扩展。

在这里插入图片描述
通过MQ间接调用，系统间解耦，提高容错性和扩展维护性。

  1. 异步提速

在这里插入图片描述
在这里插入图片描述
异步调用提高了用户的体验，提高了系统的吞吐量(单位时间内处理请求的数目)。

  1. 削峰填谷
    在这里插入图片描述
    在这里插入图片描述

在这里插入图片描述
使用MQ后，高峰期来的请求会积压在MQ中，订单系统的请求高峰就被削掉了。这就是削峰
在高峰期过后的一段时间内，订单系统处理请求仍会维持在1000，直到积压的消息被消费完。这就是添谷
使用MQ能提高系统的稳定性。

1.4 MQ的劣势

在这里插入图片描述

  • 系统的可用性降低
    系统引入的外部依赖越多，系统稳定性越差。一旦MQ宕机，就会对业务造成影响。如何保证MQ的高可用？
  • 系统的复杂度提高
    MQ的加入大大增加了系统的复杂度，以前系统间是同步的远程调用，现在通过MQ进行异步调用。如何保证消息没有被重复消费？怎么处理消息丢失情况？怎么保证消息传递的顺序性？
  • 一致性问题
    A系统处理完业务，通过MQ交给B、C、D三个子系统。如果B、C成功完成，D执行失败。怎么保证数据处理的一致性？

1.5 MQ的使用条件

  1. 生产者不需要从消费者处获取反馈，直接调用的接口返回值应该为空，才可以异步调用。比如 A系统直接调用B系统，如果A系统不需要B系统返回信息那么就可以异步调用，使用MQ.
  2. 容许短暂的不一致性。
  3. 使用了MQ的效果大于管理MQ的成本。

1.6 常见的MQ产品

在这里插入图片描述

追求可用性：Kafka、 RocketMQ 、RabbitMQ

追求可靠性：RabbitMQ、RocketMQ

追求吞吐能力：RocketMQ、Kafka

追求消息低延迟：RabbitMQ、Kafka

2. RabbitMQ简介

2.1 AMQP协议

AMQP协议： Advanced Message Queuing Protocol 高级消息队列协议。是应用层的网络协议，为面向消息的中间件设计。基于此协议的 客户端与消息中间件可传递消息，不受客户端/中间件不同产品，不同开发语言等条件的限制。类比于HTTP。
在这里插入图片描述

2.2 RabbitMQ架构

在这里插入图片描述

  • Broker: 接受和分发消息的应用，RabbitMQ Server 就是Message Broker
  • Virtual Host: 处于多租户和安全因素设计的，把AMQP的基本组件划分到一个虚拟的分组中。当多用户使用同一个RabbitMQ Server提供的服务时，每个用户在自己的vhost中创建exchange/queue等。
  • Connection: publisher、Consumer和Broker之间的TCP连接。
  • Channel: 如果每次访问RabbitMQ Server都建立一个Connection，效率低开销大。Channel是在Connection内部建立的逻辑连接，多线程每个线程都创建单独的Channel进行通信，有channel id用于区分。Channel作为轻量级的Connection极大减少了操作系统建立TCP Connection的开销。
  • Exchange: 根据分发规则，匹配查询查询表中的routing key，分发消息到queue中。常用类型有: direct、topic、fanout。
  • Queue: 消息存放的地方，等待consumer取走。
  • Binding: exchange和queue之间的虚拟连接，binding中可以包含routing key。Binding信息被保存到exchange中的查询表中，用于message的分发依据。

2.3 RabbitMQ的工作模式

工作模式： 生产、消费 消息的一种工作方式。

官网工作模式https://www.rabbitmq.com/getstarted.html

  1. BasicQueue 基本消息队列
    在这里插入图片描述
  2. WorkQueue 工作消息队列
    在这里插入图片描述
  3. Fanout Exchange 广播
    在这里插入图片描述
  4. Direct Exchange 路由
    在这里插入图片描述
  5. Topic Exchange 主题
    在这里插入图片描述

2.4 JMS

  • JMS即Java 消息服务(JavaMessage Service) 应用程序接口，是一个Java平台中关于面向消息中间件的API.
  • JMS是JavaEE规范中的一种，类比JDBC。
  • 很多消息中间件都实现了JMS规范，例如ActiveMQ。 RabbitMQ没有实现，但开源社区有。

3. RabbitMQ 安装

使用Docker 安装

  1. 在线拉取或本地加载镜像
docker pull rabbitmq:3.8-management
  1. 创建RabbitMQ容器
docker run \
 -e RABBITMQ_DEFAULT_USER=root \   # 设置 用户名
 -e RABBITMQ_DEFAULT_PASS=root \   # 设置 密码
 -v mq-plugins:/plugins \          # 可能用到插件，挂载插件目录
 --name mq \                       # 容器名
 --hostname mq \                   # 主机名
 -p 15672:15672 \                  # rabbitmq的控制台网页端口
 -p 5672:5672 \                    # 消息传输的端口
 -d \                              # 后台运行
 rabbitmq:3.8-management           # 使用的镜像版本

4. RabbiMQ快速入门

4.1 “Hello World!” 模式

在这里插入图片描述

  • 生产者生产消息到队列，消费者从队列获取消息消费。
  • 使用默认的交换机。

步骤：

  1. 创建工程 (生产者、消费者)
    在这里插入图片描述
  2. 分别添加依赖
        <!--RabbitMQ-->
        <dependency>
            <groupId>com.rabbitmq</groupId>
            <artifactId>amqp-client</artifactId>
        </dependency>
  1. 生产者发送消息代码
		//RabbitMQ
        //创建连接工厂
        ConnectionFactory connectionFactory = new ConnectionFactory();
        //设置参数
        connectionFactory.setHost("192.168.205.131"); //RabbitMQ所在的服务器地址
        connectionFactory.setPort(5672); //RabbitMQ 通信端口
        connectionFactory.setVirtualHost("order"); //虚拟主机名,隔离多租户
        connectionFactory.setUsername("root");
        connectionFactory.setPassword("root");
        //创建连接
        Connection connection = connectionFactory.newConnection();
        //创建channel
        Channel channel = connection.createChannel();
        //创建queue,简单模式使用默认的交换机
        channel.queueDeclare("queue", true, false, false, null);
        //发送消息
        String body = "hello RabbitMQ";
        channel.basicPublish("", "queue", null, body.getBytes());
        //关闭资源
        channel.close();
        connection.close();
  1. 消费者消费消息代码
		//创建工厂
        ConnectionFactory connectionFactory = new ConnectionFactory();
        //设置参数
        connectionFactory.setHost("192.168.205.131");
        connectionFactory.setPort(5672);
        connectionFactory.setVirtualHost("order");
        connectionFactory.setUsername("root");
        connectionFactory.setPassword("root");
        //创建连接
        Connection connection = connectionFactory.newConnection();
        //创建channel
        Channel channel = connection.createChannel();
        
        //获取消息
        Consumer consumer = new DefaultConsumer(channel) {
            @Override
            public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
                System.out.println(consumerTag);
                System.out.println(envelope.getExchange());
                System.out.println(envelope.getRoutingKey());
                System.out.println(envelope.getDeliveryTag());
                System.out.println(properties);
                System.out.println(new String(body));
            }
        };
        //从queue队列获取消息
        channel.basicConsume("queue", consumer);

4.2 Work queues 模式

在这里插入图片描述

  • 在一个队列中有多个消费者，消费者之间是竞争的关系。
  • Work Queue对于任务过重或任务较多的情况下使用可以提高处理速度。

生产者代码

        //RabbitMQ
        //创建工厂
        ConnectionFactory connectionFactory = new ConnectionFactory();
        //设置参数
        connectionFactory.setHost("192.168.205.131");
        connectionFactory.setPort(5672);
        connectionFactory.setVirtualHost("order");
        connectionFactory.setUsername("itcast");
        connectionFactory.setPassword("123456");
        //创建连接
        Connection connection = connectionFactory.newConnection();
        //创建channel
        Channel channel = connection.createChannel();
        //创建queue
        channel.queueDeclare("work queue", true, false, false, null);
        //发送多条消息
        for (int i = 0; i < 10; i++) {
            String body = i + " hello RabbitMQ";
            channel.basicPublish("", "work queue", null, body.getBytes());
        }
        //关闭资源
        channel.close();
        connection.close();

消费者1代码

        //创建工厂
        ConnectionFactory connectionFactory = new ConnectionFactory();
        //设置参数
        connectionFactory.setHost("192.168.205.131");
        connectionFactory.setPort(5672);
        connectionFactory.setVirtualHost("order");
        connectionFactory.setUsername("itcast");
        connectionFactory.setPassword("123456");
        //创建连接
        Connection connection = connectionFactory.newConnection();
        //创建channel
        Channel channel = connection.createChannel();
        //获取消息
        Consumer consumer = new DefaultConsumer(channel) {
            @Override
            public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
                System.out.println(new String(body));
            }
        };
        channel.basicConsume("work queue", consumer);

消费者2代码
和消费者1代码一样

演示情况
在这里插入图片描述

4.3 Publish/Subscribe 模式

在这里插入图片描述

  • 交换机类型：FANOUT
  • 交换机将消息分发给所有绑定的队列。
  • 多个消费者从各自的队列获取消息。
    生产者代码
        //RabbitMQ
        //创建工厂
        ConnectionFactory connectionFactory = new ConnectionFactory();
        //设置参数
        connectionFactory.setHost("192.168.205.131");
        connectionFactory.setPort(5672);
        connectionFactory.setVirtualHost("order");
        connectionFactory.setUsername("itcast");
        connectionFactory.setPassword("123456");
        //创建连接
        Connection connection = connectionFactory.newConnection();
        //创建channel
        Channel channel = connection.createChannel();
        //创建交换机
        channel.exchangeDeclare("fanout exchange", BuiltinExchangeType.FANOUT, true, false, false, null);
        //创建两个queue
        channel.queueDeclare("fanout queue1", true, false, false, null);
        channel.queueDeclare("fanout queue2", true, false, false, null);
        //绑定交换机和队列,广播路由规则为""
        channel.queueBind("fanout queue1","fanout exchange","");
        channel.queueBind("fanout queue2","fanout exchange","");
        //发送消息
        String body = "hello RabbitMQ";
        channel.basicPublish("fanout exchange", "", null, body.getBytes());
        //关闭资源
        channel.close();
        connection.close();

消费者代码
和之前没有区别，各个消费者从各自的队列获取消息就行了。

        //创建工厂
        ConnectionFactory connectionFactory = new ConnectionFactory();
        //设置参数
        connectionFactory.setHost("192.168.205.131");
        connectionFactory.setPort(5672);
        connectionFactory.setVirtualHost("order");
        connectionFactory.setUsername("itcast");
        connectionFactory.setPassword("123456");
        //创建连接
        Connection connection = connectionFactory.newConnection();
        //创建channel
        Channel channel = connection.createChannel();
        //获取消息
        Consumer consumer = new DefaultConsumer(channel) {
            @Override
            public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
                System.out.println(new String(body));
            }
        };
        channel.basicConsume("fanout queue1", consumer);

4.4 Routing 模式

在这里插入图片描述

  • 交换机类型: DIRECT
  • 交换机在绑定队列时，需要指定 RoutingKey
  • 消息的发送方在向交换机发送消息时也需要指定消息的Routing Key.
  • Exchange在分发消息的时候，后根据Routing Key 分发给对应的队列。

生产者代码

在这里插入图片描述

4.5 Topics 模式

在这里插入图片描述

  • 交换机类型：Topic
  • RoutingKey 使用通配符。 * 一个单词，# 多个单词

生产者代码
在这里插入图片描述

5. Spring 整合RabbitMQ

引入依赖坐标

            <dependency>
                <groupId>org.springframework</groupId>
                <artifactId>spring-context</artifactId>
                <version>5.3.19</version>
            </dependency>
            <dependency>
                <groupId>org.springframework</groupId>
                <artifactId>spring-test</artifactId>
                <version>5.3.19</version>
            </dependency>
            <dependency>
                <groupId>org.springframework.amqp</groupId>
                <artifactId>spring-rabbit</artifactId>
                <version>2.2.15.RELEASE</version>
            </dependency>
            <dependency>
                <groupId>junit</groupId>
                <artifactId>junit</artifactId>
                <version>4.13</version>
                <scope>test</scope>
            </dependency>

生产者 Beans.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 https://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 https://www.springframework.org/schema/rabbit/spring-rabbit.xsd">

    <!--加载配置文件-->
    <context:property-placeholder location="classpath:rabbitmq.properties"/>

    <!--定义ConnectionFactory Bean-->
    <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="queue0" name="spring_queue_0" auto-declare="true"/>
    <rabbit:queue id="queue1" name="spring_queue_1" auto-declare="true"/>
    <rabbit:queue id="queue2" name="spring_fanout_queue_1" auto-declare="true"/>
    <rabbit:queue id="queue3" name="spring_fanout_queue_2" auto-declare="true"/>
    <rabbit:queue id="queue4" name="spring_direct_queue_1" auto-declare="true"/>
    <rabbit:queue id="queue5" name="spring_direct_queue_2" auto-declare="true"/>
    <rabbit:queue id="queue6" name="spring_topic_queue_1" auto-declare="true"/>
    <rabbit:queue id="queue7" name="spring_topic_queue_2" auto-declare="true"/>

    <!--定义fanout交换机并绑定队列-->
    <rabbit:fanout-exchange id="fanoutExchange" name="spring_fanout_exchange" auto-declare="true">
        <rabbit:bindings>
            <rabbit:binding queue="queue2"/>
            <rabbit:binding queue="queue3"/>
        </rabbit:bindings>
    </rabbit:fanout-exchange>

    <!--定义direct交换机并绑定队列-->
    <rabbit:direct-exchange id="directExchange" name="spring_direct_exchange">
        <rabbit:bindings>
            <rabbit:binding key="aaa" queue="queue4"/>
            <rabbit:binding key="bbb" queue="queue5"/>
        </rabbit:bindings>
    </rabbit:direct-exchange>

    <!--定义Topic交换机并绑定队列-->
    <rabbit:topic-exchange id="topicExchange" name="spring_topic_exchange" auto-declare="true">
        <rabbit:bindings>
            <rabbit:binding pattern="#.info" queue="queue6"/>
            <rabbit:binding pattern="#.error" queue="queue7"/>
        </rabbit:bindings>
    </rabbit:topic-exchange>

    <!---->
    <rabbit:template id="rabbitTemplate" connection-factory="connectionFactory"/>

</beans>

生产者测试代码

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;

/**
 * @author : ZHX
 * @date : 2022/6/5 17:40
 * @description:
 */
@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(locations = "classpath:beans.xml")
public class ProducerTest {

    @Autowired
    private RabbitTemplate rabbitTemplate;

    @Test
    public void testHelloWorld() {
        //简单模式工作模式 发送消息，使用默认交换机、routingkey使用queue名字，
        rabbitTemplate.convertAndSend("spring_queue_0", "hello world");
        //工作模式
        rabbitTemplate.convertAndSend("spring_queue_0", "hello world");
        rabbitTemplate.convertAndSend("spring_queue_1", "hello world");

        //发布订阅模式
        //fanout交换机
        rabbitTemplate.convertAndSend("spring_fanout_exchange", "", "hello hacker");
        //Direct交换机
        rabbitTemplate.convertAndSend("spring_direct_exchange", "aaa", "hello ");
        rabbitTemplate.convertAndSend("spring_direct_exchange", "aaa", "hello ");
        rabbitTemplate.convertAndSend("spring_direct_exchange", "bbb", "hello ");
        //topic交换机
        rabbitTemplate.convertAndSend("spring_topic_exchange", "a.info", "hello ");
        rabbitTemplate.convertAndSend("spring_topic_exchange", "b.info", "hello ");
        rabbitTemplate.convertAndSend("spring_topic_exchange", "a.error", "hello ");
    }
}

消费者 beans.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 https://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 https://www.springframework.org/schema/rabbit/spring-rabbit.xsd">

    <!--加载配置文件-->
    <context:property-placeholder location="classpath:rabbitmq.properties"/>

    <!--定义ConnectionFactory Bean-->
    <rabbit:connection-factory id="connectionFactory"
                               host="${rabbitmq.host}"
                               port="${rabbitmq.port}"
                               username="${rabbitmq.username}"
                               password="${rabbitmq.password}"
                               virtual-host="${rabbitmq.virtual-host}"/>

    <bean id="queue0Listener" class="rabbitmq.listener.queue0Listener"/>
    <bean id="queue1Listener" class="rabbitmq.listener.queue1Listener"/>
    <bean id="queue2Listener" class="rabbitmq.listener.queue2Listener"/>
    <bean id="queue3Listener" class="rabbitmq.listener.queue3Listener"/>
    <bean id="queue4Listener" class="rabbitmq.listener.queue4Listener"/>
    <bean id="queue5Listener" class="rabbitmq.listener.queue5Listener"/>
    <bean id="queue6Listener" class="rabbitmq.listener.queue6Listener"/>
    <bean id="queue7Listener" class="rabbitmq.listener.queue7Listener"/>

    <rabbit:listener-container connection-factory="connectionFactory" auto-declare="true">
        <rabbit:listener ref="queue0Listener" queue-names="spring_queue_0"/>
        <rabbit:listener ref="queue1Listener" queue-names="spring_queue_1"/>
        <rabbit:listener ref="queue2Listener" queue-names="spring_fanout_queue_1"/>
        <rabbit:listener ref="queue3Listener" queue-names="spring_fanout_queue_2"/>
        <rabbit:listener ref="queue4Listener" queue-names="spring_direct_queue_1"/>
        <rabbit:listener ref="queue5Listener" queue-names="spring_direct_queue_2"/>
        <rabbit:listener ref="queue6Listener" queue-names="spring_topic_queue_1"/>
        <rabbit:listener ref="queue7Listener" queue-names="spring_topic_queue_2"/>
    </rabbit:listener-container>


</beans>

消费者测试代码

package rabbitmq.listener;

import org.springframework.amqp.core.Message;
import org.springframework.amqp.core.MessageListener;

/**
 * @author : ZHX
 * @date : 2022/6/5 21:28
 * @description: 启动程序,监听器会区对应的queue中消费消息。
 */
public class queue0Listener implements MessageListener {

    @Override
    public void onMessage(Message message) {
        System.out.println(new String(message.getBody()));
    }
}

import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;

/**
 * @author : ZHX
 * @date : 2022/6/5 20:55
 * @description:
 */
@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(locations = "classpath:beans.xml")
public class ConsumerTest {

    @Test
    public void testConsumer(){
        while (true){

        }
    }

}

6. Spring Boot 整合RabbitMQ

导入依赖

        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-amqp</artifactId>
        </dependency>

生产者 application.yml配置文件

spring:
  rabbitmq:
    host: 192.168.205.132
    port: 5672
    virtual-host: order
    username: itcast
    password: 123456

配置exchange、queue、binding

package com.example.rabbitmq.config;

import org.springframework.amqp.core.*;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

/**
 * @author : ZHX
 * @date : 2022/6/5 23:04
 * @description:
 */
@Configuration
public class RabbitMQConfig {

    public static final String TOPIC_EXCHANGE_NAME = "spring_topic_exchange";
    public static final String QUEUE_NAME = "spring_topic_queue_1";

    //1.交换机
    @Bean("exchange")
    public Exchange getExchange() {
        return ExchangeBuilder.topicExchange(TOPIC_EXCHANGE_NAME).durable(true).build();
    }

    //2.队列
    @Bean("queue")
    public Queue getQueue() {
        return QueueBuilder.durable(QUEUE_NAME).build();
    }

    //3.绑定关系
    @Bean("binding")
    public Binding getBinding(Queue queue, Exchange exchange) {
        return BindingBuilder.bind(queue).to(exchange).with("#.info").noargs();
    }
}

生产者发送消息代码

@SpringBootTest
@RunWith(SpringRunner.class)
public class ProducerTest {
    @Autowired
    private RabbitTemplate rabbitTemplate;

    @Test
    public void testTopic(){
        rabbitTemplate.convertAndSend(RabbitMQConfig.TOPIC_EXCHANGE_NAME,"aa.info","hello");
    }
}

消费者消费消息代码

@Component
public class RabbitMQListener {
    @RabbitListener(queues = "spring_topic_queue_1")
    public void listenerQueue(Message message) {
        System.out.println(new String(message.getBody()));
    }
	
	//通过注解，创建交换机、队列、绑定关系
    @RabbitListener(bindings = {@QueueBinding(exchange = @Exchange(value = "topic.exchange",type = "topic"), value = @Queue("topic.queue"), key = "china.#")})
    public void receiveTopic(String msg) {
        System.out.println(msg);
    }
}

7. 消息转换器

Spring会把发送的消息序列化为字节发送给MQ, 接受消息时，将字节反序列化为Java对象。

JDK序列化 数据体积大、有安全漏洞、可读性差。

使用jackson序列化

  1. 依赖
        <dependency>
            <groupId>com.fasterxml.jackson.dataformat</groupId>
            <artifactId>jackson-dataformat-xml</artifactId>
        </dependency>
  1. 注入IOC容器
@Configuration
public class MessageConverterConfig {

    @Bean
    public MessageConverter messageConverter() {
        return new Jackson2JsonMessageConverter();
    }
}

8. RabbitMQ 高级特性

8.1 消息的可靠投递

RabbitMQ提供了两种模式，将消息是否成功发送告诉给发送方。

  • confirm 确认模式
  • return 退回模式

RabbitMQ消息投递的路径为：

producer->rabbingmq broker -> exchange-> queue->consumer

  • confirm模式: 消息从producer发到exchange，不管成功或失败都会执行ConfirmCallback函数 返回true/false。
  • return模式：消息从exchange到queue, 只有失败了才会执行returnCallback函数。

confirm模式

  1. 开启confirm模式
    在这里插入图片描述
  2. 设置ConfirmCallback函数
    在这里插入图片描述

return模式

  1. 开启 return模式
    在这里插入图片描述
  2. 设置函数
    在这里插入图片描述

8.2 Consumer ACK

acknowledge, 表示消费者收到消息后的确认方式。有三种：

  • 自动确认：none
  • 手动确认: manual
  • 根据异常情况确认：auto

自动确认模式：是指消息一旦被消费者接收到，就自动确认收到，并将相应的message从queue删除，但实际业务中很可能消息接收到，处理出现异常，那么该消息就丢失了。
手动确认模式：业务成功处理后调用channer.basicACK()，手动确认。如果业务处理失败，则调用channel.basicNack(方法，消息重回队列。

  1. 开启手动模式
    在这里插入图片描述
  2. 消费者代码
    在这里插入图片描述

8.3 消费端限流

  • 先将消费端的确认模式为手动模式
  • 设置perfetch ：消费端每次拉取的消息数。

配置
在这里插入图片描述
代码
在这里插入图片描述

8.4 TTL

  • TTL：Time To Live 存活时间。
  • 当消息到达存活时间后，还没被消费会被自动删除。
  • RabbitMQ可以对消息设置过期时间，也可以对整个队列设置过期时间。

设置队列的TTL
在这里插入图片描述
设置单个消息的TTL
在这里插入图片描述

8.5 DLX

  • Dead Letter Exchange 死信交换机
  • 当消息超时成为死信后，可以重新被发送到DLX，

在这里插入图片描述
消息称为死信的三种情况

  1. 队列消息长度达到限制。
  2. 消费者拒收消息，basicNick/basicReject,并且不把消息重新放入原目标队列 requeue=false.
  3. 原消息队列存在过期设置，消息到达过期时间未被消费。

给队列绑定死信交换机

在这里插入图片描述

8.6 延迟队列

RabbitMQ 没有定时功能，但可以通过 TTL + DXL 实现。

9. 参考资料

https://www.bilibili.com/video/BV15k4y1k7Ep?p=22

https://www.bilibili.com/video/BV1cb4y1o7zz?p=2

https://www.rabbitmq.com/

从零开始的JAVA世界
关注
专栏目录
RabbitMQ-笔记02
dark
04-10 157
黑马程序员MQ 学习笔记 https://www.rabbitmq.com/ https://www.rabbitmq.com/getstarted.html RabbitMQ高级特性 消息可靠性投递 Consumer ACK TTL 死信队列 延迟队列 日志与监控 消息可靠性分析与追踪 管理 RabbitMQ应用问题 消息可靠性保障 消息幂等性处理 RabbitMQ集群搭建 高可用集群搭建 ...
rabbitmq性能测试工具rabbitmq-perf-test（官网阅读笔记）
zhuangzi123456的博客
11-08 7575
Java Tools 翻译：limuitech 时间：201811月 官网连接：http://www.rabbitmq.com/java-tools.html 以下内容为官网资料，非全部翻译，只是自己在阅读的时候，随手在关键部分加了自己的翻译。 翻译英文技术文档的难点除了语言之外，更重要的是对语言内容的理解，否则翻译出来也会觉得别扭。翻译能力有限，如果有问题，请大家指正；   Thi...
RabbitMq-笔记
weixin_45653314的博客
03-23 2668
rabbitMq 基础知识
RabbitMQ学习笔记：节点名称详解、rabbitmq-server、及rabbitmq-env.conf
m0_67391121的博客
08-23 416
如果系统使用完全限定名（FQDNS Fully Qualified Domain Name）作为主机名，RabbitMQ节点和CLI工具必须配置为使用所谓的长节点名称，对于服务器节点，这是通过将RABBITMQ_USE_LONGNAME环境变量设置为true来完成的。在一个集群中节点名称必须是唯一的。RabbitMQ节点由节点名称标识，节点名称由两部分组成，前缀（通常是rabbit）和主机名，例如：rabbit@rabbit1是一个节点名包含前缀rabbit和主机名rabbit1。
RabbitMQ-笔记01
dark
04-10 378
黑马程序员MQ 学习笔记 https://www.rabbitmq.com/ https://www.rabbitmq.com/getstarted.html 1.MQ的基本概念 1.1MQ概述 MQ全称Message Queue(消息队列),是在消息的传输过程中保存消息的容器。多用于分布式系统之间进行通信。 1.2MQ优势和劣势 1.3MQ的优势 1.应用解耦 before 系统容错性差: 当库存系统不可用，导致整个订单系统不可用。 可维护性差: 新增x系统，需要修改订单系统。 after: .
RabbitMQ-学习笔记
weixin_47135811的博客
03-11 3259
rabbitMq学习笔记
RabbitMQ学习笔记：rabbitmq-server -detached Warning: PID file not written； -detached was passed
smart_an的专栏
07-08 343
作者简介：大家好，我是哥，前中兴通讯、美团架构师，现某互联网公司联系qq：184480602，加我进群，大家一起学习，一起进步，一起对抗互联网寒冬学习必须往深处挖，挖的越深，基础越扎实！
RabbitMQ-笔记
09-18
Rabbitmq笔记
安装rabbitmq-server操作笔记
热门推荐
沉底的石头
06-25 2万+
操作步骤没有错，在不同的系统下安装可能会有不同的错，需要具体问题具体对待了。 1.erlang安装 在openSUSE下，安装erlang。 下载地址：http://www.erlang.org/download.html linux-bnnq:/opt # wget http://www.erlang.org/download/otp_src_R15B.tar.gz cd otp_s
RabbitMQ笔记
baidu_39600789的博客
08-26 209
安装 此软件 windows 环境下 第一遍安装rabbitma-server-3.7.17 必须先删除 APP_DATA 第一遍安装时后删除需要重启下 不然会提示 此管理员删除不掉 因为这个耗费了两个多小时时间..... 在rabbitmq 中运行 rabbitmq-plugins.bat enable rabbitmq_management 第二步授...
rabbitmq-c++(SimpleAmqpClient) 笔记代码一
大葱敏的博客
07-30 1万+
前记之前也写过rabbitmq的笔记（链接点此），但当时是参见官网的java版本（链接点此）所写，更像是译文，而后在实际过程中，要用到C++来使用消息队列，然而官网却没有C++相关的教程，经过自己的摸索，我把官网的教程代码翻译成C++版本，并做了些注释，希望能对有需要的人有帮助。需要安装使用C++来写rabbitmq代码时，我使用的是SimpleAmqpClient，需要安装的还挺多，但其githu
RabbitMQ 存储机制
qingyuwp的博客
11-01 1305
在将消息从 Delta 转移到 Q3 的过程中，是按照索引分段读取的，首先读取某一段，然后判断读取的消息的个数与 Delta 中消息的个数是否相等，如果相等，则可以判定此时 Delta 中已无消息，则直接将 Q2 和刚读取到的消息一并放入到 Q3 中；即使是持久化的消息，在被写入磁盘的同时也会在内存中驻留一份备份。惰性队列会将接收到的消息直接存入文件系统中，而不管是持久化的或者是非持久化的，这样可以减少了内存的消耗，但是会增加 I/O 的使用，如果消息是持久化的，那么这样的 I/O 操作不可避免，
【RabbitMQ】01-RabbitMQ
Infinity的博客
11-03 461
MQ可以有更好的并发性。
什么是RabbitMQ
QQ1817117243的博客
10-31 672
RabbitMQ 是一个开源的消息代理软件，旨在支持多种消息协议。RabbitMQ 允许应用程序和服务之间进行异步通信，能够在不同的应用和系统之间传递消息，从而实现解耦。同时，RabbitMQ 也支持消息持久化，将消息保存在磁盘上，以便在重启时恢复。：RabbitMQ 提供多种语言的客户端库，支持 Java、Python、Ruby、Go 等多种编程语言，方便开发者与 RabbitMQ 进行交互。：RabbitMQ 可以根据需求进行水平扩展，使之适应更大规模的消息处理需求。
RabbitMQ 七种工作模式介绍
chaodddddd的博客
11-02 1724
RabbitMQ 共提供了7种⼯作模式供我们进⾏消息传递,接下来一一介绍它的实现与目的
【RabbitMQ】04-发送者可靠性
Infinity的博客
11-07 166
每个RabbitTemplate只能配置一个ReturnCallback，因此我们可以在配置类中统一设置。@Slf4j@Overridelog.error("触发return callback,");});由于每个消息发送时的处理逻辑不一定相同，因此ConfirmCallback需要在每次发消息时定义。@Test// 1.创建CorrelationData// 2.给Future添加ConfirmCallback@Override。
centos docker 安装 rabbitmq
liyongbing1122的博客
11-07 495
如果您之前安装过Docker，可能需要先卸载旧版本。安装一些必要的工具，如yum-utils阿里云清华大学源。
RabbitMQ 高级特性——消息分发
最新发布
不能再留遗憾了的博客
11-07 360
RabbitMQ消息分发
win11安装最新rabbitmq
qq_20376949的博客
11-03 315
因为RabbitMQ默认启动的，当键入启动命令时，会出现如下情况，直接关闭RabbitMQ服务，再启动就行。RabbitMQ后台访问地址 http://localhost:15672。身份运行cmd，，执行下面命令启动RabbitMQ。关闭后再重新执行启动命令即可。默认的用户名：guest。默认的密码为：guest。关闭RabbitMQ。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值