SpringBoot整合RabbitMQ——交换机和队列的管理和绑定

本博文从某个角度来说，应该是rabbitMQ应用开发的知识点梳理，使用目前最广泛流行的SpringBoot来集成rabbitMQ的功能开发，在开发的过程中讲解rabbitMQ的各种特性、技能点以及开发过程中需要注意的地方

上一篇博文Centos7下RabbitMQ的搭建我们已经搭建好RabbitMQ的服务器，并且简单的介绍了MQ服务中主要的几个概念，各个概念的主要作用以及为了实现消息的发送和接收机制，各个概念之间的依存关系。也简单的介绍了消息生产和消费的业务流程图，大致了的了解了RabbitMQ的整体的概念模型，但是talk is cheap, show me the code，所以为了更加真实的了解如何使用代码来实现的，下面我们就SpringBoot来整合RabbitMQ的开发环境，并且简单了解具体的技术参数的运用

上一篇博文：

• Centos7下RabbitMQ的搭建

SpringBoot集成RabbitMQ

SpringBoot集成RabbitMQ非常简单，只需要在maven依赖中添加依赖即可

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

然后再application.yml文件中添加rabbitMQ的配置信息

    spring:
      rabbitmq:
        addresses: 192.168.56.105:5672
        username: root
        password: root
        virtual-host: /

这样一个简单的rabbitMQ的开发环境就搭建好了，下面我们开始编写交换机创建和队形注册rabbitMQ的相关功能，最好是能独立成一个简单通用的jar被其他项目复用，下面我们来新建个项目，有两个子module,其中一个是消费者，另外一个是生产者。具体的目录结构如下：
具体的项目可以参考我的gitee项目:Gitee-rabbitmq

其中common主要是存放消费者和生产者共同的代码，比如一些常量和通用配置类的信息

连接RabbitMQ

系统应该在一启动的时候就连接RabbitMQ，我们这里不采用SpringBoot默认提供的RabbitTemplate,这样不方便我们自定义扩展的属性，所以我们手动注册ConnectionFactory,并且提供RabbitAdmin来进行交换机、队列以及路由绑定的管理

    @Configuration
    public class RabbitMQConfig {
        /**
         * rabbitMQ服务器的地址
         */
        @Value("${spring.rabbitmq.addresses:192.168.56.105:5672}")
        private String addresses;
        /**
         * rabbitMQ用户名
         */
        @Value("${spring.rabbitmq.username:root}")
        private String username;
        /**
         * rabbitMQ密码
         */
        @Value("${spring.rabbitmq.password:root}")
        private String password;
        /**
         * rabbitMQ虚拟机 这里默认 /
         */
        @Value("${spring.rabbitmq.virtual-host:/}")
        private String virtualHost;
    
        /**
         * 注册rabbitMQ的Connection
         *
         * @return
         */
        @Bean
        public ConnectionFactory connectionFactory() {
            CachingConnectionFactory cachingConnectionFactory = new CachingConnectionFactory();
            cachingConnectionFactory.setAddresses(this.addresses);
            cachingConnectionFactory.setUsername(this.username);
            cachingConnectionFactory.setPassword(this.password);
            cachingConnectionFactory.setVirtualHost(this.virtualHost);
            return cachingConnectionFactory;
        }
    
        /**
         * 注册rabbitAdmin 方便管理
         *
         * @param connectionFactory
         * @return
         */
        @Bean
        public RabbitAdmin rabbitAdmin(ConnectionFactory connectionFactory) {
            return new RabbitAdmin(connectionFactory);
        }
    }

交换机的管理

Exchange和Queueshi AMQP中的high-level层面的构建模块，应用程序应该提供对其的管理，我们首先来实现对交换机的管理

交换机的特性

• exchangeName: 交换机的名称
• type: 交换机的类型
• durable: 是否持久化
• autoDelete: 是否自动删除
• internal: 是否内置交换机
• argument: 结构化参数

    public class MqExchage {
        /**
         * 交换机的名称
         */
        @NotNull(message = "交换机名称不能为空")
        private String name;
    
        /**
         * 交换机的类型
         */
        @NotNull(message = "交换机类型不能为空")
        private ExchangeTypeEnum type;
        /**
         * 是否持久化
         * 持久化可以将交换机存盘，在服务器重启的时候不会丢失相关的信息
         */
        private boolean durable;
        /**
         * 是否自动删除
         * 自动删除的前提是至少有一个队列或者交换机与这个交互机绑定，之后所有与这个交换机绑定的队列或者交换机都与此解绑
         */
        private boolean autoDelete;
    
        public MqExchage name(String name) {
            this.name = name;
            return this;
        }
    
    
        public MqExchage type(ExchangeTypeEnum type) {
            this.type = type;
            return this;
        }
    
        public MqExchage durable(boolean durable) {
            this.durable = durable;
            return this;
        }
    
        public MqExchage autoDelete(boolean autoDelete) {
            this.autoDelete = autoDelete;
            return this;
        }
    
        /**
         * 自定义属性参数
         * 比如：alternate-exchange
         */
        private Map<String, Object> arguments;
        public class MqExchage {
        /**
         * 交换机的名称
         */
        @NotNull(message = "交换机名称不能为空")
        private String name;
    
        /**
         * 交换机的类型
         */
        @NotNull(message = "交换机类型不能为空")
        private ExchangeTypeEnum type;
        /**
         * 是否持久化
         * 持久化可以将交换机存盘，在服务器重启的时候不会丢失相关的信息
         */
        private boolean durable;
        /**
         * 是否自动删除
         * 自动删除的前提是至少有一个队列或者交换机与这个交互机绑定，之后所有与这个交换机绑定的队列或者交换机都与此解绑
         */
        private boolean autoDelete;
    
        public MqExchage name(String name) {
            this.name = name;
            return this;
        }
    
    
        public MqExchage type(ExchangeTypeEnum type) {
            this.type = type;
            return this;
        }
    
        public MqExchage durable(boolean durable) {
            this.durable = durable;
            return this;
        }
    
        public MqExchage autoDelete(boolean autoDelete) {
            this.autoDelete = autoDelete;
            return this;
        }
    
        /**
         * 自定义属性参数
         * 比如：alternate-exchange
         */
        private Map<String, Object> arguments;
            
    }

交换机的注册和销毁

    //通用的Declare
    public abstract class AbstractDeclare {
    
        public final Log logger = LogFactory.getLog(this.getClass());
        @Autowired
        RabbitAdmin rabbitAdmin;
    
        /**
         * 自定义的校验
         *
         * @param object
         */
        public abstract void DefinedValidate(Object object);
    
        /**
         * 通用校验
         * 1. 校验字段是否是非空
         *
         * @param object
         */
        public void validate(Object object) {
            Result result = ValidateUtils.validate(object);
            if (!ResultEnum.success().equals(result.getCode())) {
                RabbitMQExceptionUtils.throwRabbitMQException(result.getMsg());
            }
    
            this.DefinedValidate(object);
        }
    }

   @Component
    public class AmExchangeDeclare extends AbstractDeclare {
    
        @Autowired
        RabbitAdmin rabbitAdmin;
    
        /**
         * 向rabbitMQ服务器注册指定的交换机以及交换机的类型
         *
         * @param mqExchage
         * @return
         */
        public Exchange declareExchange(MqExchage mqExchage) {
            this.logger.info("declare exchange is :" + mqExchage.toString());
    
            Exchange exchange = null;
    
            super.validate(mqExchage);
            exchange = this.initExchange(mqExchage);
            this.rabbitAdmin.declareExchange(exchange);
    
            this.logger.info("declare exchange success");
            return exchange;
        }
    
        /**
         * 从RabbitMQ服务端上删除指定的交换机
         *
         * @param exchangeName
         * @return
         */
        public boolean deleteExchange(String exchangeName) {
            this.logger.info("delete exchange is : " + exchangeName);
    
            if (StringUtils.isEmpty(exchangeName)) {
                throw new RabbitMQException("the parameter exchangeName couldn't not be null");
            }
    
            return this.rabbitAdmin.deleteExchange(exchangeName);
        }
    
        /**
         * 根据不同类型初始化不同类型的交换机
         *
         * @param mqExchage
         * @return
         */
        private Exchange initExchange(MqExchage mqExchage) {
            ExchangeTypeEnum exchangeTypeEnum = mqExchage.getType();
            switch (exchangeTypeEnum) {
                case DIRECT:
                    return new DirectExchange(mqExchage.getName(), mqExchage.isDurable(), mqExchage.isAutoDelete(), mqExchage.getArguments());
                case TOPIC:
                    return new TopicExchange(mqExchage.getName(), mqExchage.isDurable(), mqExchage.isAutoDelete(), mqExchage.getArguments());
                case FANOUT:
                    return new FanoutExchange(mqExchage.getName(), mqExchage.isDurable(), mqExchage.isAutoDelete(), mqExchage.getArguments());
                case HEADERS:
                    return new HeadersExchange(mqExchage.getName(), mqExchage.isDurable(), mqExchage.isAutoDelete(), mqExchage.getArguments());
                default:
                    return null;
            }
        }
    
        /**
         * 自定义校验规则
         *
         * @param object
         */
        @Override
        public void DefinedValidate(Object object) {
    
        }
    }
    

队列的管理

队列是存储消息的载体，默认没有指定交换机的哈，队列的创建都是绑定RabbitMQ提供的默认的交换机，队列的创建和维护与交换机比较类似，见如下的代码:

Queue的管理

    public class MqQueue {
        /**
         * 队列名称
         */
        @NotNull(message = "队列名称不能为空")
        private String name;
        /**
         * 是否持久化
         * 持久化会存盘，服务器重启时不会丢失相关信息
         */
        private boolean durable;
        /**
         * 是否排他
         * 如果是排他，则该队列对首次声明他的连接有效，并在连接断开时自动删除
         * 注意：
         * 1. 同一个连接的其他的Channel是可以连接该排他队列的
         * 2. 首次是说其他连接就不同创建同名的排他队列
         * 适用于一个客户端同时发送和读取消息
         */
        private boolean exclusive;
        /**
         * 是否自动删除
         * 自动删除的前提是至少有一个队列或者交换机与这个交互机绑定，之后所有与这个交换机绑定的队列或者交换机都与此解绑
         */
        private boolean autoDelete;
        /**
         * 结构化参数
         * x-message-ttl、x-expires等
         */
        private Map<String, Object> arguments;
    
        public MqQueue name(String name) {
            this.name = name;
            return this;
        }
    
        public MqQueue durable(boolean durable) {
            this.durable = durable;
            return this;
        }
    
        public MqQueue exclusive(boolean exclusive) {
            this.exclusive = exclusive;
            return this;
        }
    
        public MqQueue autoDelete(boolean autoDelete) {
            this.autoDelete = autoDelete;
            return this;
        }
    
        public MqQueue arguments(Map<String, Object> arguments) {
            this.arguments = arguments;
            return this;
        }
    }

    @Component
    public class AmQueueDeclare extends AbstractDeclare {
    
        /**
         * 声明队列
         * 向rabbitMQ服务器声明一个队列
         *
         * @param mqQueue
         * @return
         */
        public Queue declareQueue(MqQueue mqQueue) {
            this.logger.info("the parameter queue is : " + mqQueue.toString());
    
            super.validate(mqQueue);
    
            Queue queue = new Queue(mqQueue.getName());
            BeanUtils.copyProperties(mqQueue, queue);
    
            this.logger.info("declare queue is : " + queue.toString());
    
            super.rabbitAdmin.declareQueue(queue);
    
            this.logger.info("declare queue success");
            return queue;
        }
    
        /**
         * 清空队列中的消息
         *
         * @param queueName
         * @return 清楚队列中的消息的个数
         */
        public int purgeQueue(String queueName) {
            if (StringUtils.isEmpty(queueName)) {
                RabbitMQExceptionUtils.throwRabbitMQException();
            }
            this.logger.info("purge queue is : " + queueName);
            return super.rabbitAdmin.purgeQueue(queueName);
        }
    
        /**
         * 判断指定的队列是否存在
         * 1. 如果存在则返回该队列
         * 2. 如果不存在则返回null
         *
         * @param queueName
         * @return true 存在， false 不存在
         */
        public boolean isQueueExist(String queueName) {
            if (StringUtils.isEmpty(queueName)) {
                RabbitMQExceptionUtils.throwRabbitMQException();
            }
    
            this.logger.info("isQueueExist queue is : " + queueName);
    
            String isExist = super.rabbitAdmin.getRabbitTemplate().execute((channel -> {
                try {
                    AMQP.Queue.DeclareOk declareOk = channel.queueDeclarePassive(queueName);
                    return declareOk.getQueue();
                } catch (Exception e) {
                    if (this.logger.isDebugEnabled()) {
                        RabbitMQExceptionUtils.throwRabbitMQException(e.getMessage());
                    }
                    return null;
                }
            }));
    
            this.logger.info("the queue " + queueName + " is exist : " + isExist);
            return StringUtils.isEmpty(isExist) ? Boolean.FALSE : Boolean.TRUE;
        }
    
        /**
         * 从rabbitMQ服务器中删除指定的队列
         *
         * @param queueName
         * @return
         */
        public boolean deleteQueue(String queueName) {
            this.logger.info("delete queue is :" + queueName);
    
            if (StringUtils.isEmpty(queueName)) {
                RabbitMQExceptionUtils.throwRabbitMQException();
            }
    
            return super.rabbitAdmin.deleteQueue(queueName);
        }
    
        /**
         * 从rabbitMQ服务器中删除指定的队列
         *
         * @param queueName 队列名称
         * @param unused    队列是否在使用，如果设置为true则该队列只能在没有被使用的情况下才能删除
         * @param empty     队列是否为空，如果设置为true则该队列只能在该队列没有消息时才会被删除
         */
        public void deleteQueue(String queueName, boolean unused, boolean empty) {
            this.logger.info("delete queue is : { queueName : '" + queueName
                    + "' , unused: '" + unused + "' , empty:'" + empty + "'}");
    
            if (StringUtils.isEmpty(queueName)) {
                RabbitMQExceptionUtils.throwRabbitMQException();
            }
    
            super.rabbitAdmin.deleteQueue(queueName, unused, empty);
        }
    
        /**
         * 自定义的校验
         *
         * @param object
         */
        @Override
        public void DefinedValidate(Object object) {
    
        }
    }

Bing绑定

上一篇博文中我们详细介绍了交换机和队列之间的关系：生产者将消息投递给交换机，然后由交换器路由到一个或多个队列中，在这里我们需要重点理解下，交换机是如何路由到对应的队列？也可以理解为：交换机如何和队列进行绑定。

在理解前，我们需要知道两个概念：RoutingKey和BindingKey

生产者将消息发送给交换机，一般会指定一个RoutingKey，通过这个指定这个消息的路由规则，而这个RoutingKey需要与交换机的类型和Bindingkey联合使用才能生效。

RoutingKey是决定消息的流向的，生产者将消息发送给交换机时，需要一个RoutingKey，当BindingKey和RoutingKey相匹配时，消息会被路由到对应的队列中。

BindingKey可以是相同的，但是在Fanout类型的交换机时不生效的

上面说的可能比较晦涩，我们打个比方应该就比较容易理解了

还是之前我们的邮局投递邮件，RoutingKey相当于邮件上的地址，而BindingKey则相当于邮件的目的地，当地址和目的地是相匹配的时候，收件人（队列）才能收到邮件，如果不一致的话，则邮件可能会送不到，或者返回给发件人或者邮件丢失等

    @Component
    public class AmBindDeclare extends AbstractDeclare {
    
    
        @Autowired
        RabbitAdmin rabbitAdmin;
    
        /**
         * 队列与交换机进行绑定
         *
         * @param queueName    队列名称
         * @param exchangeName 交换机名称
         * @param routingKey   路由键
         * @return
         */
        public boolean queueBind(String queueName, String exchangeName, String routingKey) {
            return this.bing(queueName, Binding.DestinationType.QUEUE, exchangeName, routingKey, null);
        }
    
        /**
         * 交换机和交换机进行绑定
         *
         * @param destExchangeName 目标交换机名称
         * @param exchangeName     交换机名称
         * @param routingKey       路由键
         * @return
         */
        public boolean exchangeBind(String destExchangeName, String exchangeName, String routingKey) {
            return this.bing(destExchangeName, Binding.DestinationType.EXCHANGE, exchangeName, routingKey, null);
        }
    
        /**
         * bind绑定
         *
         * @param destName     目标名称（可以是队列 也可以是交换机）
         * @param type         绑定的类型 交换机 / 队列
         * @param exchangeName 交换机的名称
         * @param routingKey   路由键
         * @param map          结构参数
         * @return
         */
        private boolean bing(String destName, Binding.DestinationType type, String exchangeName, String routingKey, Map<String, Object> map) {
            this.logger.info("bind parameter is destName: " + destName + ", type: " + type.name()
                    + ", exchangeName: " + exchangeName + ", routingKey: " + routingKey + ", map: " + map.toString());
    
            Binding binding = new Binding(destName, Binding.DestinationType.QUEUE, exchangeName, routingKey, map);
            try {
                this.rabbitAdmin.declareBinding(binding);
            } catch (Exception e) {
                if (this.logger.isDebugEnabled()) {
                    RabbitMQExceptionUtils.throwRabbitMQException(e.getMessage());
                }
                return Boolean.FALSE;
            }
    
            return Boolean.TRUE;
        }
    
        @Override
        public void DefinedValidate(Object object) {
    
        }
    }