RabbitMQ整合Springboot

0-前言

RabbitMQ是消息队列的一种，但其不是基于JMS实现的，而是基于AMQP（Advanced Message Queue，高级消息队列协议）实现的，因此RabbitMQ的结构与传统的消息队列有很大的区别。

1-结构介绍

结构.png

与基于JMS实现的消息队列中仅有消费者、生产者和队列不同，AMQP中还增加了Exchange、Binding和Virtual Host的概念。

• Exchange
  Exchange是交换器，用于和生产者进行连接，在这种模式下生产者和队列是隔离的，可以认为是生产者发送消息通过Exchange进行路由最终到达Queue。常用的Exchange类型有三种，分别是direct、fanout和topic。
• Binding
  Binding不是实际的组件，而是一种路由规则，简单理解就是指定了Exchange和Queue之间的关联关系。

• Virtual Host
  每个Virtual Host相当于一个相对独立的RabbitMQ服务器，每个Virtual Host之间是相互隔离的，其中的Exchange、Queue、Message等都是不能互通的。如下图所示为guest用户的Virtual Host，其命名为默认值"/"（这里的"/"只代表一个名称没有任何含义）。

  
  
  virtual host.png

2-代码实现

在springboot框架中集成rabbitmq非常简单，首先需要在pom中引入依赖

    
        org.springframework.boot
        spring-boot-starter-amqp
    

然后填写配置文件

spring.rabbitmq.host=127.0.0.1
spring.rabbitmq.port=5672
spring.rabbitmq.username=guest
spring.rabbitmq.password=guest
spring.rabbitmq.virtual-host=/

这里要注意的是配置的用户一定要是具有对应的Virtual Host访问权限，否则无法连接Rabbitmq。
最后根据Exchange类型的不同有不同的代码实现，下面逐一介绍。

2.1-Direct模式

direct.png

从示意图可以看出该模式是通过发送消息的routing key进行完全匹配的，这里的routing key匹配的是Queue的队列名称，只有当两者完全一致时才会将消息转发到该Queue中。这与JMS中queue队列的模式非常相似。
代码实现首先需要创建配置类：

@Configuration
public class SenderConf {

    @Bean
    public Queue queue() {
         return new Queue("one");
    }
    
    @Bean
    public Queue queue2() {
        return new Queue("two");
    }
}

接着创建生产者类

@Service
public class RabbitMQProvider {

    @Autowired
    private AmqpTemplate template;
    
    public boolean send() {
        template.convertAndSend("one",  "direct test~~~");
        return true;
    }
}

最后创建消费者

@Service
public class RabbitMQConsumer {

    @RabbitListener(queues = "one")
    public void recevier(String message){
        System.out.println("one收到的 message 是：" + message);
    }
    
    @RabbitListener(queues = "two")
    public void recevier2(String message){
        System.out.println("two收到的 message 是：" + message);
    }
}

调用send()方法运行结果为

one收到的 message 是：direct test~~~

由于发送消息时设置的routing key为one，因此只有队列one能收到消息，two无法收到。

2.2-Fanout模式

fanout.png

从示意图可以看出，该模式下只要是绑定了Exchange的Queue，都会收到发送至该Exchange的消息，有点类似于JMS中的virtual topic模式。
代码实现首先需要创建配置类：

@Configuration
public class SenderConf {

    @Bean
    public Queue queue() {
         return new Queue("one");
    }
    
    @Bean
    public Queue queue2() {
        return new Queue("two");
    }
    
    @Bean
    FanoutExchange exchange() {
        return new FanoutExchange("fanout");
    }
    
    @Bean
    Binding bindingExchangeMessage(Queue queue, FanoutExchange exchange) {
        return BindingBuilder.bind(queue).to(exchange);
    }
    
    @Bean
    Binding bindingExchangeMessage2(Queue queue2, FanoutExchange exchange) {
        return BindingBuilder.bind(queue2).to(exchange);
    }
}

接着创建生产者类

@Service
public class RabbitMQProvider {

    @Autowired
    private AmqpTemplate template;
    
    public boolean send() {
        template.convertAndSend("fanout", "any", "fanout test~~~");//此处"any"不起任何路由作用
        return true;
    }
}

最后创建消费者

@Service
public class RabbitMQConsumer {

    @RabbitListener(queues = "one")
    public void recevier(String message){
        System.out.println("one收到的 message 是：" + message);
    }
    
    @RabbitListener(queues = "two")
    public void recevier2(String message){
        System.out.println("two收到的 message 是：" + message);
    }
}

调用send()方法运行结果为

two收到的 message 是：fanout test~~~
one收到的 message 是：fanout test~~~

由运行结果可以看到绑定了FanoutExchange的one和two都接收到了消息。

2.3-Topic模式

topic.png

从示意图可以看出，该模式下可以根据消息的routing key与binding key的匹配关系进行路由，这里的key可以由多个单词组成，这些单词之间用.隔开。这里允许使用两个通配符：符号#和符号。#匹配0个或多个单词，匹配1个单词。
代码实现首先需要创建配置类：

@Configuration
public class SenderConf {

    @Bean(name = "one")
    public Queue queue() {
        return new Queue("one");
    }

    @Bean(name = "two")
    public Queue queue2() {
        return new Queue("two");
    }

    @Bean
    TopicExchange exchange() {
        return new TopicExchange("exchange");
    }

    @Bean
    Binding bindingExchangeMessage(@Qualifier("one")Queue queue, TopicExchange exchange) {
        return BindingBuilder.bind(queue).to(exchange).with("topic.#");
    }

    @Bean
    Binding bindingExchangeMessage2(@Qualifier("two")Queue queue, TopicExchange exchange) {
        return BindingBuilder.bind(queue).to(exchange).with("topic.match");
    }
}

接着创建生产者类

@Service
public class RabbitMQProvider {

    @Autowired
    private AmqpTemplate template;

    public boolean send1() {
        template.convertAndSend("exchange", "topic.match",  "topic-1 test~~~");
        return true;
    }

    public boolean send2() {
        template.convertAndSend("exchange", "topic.all",  "topic-2 test~~~");
        return true;
    }

}

最后创建消费者

@Service
public class RabbitMQConsumer {

    @RabbitListener(queues = "one")
    public void recevier(String message) {
        System.out.println("one收到的 message 是：" + message);
    }

    @RabbitListener(queues = "two")
    public void recevier2(String message) {
        System.out.println("two收到的 message 是：" + message);
    }
}

分别调用send1()和send2()方法，运行结果分别为

two收到的 message 是：topic-1 test~~~
one收到的 message 是：topic-1 test~~~

one收到的 message 是：topic-2 test~~~

从结果可以看到当routing key为topic.match时，binding key为topic.#和topic.match的one和two队列都能接收到消息；而当routing key为topic.all时，只有binding key为topic.#的one队列才能接收到消息。

3-总结

本文对RabbitMQ的消息路由原理进行了简单介绍，并对三种常用的Exchange模式及其在Springboot中的集成做了讲解。