安装文件：RabbitMQ部署指南.md

1.什么是同步请求?优缺点?

  1. 代替服务器，使用mq减少服务器的使用，
  2. 同步请求，同一时间只能做一件事，
  3.   优点点：及时性很强
  4.   缺点：耦合度高，出现级联问题

2.什么是异步请求?优缺点?

  1. 同一时间只能做多件事，
  2.   优点：
  3.   - 吞吐量提升：无需等待订阅者处理完成，响应更快速
  4.   - 故障隔离：服务没有直接调用，不存在级联失败问题
  5.   - 调用间没有阻塞，不会造成无效的资源占用
  6.   - 耦合度极低，每个服务都可以灵活插拔，可替换
  7.   - 流量削峰：不管发布事件的流量波动多大，都由Broker接收，订阅者可以按照自己的速度去处理事件
  8.   缺点：
  9.       - 数据不一致
  10.       - 架构复杂了，业务没有明显的流程线，不好管理
  11.     - 需要依赖于Broker的可靠、安全、性能

3.同步请求和异步请求区别?

  1.   吞吐量提升：无需等待订阅者处理完成，响应更快速
  2.   故障隔离：服务没有直接调用，不存在级联失败问题
  3.   调用间没有阻塞，不会造成无效的资源占用
  4.   耦合度极低，每个服务都可以灵活插拔，可替换
  5.   流量削峰：不管发布事件的流量波动多大，都由Broker接收，订阅者可以按照自己的速度去处理事件

4.RabbitMQ通讯模型架构是什么?

  1. 消息生产者-》通道-》mq（虚拟主机-》exchange-》queue）-》通道消费者

5.名词解释

  1. Borker是什么: MQ消息队列
  2. Virtual Host是什么:虚拟主机
  3. Exchange 是什么什么作用: 
  4. Queue是什么什么作用: 队列用于存储数据

6.RabbitMQ常见的5种工作模式

  1. 1、HelloWorld 入门、基本模式
  2.       单生产-》队列（只有一个队列，交换机省去不写，默认交换机与队列名称一致）-》
  3.   单消费
  4. 2、work 工作模式
  5.       单生产-》队列-》多消费
  6. 3、fanout 扇出（广播）  
  7.     多生产-》交换机-》多个队列-》多个消费
  8. 4、Direct 路由模式
  9.       发送消息到交换机并且要指定路由key ，消费者将队列绑定到交换机时需要指定路由key
  10. 5、topic模式
  11.   将路由键和某模式进行匹配，此时队列需要绑定在一个模式上，“#”匹配一个词或多个词，“*”只匹配一个词。

7.简述RabbitMQ发送消息时的链路

  1.   // 1.建立连接
  2.         ConnectionFactory factory = new ConnectionFactory();
  3.         // 1.1.设置连接参数，分别是：主机名、端口号、vhost、用户名、密码
  4.         factory.setHost("192.168.200.129");
  5.         factory.setPort(5672);
  6.         factory.setVirtualHost("/");
  7.         factory.setUsername("itcast");
  8.         factory.setPassword("1234");
  9.         // 1.2.建立连接
  10.         Connection connection = factory.newConnection();
  12.         // 2.创建通道Channel
  13.         Channel channel = connection.createChannel();
  15.         // 3.创建队列
  16.         String queueName = "simple.queue";
  17.         channel.queueDeclare(queueName, false, false, false, null);
  19.         // 4.发送消息
  20.         String message = "hello, rabbitmq!";
  21.         channel.basicPublish("", queueName, null, message.getBytes());
  22.         System.out.println("发送消息成功：【" + message + "】");
  24.         // 5.关闭通道和连接
  25.         channel.close();
  26.         connection.close();

8.简述RabbitMQ接收消息时的链路

 // 1.建立连接
        ConnectionFactory factory = new ConnectionFactory();
        // 1.1.设置连接参数，分别是：主机名、端口号、vhost、用户名、密码
        factory.setHost("192.168.200.129");
        factory.setPort(5672);
        factory.setVirtualHost("/");
        factory.setUsername("itcast");
        factory.setPassword("1234");
        // 1.2.建立连接
        Connection connection = factory.newConnection();

        // 2.创建通道Channel
        Channel channel = connection.createChannel();

        // 3.创建队列
        String queueName = "simple.queue";
        channel.queueDeclare(queueName, false, false, false, null);

        // 4.订阅消息
        channel.basicConsume(queueName, true, new DefaultConsumer(channel){
            @Override
            public void handleDelivery(String consumerTag, Envelope envelope,
                                       AMQP.BasicProperties properties, byte[] body) throws IOException {
                // 5.处理消息
                String message = new String(body);
                System.out.println("接收到消息：【" + message + "】");
            }
        });
        System.out.println("等待接收消息。。。。");
    }

9.SpringAMQP使用步骤

1、在父工程mq中引入依赖
  <!--AMQP依赖，包含RabbitMQ-->
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-amqp</artifactId>
</dependency>
2、配置publisher服务的application.yml
  spring:
  rabbitmq:
    host: 192.168.200.129 # 主机名
    port: 5672 # 端口
    virtual-host: / # 虚拟主机
    username: itcast # 用户名
    password: 1234 # 密码
 3、测试
 4、消息接收consumer服务的application.yml
spring:
  rabbitmq:
    host: 192.168.200.129 # 主机名
    port: 5672 # 端口
    virtual-host: / # 虚拟主机
    username: itcast # 用户名
    password: 1234 # 密码
    listener:
      simple:
        prefetch: 1
  5、consumer服务的cn.itcast.mq.listener包中新建一个类SpringRabbitListener
    @RabbitListener(queues = "simple.queue")
    public void listenSimpleQueueMessage(String msg) throws InterruptedException {
        System.out.println("spring 消费者接收到消息：【" + msg + "】");
    }

10.常见的5种工作模式示例代码

1、入门模式
  /**
     * 入门 helloworld
     * @param msg
     * @throws InterruptedException
     */
    @RabbitListener(queues = "simple.queue")
    public void listenSimpleQueueMessage(String msg) throws InterruptedException {
        System.out.println("spring 消费者接收到消息：【" + msg + "】");
    }
2、工作模式
  /**
     * wordk 工作模式 按劳分配
     * @param msg
     * @throws InterruptedException
     */

    @RabbitListener(queues = "simple.queue")
    public void listenSimpleQueueMessage1(String msg) throws InterruptedException {
        System.out.println("spring 消费者接收到消息：【" + msg + "】1");
        Thread.sleep(20);
    }
    @RabbitListener(queues = "simple.queue")
    public void listenSimpleQueueMessage2(String msg) throws InterruptedException {
        System.out.println("spring 消费者接收到消息：【" + msg + "】2");
        Thread.sleep(200);
    }
3、发布、订阅模式
  消费者
  /**
 * @author: hanyaning
 * @date: 2022/06/25
 * @description:
 */
@Configuration
public class FanoutConfig {

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

    /**
     * 第1个队列
     */
    @Bean
    public Queue fanoutQueue1(){
        return new Queue("fanout.queue1");
    }

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

    /**
     * 第2个队列
     */
    @Bean
    public Queue fanoutQueue2(){
        return new Queue("fanout.queue2");
    }

    /**
     * 绑定队列和交换机
     */
    @Bean
    public Binding bindingQueue2(Queue fanoutQueue2, FanoutExchange fanoutExchange){
        return BindingBuilder.bind(fanoutQueue2).to(fanoutExchange);
    }
}
  /**
     * 发布、订阅模式
     * @param msg
     */
    @RabbitListener(queues = "fanout.queue1")
    public void listenFanoutQueue1(String msg) {
        System.out.println("消费者1接收到Fanout消息：【" + msg + "】");
    }

    @RabbitListener(queues = "fanout.queue2")
    public void listenFanoutQueue2(String msg) {
        System.out.println("消费者2接收到Fanout消息：【" + msg + "】");
    }
    发布者：
        /**
     * fanout 扇出
     */
    @Test
    public void testFanoutExchange() {
        // 队列名称
        String exchangeName = "itcast.fanout";
        // 消息
        String message = "hello, everyone!";
        rabbitTemplate.convertAndSend(exchangeName, "", message);
    }
四、路由模式
  发布者
  /**
     *  direct
     */
    @Test
    public void testSendDirectExchange() {
        // 交换机名称
        String exchangeName = "di.exchange";
        // 消息
        String message = "红色警报！日本乱排核废水，导致海洋生物变异，惊现哥斯拉！";
        // 发送消息
        rabbitTemplate.convertAndSend(exchangeName, "red", message);
        rabbitTemplate.convertAndSend(exchangeName, "blue", message);
        rabbitTemplate.convertAndSend(exchangeName, "green", message);
        rabbitTemplate.convertAndSend(exchangeName, "yellow", message);
    }
    消费者：
      /**
     * direct
     * @param msg
     */
    @RabbitListener(bindings = @QueueBinding(
            value = @Queue("di.queue"),
            exchange = @Exchange("di.exchange"),
            key = {
                    "red","blue"
            }
    ))
    public void listenFanoutQueue1(String msg) {
        System.out.println("消费者1接收到Fanout消息：【" + msg + "】");
    }

    @RabbitListener(bindings = @QueueBinding(
            value = @Queue("di.queue1"),
            exchange = @Exchange("di.exchange"),
            key = {
                    "green","yellow"
            }
    ))
    public void listenFanoutQueue2(String msg) {
        System.out.println("消费者2接收到Fanout消息：【" + msg + "】");
    }
    5、Topic模式
      消费者
        @RabbitListener(bindings = @QueueBinding(
            value = @Queue("top.queue3"),
            exchange = @Exchange("topic.exchange"),
            key = {
                    "china.#"
            }
    ))
    public void listenFanoutQueue3(String msg) {
        System.out.println("消费者3接收到Fanout消息：【" + msg + "】");
    }
    发布者：
      /**
     * Topic
     */
    @Test
    public void testSendTopicExchange() {
        // 交换机名称
        String exchangeName = "topic.exchange";
        // 消息
        String message = "china红色警报！日本乱排核废水，导致海洋生物变异，惊现哥斯拉！";
        // 发送消息
        rabbitTemplate.convertAndSend(exchangeName, "china.", message);
        rabbitTemplate.convertAndSend(exchangeName, "china.news", message);
    }

11.SpringAMQP消息转换器的作用和使用步骤

1、在publisher和consumer两个服务中都引入依赖：
  <dependency>
    <groupId>com.fasterxml.jackson.dataformat</groupId>
    <artifactId>jackson-dataformat-xml</artifactId>
    <version>2.9.10</version>
</dependency>
2、配置消息转换器bean
    @Bean
    public MessageConverter jsonMessageConverter(){
        return new Jackson2JsonMessageConverter();
    }

12.SpringAMQP创建交换机和队列的两种方式

1、   /**
     * 声明交换机
     * @return Fanout类型交换机
     */
    @Bean
    public FanoutExchange fanoutExchange(){
        return new FanoutExchange("itcast.fanout");
    }

    /**
     * 第1个队列
     */
    @Bean
    public Queue fanoutQueue1(){
        return new Queue("fanout.queue1");
    }

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

    /**
     * 第2个队列
     */
    @Bean
    public Queue fanoutQueue2(){
        return new Queue("fanout.queue2");
    }

    /**
     * 绑定队列和交换机
     */
    @Bean
    public Binding bindingQueue2(Queue fanoutQueue2, FanoutExchange fanoutExchange){
        return BindingBuilder.bind(fanoutQueue2).to(fanoutExchange);
    }
2、注解
   @RabbitListener(bindings = @QueueBinding(
            value = @Queue("top.queue3"),//队列名称
            exchange = @Exchange("topic.exchange"),//交换机名称
            key = {
                    "china.#" //key
            }
    ))

13.什么是springAMQP

SpringAMQP是基于RabbitMQ封装的一套模板，并且还利用SpringBoot对其实现了自动装配，使用起来非常方便。
SpringAmqp的官方地址：https://spring.io/projects/spring-amqp

WorkQueue

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

能者多劳

在spring中有一个简单的配置，可以解决这个问题。我们修改consumer服务的application.yml文件，添加配置： :::tips spring:
rabbitmq:
listener:
simple:
prefetch: 1 # 每次只能获取一条消息，处理完成才能获取下一个消息 :::

总结

Work模型的使用：

  • 多个消费者绑定到一个队列，同一条消息只会被一个消费者处理

  • 通过设置prefetch来控制消费者预取的消息数量

    发布/订阅

    image.png

  • Publisher：生产者，也就是要发送消息的程序，但是不再发送到队列中，而是发给X（交换机）

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

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

    Fanout

    image.png
    在广播模式下，消息发送流程是：

  • 1） 可以有多个队列

  • 2） 每个队列都要绑定到Exchange（交换机）
  • 3） 生产者发送的消息，只能发送到交换机，交换机来决定要发给哪个队列，生产者无法决定
  • 4） 交换机把消息发送给绑定过的所有队列

  • 5） 订阅队列的消费者都能拿到消息

    总结

    交换机的作用是什么？

  • 接收publisher发送的消息

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

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

  • Queue
  • FanoutExchange

  • Binding

    Direct

    在Fanout模式中，一条消息，会被所有订阅的队列都消费。但是，在某些场景下，我们希望不同的消息被不同的队列消费。这时就要用到Direct类型的Exchange。
    image.png
    在Direct模型下：

  • 队列与交换机的绑定，不能是任意绑定了，而是要指定一个RoutingKey（路由key）

  • 消息的发送方在 向 Exchange发送消息时，也必须指定消息的 RoutingKey。

  • Exchange不再把消息交给每一个绑定的队列，而是根据消息的Routing Key进行判断，只有队列的Routingkey与消息的 Routing key完全一致，才会接收到消息

    总结

    描述下Direct交换机与Fanout交换机的差异？

  • Fanout交换机将消息路由给每一个与之绑定的队列

  • Direct交换机根据RoutingKey判断路由给哪个队列
  • 如果多个队列具有相同的RoutingKey，则与Fanout功能类似

基于@RabbitListener注解声明队列和交换机有哪些常见注解？

  • @Queue

  • @Exchange

    Topic

    Topic类型的Exchange与Direct相比，都是可以根据RoutingKey把消息路由到不同的队列。只不过Topic类型Exchange可以让队列在绑定Routing key 的时候使用通配符！Routingkey 一般都是有一个或多个单词组成，多个单词之间以”.”分割，例如： item.insert
    通配符规则：
    #：匹配一个或多个词
    ：匹配不多不少恰好1个词 :::tips 举例：
    item.#：能够匹配item.spu.insert 或者 item.spu
    item.    ：只能匹配item.spu ::: image.png

    总结

    描述下Direct交换机与Topic交换机的差异？

  • Topic交换机接收的消息RoutingKey必须是多个单词，以 . 分割

  • Topic交换机与队列绑定时的bindingKey可以指定通配符

  • ：代表0个或多个词

  • *：代表1个词

    消息转换器

    配置JSON转换器

    在publisher和consumer两个服务中都引入依赖： :::tips
    com.fasterxml.jackson.dataformat
    jackson-dataformat-xml
    2.9.10
    ::: 在启动类中添加一个Bean :::tips @Bean
    public MessageConverter jsonMessageConverter(){
    return new Jackson2JsonMessageConverter();
    } :::