关于Java中RabbitMQ的高级特性

<rabbit:connection-factory id="connectionFactory" 
                           host="${rabbitmq.host}"
                           port="${rabbitmq.port}"
                           username="${rabbitmq.username}"
                           password="${rabbitmq.password}"
                           virtual-host="${rabbitmq.virtual-host}"
                           publisher-confirms="true"
/>

@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(locations = "classpath:spring-rabbitmq-producer.xml")
public class ProducerTest {
    /**
     * 注入RabbitTemplate
     */
    @Autowired
    private RabbitTemplate rabbitTemplate;
    /**
     * 测试默认的队列发送消息
     */
    @Test
    public void testConfirmCallback() throws InterruptedException {
        // 设置回调
        rabbitTemplate.setConfirmCallback(new RabbitTemplate.ConfirmCallback() {
            /**
             * 回调方法
             * @param correlationData 回调的相关数据。
             * @param ack true 表示发送成功, false 发送失败
             * @param cause 失败原因，ack==true->null
             */
            @Override
            public void confirm(CorrelationData correlationData, boolean ack, String cause) {
                if (ack) {
                    System.out.println("发送成功");
                } else {
                    System.out.println("发送失败，原因：" + cause);
                    // 失败后处理流程
                }
            }
        });
        rabbitTemplate.convertAndSend("spring_queue", "hello world");
        // 防止发送完成后，未完成回调关闭通道
        Thread.sleep(5000);
    }
}

<rabbit:connection-factory id="connectionFactory" host="${rabbitmq.host}"
                           port="${rabbitmq.port}"
                           username="${rabbitmq.username}"
                           password="${rabbitmq.password}"
                           virtual-host="${rabbitmq.virtual-host}"
                           publisher-returns="true"
/>

@Test
    public void testReturnCallback() throws InterruptedException {
        // 设置交换机处理失败消息的模式
        rabbitTemplate.setMandatory(true);
        // 设置回调
        rabbitTemplate.setReturnCallback(new RabbitTemplate.ReturnCallback() {
            /**
             * 返回消息
             * @param message 消息对象
             * @param replyCode 错误码
             * @param replyText 交换信息
             * @param exchange 交换机
             * @param routingKey 路由键
             */
            @Override
            public void returnedMessage(Message message, int replyCode, String replyText, String exchange, String routingKey) {
                System.out.println("消息对象：" + new String(message.getBody()));
                System.out.println("错误码：" + replyCode);
                System.out.println("交换信息：" + replyText);
                System.out.println("交换机：" + exchange);
                System.out.println("路由键：" + routingKey);
            }
        });
        rabbitTemplate.convertAndSend("spring_direct_exchange", "direct_key_3",
                "spring_direct_exchange_direct_key_1");
        // 防止发送完成后，未完成回调关闭通道
        Thread.sleep(5000);
    }

/**
 * @author zhong
 * <p>
 * Consumer Ack机制
 * 1.设置手动签收，acknowledge="manual"
 * 2.让监听器实现ChannelAwareMessageListener接口
 * 3.如果消息成功处理，则调用channel.basicAck()
 * 4.如果消息处理失败，则调用 channel.basicNack(),broker重新发送consumer
 */
@Component
public class AckSpringQueueListener implements ChannelAwareMessageListener {
    @Override
    public void onMessage(Message message, Channel channel) throws Exception {
        long deliveryTag = message.getMessageProperties().getDeliveryTag();
        // 接收消息
        System.out.println("Message:" + new String(message.getBody()));
        // 手动签收
        /**
         * deliveryTag: 标识id
         * multiple: 确认所有消息
         */
        channel.basicAck(deliveryTag, true);
        // 手动拒绝
        /**
         * requeue:如果被拒绝的消息应该被重新排队而不是被丢弃/死信
         */
        //channel.basicNack(deliveryTag, true, true);
    }
}

<context:component-scan base-package="org.example"/>
<rabbit:listener-container connection-factory="connectionFactory" acknowledge="manual" auto-declare="true">
    <rabbit:listener ref="ackSpringQueueListener" queue-names="spring_queue"/>
</rabbit:listener-container>

<context:component-scan base-package="org.example"/>
<rabbit:listener-container connection-factory="connectionFactory" acknowledge="manual" prefetch="1"
                           auto-declare="true">
    <rabbit:listener ref="qosListener" queue-names="spring_queue"/>
</rabbit:listener-container>

/**
 * Consumer 限流机制
 * 1.确保ack机制为手动确认
 * 2.listener-container 配置属性
 * perfetch = 1 表示消费端每次从mq拉取一条消息来消费，直到手动确认消费完毕后，才会继续拉去下一条消息。
 */
@Component
public class QosListener implements ChannelAwareMessageListener {
    @Override
    public void onMessage(Message message, Channel channel) throws Exception {
        System.out.println("QosListener:" + new String(message.getBody()));
        long deliveryTag = message.getMessageProperties().getDeliveryTag();
        // 签收消息
        Thread.sleep(1000);
        channel.basicAck(deliveryTag, true);
    }
}

@Test
public void testTTL() {
    // 消息后处理队列，设置一下消息参数信息
    MessagePostProcessor messagePostProcessor = message -> {
        // 1.设置message的消息
        message.getMessageProperties().setExpiration("50000");// 设置过期时间，字符串，毫秒
        // 2.返回消息
        return message;
    };
    // 传入
    rabbitTemplate.convertAndSend("spring_fanout_exchange", "key", "RabbitMQ", messagePostProcessor);
}