RabbitMQ高级特性：交换机、绑定、备份与优先级队列管理,-优快云博客

本文链接：https://blog.youkuaiyun.com/weixin_43869269/article/details/137071617

RabbitMQ

交换机

Exchanges

RabbitMQ消息传递模型的核心思想是：生产者生产的消息从不会直接发送到队列。实际上，通常生产者甚至都不知道这些消息传递传递到了哪些队列中。相反，生产者只能将消息发送到交换机(exchange)。而交换机工作的内容非常简单，一方面它接收来自生产者的消息，另一方面将它们推入队列。交换机必须确切知道如何处理收到的消息。是应该把这些消息放到特定队列还是说把他们到许多队列中还是说应该丢弃它们。这就的由交换机的类型来决定。

交换机总共有以下几个类型：

直接(路由)类型（direct）、主题类型（topic）、标题类型（headers）、扇出(发布订阅)类型（fanout）

无名交换机：

在本教程的前面部分我们对exchange一无所知，但仍然能够将消息发送到队列。之前能实现的原因是因为我们使用的是默认交换机，我们通过空字符串(“ ”)进行标识。

第一个参数是交换机的名称。空字符串表示默认或无名称交换机:消息能路由发送到队列中其实是由routingKey(bindingkey)绑定key指定的，例如下面的路由Key=“hello”

channel.basiPublish("","hello",null,message.getBytes())；

绑定（bindings）

binding其实是交换机和队列之间的桥梁，它告诉我们交换机和那个队列进行了绑定关系，同时队列只对它绑定的交换机的消息感兴趣，绑定之后的意义由其交换机类型决定。比如说下面这张图告诉我们的就是×与Q1和Q2进行了绑定，其实就是通过设置交换积的routingKey(bindingkey)绑定key指定的队列。

在这里插入图片描述

备份交换机

当交换机确认消息失败或者交换机发送消息到队列失败，都可以通过回调方法让生产者重新发送消息

当交换机接收到一条不可路由消息时怎么办呢，这时候就可以为交换机设置备份交换机，来接收不可路由的消息。

接收到不可路由的消息时，交换机将会把消息转发到备份交换机中，由备份交换机来进行转发和处理，通常备份交换机的类型为 Fanout （扇出），这样就能把所有消息都投递到与其绑定的队列中，然后我们在备份交换机下绑定一个队列，这样所有那些原交换机无法被路由的消息，就会都进入这个队列了。当然我们还可以建立一个报警队列，用独立的消费者来进行监测和报警。
在这里插入图片描述

配置类代码

@Configuration 
public class ConfirmConfig { 
 
 
    public static final String CONFIRM_EXCHANGE_NAME = "confirm.exchange"; 
    public static final String CONFIRM_QUEUE_NAME = "confirm.queue"; 
    public static final String BACKUP_EXCHANGE_NAME = "backup.exchange"; 
    public static final String BACKUP_QUEUE_NAME = "backup.queue"; 
    public static final String WARNING_QUEUE_NAME = "warning.queue"; 
    // 声明确认队列 
    @Bean("confirmQueue") 
    public Queue confirmQueue(){ 
        return QueueBuilder.durable(CONFIRM_QUEUE_NAME).build(); 
    } 
    //声明确认队列绑定关系 
    @Bean 
    public Binding queueBinding(@Qualifier("confirmQueue") Queue queue, 
                                @Qualifier("confirmExchange") DirectExchange exchange){ 
        return BindingBuilder.bind(queue).to(exchange).with("key1"); 
    } 
    //声明备份Exchange 
    @Bean("backupExchange") 
    public FanoutExchange backupExchange(){ 
        return new FanoutExchange(BACKUP_EXCHANGE_NAME); 
    } 
    //声明确认Exchange交换机的备份交换机 
    @Bean("confirmExchange") 
    public DirectExchange confirmExchange(){ 
        ExchangeBuilder exchangeBuilder = 
                ExchangeBuilder.directExchange(CONFIRM_EXCHANGE_NAME) 
                        .durable(true) 
                        //设置该交换机的备份交换机 
                        .withArgument("alternate-exchange", BACKUP_EXCHANGE_NAME); 
        return (DirectExchange)exchangeBuilder.build(); 
    } 
 
    // 声明警告队列 
    @Bean("warningQueue") 
    public Queue warningQueue(){ 
        return QueueBuilder.durable(WARNING_QUEUE_NAME).build(); 
    } 
    // 声明报警队列绑定关系 
    @Bean 
    public Binding warningBinding(@Qualifier("warningQueue") Queue queue, 
                                  @Qualifier("backupExchange") FanoutExchange 
backupExchange){ 
        return BindingBuilder.bind(queue).to(backupExchange); 
    } 
    // 声明备份队列 
    @Bean("backQueue") 
    public Queue backQueue(){ 
        return QueueBuilder.durable(BACKUP_QUEUE_NAME).build(); 
    } 
    // 声明备份队列绑定关系 
    @Bean 
    public Binding backupBinding(@Qualifier("backQueue") Queue queue, 
                                 @Qualifier("backupExchange") FanoutExchange backupExchange){ 
        return BindingBuilder.bind(queue).to(backupExchange); 
    } 
}

报警消费者代码

@Component 
@Slf4j 
public class WarningConsumer { 
    public static final String WARNING_QUEUE_NAME = "warning.queue"; 
    
    @RabbitListener(queues = WARNING_QUEUE_NAME) 
	public void receiveWarningMsg(Message message) { 
		String msg = new String(message.getBody()); 
		log.error("报警发现不可路由消息：{}", msg); 
	} 
}

同理可以写警告消费者等，用于消费备份交换机队列里的消息。

回退消息

在仅开启了生产者确认机制的情况下，交换机接收到消息后，会直接给消息生产者发送确认消息，如果发现该消息不可路由，那么消息会被直接丢弃，此时生产者是不知道消息被丢弃这个事件的。通过设置mandatory参数可以在当消息传递过程中不可达目的地时将消息返回给生产者。

生产者代码

@Slf4j 
@Component 
public class MessageProducer implements RabbitTemplate.ConfirmCallback , 
RabbitTemplate.ReturnCallback { 
    @Autowired 
    private RabbitTemplate rabbitTemplate; 
    //rabbitTemplate注入之后就设置该值 
    @PostConstruct 
    private void init() { 
        rabbitTemplate.setConfirmCallback(this); 
        /** 
         * true： 
         *      交换机无法将消息进行路由时，会将该消息返回给生产者 
         * false： 
         *      如果发现消息无法进行路由，则直接丢弃 
         */ 
        rabbitTemplate.setMandatory(true); 
        //设置回退消息交给谁处理 
        rabbitTemplate.setReturnCallback(this); 
    } 
    @GetMapping("sendMessage") 
public void sendMessage(String message){ 
    //让消息绑定一个id值 
    CorrelationData correlationData1 = new CorrelationData(UUID.randomUUID().toString()); 
    
 
 
rabbitTemplate.convertAndSend("confirm.exchange","key1",message+"key1",correlationData1)
 ; 
    log.info("发送消息id为:{}内容为{}",correlationData1.getId(),message+"key1"); 
    CorrelationData correlationData2 = new CorrelationData(UUID.randomUUID().toString()); 
    
rabbitTemplate.convertAndSend("confirm.exchange","key2",message+"key2",correlationData2)
 ; 
    log.info("发送消息id为:{}内容为{}",correlationData2.getId(),message+"key2"); 
} 
    @Override 
    public void confirm(CorrelationData correlationData, boolean ack, String cause) { 
        String id = correlationData != null ? correlationData.getId() : ""; 
        if (ack) { 
            log.info("交换机收到消息确认成功, id:{}", id); 
        } else { 
            log.error("消息id:{}未成功投递到交换机,原因是:{}", id, cause); 
        } 
    } 
    @Override 
    public void returnedMessage(Message message, int replyCode, String replyText, String 
exchange, String routingKey) { 
        log.info("消息:{}被服务器退回，退回原因:{}, 交换机是:{}, 路由key:{}", 
                new String(message.getBody()),replyText, exchange, routingKey); 
    } 
}

回调接口

@Component 
@Slf4j 
public class MyCallBack implements 
RabbitTemplate.ConfirmCallback,RabbitTemplate.ReturnCallback { 
    /** 
     * 交换机不管是否收到消息的一个回调方法 
     * CorrelationData 
     *  消息相关数据 
     * ack 
     *  交换机是否收到消息 
     */ 
    @Override 
    public void confirm(CorrelationData correlationData, boolean ack, String cause) { 
        String id=correlationData!=null?correlationData.getId():""; 
        if(ack){ 
            log.info("交换机已经收到id为:{}的消息",id); 
        }else{ 
            log.info("交换机还未收到id为:{}消息,由于原因:{}",id,cause); 
        } 
    } 
    //当消息无法路由的时候的回调方法 
    @Override 
    public void returnedMessage(Message message, int replyCode, String replyText, String 
exchange, String routingKey) { 
        log.error("消息{},被交换机{}退回，退回原因:{},路由key:{}",new 
String(message.getBody()),exchange,replyText,routingKey); 
    } 
}

优先级队列

自定义队列优先级，让消费者按照优先级去消费消息。

// 在MQ当中优先级取值范围 : 0 ~ 255 (数值越大越优先)

// 方法一、在队列中添加优先级
    Map<String, Object> params = new HashMap(); 
    params.put("x-max-priority", 10); 
    channel.queueDeclare("hello", true, false, false, params);

// 方法二、在消息代码中添加优先级
    rabbitTemplate.convertAndSend(CONFIRM_EXCHANGE_NAME, CONFIRM_ROUTING_KEY, msg + i, message -> {
                message.getMessageProperties().setPriority(finalI);
                return message;
        }, correlationData);

惰性队列

惰性队列主要作用的将消息尽可能的存到磁盘中 , 而消费者响应消息的时候才会被加载到内存中 , 设计初衷主要是容纳更多的消息 , 以免高峰期导致内存爆炸现象

不同情况下的队列 :

普通队列(default) : 消息保存到内存中 (尽可能提高性能)
惰性队列(lazy) : 消息保存到磁盘中 (尽可能存储更多的消息)

惰性优点 :

消费者失效 , 消息堆积情况
大量消息 , 占用内存小

应用 :

在队列中配置模式属性 : x-queue-mode: lazy
大量发送消息
观察Web内存占用情况

在队列声明的时候可以通过“x-queue-mode”参数来设置队列的模式，取值为“default”和“lazy”。下面示
例中演示了一个惰性队列的声明细节：

    Map<String, Object> args = new HashMap<String, Object>(); 
    args.put("x-queue-mode", "lazy"); 
    channel.queueDeclare("myqueue", false, false, false, args);