SpringBoot 整合RabbitMQ

一、 添加依赖

        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-amqp</artifactId>
        </dependency>    

只要添加该starter, Spring Boot 就会添加 spring-rabbit 依赖库，就会自动配置 CachingConnectionFactory, 还会自动配置 AmqpAdmin 和 AmqpTemplate, SpringBoot 基于标准的AMQP 与 RabbitMQ进行通信。

其中 AmqpAdmin 提供了如下常用方法， 主要负责管理 Exchange、队列 和绑定

     void declareExchange(Exchange exchange);  //声明Exchange

     String declareQueue(Queue queue);  //声明队列
    
     Queue declareQueue();  //声明由服务器命名的、独享的、会自动删除的、非持久化的队列
    
     void declareBinding(Binding binding);  //声明队列或Exchange 与 Exchange 的绑定
    
     boolean deleteExchange(String exchangeName); //删除 Exchange
    
     boolean deleteQueue(String queueName);   //无条件的删除队列
    
     void deleteQueue(String queueName, boolean unused, boolean empty); //删除队列，只有当该队列不再使用且没有消息时才删除
    
     void removeBinding(Binding binding);   //解除绑定

AmqpTemplate 则用于发送、接收消息，包含了如下常用方法

    //自动将message参数转化成消息发送给exchange, 发送之前还可通过messagePostProcessor 参数对消息进行修改
     void convertAndSend(String exchange, String routingKey, Object message, MessagePostProcessor messagePostProcessor);    
     
    //该方法在发送消息之后会等待返回的消息，在发送之前可以通过messagePostProcessor 参数对消息进行修改
     void converSendAndReceive(String exchange, String routingKey, Object message, MessagePostProcessor messagePostProcessor);  
    
     void send(String exchange, String routingKey, Message message);    //发送消息
    
     void sendAndReceive(String exchange, String routingKey, Message message);  //该方法在发送消息之后会等待返回的消息
    
     Message receive(String queueName, long timeoutMilles); //制定从queueName队列中接收消息

AmqpTemplate 和 AmqpAdmin 加起来就等于 RabbitMQ Client 中 Channel 的功能。

二、对RabbitMQ 进行配置

对RabbitMQ 的配置可在 properties 中增加 spring.rabbitmq 开头的配置属性， 源代码如下

package org.springframework.boot.autoconfigure.amqp;

import java.time.Duration;
import java.time.temporal.ChronoUnit;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
import java.util.Optional;
import org.springframework.amqp.core.AcknowledgeMode;
import org.springframework.amqp.rabbit.connection.AbstractConnectionFactory.AddressShuffleMode;
import org.springframework.amqp.rabbit.connection.CachingConnectionFactory.CacheMode;
import org.springframework.amqp.rabbit.connection.CachingConnectionFactory.ConfirmType;
import org.springframework.boot.context.properties.ConfigurationProperties;
import org.springframework.boot.convert.DurationUnit;
import org.springframework.util.CollectionUtils;
import org.springframework.util.StringUtils;

@ConfigurationProperties(
    prefix = "spring.rabbitmq"
)
public class RabbitProperties {
    private static final int DEFAULT_PORT = 5672;
    private static final int DEFAULT_PORT_SECURE = 5671;
    private static final int DEFAULT_STREAM_PORT = 5552;
    private String host = "localhost";
    private Integer port;
    private String username = "guest";
    private String password = "guest";
    private final RabbitProperties.Ssl ssl = new RabbitProperties.Ssl();
    private String virtualHost;
    private String addresses;
    private AddressShuffleMode addressShuffleMode;
    @DurationUnit(ChronoUnit.SECONDS)
    private Duration requestedHeartbeat;
    private int requestedChannelMax;
    private boolean publisherReturns;
    private ConfirmType publisherConfirmType;
    private Duration connectionTimeout;
    private Duration channelRpcTimeout;
    private final RabbitProperties.Cache cache;
    private final RabbitProperties.Listener listener;
    private final RabbitProperties.Template template;
    private final RabbitProperties.Stream stream;
    private List<RabbitProperties.Address> parsedAddresses;
　　...
　　...

application.properties 文件配置如下， 除此之外，还可进行其他配置，此处列举部分

#rabbitMQ
spring.rabbitmq.host=localhost
spring.rabbitmq.port=5672
spring.rabbitmq.username=root
spring.rabbitmq.password=123456
#上述rabbitMQ配置可用下方链接代替
#spring.rabbitmq.addresses=amqp://root:123456@localhost:5672
#设置虚拟主机
spring.rabbitmq.virtual-host=yyds-vhost

#rabbitMQ 缓存相关配置
#设置 Channel 还是 Connection
spring.rabbitmq.cache.connection.mode=channel
#设置缓存 Channel 的数量, 根据缓存方式channel 还是 connection
spring.rabbitmq.cache.channel.size=20
#设置缓存 Connection 的数量, 根据缓存方式channel 还是 connection
#spring.rabbitmq.cache.connection.size=5

#rabbitMQ AmqpTemplate 配置
#启用AmqpTemplate 的自动重试功能, 默认没有启用
spring.rabbitmq.template.retry.enabled=true
#设置自动重试的时间间隔为2s
spring.rabbitmq.template.retry.initial-interval=2s
#设置AmqpTemplate 的默认Exchagne 为 ""
spring.rabbitmq.template.exchange=""
#设置AmqpTemplate 的默认路由key 为 "test"
spring.rabbitmq.template.routing-key=test

三、使用AmqpTemplate 发送消息

示例如下：

import lombok.var;
import org.springframework.amqp.core.*;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

@Service
public class RabbitMessageService {

    public static final String EXCHANGE_NAME = "boot.delay";
    public static final String[] QUEUE_NAMES = {"myQueue1", "myQueue2"};
    private final AmqpAdmin amqpAdmin;
    private final AmqpTemplate amqpTemplate;

    @Autowired
    public RabbitMessageService(AmqpAdmin amqpAdmin, AmqpTemplate amqpTemplate) {
        this.amqpAdmin = amqpAdmin;
        this.amqpTemplate = amqpTemplate;

        //创建 Exchange 对象，根据Exchange 类型的不同，可使用 DirectExchange、FanoutExchange、HeadersExchange、TopicExchange
        var exchange = new FanoutExchange(EXCHANGE_NAME, true/* 是否持久化 */, true /* 是否自动删除*/);
        this.amqpAdmin.declareExchange(exchange);
        //使用循环声明并绑定了2个队列
        for(String queueName : QUEUE_NAMES) {
            var queue = new Queue(queueName, true /*是否持久化*/, false/*是否独享*/, true/*是否自动删除*/);

            //声明队列
            this.amqpAdmin.declareQueue(queue);
            var binding = new Binding(queueName,
                    Binding.DestinationType.QUEUE, /* 制定绑定的目的为队列*/
                    EXCHANGE_NAME,
                    "",   /* 路由 key*/
                    null
                    );

            //声明绑定
            this.amqpAdmin.declareBinding(binding);
        }
    }

    public void produce(String message) {
        this.amqpTemplate.convertAndSend(EXCHANGE_NAME, "", message);
    }

}

四、接收消息

SpringBoot 会自动将 @RabbitListener 注解修饰的方法注册为消息监听机制， 如果没有显式配置监听器容器工厂(RabbitListenerContainerFactory), SpringBoot 会在容器中自动配置一个 SimpleRabbitListenerContainerFactory 作为监听器工厂， 如果希望使用 DirectRabbitListenerContainerFactory ，则可在application。properties 中添加如下配置：

spring.rabbitmq.listener.type=direct

如果容器中配置了 MessageRecoverer 或 MessageConverter, 他们会被自动关联到默认的监听器容器工厂

    @RabbitListener(queues="myQueue1")
    public void processMessage1(String content) {

        System.out.println("从myQueue1 收到消息：" + content);

    }

    @RabbitListener(queues="myQueue2")
    public void processMessage2(String content) {

        System.out.println("从myQueue2 收到消息：" + content);

    }

运行程序，发送2条消息， 监听器自动获取到队列内的消息

    @Test
    public void produceTest() {
        rabbitMessageService.produce("hello world");
        rabbitMessageService.produce("i love code");
    }

 

结果如下