@Configuration
public class config {
    @Bean
    public Queue queue(){
        return new Queue("queue_01",false);
    }
}

@SpringBootTest(classes = Main.class)
public class Producer {
    @Autowired
    RabbitTemplate rabbitTemplate;
    @Test
    public void producerMsg(){
        rabbitTemplate.convertAndSend("queue_01","hello_world");
    }
}

@Component
@Slf4j
public class Consumer {
    @RabbitListener(queues = {"queue_01"})
    public void consumerMsg(String msg, Message message,Channel channel){
        try {
            log.info("消費者消費消息： "+msg);
            /**
             * 沒有異常就確認消息
             * basicAck(long deliveryTag, boolean multiple)
             * deliveryTag:當前消息在隊列中的的索引;
             * multiple:為true的話就是批量確認
             */
            channel.basicAck(message.getMessageProperties().getDeliveryTag(),false);
        } catch (Exception e) {
            /**
             * 有異常就拒收消息
             * basicNack(long deliveryTag, boolean multiple, boolean requeue)
             * requeue:true為將消息重返當前消息隊列,重新發(fā)送給消費者;
             *         false將消息丟棄
             */
            try {
                channel.basicNack(message.getMessageProperties().getDeliveryTag(), false, true);
            } catch (Exception ex) {
                log.error(ex.getMessage());
            }
        }
    }
}

@GetMapping("/direct/wx/transactional")
@Transactional(rollbackFor = Exception.class)
public String sendDirectMessageTransactional() {
  rabbitTemplate.convertAndSend("direct_exchange", "wx","hello world!");
  log.info("開啟事務(wù)消息機制");
    try {
           Thread.sleep(5000);
       } catch (Exception e) {
            e.printStackTrace();
       }
      return "ok";
}

@Slf4j
@Component
public class RabbitmqService implements RabbitTemplate.ConfirmCallback, RabbitTemplate.ReturnCallback {
    @Autowired
    private RabbitTemplate rabbitTemplate;
    public void sendMessage(String exchange,String routingKey,Object msg) {
        // 設(shè)置交換機處理失敗消息的模式     true 表示消息由交換機 到達不了隊列時，會將消息重新返回給生產(chǎn)者
        // 如果不設(shè)置這個指令，則交換機向隊列推送消息失敗后，不會觸發(fā) setReturnCallback
        rabbitTemplate.setMandatory(true);
        //消息消費者確認收到消息后，手動ack回執(zhí)
        rabbitTemplate.setConfirmCallback(this);
        // 暫時關(guān)閉 return 配置
        //rabbitTemplate.setReturnCallback(this);
        //發(fā)送消息
        rabbitTemplate.convertAndSend(exchange,routingKey,msg);
    }
    /**
     * 交換機并未將數(shù)據(jù)丟入指定的隊列中時，觸發(fā)
     *  channel.basicPublish(exchange_name,next.getKey(), true, properties,next.getValue().getBytes());
     *  參數(shù)三：true  表示如果消息無法正常投遞，則return給生產(chǎn)者 ；false 表示直接丟棄
     * @param message   消息對象
     * @param replyCode 錯誤碼
     * @param replyText 錯誤信息
     * @param exchange 交換機
     * @param routingKey 路由鍵
     */
    @Override
    public void returnedMessage(Message message, int replyCode, String replyText, String exchange, String routingKey) {
        log.info("---- returnedMessage ----replyCode="+replyCode+" replyText="+replyText+" ");
    }
    /**
     * 消息生產(chǎn)者發(fā)送消息至交換機時觸發(fā)，用于判斷交換機是否成功收到消息
     * @param correlationData  相關(guān)配置信息
     * @param ack exchange 交換機，判斷交換機是否成功收到消息    true 表示交換機收到
     * @param cause  失敗原因
     */
    @Override
    public void confirm(CorrelationData correlationData, boolean ack, String cause) {
        log.info("---- confirm ----ack="+ack+"  cause="+String.valueOf(cause));
        log.info("correlationData -->"+correlationData.toString());
        if(ack){
            // 交換機接收到
            log.info("---- confirm ----ack==true  cause="+cause);
        }else{
            // 沒有接收到
            log.info("---- confirm ----ack==false  cause="+cause);
        }
    }
}