消息队列RabbitMQ 整合 springboot，带确认机制和退回机制

源码Git地址：https://gitee.com/spring960105/springboot-rabbitmq.git

确认机制方案：

—— 图来自于尚硅谷的截图

1、配置文件：
publisher-confirm-type=correlated：发布消息成功到交换器后会触发回调方法

spring.rabbitmq.host=127.0.0.1
spring.rabbitmq.port=5672
spring.rabbitmq.username=guest
spring.rabbitmq.password=guest
spring.rabbitmq.publisher-confirm-type=correlated
spring.rabbitmq.publisher-returns=true

2、引入依赖

 		<!--RabbitMQ 依赖-->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-amqp</artifactId>
        </dependency>
          <!--RabbitMQ 测试依赖-->
        <dependency>
            <groupId>org.springframework.amqp</groupId>
            <artifactId>spring-rabbit-test</artifactId>
            <scope>test</scope>
        </dependency>

3、配置类：定义队列、交换机，绑定

@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 CONFIRM_ROUTING_KEY = "key1";
    //备份交换机
    public static final String BACKUP_EXCHANGE_NAME =  "backup.exchange";
    public static final String BACKUP_QUEUE_NAME = "backup.queue";
    //警告队列
    public static final String WARNNING_QUEUE_NAME = "warnning.queue";


    //声明交换机
    @Bean
    public DirectExchange confirmExchange(){
        return ExchangeBuilder.directExchange(CONFIRM_EXCHANGE_NAME).durable(true)
                .withArgument("alternate-exchange",BACKUP_EXCHANGE_NAME).build();
    }

    //声明队列
    @Bean
    public Queue confirmQueue(){
        return new Queue(CONFIRM_QUEUE_NAME);
    }

    //绑定
    @Bean
    public Binding queeuBindingExchange(@Qualifier("confirmQueue")Queue confirmQueue,
                                        @Qualifier("confirmExchange") DirectExchange confirmExchange){
        return BindingBuilder.bind(confirmQueue).to(confirmExchange).with(CONFIRM_ROUTING_KEY);
    }


    /**备份交换机*/
    @Bean
    public FanoutExchange backupExchange(){
        return new FanoutExchange(BACKUP_EXCHANGE_NAME);
    }

    //备份队列
    @Bean
    public Queue backupQueue(){
        return new Queue(BACKUP_QUEUE_NAME);
    }

    //警告队列
    @Bean
    public Queue warnningQueue(){
        return new Queue(WARNNING_QUEUE_NAME);
    }

    //绑定
    @Bean
    public Binding backupQueenBindingBackupExchange(@Qualifier("backupQueue")Queue backupQueue,
                                        @Qualifier("backupExchange") FanoutExchange backupExchange){
        return BindingBuilder.bind(backupQueue).to(backupExchange);
    }

    @Bean
    public Binding warnningQueenBindingBackupExchange(@Qualifier("warnningQueue")Queue warnningQueue,
                                                    @Qualifier("backupExchange") FanoutExchange backupExchange){
        return BindingBuilder.bind(warnningQueue).to(backupExchange);
    }
}

4、生产者：发送消息

@RestController
@RequestMapping("/confirm")
@Slf4j
public class ProducerController {
    @Autowired
    private RabbitTemplate rabbitTemplate;

    //开始发消息：测试发布确认：交换机接收不到信息时的处理
    @GetMapping("sendMessage/{message}")
    public void sendMessage(@PathVariable String message){
        CorrelationData correlationData = new CorrelationData("1");
        rabbitTemplate.convertAndSend(ConfirmConfig.CONFIRM_EXCHANGE_NAME, ConfirmConfig.CONFIRM_ROUTING_KEY,
                "消息来自 QC的ttl的队列: "+message+",key1",correlationData);
        log.info("发送------发送一条信息内容:{}",message+",key1");

		//此处的routingKey是故意写错，为测试报警队列
        CorrelationData correlationData2 = new CorrelationData("2");
        rabbitTemplate.convertAndSend(ConfirmConfig.CONFIRM_EXCHANGE_NAME, ConfirmConfig.CONFIRM_ROUTING_KEY+"2",
                "消息来自 QC的ttl的队列: "+message+",key21",correlationData2);
        log.info("发送------发送一条信息内容:{}",message+",key21");

    }
}

5、回调接口 ：确认、退回

@Component
@Slf4j
public class MyCallBack implements RabbitTemplate.ConfirmCallback,RabbitTemplate.ReturnCallback{
    @Autowired
    private RabbitTemplate rabbitTemplate;

    @PostConstruct
    public void inti(){
        //注入
        rabbitTemplate.setConfirmCallback(this);
        rabbitTemplate.setReturnCallback(this);
    }

    /**
     * 交换机确认回调方法
     * 1、发消息：交换机接收到了 回调
     *  1.1 correlationData 保存了回调信息的ID以及相关信息
     *  1.2 ack 交换机收到消息了  true
     *  1.3 cause 失败的原因
     * 2、发消息 交换机失败了
     *  2.1 correlationData 保存了回调信息的ID以及相关信息
     *  2.2 ack 交换机没有收到消息了  false
     *  2.3 cause 失败的原因 null
     * @param correlationData
     * @param ack
     * @param cause
     */
    @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);
        }
    }

    /**
     * @description: 可以在当消息传递过程中不可达目的地时将消息返回给生产者
     * @author: zhangxue
     * @date: 2022/3/18 13:37
     * @param:  message:
     * @Param replyCode:
     * @Param replyText:
     * @Param exchange:
     * @Param routingKey:
     * @return: * @return: void
    */
    @Override
    public void returnedMessage(Message message, int replyCode, String replyText, String exchange, String routingKey) {
        log.info("消息返回给生产者----消息：{}被交换机{}退回，退回的原因：{}，路由key{}",
                message.getBody().toString(),exchange,replyText,routingKey);
    }
}

6、消费者：接收消息，包括确认消费者和警告的消费者

@Component
@Slf4j
public class ConfirmConsumer {

    //接受确认队列消息
    @RabbitListener(queues = ConfirmConfig.CONFIRM_QUEUE_NAME)
    public void receiveMsg(Message message){
        String msg=new String(message.getBody());
        log.info("确认-----接受到队列 confirm.queue 消息:{}",msg);
    }

    //接受报警队列消息
    @RabbitListener(queues = ConfirmConfig.WARNNING_QUEUE_NAME)
    public void receiveWarnningMsg(Message message) {
        String msg = message.getBody().toString();
        log.error("报警-----报警发现不可路由消息:{}", msg);
    }
}

最终，调用测试，浏览器执行打印结果如下