SpringAMQP学习二（Basic Queue 简单队列模型、Work Queue 工作队列模型、发布、订阅模型-Fanout）

SpringAMQP是基于RabbitMQ封装的一套模板，并且还利用SpringBoot对其实现了自动装配，使用起来非常方便。

SpringAmqp的官方地址：https://spring.io/projects/spring-amqp

SpringAMQP提供了三个功能：

自动声明队列、交换机及其绑定关系
基于注解的监听器模式，异步接收消息
封装了RabbitTemplate工具，用于发送消息

1、Basic Queue 简单队列模型

在上一个RabitMQ的HelloWord工程中完成队列模型的快速入门

入门案例：消息发送

在父工程mq-demo中引入依赖

<!--AMQP依赖，包含RabbitMQ-->
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-amqp</artifactId>
</dependency>

在`publisher`模块的`application.yml`配置文件中配置mq的连接信息

# 配置mq的连接信息
spring:
  rabbitmq:
    host: 192.168.26.131 # rabbitmq的宿主ip地址
    port: 5672 # 访问端口
    username: itcast
    password: 123321
    virtual-host: / # 虚拟主机

在`publisher`模块中建立一个测试类，编写测试方法

package cn.itcast.mq.spring;

import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.amqp.rabbit.core.RabbitAdmin;
import org.springframework.amqp.rabbit.core.RabbitTemplate;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;

/**
 * 项目名称：mq-demo
 * 描述：SpringAMQP测试发送信息
 *
 * @author zhong
 * @date 2022-05-31 10:59
 */
@RunWith(SpringJUnit4ClassRunner.class)
@SpringBootTest
public class SpringAMQPTest {
      
      
    /**
     * 注入对象
     */
    @Autowired
    RabbitTemplate rabbitTemplate;

    /**
     * 测试类
     */
    @Test
    public void testsendMessage() {
      
      
        // 队列名称
        String queueName = "simple.queue";
        // 队列内容
        String message = "hello,Spring AMQP";
        rabbitTemplate.convertAndSend(queueName,message);
    }
}

测试运行成功后，访问rabbitmq管理查看队列消息，再运行接收的队列消息的程序

入门案例：消息接收

在`consumer`中编写消费逻辑，监听Simple.queued

在publisher模块的application.yml配置文件中配置mq的连接信息

入上面的一样

创建一个``类型进行测试

package cn.itcast.mq.listener;

import org.springframework.amqp.rabbit.annotation.RabbitListener;
import org.springframework.stereotype.Component;

/**
 * 项目名称：mq-demo
 * 描述：SpringAMQP接收队列消息
 *
 * @author zhong
 * @date 2022-05-31 12:00
 */
@Component
public class SpringRabbitListener {
      
      

    /**
     * 接收队列消息
     */
    @RabbitListener(queues = "simple.queue")
    public void listenerSimpleQueue(String msg) {
      
      
        System.out.println("接收到simple.queue队列消息："+msg);
    }
}

启动springboot的main函数，查看接收的队列消息

测试结果

当我有两个消费者的时候，我发送一条消息，消费者同时运行，只能一个人接收，轮流来
单我没有运行消费者时，发送的队列消息不会缓存到rabbitmq中【可能是电脑问题，目前再次测试又可以了】
队列消息被接受之后就会销毁，不会被回溯

2、Work Queue 工作队列模型

Work queues，也被称为（Task queues），任务模型。简单来说就是让多个消费者绑定到一个队列，共同消费队列中的消息。

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-y7uYcRMc-1653987963298)(images/image-20220531143136237.png)]

当消息处理比较耗时的时候，可能生产消息的速度会远远大于消息的消费速度。长此以往，消息就会堆积越来越多，无法及时处理。

此时就可以使用work 模型，多个消费者共同处理消息处理，速度就能大大提高了。

模拟WorkQueue，实现一个队列绑定多个消费者

在publisher服务中定义测试方法，每秒产生50条信息，发送到simple.queue队列中【发送者】

/**
 * workqueue
 * @throws InterruptedException
 */
@Test
public void testsendWorkQueue() throws InterruptedException {
      
      
    // 队列名称
    String queueName = "simple.queue";
    // 消息
    String message = "hello, message___";
    for (int i = 1; i <= 50;i++) {
      
      
        // 发送消息
        rabbitTemplate.convertAndSend(queueName, message+i);
        // 线程休眠
        Thread.sleep(20);
    }
}

在consumer服务中定义两个信息监听者，都监听simple.queue队列【消费者】

/**
 * 接收队列消息
 */
@RabbitListener(queues = "simple.queue")
public void listenerworkQueue1(String msg) throws InterruptedException {
      
      
    System.out.println("消费者1接收的队列消息：："+msg +"当前接收消息时间为："+ LocalDateTime.now());
    Thread.sleep(20);
}

@RabbitListener(queues = "simple.queue")
public void listenerworkQueue2(String msg) throws InterruptedException {
      
      
    System.err.println("消费者2__________接收的队列消息：："+msg +"当前接收消息时间为："+ LocalDateTime.now());
    Thread.sleep(200);
}

消费者1每秒处理50条消息，消费者2每秒处理10条消息
启动测试

启动ConsumerApplication后，在执行publisher服务中刚刚编写的发送测试方法testWorkQueue。

可以看到消费者1很快完成了自己的25条消息。消费者2却在缓慢的处理自己的25条消息。

也就是说消息是平均分配给每个消费者，并没有考虑到消费者的处理能力。这样显然是有问题的。
能者多劳分配

在spring中有一个简单的配置，可以解决这个问题。我们修改consumer服务的application.yml文件，添加配置：
```
spring:
  rabbitmq:
    listener:
      simple:
        prefetch: 1 # 每次只能获取一条消息，处理完成才能获取下一个消息
```
再次运行测试就会发现，消费者一获取的消息会更多了，而消费者而就会量力而行

Work模型的使用：

多个消费者绑定到一个队列，同一条消息只会被一个消费者处理
通过设置prefetch来控制消费者预取的消息数量

发布/订阅

发布订阅的模型如图：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-gqNIQ03D-1653987963299)(images/image-20220531150000104.png)]

可以看到，在订阅模型中，多了一个exchange角色，而且过程略有变化：

Publisher：生产者，也就是要发送消息的程序，但是不再发送到队列中，而是发给X（交换机）
Exchange：交换机，图中的X。一方面，接收生产者发送的消息。另一方面，知道如何处理消息，例如递交给某个特别队列、递交给所有队列、或是将消息丢弃。到底如何操作，取决于Exchange的类型。Exchange有以下3种类型：
- Fanout：广播，将消息交给所有绑定到交换机的队列
- Direct：定向，把消息交给符合指定routing key 的队列
- Topic：通配符，把消息交给符合routing pattern（路由模式）的队列
Consumer：消费者，与以前一样，订阅队列，没有变化
Queue：消息队列也与以前一样，接收消息、缓存消息。

Exchange（交换机）只负责转发消息，不具备存储消息的能力，因此如果没有任何队列与Exchange绑定，或者没有符合路由规则的队列，那么消息会丢失！

3、发布、订阅模型-Fanout

Fanout，英文翻译是扇出，我觉得在MQ中叫广播更合适。

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-vF6QLe64-1653987963299)(images/image-20220531150410601.png)]

在广播模式下，消息发送流程是这样的：

1）可以有多个队列
2）每个队列都要绑定到Exchange（交换机）
3）生产者发送的消息，只能发送到交换机，交换机来决定要发给哪个队列，生产者无法决定
4）交换机把消息发送给绑定过的所有队列
5）订阅队列的消费者都能拿到消息

我们的计划是这样的：

创建一个交换机 itcast.fanout，类型是Fanout
创建两个队列fanout.queue1和fanout.queue2，绑定到交换机itcast.fanout

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-u8cGR6nX-1653987963300)(images/image-20220531150422929.png)]

声明队列和交换机

Spring提供了一个接口Exchange，来表示所有不同类型的交换机：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-UKCcDFah-1653987963300)(images/image-20220531150443700.png)]

在`consumer`中创建一个类，声明队列和交换机：

package cn.itcast.mq.config;

import org.springframework.amqp.core.Binding;
import org.springframework.amqp.core.BindingBuilder;
import org.springframework.amqp.core.FanoutExchange;
import org.springframework.amqp.core.Queue;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

/**
 * 项目名称：mq-demo
 * 描述：声明队列与交换机
 *
 * @author zhong
 * @date 2022-05-31 15:05
 */
@Configuration
public class FanoutConfig {
    
    

    /**
     * 声明交换机
     * @return
     */
    @Bean
    public FanoutExchange fanoutExchange(){
    
    
        return new FanoutExchange("zcl.fanout");
    }

    /**
     * 创建队列1
     * @return
     */
    @Bean
    public Queue fanoutQueue1() {
    
    
        return new Queue("zcl.queue1");
    }

    /**
     * 队列与交换机绑定1
     * @param fanoutExchange 交换机
     * @param fanoutQueue1 队列
     * @return
     */
    @Bean
    public Binding fanoutBinding(FanoutExchange fanoutExchange,Queue fanoutQueue1) {
    
    
        return BindingBuilder.bind(fanoutQueue1).to(fanoutExchange);
    }

    /**
     * 创建队列2
     * @return
     */
    @Bean
    public Queue fanoutQueue2() {
    
    
        return new Queue("zcl.queue2");
    }

    /**
     * 队列与交换机绑定2
     * @param fanoutExchange 交换机
     * @param fanoutQueue2 队列
     * @return
     */
    @Bean
    public Binding fanoutBinding2(FanoutExchange fanoutExchange,Queue fanoutQueue2) {
    
    
        return BindingBuilder.bind(fanoutQueue2).to(fanoutExchange);
    }
}

启动springboot引导类，就可以到rabbitmq的管理页面查看消息了

查看交换机
查看队列
点击交换机查看绑定关系

在消费者中编写接收队列消息代码

@RabbitListener(queues = "zcl.queue1")
public void listenerFanoutQueue1(String msg) throws InterruptedException {
    
    
    System.out.println("消费者接收到了zcl.queue1队列消息："+msg);
}

@RabbitListener(queues = "zcl.queue2")
public void listenerFanoutQueue2(String msg) throws InterruptedException {
    
    
    System.out.println("消费者接收到了zcl.queue2队列消息："+msg);
}

重启消费者服务代码

编写消息发送者代码

/**
 * 发送消息到交换机
 */
@Test
public void testFanoutExchange(){
    
    
    String exchangeName = "zcl.fanout";
    String message = "hello, every one!";
    rabbitTemplate.convertAndSend(exchangeName,"",message);
}

这一次发送消息，两个队列都会接收到数据

总结

交换机的作用是什么？

接收publisher发送的消息
将消息按照规则路由到与之绑定的队列
不能缓存消息，路由失败，消息丢失
FanoutExchange的会将消息路由到每个绑定的队列

声明队列、交换机、绑定关系的Bean是什么？

Queue
FanoutExchange
Binding