Spring Boot整合RabbitMQ （手动应答模式）

手动应答模式

• 第1步，编写application.properties

spring.rabbitmq.host = 127.0.0.1
spring.rabbitmq.port = 5672
spring.rabbitmq.password = test
spring.rabbitmq.username = test
spring.rabbitmq.virtual-host = /test
# 手动应答模式下，开启消息回调功能
spring.rabbitmq.publisher-confirms = true
spring.rabbitmq.publisher-returns = true

• 第2步，编写RabbitMQ配置

import org.springframework.amqp.core.*;
import org.springframework.amqp.rabbit.core.RabbitTemplate;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

import javax.annotation.Resource;

/**
 * RabbitMQ配置
 */
@Configuration
public class SpringBootRabbitMQConfiguration2 {


    // ======== 生产者配置 ========

    @Autowired
    private RabbitTemplate rabbitTemplate;

    @Bean
    public AmqpTemplate amqpTemplate() {
        // 必须开启回调才会生效
        rabbitTemplate.setMandatory(true);
        // 消息确认，需要配置 spring.rabbitmq.publisher-returns = true
        rabbitTemplate.setConfirmCallback((correlationData, ack, cause) -> {
            System.out.println("------------------------------------------------");
            System.out.println("ConfirmCallBackListener：correlationData=" + correlationData + "，ack=" + ack + "，cause=" + cause);
            System.out.println("------------------------------------------------");
        });
        // 消息发送失败返回到队列中，需要配置spring.rabbitmq.publisher-confirms = true
        rabbitTemplate.setReturnCallback((message, replyCode, replyText, exchange, routingKey) -> {
            System.out.println("------------------------------------------------");
            System.out.println("ReturnCallBackListener：message=" + new String(message.getBody()) + "，replyCode=" + replyCode + "，replyText=" + replyText + "，exchange=" + exchange + "，routingKey=" + routingKey);
            System.out.println("------------------------------------------------");
        });
        return rabbitTemplate;
    }

    /**
     * 声明了一个TopicExchange
     *
     * @return
     */
    @Bean
    public TopicExchange myExchange() {
        return new TopicExchange("myExchange");
    }


    // ======== 消费者配置 ========

    /**
     * 声明了一个Queue
     *
     * @return
     */
    @Bean
    public Queue myQueue() {
        return new Queue("myQueue");
    }


    // ======== 实际项目中为了解耦，绑定队列是放在RabbitMQ的Web端操作========

    /**
     * 队列1绑定TopicExchange并关联到RoutingKey
     *
     * @param myQueue
     * @param myExchange
     * @return
     */
    @Bean
    public Binding bindingMyQueueToTestTopicExchange(@Qualifier("myQueue") Queue myQueue, @Qualifier("myExchange") TopicExchange myExchange) {
        return BindingBuilder.bind(myQueue).to(myExchange).with("foo.*");
    }

}

• 第3步，编写消费者类

import com.rabbitmq.client.Channel;
import org.springframework.amqp.core.Message;
import org.springframework.amqp.rabbit.annotation.RabbitListener;
import org.springframework.amqp.rabbit.core.ChannelAwareMessageListener;
import org.springframework.stereotype.Component;

/**
 * 消费者确认消息
 */
@Component("springBoot2Consumer")
public class Consumer {

    @RabbitListener(queues = "myQueue")
    public void onMessage(Message message, Channel channel) throws Exception {
        try {
            System.out.println("消费者： " + new String(message.getBody()));
            // 当消费者把消息消费成功，再手动应答RabbitMQ
            channel.basicAck(message.getMessageProperties().getDeliveryTag(), false);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

• 第4步，编写生产者类

import org.springframework.amqp.core.AmqpTemplate;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.stereotype.Component;

import javax.annotation.Resource;

/**
 * 生产者发送消息，并得到消息送达情况
 */
@Component("springBoot2Producer")
public class Producer {

    public static final String EXCHANGE = "myExchange";
    public static final String ROUTING_KEY = "foo.bar";

    @Resource
    private AmqpTemplate amqpTemplate;

    /**
     * 情况1：exchange和routingKey都正确：ConfirmCallBackListener回调被执行，ack=true
     *
     * @throws InterruptedException
     */
    public void test1() throws InterruptedException {
        // 发送消息，指定交换机和路由标识
        amqpTemplate.convertAndSend(EXCHANGE, ROUTING_KEY, "Hello, world!!!");
    }

    /**
     * 情况2：exchange错误，routingKey正确：ConfirmCallBackListener回调被执行，ack=false
     *
     * @throws InterruptedException
     */
    public void test2() throws InterruptedException {
        // 故意乱指定了一个exchange，表达消息发送到exchange失败
        amqpTemplate.convertAndSend("aaa", ROUTING_KEY, "Hello, world!!!");
    }

    /**
     * 情况3：exchange正确，routingKey错误：ConfirmCallBackListener回调被执行，ack=true、ReturnCallBackListener回调被执行
     *
     * @throws InterruptedException
     */
    public void test3() throws InterruptedException {
        // 故意乱指定了一个routingKey，表达消息发送到queue失败
        amqpTemplate.convertAndSend(EXCHANGE, "bbb", "Hello, world!!!");
    }

    /**
     * 情况4：exchange和routingKey都错误：ConfirmCallBackListener回调被执行，ack=false
     *
     * @throws InterruptedException
     */
    public void test4() throws InterruptedException {
        // 故意乱指定了exchange和routingKey
        amqpTemplate.convertAndSend("aaa", "bbb", "Hello, world!!!");
    }
}

• 第6步，编写测试类

/**
 * 生产者发送消息，并得到消息送达情况
 */
@RunWith(SpringRunner.class)
@SpringBootTest
public class SpringBootRabbitMQTest2 {

    @Autowired
    @Qualifier("springBoot2Producer")
    private Producer producer;

    /**
     * 情况1：exchange和routingKey都正确：ConfirmCallBackListener回调被执行，ack=true
     *
     * @throws InterruptedException
     */
    @Test
    public void test1() throws InterruptedException {
        producer.test1();
    }

    /**
     * 情况2：exchange错误，routingKey正确：ConfirmCallBackListener回调被执行，ack=false
     *
     * @throws InterruptedException
     */
    @Test
    public void test2() throws InterruptedException {
        producer.test2();
    }

    /**
     * 情况3：exchange正确，routingKey错误：ConfirmCallBackListener回调被执行，ack=true、ReturnCallBackListener回调被执行
     *
     * @throws InterruptedException
     */
    @Test
    public void test3() throws InterruptedException {
        producer.test3();
    }

    /**
     * 情况4：exchange和routingKey都错误：ConfirmCallBackListener回调被执行，ack=false
     *
     * @throws InterruptedException
     */
    @Test
    public void test4() throws InterruptedException {
        producer.test4();
    }

}