浅谈RabbitMQ——拒绝繁琐概念，简单搞懂MQ

MQ简介

我个人觉得MQ归根结底就好似方法的调用，假如我在网上买个东西
当我下单的那一刻，可能会发生如下操作
1.去我的银行卡中扣款
2.将此物品添加到我的购买记录中
3.将此物品的信息从我的购物车中删除
4.将此订单的信息添加到订单表中
5.在商家那里记录此物品的数量-1，并记录下顾客的信息
6.然后可能还会根据你所购买的物品来推荐你感兴趣的物品
可能还有等等操作

然后如果我们写demo的时候，这些操作都可以放到一个方法中，然后去挨个调用，当然可能耗时会久一些，而且一个方法中操作过多的时候出问题的几率也会增加

并且在微服务项目中，如果将这些服务都进行拆分，那么互相引用也是很繁琐的，一个操作就要去引多个service

所以有了MQ去帮我们解决这些问题，当有了MQ之后，当我们下单之后的场景就会变成这样
MQ将我下单的消息以及我的信息，商品的信息去发送到各个服务
1.支付业务中的MQ消费者会读取到我的信息，然后去进行扣款操作
2.订单服务中的MQ消费者就会去接收到相关信息，生成订单并保存
3.商户服务中的MQ消费者会接收到信息，进行操作等等

而且当双11的时候数据量猛然增大，为了减轻服务器压力，不要紧的服务可以去慢慢消费
这里就完成了MQ的异步，削峰，以及解耦

简单的消息生产消费模型

接下来我们看如何在Java代码中对其进行操作
首先我们来看最简单的操作，一个消费者，一个生产者，还有一个队列
因为我们要把消息投递到某个队列中，消费者才能去消费
1.首先spring集成了相关的依赖，对其进行引入

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

2.在yml文件中进行配置

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

3.编写消息生产者，指定队列的名称，以及要发送的消息，这样一个简单的消息生产者就写好了

@Component
public class MsgProducer {
  @Autowired
  private RabbitTemplate rabbitTemplate;

  public void sendMsg() {
    String queueName = "queue";
    String message = "hello world";
    rabbitTemplate.convertAndSend(queueName,message);
  }

4.编写消息消费者，在这里使用@RabbitListener注解去监听队列，当这个队列被投递进消息后，就会立刻去接收，消费掉的消息就会消失掉，相当于阅后即焚

@Component
public class MsgReceiver {
  @RabbitListener(queues = "queue")
  public void process(String content) {
    System.out.println("接收处理队列A当中的消息： " + content);
  }
}

上面是一个简单的消息发布消费模型，但是在实际业务中，假设订单和商品都有消费者，当我们下单之后，想要将这个消息分别投递给两个服务中的消费者，因为按照上面的模式，被订单服务给消费了之后，商品服务就无法接收了，这肯定是不合理的

引入交换机之后的消息生产消费模型

所以MQ引入了exchange（交换机）这一概念
常见的exchange类型分为三种，只负责消息转发
Fanout：广播
Direct：路由
Topic：话题

Fanout：（绑定模式）

是去将交换机与队列进行绑定
代码如下：

@Configuration
public class FanoutConfig {
  // 声明交换机
  @Bean
  public FanoutExchange fanoutExchange() {
    return new FanoutExchange("fanout");
  }

  // 声明第一个队列
  @Bean
  public Queue fanoutQueue1() {
    return new Queue("fanout:Queue1");
  }

  // 声明第二个队列
  @Bean
  public Queue fanoutQueue2() {
    return new Queue("fanout:Queue2");
  }

  // 绑定第一个队列与交换机
  @Bean
  public Binding bindingQueue1(Queue fanoutQueue1, FanoutExchange fanoutExchange) {
    return BindingBuilder.bind(fanoutQueue1).to(fanoutExchange);
  }
  // 绑定第二个队列与交换机
  @Bean
  public Binding bindingQueue2(Queue fanoutQueue2, FanoutExchange fanoutExchange) {
    return BindingBuilder.bind(fanoutQueue2).to(fanoutExchange);
  }

下图是消息生产者，我们将消息发到之前声明的交换机中，中间为空的参数是routingKey，这个我们下面再说

@Component
public class MsgProducer {
  @Autowired
  private RabbitTemplate rabbitTemplate;

  public void sendMsg() {
    String exchangeName = "fanout";
    String message = "hello world";
    rabbitTemplate.convertAndSend(exchangeName,"",message);
  }
}

如下是消息消费者

@RabbitListener(queues = "fanout:Queue1")
  public void process1(String content) {
    System.out.println("接收处理队列当中的消息： " + content);
  }

  @RabbitListener(queues = "fanout:Queue2")
  public void process2(String content) {
    System.out.println("接收处理队列当中的消息： " + content);
  }

这样两个消费者会收到相同的消息，因为我们定义了这个交换机与两个队列进行绑定

Direct：（路由模式）

它会将消息按照规则路由到指定的队列

首先我们还是去写一个消息生产者，同样的是去指定队列以及发送消息，和上面不一样的地方就是这个convertAndSend方法中第二个参数有数值了，我们接着往下看

public void sendDirectMsgOne() {
    String exchangeName = "direct";
    String message = "hello world";
    rabbitTemplate.convertAndSend(exchangeName,"order",message);
  }
 public void sendDirectMsgTwo() {
    String exchangeName = "direct";
    String message = "hello world";
    rabbitTemplate.convertAndSend(exchangeName,"admin",message);
 }

下面这段代码是通过@RabbitListener注解将交换机与队列进行绑定
然后这个key的作用就是接收上面传过来的convertAndSend方法的第二个参数
如果上面传过来的是order则被队列1去消费，如果是commodity则被队列2去消费
如果传过来的是admin两个队列就会都去消费

@RabbitListener(bindings = @QueueBinding(value = @Queue(name = "direct.queue1"),
      exchange = @Exchange("direct"), key = {"order","admin"}))
  public void process1(String content) {
    System.out.println("接收处理队列1当中的消息： " + content);
  }

  @RabbitListener(bindings = @QueueBinding(value = @Queue(name = "direct.queue2"),
      exchange = @Exchange("direct"), key = {"commodity","admin"}))
  public void process2(String content) {
    System.out.println("接收处理队列2当中的消息： " + content);
  }

Topic（话题模式）

Topic交换机和Direct很像，区别就是它的key必须是多个单词的列表，并以.进行分割
比如 sport.basketball (代表体育中的篮球) sport.football (代表体育中的足球)
因为实际业务中的复杂情况，可能会配置多种多样的key，如果按照Direct交换机，则要去指定很多个key，是非常繁琐的，所以为了简化配置，就有了Topic交换机模式
而且还支持通配符
#：代指0个或多个单词
*：代指一个单词

消息生产者代码如下：

public void sendTopicMsg() {
    String exchangeName = "topic";
    String message = "hello world";
    rabbitTemplate.convertAndSend(exchangeName,"sport.football",message);
  }

消息消费者代码如下：

@RabbitListener(bindings = @QueueBinding(value = @Queue(name = "topic.queue1"),
      exchange = @Exchange(value = "topic", 
      type = ExchangeTypes.TOPIC), 
      key = {"sport.*"}))
  public void process1(String content) {
    System.out.println("接收处理队列1当中的消息： " + content);
  }

  @RabbitListener(bindings = @QueueBinding(value = @Queue(name = "topic.queue2"),
      exchange = @Exchange(value = "topic", 
      type = ExchangeTypes.TOPIC), 
      key = {"*.football"}))
  public void process2(String content) {
    System.out.println("接收处理队列2当中的消息： " + content);
  }

这样下面这两个消费者都会消费到消息，如果我们将生产者里的sport.football改为sport.basketball,
那样就只有队列1可以消费到