消息队列中间件，RabbitMQ的使用，死信队列，延迟队列，利用枚举实现队列，交换机，RountKey的声明

已于 2024-04-22 10:16:43 修改
阅读量1.3w 收藏
点赞数 1
分类专栏： 中间件 消息队列 开发小技巧 文章标签： 中间件 rabbitmq 分布式
于 2024-04-09 18:34:43 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_68135906/article/details/137562729
版权

目录

0.交换机种类和区别

1.声明队列和交换机以及RountKey

2.初始化循环绑定

3.声明交换机

4.监听队列

4.1 监听普通队列

4.2监听死信队列

 5.削峰填谷的实现

0.交换机种类和区别

  1. Direct Exchange（直连交换机）：

    • 直连交换机将消息发送到与消息的路由键完全匹配的队列。它是最简单的交换机类型之一。
    • 当一个队列使用某个直连交换机绑定时，它需要指定一个绑定键（binding key），当消息的路由键与该绑定键完全匹配时，消息会被发送到该队列。

  2. Fanout Exchange（扇出交换机）：

    • 扇出交换机会将消息发送到与其绑定的所有队列，忽略消息的路由键。
    • 当一个队列使用扇出交换机绑定时，它会接收到交换机发送的所有消息，无论消息的路由键是什么。

  3. Topic Exchange（主题交换机）：

    • 主题交换机根据消息的路由键和绑定键之间的模式匹配来路由消息。
    • 绑定键可以使用通配符进行匹配，支持 '*' 匹配一个单词，'#' 匹配零个或多个单词，从而允许更灵活的路由规则。

  4. Headers Exchange（标头交换机）：

    • 标头交换机根据消息的标头（headers）中的键值对来路由消息，而不是使用路由键。
    • 在将队列绑定到标头交换机时，可以指定一组标头键值对，只有当消息的标头中包含与绑定相匹配的所有键值对时，消息才会被路由到该队列。

如果满足key的前提下，绑定同一个交换机的队列都会分配到相同数量的信息

比如此时交换机有20条信息，a，b队列都会分配到20条信息

默认情况下，会轮询分配给消费者，也可以设置最多获取多少条未被消费的信息，根据消费者的消费能力来设置

1.声明队列和交换机以及RountKey

package com.example.config;


import lombok.Getter;

@Getter
public enum RabbitmqBind {


    DATA_CLEAN_PROCESS_DEAD(
            RabbitMqExchangeEnum.DEAD_E_DIRECT_RCP,
            RabbitMqQueueConstants.Q_DATA_CLEAN_PROCESS_DEAD,
            RabbitmqRoutingKey.K_DATA_CLEAN_PROCESS_DEAD,
            false,
            false,
            null,
            null
    ),

    DATA_CLEAN_PROCESS(
            RabbitMqExchangeEnum.E_DIRECT_RCP,
            RabbitMqQueueConstants.Q_DATA_CLEAN_PROCESS,
            RabbitmqRoutingKey.K_DATA_CLEAN_PROCESS,
            true,
            true,
            RabbitMqExchangeEnum.DEAD_E_DIRECT_RCP,
            RabbitmqRoutingKey.K_DATA_CLEAN_PROCESS_DEAD),

    SMS_CLEAN_DEAD(
            RabbitMqExchangeEnum.DEAD_E_DIRECT_RCP,
            RabbitMqQueueConstants.Q_API_TO_DCN_SMS_DEAD,
            RabbitmqRoutingKey.K_DATA_CLEAN_FINISH_DEAD,
            true,
            false,
            null,
            null
    ),

    SMS_CLEAN(
            RabbitMqExchangeEnum.E_TOPIC_RCP,
            RabbitMqQueueConstants.Q_API_TO_DCN_SMS,
            RabbitmqRoutingKey.K_API_TO_DCN_SMS,
            true,
            true,
            RabbitMqExchangeEnum.DEAD_E_DIRECT_RCP,
            RabbitmqRoutingKey.K_DATA_CLEAN_FINISH_DEAD
    ),


    ;

    /**
     * 交换机
     */
    private RabbitMqExchangeEnum exchange;

    /**
     * 队列名称
     */
    private String queueName;

    /**
     * 路由Key
     */
    private RabbitmqRoutingKey routingKey;

    /**
     * 绑定标识
     * 是否启用
     */
    private Boolean isBind;

    /**
     * 是否绑定死信
     */
    private Boolean isDeathBelief;

    /**
     * 绑定的死信交换机
     */
    private RabbitMqExchangeEnum boundDeadExchange;

    /**
     * 死信key
     */
    private RabbitmqRoutingKey deadRoutingKey;


    RabbitmqBind(RabbitMqExchangeEnum exchange, String queueName, RabbitmqRoutingKey routingKey, Boolean isBind,
                 Boolean isDeathBelief, RabbitMqExchangeEnum boundDeadExchange, RabbitmqRoutingKey deadRoutingKey
    ) {
        this.exchange = exchange;
        this.queueName = queueName;
        this.routingKey = routingKey;
        this.isBind = isBind;
        this.isDeathBelief = isDeathBelief;
        this.boundDeadExchange = boundDeadExchange;
        this.deadRoutingKey = deadRoutingKey;
    }

    /**
     * 交换机
     */
    @Getter
    public enum RabbitMqExchangeEnum {

        /**
         * 交换机定义，类型 - 名称
         */
        E_DIRECT_RCP("direct", "E_DIRECT_RCP"),
        DEAD_E_DIRECT_RCP("direct", "DEAD_E_DIRECT_RCP"),

        E_TOPIC_RCP("topic", "E_TOPIC_RCP"),

        E_TOPIC_PAY("topic", "E_TOPIC_PAY");

        private String exchangeType;

        private String exchangeName;

        RabbitMqExchangeEnum(String exchangeType, String exchangeName) {
            this.exchangeType = exchangeType;
            this.exchangeName = exchangeName;
        }
    }

    /**
     * 队列名定义
     */
    public interface RabbitMqQueueConstants {

        /**
         * 接收清洗数据
         */
        String Q_DATA_CLEAN_PROCESS = "RMPS_TO_RCP_DATA_CLEAN_PROCESS";

        /**
         * 清洗结束通知
         */
        String Q_API_TO_DCN_SMS = "Q_API_TO_DCN_SMS";

        /**
         * 死信队列
         */
        String Q_DATA_CLEAN_PROCESS_DEAD = "Q_DATA_CLEAN_PROCESS_DEAD";

        /**
         * 清洗结束通知死信队列
         */
        String Q_API_TO_DCN_SMS_DEAD = "Q_API_TO_DCN_SMS_DEAD";
    }

    /**
     * routingKey
     */
    @Getter
    public enum RabbitmqRoutingKey {

        /**
         * 路由
         */
        K_DATA_CLEAN_PROCESS("K_DATA_CLEAN_PROCESS"),
        K_API_TO_DCN_SMS("K_API_TO_DCN_SMS"),

        // 路由绑定死信路由
        DEAD("DEAD"),

        //死信路由
        K_DATA_CLEAN_PROCESS_DEAD("K_DATA_CLEAN_PROCESS_DEAD"),
        K_DATA_CLEAN_FINISH_DEAD("K_DATA_CLEAN_FINISH_DEAD"),
        ;

        private String keyName;

        RabbitmqRoutingKey(String keyName) {
            this.keyName = keyName;
        }
    }

}

2.初始化循环绑定

package com.example.config;

import org.springframework.amqp.core.Binding;
import org.springframework.amqp.core.Exchange;
import org.springframework.amqp.core.Queue;
import org.springframework.amqp.core.QueueBuilder;
import org.springframework.amqp.rabbit.annotation.EnableRabbit;
import org.springframework.amqp.rabbit.config.SimpleRabbitListenerContainerFactory;
import org.springframework.amqp.rabbit.connection.ConnectionFactory;
import org.springframework.amqp.rabbit.core.RabbitAdmin;
import org.springframework.amqp.rabbit.core.RabbitTemplate;
import org.springframework.amqp.rabbit.transaction.RabbitTransactionManager;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.autoconfigure.amqp.SimpleRabbitListenerContainerFactoryConfigurer;
import org.springframework.boot.autoconfigure.condition.ConditionalOnClass;
import org.springframework.boot.autoconfigure.condition.ConditionalOnMissingBean;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.Lazy;

import javax.annotation.PostConstruct;
import javax.annotation.Resource;
import java.util.Arrays;

@Configuration
@ConditionalOnClass(EnableRabbit.class)
public class MqConfig {
    @Resource
    protected RabbitTemplate rabbitTemplate;
    @Resource
    ConnectionFactory connectionFactory;
//
//    @Lazy
//    @Autowired
//    protected RabbitAdmin rabbitAdmin;
//
//
//    public static final int DEFAULT_CONCURRENT = 10;
//
//    @Bean("customContainerFactory")
//    public SimpleRabbitListenerContainerFactory containerFactory(SimpleRabbitListenerContainerFactoryConfigurer configurer,
//                                                                 ConnectionFactory connectionFactory) {
//        SimpleRabbitListenerContainerFactory factory = new SimpleRabbitListenerContainerFactory();
//        factory.setConcurrentConsumers(DEFAULT_CONCURRENT);
//        factory.setMaxConcurrentConsumers(DEFAULT_CONCURRENT);
//        configurer.configure(factory, connectionFactory);
//        return factory;
//    }
//
//    @Bean
//    @ConditionalOnMissingBean
//    public RabbitTransactionManager rabbitTransactionManager(ConnectionFactory connectionFactory) {
//        return new RabbitTransactionManager(connectionFactory);
//    }
//
//    @Bean
//    @ConditionalOnMissingBean
//    public RabbitAdmin rabbitAdmin(ConnectionFactory connectionFactory) {
//        return new RabbitAdmin(connectionFactory);
//    }

    @PostConstruct
    protected void init() {
        RabbitAdmin rabbitAdmin = new RabbitAdmin(connectionFactory);


        rabbitTemplate.setChannelTransacted(true);
        //创建exchange
        Arrays.stream(RabbitmqBind.RabbitMqExchangeEnum.values())
                .forEach(rabbitMqExchangeEnum -> {
                            Exchange exchange = RabbitmqExchange
                                    .getInstanceByType(rabbitMqExchangeEnum.getExchangeType())
                                    .createExchange(rabbitMqExchangeEnum.getExchangeName());
                            rabbitAdmin.declareExchange(exchange);
                        }
                );

        //创建队列并绑定exchange
        Arrays.stream(RabbitmqBind.values()).forEach(RabbitmqBind -> {
            if (RabbitmqBind.getIsBind()) {
                if (RabbitmqBind.getIsDeathBelief()) {
                    //需要绑定死信交换机的队列
                    rabbitAdmin.declareQueue(QueueBuilder.durable(RabbitmqBind.getQueueName())
                            .ttl(60000).deadLetterExchange(RabbitmqBind.getBoundDeadExchange().getExchangeName())
                            .deadLetterRoutingKey(RabbitmqBind.getDeadRoutingKey().getKeyName()).build());
                    rabbitAdmin.declareBinding(new Binding(RabbitmqBind.getQueueName(),
                            Binding.DestinationType.QUEUE,
                            RabbitmqBind.getExchange().getExchangeName(),
                            RabbitmqBind.getRoutingKey().getKeyName(), null));
                } else {
                    //不需要绑定死信交换机的队列
                    rabbitAdmin.declareQueue(new Queue(RabbitmqBind.getQueueName(),
                            true, false, false, null));
                    rabbitAdmin.declareBinding(new Binding(RabbitmqBind.getQueueName(),
                            Binding.DestinationType.QUEUE,
                            RabbitmqBind.getExchange().getExchangeName(),
                            RabbitmqBind.getRoutingKey().getKeyName(), null));
                }
            }
        });
    }

}

 绑定的形式由枚举类中定义

3.声明交换机

package com.example.config;

import lombok.Getter;
import lombok.extern.slf4j.Slf4j;
import org.springframework.amqp.core.DirectExchange;
import org.springframework.amqp.core.Exchange;
import org.springframework.amqp.core.TopicExchange;

import java.util.Arrays;


@Getter
@Slf4j
public enum RabbitmqExchange {

    DIRECT("direct"){
        @Override
        public Exchange createExchange(String exchangeName) {
            return new DirectExchange(exchangeName, true, false);
        }
    },

    TOPIC("topic"){
        @Override
        public Exchange createExchange(String exchangeName) {
            return new TopicExchange(exchangeName, true, false);
        }
    };

    public static RabbitmqExchange getInstanceByType(String type){

        return Arrays.stream(RabbitmqExchange.values()).filter(e -> e.getType().equals(type))
                .findAny()
                .orElseThrow(() ->
//                        new ProcessException("无效的exchange type")

                        new RuntimeException("无效的exchange type")
                );
    }

    private String type;


    RabbitmqExchange(String type) {
        this.type = type;
    }

    public abstract Exchange createExchange(String exchangeName);

}

4.监听队列

4.1 监听普通队列

package com.example.listener;

import com.example.config.RabbitmqBind;
import lombok.extern.slf4j.Slf4j;
import org.apache.commons.lang.StringUtils;
import org.springframework.amqp.rabbit.annotation.RabbitHandler;
import org.springframework.amqp.rabbit.annotation.RabbitListener;
import org.springframework.stereotype.Component;


@Slf4j
@Component
@RabbitListener(queues = {
        RabbitmqBind.RabbitMqQueueConstants.Q_DATA_CLEAN_PROCESS }, concurrency = "1-5")
//, containerFactory = "customContainerFactory"
public class MqListener {



    @RabbitHandler
    public void processMessage(String message) {
        log.info("DataClean recive message :{} ", message);
        process(message);
    }

    @RabbitHandler
    public void processMessage(byte[] message) {
        String msg = new String(message);
        log.info("DataClean recive message :{} ", msg);
        process(msg);
    }

    /**
     * 处理推送消息
     * @param message
     */
    private void process(String message) {
        log.info("process message :{}" , message);
        if(StringUtils.isBlank(message)) {
            log.error("process message is blank , message:{}" , message);
            return;
        }
    }

}

 监听并处理任务

4.2监听死信队列

package com.example.listener;

import com.example.config.RabbitmqBind;
import lombok.extern.slf4j.Slf4j;
import org.apache.commons.lang.StringUtils;
import org.springframework.amqp.rabbit.annotation.RabbitHandler;
import org.springframework.amqp.rabbit.annotation.RabbitListener;
import org.springframework.stereotype.Component;

@Slf4j
@Component
@RabbitListener(queues = {
        RabbitmqBind.RabbitMqQueueConstants.Q_API_TO_DCN_SMS_DEAD }, concurrency = "1-5")
public class DeadListener {

    @RabbitHandler
    public void processMessage(String message) {
        log.info("DataClean recive message :{} ", message);
        process(message);
    }

    @RabbitHandler
    public void processMessage(byte[] message) {
        String msg = new String(message);
        log.info("DataClean recive message :{} ", msg);
        process(msg);
    }


    /**
     * 处理推送消息
     * @param message
     */
    private void process(String message) {
        log.info("Dead process message :{}" , message);
        if(StringUtils.isBlank(message)) {
            log.error("Dead process message is blank , message:{}" , message);
            return;
        }
    }

}

 5.削峰填谷的实现

把高峰期的消息填进低峰期

可以用拉取的方式来实现

或者用消费者的最大数量和最小数量来实现

channel.basicQos();//设置最大获取未确认消息的数量，实现权重

避暑人
关注
专栏目录
RabbitMQ的Exchange 模式之direct（指定模式）
浪丶荡
11-30 4781
direct模式是rabbitmq的默认模式，看懂了下图基本就明白了该模式 在这个模式中，我们可以看到两个队列在direct模式下绑定的Exchange（交换机）X. 第一个队列用binding key（绑定关键字）orange绑定，第二个队列有两个binding key，一个为black，一个是green在这种模式中，通过binding key orange发布到Exchange的消息 将被
SpringBoot集成RabbitMQ-动态注入Bean方式
wenshuai0725的专栏
01-03 5185
实现Direct,Fanout,Topic和死信转发方式实现的延迟队列 一个让处女座程序员很难受的问题:  每次申明一个队列,都需要用@Bean注解在config类里面显式的往容器里面注入一个Queue Bean和Binding Bean,十几个队列下来,那场面简直不能忍. 怎么解决呢,思路:  通过遍历枚举的方式,统一往spring容器中注入bean.废话不多说,上代码 ...
RabbitMQ 交换机类型
19：30的博客
01-04 300
RabbitMQ 交换机类型
SpringBoot整合RabbitMQ，实现MQ动态配置交换机-路由-队列信息
ILoveController的博客
09-05 1232
YamlAndPropertySourceFactory.class：该类为了解决读取yaml以及yml配置文件无法映射的问题。可根据不同的交换机，进行队列，路由的定义。也可以对队列路由进行扩充。目前这里只用到直连类型的交换机。动态参数配置校验（校验可不配置）：可根据不同的交换机类型，做校验，这里是对直连交换机的参数做的校验。以上五个步骤就完成了根据配置文件初始化rabbitMQ的交换机-路由-队列。扩充的属性可以看（三）中对应的实体类。如果可以映射配置文件，可以忽略这个。
RabbitMQ Exchange类型详解
z69183787的专栏
06-13 1299
rabbitmq
RabbitMQ通过死信队列延迟发送消息
qq_54426630的博客
01-26 470
根据message中的JSON数据取出自己想要得到的发送push。
【RabbitMQ笔记09】消息队列RabbitMQ之常见方法的使用
✅ Java 开发工程师，从事 Web 应用程序的研发，擅长 Spring、SpringBoot 等技术。 ✅ 热爱编程，业余时间学习新知识，通过 CSDN 记录学习心得和笔记内容。
02-28 826
RabbitMQ中连接消息队列服务器，是通过ConnectionFactory连接工厂来统一管理所有的Connection连接请求的，创建连接对象的时候，可以指定需要连接的RabbitMQ的IP地址、端口号、虚拟主机、连接用户名、密码、连接超时时间、创建连接对象等等。ConnectionFactory是RabbitMQ客户端提供的一个连接工厂类，通过该类可以获取到具体的Connection连接对象，下面看下
消息中间件--RabbitMQ学习（十七）---高级特性之死信队列
weixin_39218894的博客
11-02 362
死信队列:DLX,Dead- Letter- Exchange 利用DLX,当消息在一个队列中变成死信( dead message)之后它能被重新 publish到另一个 Exchange,这个 Exchange就是DLX 死信队列消息变成死信有一下几种情况 消息被拒绝( basic. reject/ basic nack)并且 requeue= false 消息TTL过期 队列达到最大长度...
中间件 - 消息队列 - RabbitMQ - 消息的可靠性投递
weixin_42254177的博客
10-10 390
消息的投递有4个环节, 如下图 欢迎使用Markdown编辑器 你好！ 这是你第一次使用 Markdown编辑器 所展示的欢迎页。如果你想学习如何使用Markdown编辑器, 可以仔细阅读这篇文章，了解一下Markdown的基本语法知识。 新的改变 我们对Markdown编辑器进行了一些功能拓展与语法支持，除了标准的Markdown编辑器功能，我们增加了如下几点新功能，帮助你用它写博客： 全新的界面设计 ，将会带来全新的写作体验； 在创作中心设置你喜爱的代码高亮样式，Markdown 将代码片显示选择的
Windows c++中RabbitMQ-c特殊消息队列的保姆教程（csdn）————程序.pdf
12-04
在Windows环境下，使用C++与RabbitMQ进行通信，我们需要首先了解RabbitMQ的基本概念，它是一个开源的消息代理和队列服务器，常用于处理异步任务和分布式系统中的消息传递。RabbitMQ-c是一个C语言编写的轻量级...
RabbitMq.rar
06-15
RabbitMQ是一款开源的消息中间件，它基于AMQP（Advanced Message Queuing Protocol）协议实现，广泛应用于分布式系统中，用于处理异步任务、解耦组件以及实现系统间的通信。在这个"RabbitMq.rar"压缩包中，我们很...
SpringBoot学习(四) 缓存、消息队列、消息队列、检索、任务
qq_43644273的博客
12-05 2042
目录一.缓存 一.缓存 1.spring 缓存抽象 几个重要概念&缓存注解 概念/注解 解释说明 Cache 缓存接口，定义缓存操作。实现有RedisCache,EhCache,ConcurrentMapCache等 CacheManager 缓存管理器，管理各种缓存组件 @Cacheable 主要针对方法配置，能根据方法的请求参数对其结果进行缓存 @CacheEvict 清空缓存 @CachePut 保证方法被调用，又希望结果被缓存 @EnableCaching
RabbitMQ消费端之消息确认及消息预取详解
qqxhb 资源共享
04-27 2020
阅读本文之前，请先查看基础安装及操作：RabbitMQ 基本api使用 以及和spring、springboot整合 1. 消费者如何确认消费？ 为什么要确认消费？ 默认情况下 消费者在拿到rabbitmq的消息时 已经自动确认这条消息已经消费了， 讲白话就是rabbitmq的队列里就会删除这条消息了， 但是 我们实际开发中 难免会遇到这种情况， 比如说 拿到这条消息 发现我处理不了 比如说 参数...
有关NLog及中间件实现日志记录
m0_73847536的博客
09-15 969
NLog 是一个非常强大的日志记录库，广泛应用于 .NET 应用程序中。它支持多种日志目标（如文件、数据库、控制台、远程服务器等），并且可以根据日志级别（如 Trace、Debug、Info、Warn、Error、Fatal）灵活地输出日志。NLog 的设计非常灵活，允许开发人员通过配置文件或代码轻松控制日志记录的行为。第一步：安装 NLog 相关 NuGet 包。第二步：配置文件以指定日志存储目标（如数据库）。第三步：在Program.cs中设置 NLog 作为日志提供者。第四步。
中间件：maxwell、canal
最新发布
小丁的博客
09-19 856
maxwells官网。
it基础软件运维管理：从操作系统到数据库，再到中间件和应用系统
MXsoft618的博客
09-14 693
通过引入监控易一体化运维软件，运维团队可以更加高效地监控和管理操作系统、数据库、中间件和应用系统等关键环节，确保企业信息系统的稳定与高效运行。在未来的发展中，我们将继续探索新的运维技术和方法，不断提升运维水平，为企业的信息化建设提供坚实保障。通过监控易软件，可以实时监控数据库的连接状态、进程使用资源、表空间使用情况等，确保数据库的高效运行。运维团队需要制定详细的备份计划，并定期进行备份，以防止数据丢失。性能分析与优化：通过监控易收集的中间件性能指标数据，运维团队可以进行深入的性能分析，找出潜在的性能瓶颈。
【RabbitMQ 项目】服务端数据管理模块之交换机管理
weixin_74113106的博客
09-15 708
服务端的数据管理模块之交换机管理
RabbitMq中交换机（Exchange）、队列（Queue）和路由键（Routing Key）
weixin_38650077的博客
09-17 738
RabbitMQ 是一个消息代理系统，使用交换机（Exchange）、队列（Queue）和路由键（Routing Key）来管理消息的传递。它们分别起到不同的作用，构成了消息从生产者到消费者的传递路径。
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、付费专栏及课程。

余额充值