spring-boot对rabbitMQ的操作

水痕012023-12-02 18:58

一、安装rabbitMQ

  • 1、直接使用docker拉取镜像

    properties 复制代码 
    docker pull rabbitmq:3.8

  • 2、启动容器

    properties 复制代码 
    docker run \
 -e RABBITMQ_DEFAULT_USER=admin \
 -e RABBITMQ_DEFAULT_PASS=123456 \
 -v mq-plugins:/plugins \
 --name rabbit01 \
 --hostname rabbit01 --restart=always \
 -p 15672:15672 \
 -p 5672:5672 \
 -d \
 rabbitmq:3.8

  • 3、关于端口的介绍

    • 15672的给浏览器控制台使用的
    • 5672是给程序调用的

  • 4、进入到rabbit01容器中

    properties 复制代码 
    docker exec -it rabbit01 /bin/bash

  • 5、开启可视化界面操作

    properties 复制代码 
    rabbitmq-plugins enable rabbitmq_management

  • 6、客户端直接访问xx:15672

  • 7、或者直接用别人搞好的镜像

    properties 复制代码 
    docker run \
 -e RABBITMQ_DEFAULT_USER=admin \
 -e RABBITMQ_DEFAULT_PASS=123456 \
 -v mq-plugins:/plugins \
 --name rabbit02 \
 --hostname rabbit02 --restart=always \
 -p 15672:15672 \
 -p 5672:5672 \
 -d \
 rabbitmq:3.8-management

二、在spring-boot中整合

  • 1、引入依赖包

    xml 复制代码 
    <!--   spring boot和junit整合单元测试包     -->
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-test</artifactId>
    <scope>test</scope>
</dependency>
<!--   rabbitmq的包引入     -->
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-amqp</artifactId>
</dependency>

  • 2、在配置文件中引入配置

    properties 复制代码 
    server.port=8000
spring.rabbitmq.host=localhost
spring.rabbitmq.port=5672
spring.rabbitmq.username=admin
spring.rabbitmq.password=123456
spring.rabbitmq.virtual-host=/

三、简单模式

  • 1、简单模式就是一个生产者一个消费者

  • 2、生产者代码,运行下面的代码,查看可视化界面,并不存在消息,原因是因为需要手动创建simple_queue这个队列

    java 复制代码 
    @SpringBootTest(classes = ProducerApplication.class)
public class ProducerTest01 {
    @Autowired
    private RabbitTemplate rabbitTemplate;

    @Test
    public void test01() {
        /**
         * 第一个参数:表示队列的名称
         * 第二个参数:表示要发送的数据
         */
        rabbitTemplate.convertAndSend("simple_queue", "hello world");
    }
}

  • 3、运行后查看可视化界面

  • 4、定义一个消费者来消费消息

    java 复制代码 
    package com.example.listener01;

import org.springframework.amqp.core.Message;
import org.springframework.amqp.rabbit.annotation.RabbitListener;
import org.springframework.stereotype.Component;

@Component
public class ConsumerListener01 {
    @RabbitListener(queues = "simple_queue")
    public void listener01(Message message) {
        String msg = new String(message.getBody());
        System.out.println("接收到的消息:" + msg);
    }
}

四、work工作模式

  • 1、简单的来理解，就是在上面简单模式下增加几个消费者，如同搬砖一样的，一个搬运工搬不过来，多叫几个人来干活的性质，避免消息堆积

  • 2、同样的要先手动创建队列,在生产者端循环发送数据

    java 复制代码 
    @Test
public void test02() {
    for (int i = 0; i < 10; i++) {
        rabbitTemplate.convertAndSend("work_queue", "hello world");
    }
}

  • 3、定义2个消费者来一起消费消息

    java 复制代码 
    @Component
public class ConsumerListener01 {
    @RabbitListener(queues = "work_queue")
    public void listener01(Message message) {
        String msg = new String(message.getBody());
        System.out.println("消费者1接收到的消息:" + msg);
    }
}

  • 4、先运行消费者,然后运行生产者

五、发布模式

  • 1、发布模式是指发送一个消息，希望在几个消费者那边都能接收到,上面的工作模式，一条消息被一个消费者消费了，另外一个消费者就接收不到消息，在一些场景需要给每个消费者就要用发布者模式
  • 2、根据交换机的模式可以分为以下几种
    • Fanout，广播模式,将消息全部交给所有与之绑定的队列，这里的router key为空字符串
    • Direct，将消息指定到对应的routing key上
    • Topic，通配符模式，这里的routing key根据规则匹配
      • *表示一个单词
      • #表示多个单词
一、Fanout模式

  • 1、使用配置文件的方式创建交换机和队列,并且将他们绑定在一起

    java 复制代码 
    package com.example.config;

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

@Configuration
public class RabbitFanoutExchangeConfiguration {
    // 交换机
    @Bean
    public Exchange fanoutExchange() {
        return ExchangeBuilder.fanoutExchange("fanout_exchange").durable(true).build();
    }

    // 创建一个队列
    @Bean
    public Queue fanoutQueue1() {
        return QueueBuilder.durable("fanout_queue1").build();
    }

    // 创建一个队列
    @Bean
    public Queue fanoutQueue2() {
        return QueueBuilder.durable("fanout_queue2").build();
    }

    // 队列和交换机绑定
    @Bean
    public Binding fanoutExchangeQueue01() {
        // with表示路由key
        return BindingBuilder.bind(fanoutQueue1()).to(fanoutExchange()).with("").noargs();
    }

    @Bean
    public Binding fanoutExchangeQueue02() {
        // with表示路由key
        return BindingBuilder.bind(fanoutQueue2()).to(fanoutExchange()).with("").noargs();
    }
}

  • 2、生产者发送消息

    java 复制代码 
    @Test
public void test03() {
    rabbitTemplate.convertAndSend("fanout_exchange", "", "hello world");
}

  • 3、查看可视化界面，会自动创建一个交换机和两个路由key

  • 4、定义消费者

    java 复制代码 
    @Component
public class ConsumerListener01 {
    @RabbitListener(queues = "fanout_queue1")
    public void listener01(Message message) {
        String msg = new String(message.getBody());
        System.out.println("消费者1接收到的消息:" + msg);
    }
}

  • 5、这时候会发现，几个消费者都会同时输出

二、Direct模式
  • 1、其实就是在上面的模式上修改创建交换机的类型,及指定类型，别的都保持不变
三、Topic模式
  • 1、在定义路由key的时候使用*或者#来表示

六、直接在监听上使用注解的方式来创建交换机等

  • 1、正常创建交换机和队列的方式有三种方式

    • 直接在可视化界面手动创建
    • 使用java api方式一个一个创建需要先创建交换机、队列，并且让队列和交换机绑定在一起
    • 直接使用注解的方式来实现

  • 2、使用注解的方式直接来创建交换机和队列

    java 复制代码 
    package com.example.listener04;

import org.springframework.amqp.core.ExchangeTypes;
import org.springframework.amqp.core.Message;
import org.springframework.amqp.rabbit.annotation.Exchange;
import org.springframework.amqp.rabbit.annotation.Queue;
import org.springframework.amqp.rabbit.annotation.QueueBinding;
import org.springframework.amqp.rabbit.annotation.RabbitListener;
import org.springframework.stereotype.Component;

@Component
public class ConsumerListener01 {
    @RabbitListener(bindings = @QueueBinding(
            value = @Queue(value = "queue_01", durable = "true"),
            exchange = @Exchange(value = "direct_rabbit_exchange", type = ExchangeTypes.DIRECT),
            key = {"info", "error"}
    ))
    public void listener01(Message message) {
        String msg = new String(message.getBody());
        System.out.println("消费者1接收到的消息:" + msg);
    }
}

  • 3、运行后查看rabbitmq可视化界面

  • 4、定义发送消息的方法

    java 复制代码 
    public void test04() {
    rabbitTemplate.convertAndSend("direct_rabbit_exchange","error","hello world");
}

七、消息丢失

  • 1、消息丢失主要存在的场景
    • 生产者投递消息的时候就丢失，比如写错了交换机的名字
    • 交换机到队列丢失，比如写错了队列名称
    • 队列到接收者数据丢失
一、开启生产者确认机制

  • 1、开启生产者确认机制

    properties 复制代码 
    server.port=9000
spring.rabbitmq.host=123.56.103.229
spring.rabbitmq.port=5672
spring.rabbitmq.username=admin
spring.rabbitmq.password=123456
spring.rabbitmq.virtual-host=/
# 开启生产者确认机制
spring.rabbitmq.publisher-confirm-type=correlated

  • 2、重写RabbitTemplate,只要我们在容器中有一个RabbitTemplate，那么spring boot就不会用对RabbitTemplate自动化配置

    java 复制代码 
    package com.example.config;

import org.springframework.amqp.rabbit.connection.ConnectionFactory;
import org.springframework.amqp.rabbit.connection.CorrelationData;
import org.springframework.amqp.rabbit.core.RabbitTemplate;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

@Configuration
public class RabbitmqConfiguration {
    /**
     * ConnectionFactory 由于Spring Boot根据连接的配置信息实现自动化配置,在spring容器中是直接存在ConnectionFactory对象
     */
    @Bean
    public RabbitTemplate rabbitTemplate(ConnectionFactory connectionFactory) {
        RabbitTemplate rabbitTemplate = new RabbitTemplate(connectionFactory);
        rabbitTemplate.setConfirmCallback(new RabbitTemplate.ConfirmCallback(){

            @Override
            public void confirm(CorrelationData correlationData, boolean ack, String s) {
                if (ack) {
                    System.out.println("消息正常投递到交换机中");
                } else {
                    System.out.println("消息投递到交换机失败:"+s);
                }
            }
        });
        return rabbitTemplate;
    }

}

  • 3、发送消息的时候故意写错交换机的名字

    java 复制代码 
    @Test
public void test04() throws InterruptedException {
    rabbitTemplate.convertAndSend("direct_rabbit_exchange_xx","error","hello world");
    Thread.sleep(2000);
}

  • 4、处理消息投送失败的方式

    • 使用数据库表来保存发送失败的消息，主要字段有:消息唯一id、消息内容、重试次数、当前消息发送状态
    • 在消息投送失败的时候重试几次
    • 定时任务将失败的批量再次发送

  • 5、在发送消息的时候传递当前唯一的识别id，这里使用uuid

    java 复制代码 
    @Test
public void test04() throws InterruptedException {
    String msgUuid = UUID.randomUUID().toString().replace("-", "");
    CorrelationData correlationData = new CorrelationData(msgUuid);
    rabbitTemplate.convertAndSend("direct_rabbit_exchange", "error", "hello world", correlationData);
    Thread.sleep(2000);
}

  • 6、获取当前消息的唯一识别

    java 复制代码 
    @Configuration
public class RabbitmqConfiguration {
    /**
     * ConnectionFactory 由于Spring Boot根据连接的配置信息实现自动化配置,在spring容器中是直接存在ConnectionFactory对象
     */
    @Bean
    public RabbitTemplate rabbitTemplate(ConnectionFactory connectionFactory) {
        RabbitTemplate rabbitTemplate = new RabbitTemplate(connectionFactory);
        rabbitTemplate.setConfirmCallback(new RabbitTemplate.ConfirmCallback(){

            @Override
            public void confirm(CorrelationData correlationData, boolean ack, String s) {
                if (ack) {
                    System.out.println("消息正常投递到交换机中");
                } else {
                    String mesId = correlationData.getId();
                    System.out.println(mesId);
                    System.out.println("消息投递到交换机失败:"+s);
                }
            }
        });
        return rabbitTemplate;
    }
}
二、交换机到队列的时候出现问题

  • 1、当队列名称写错了，或者不存在的时候会出现这个情况

  • 2、开启生产者回调机制

    properties 复制代码 
    server.port=9000
spring.rabbitmq.host=123.56.103.229
spring.rabbitmq.port=5672
spring.rabbitmq.username=admin
spring.rabbitmq.password=123456
spring.rabbitmq.virtual-host=/
# 开启生产者确认机制
spring.rabbitmq.publisher-confirm-type=correlated
# 开启生产者回调机制
spring.rabbitmq.publisher-returns=true

  • 3、绑定回退函数

    java 复制代码 
    package com.example.config;

import org.springframework.amqp.core.ReturnedMessage;
import org.springframework.amqp.rabbit.connection.ConnectionFactory;
import org.springframework.amqp.rabbit.connection.CorrelationData;
import org.springframework.amqp.rabbit.core.RabbitTemplate;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

@Configuration
public class RabbitmqConfiguration {
    /**
     * ConnectionFactory 由于Spring Boot根据连接的配置信息实现自动化配置,在spring容器中是直接存在ConnectionFactory对象
     */
    @Bean
    public RabbitTemplate rabbitTemplate(ConnectionFactory connectionFactory) {
        RabbitTemplate rabbitTemplate = new RabbitTemplate(connectionFactory);
        ...
        // 绑定回退机制的回调函数
        rabbitTemplate.setMandatory(true);
        rabbitTemplate.setReturnsCallback(new RabbitTemplate.ReturnsCallback() {

            @Override
            public void returnedMessage(ReturnedMessage returnedMessage) {
                System.out.println(returnedMessage.getMessage());
                System.out.println(returnedMessage.getReplyCode());
                System.out.println(returnedMessage.getReplyText());
                System.out.println(returnedMessage.getExchange());
                System.out.println(returnedMessage.getRoutingKey());
            }
        });
        return rabbitTemplate;
    }
}
三、消息持久化

  • 1、rabbitmq默认是在内存中存储,当服务宕机后数据直接会丢失，消息在spring boot中持久化是因为框架帮你处理了,修改消息是否持久化可以参考下面

    java 复制代码 
    @Test
public void test04() throws InterruptedException {
    String msgUuid = UUID.randomUUID().toString().replace("-", "");
    CorrelationData correlationData = new CorrelationData(msgUuid);
    MessagePostProcessor messagePostProcessor = new MessagePostProcessor() {

        @Override
        public Message postProcessMessage(Message message) throws AmqpException {
            MessageProperties messageProperties = message.getMessageProperties(); // 获取到消息属性对象
            messageProperties.setDeliveryMode(MessageDeliveryMode.NON_PERSISTENT); // 设置消息不缓存
            return message;
        }
    };
    rabbitTemplate.convertAndSend("direct_rabbit_exchange", "error", "hello world",messagePostProcessor, correlationData);
    Thread.sleep(2000);
}
四、消费者消费消息不丢失

  • 1、在spring boot中消费者应答模式主要有以下几种

    • none自动应答，消费者获取到消息以后直接给rabbitmq返回ack
    • auto(默认模式),由spring boot框架根据业务执行特点决定给rabbitmq是ack还是uack,业务执行正常完成后返回ack,业务执行中出现异常的时候返回uack
    • manual手动应答模式,由程序员自己根据业务执行特点给rabbitmq返回对应的ack还是uack

  • 2、配置应答模式

    properties 复制代码 
    server.port=8000
spring.rabbitmq.host=123.56.103.229
spring.rabbitmq.port=5672
spring.rabbitmq.username=admin
spring.rabbitmq.password=123456
spring.rabbitmq.virtual-host=/
# 配置应答模式
spring.rabbitmq.listener.simple.acknowledge-mode=auto
八、消费限流

  • 1、在消费者端添加配置

    properties 复制代码 
    server.port=8000
spring.rabbitmq.host=123.56.103.229
spring.rabbitmq.port=5672
spring.rabbitmq.username=admin
spring.rabbitmq.password=123456
spring.rabbitmq.virtual-host=/
spring.rabbitmq.listener.simple.acknowledge-mode=auto
# 每次处理10个
spring.rabbitmq.listener.simple.prefetch=10

九、死信队列

  • 1、在下面几种情况下会产生死信队列

    • 消息的存活时间到了
    • 队列满了，比如队列只能放10个消息，这时候发送11个消息过来，就有一个消息为死信，在队列中时间最久的那个将为成为死信队列
    • 消费被拒绝了，或者rabbitmq返回uack

  • 2、死信队列的架构图

  • 3、创建死信队列

    java 复制代码 
    package com.example.config;

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

@Configuration
public class RabbitDlxExchangeConfiguration {
    // 创建一个死信交换机
    @Bean
    public Exchange dlxExchange() {
        return ExchangeBuilder.fanoutExchange("dlx_exchange").durable(true).build();
    }

    // 创建一个死信队列
    @Bean
    public Queue dlxQueue() {
        return QueueBuilder.durable("dlx_queue").maxLength(10).build();
    }

    // 死信交换机和死信队列绑定
    @Bean
    public Binding dlxQueueBinding() {
        return BindingBuilder.bind(dlxQueue()).to(dlxExchange()).with("dead").noargs();
    }

    // 创建一个正常的交换机
    @Bean
    public Exchange orderExchange() {
        return ExchangeBuilder.directExchange("order_exchange").durable(true).build();
    }

    // 创建一个正常队列
    @Bean
    public Queue orderQueue() {
        return QueueBuilder.durable("order_queue").
                maxLength(10).
                deadLetterExchange("dlx_exchange"). // 死信队列的交换机
                deadLetterRoutingKey("dead"). // 死信队列的routingKey
                build();
    }

    // 正常交换机和正常队列绑定
    @Bean
    public Binding orderQueueBinding() {
        return BindingBuilder.bind(orderQueue()).to(orderExchange()).with("info").noargs();
    }
}

  • 4、发送消息

    java 复制代码 
    @Test
public void test05() throws InterruptedException {
    for (int i = 0; i < 15; i++) {
        rabbitTemplate.convertAndSend("order_exchange", "info", "hello world" + i);
    }
    Thread.sleep(2000);
}

  • 5、查看可视化界面，进入死信队列的是时间最早的(也就是最先发送的)

  • 6、定义消费者

    java 复制代码 
    package com.example.listener05;

import org.springframework.amqp.core.Message;
import org.springframework.amqp.rabbit.annotation.RabbitListener;
import org.springframework.stereotype.Component;

@Component
public class ConsumerListener01 {
    @RabbitListener(queues = "dlx_queue")
    public void listener01(Message message) {
        String msg = new String(message.getBody());
        System.out.println("接收到的死信队列消息:" + msg);
    }

    @RabbitListener(queues = "order_queue")
    public void listener02(Message message) {
        String msg = new String(message.getBody());
        System.out.println("接收到的订单队列消息:" + msg);
    }
}

十、延迟任务

  • 1、在rabbitmq中没有真正意义上的延迟队列任务,只是采用ttl+死信队列来完成的

  • 2、延迟任务主要用于场景

    • 文章定时发布
    • 订单多少分钟后取消支付

  • 3、延迟任务的结构图

  • 4、创建一个延迟任务的队列

    java 复制代码 
    @Configuration
public class RabbitDlxExchangeConfiguration {
    ...
    @Bean
    public Queue orderQueue() {
        return QueueBuilder.durable("order_queue").
                // maxLength(10).
                ttl(2000). // 过期时间
                deadLetterExchange("dlx_exchange"). // 死信队列的交换机
                deadLetterRoutingKey("dead"). // 死信队列的routingKey
                build();
    }
}

  • 5、发送消息,观察可视化界面,时间到了就会进入到死信队列中

    java 复制代码 
    @Test
public void test06() throws InterruptedException {
    rabbitTemplate.convertAndSend("order_exchange", "info", "hello world");
    Thread.sleep(2000);
}

  • 6、在死信队列中监听数据来改变数据库状态

相关推荐
龙仔7254 小时前
离线安装rabbitmq全流程
分布式·rabbitmq·ruby
〆、风神6 小时前
Spring Boot 整合 Lock4j + Redisson 实现分布式锁实战
spring boot·分布式·后端
胡萝卜糊了Ohh8 小时前
kafka
分布式·kafka
桑榆080610 小时前
Spark-Streaming核心编程
大数据·分布式·spark
nbsaas-boot11 小时前
分布式微服务架构,数据库连接池设计策略
分布式·微服务·架构
掘金-我是哪吒13 小时前
分布式微服务系统架构第119集：WebSocket监控服务内部原理和执行流程
分布式·websocket·微服务·架构·系统架构
企鹅不耐热.16 小时前
Spark-Streaming核心编程
大数据·分布式·spark
掘金-我是哪吒16 小时前
分布式微服务系统架构第120集：专业WebSocket鉴权
分布式·websocket·微服务·云原生·架构
我是苏苏17 小时前
消息中间件RabbitMQ-01：简要介绍及其Windows安装流程
分布式·rabbitmq
热门推荐
01KGG转MP3工具|非KGM文件|解密音频02从零安装 LLaMA-Factory 微调 Qwen 大模型成功及所有的坑03我决定放弃搞 Java 了04Coze扣子平台完整体验和实践（附国内和国际版对比）05YOLOv8入门 | 重要性能衡量指标、训练结果评价及分析及影响mAP的因素【发论文关注的指标】06DeepSeek各版本说明与优缺点分析07yolov8，yolo11，yolo12 服务器训练到部署全流程 笔记08苍穹外卖面试总结09如何在WPS和Word/Excel中直接使用DeepSeek功能10【2025年最新】OpenWrt 更换国内源的指南（图形界面版)