RabbitMq入门

RabbitMq入门
- 1.MQ
- 2.RabbitMQ
  - 2.1安装
  - 2.2收发消息（交换机、队列）
  - 2.3数据隔离
    - 2.3.1用户管理
    - [2.3.2Virtual Host](#2.3.2Virtual Host)
- 3.SpringAMQP

1.MQ

1.1同步调用

同步调用的优势是时效性强，等到结果后才返回。但也存在很多问题，以支付服务为例，如果扣减余额、更新交易流水、更新交易订单状态三步为同步调用，上一步执行完才能继续下一个业务。会存在以下问题：

**拓展性差。**耦合度高，后续如果要在当前的业务基础上增加功能，整个业务会越来越臃肿。
**性能下降。**同步调用，调用者需要等待整个支付业务执行完毕才能继续执行。并且随着业务功能的增加，整个支付业务的执行时间会越来越长。
**级联失败。**如果基于远程调用，调用用户服务、交易服务.......时，当其中某个服务出现故障时，整个支付服务都会回滚，交易失败。

要解决这些问题，需要使用异步调用的方式来替代同步调用。

1.2异步调用

异步调用方式就是基于消息通知的方式，一般包含三个角色：

消息发送者：投递消息的人，即原来的调用方
消息Broker：管理、暂存、转发消息
消息接收者：接收和处理消息的人，即原来的服务提供方

异步调用的发送方不用同步调用接收者的业务接口，而是发送一条消息到消息Broker。接收者根据需求从Broker中订阅消息。每当发送发发送消息后，接受者都能获取消息并处理。这样发送方和接收方就能完全解耦。

还是以支付业务为例，使用异步调用后，除了必要的用户服务（扣除余额，更新支付流水），其他的业务都可以通过订阅的方式，自行处理各自的业务逻辑。在这个基础上，如果有新的业务加进来，也只需要让新业务订阅消息即可。

不管后期增加了多少消费者，对于支付业务而言，都是执行扣除余额、更新支付流水、发送消息这三个步骤，业务耗时不变，且大大降低了业务之间的耦合性。另外，即使其它业务执行过程中出现了故障，也不会影响到支付业务。

异步调用的优势：

解除耦合，拓展性强
无需等待，性能好
故障隔离，避免级联失败
缓存消息，流量削峰填谷

异步调用的缺点：

不能立即得到调用结果，时效性差
不确定下游业务执行是否成功
业务安全依赖Broker的可靠性、安全性和性能
架构复杂，后期维护和调试麻烦

1.3MQ技术选型

MQ（MessageQueue），中文是消息队列，也就是异步调用中的Broker。

目前比较常见的MQ实现：

ActiveMQ
RabbitMQ
RocketMQ
Kafka

	RabbitMQ	ActiveMQ	RocketMQ	Kafka
公司/社区	Rabbit	Apache	阿里	Apache
开发语言	Erlang	Java	Java	Scala&Java
协议支持	AMQP，XMPP，SMTP，STOMP	OpenWire，STOMP，REST，XMPP，AMQP	自定义协议	自定义协议
可用性	高	一般	高	高
单机吞吐量	一般	差	高	非常高
消息延迟	微秒级	毫秒级	毫秒级	毫秒以内
消息可靠性	高	一般	高	一般

追求可用性：Kafka、 RocketMQ 、RabbitMQ

追求可靠性：RabbitMQ、RocketMQ

追求吞吐能力：RocketMQ、Kafka

追求消息低延迟：RabbitMQ、Kafka

据统计，目前国内消息队列使用最多的还是RabbitMQ，再加上其各方面都比较均衡，稳定性也好。

2.RabbitMQ

2.1安装

RabbitMQ是基于Erlang语言开发的开源消息通信中间件，官网地址：Messaging that just works --- RabbitMQ

这里以3.8版本为例

将下载的mq.tar包上传到Linux服务器上，使用docker load命令导入mq镜像：

bash 复制代码

[root@iZ7xvgwzig5m0o0rnf19bkZ ~]# ll
-rw-r--r-- 1 root root 243M 2月  19 21:25 mq.tar
[root@iZ7xvgwzig5m0o0rnf19bkZ ~]# docker load -i mq.tar
a70daca533d0: Loading layer  75.16MB/75.16MB
1d76618777b7: Loading layer  2.494MB/2.494MB
3c4641134cb2: Loading layer    122MB/122MB
925d7d7de53e: Loading layer  345.1kB/345.1kB
c7a6248661bc: Loading layer  19.84MB/19.84MB
6ba57a07380e: Loading layer  4.608kB/4.608kB
57de3e20948c: Loading layer  1.536kB/1.536kB
56d9e5402fdd: Loading layer  17.41kB/17.41kB
ce6be100ab60: Loading layer  34.02MB/34.02MB
Loaded image: rabbitmq:3.8-management

运行镜像

bash 复制代码

[root@iZ7xvgwzig5m0o0rnf19bkZ ~]# docker network create testnet
767e702a12a708c64bafb2bb7f9b4feeb693d620a74a9cc5c52c2c869bb0110a

[root@iZ7xvgwzig5m0o0rnf19bkZ ~]# docker run \
> -e RABBITMQ_DEFAULT_USER=root \			#设置用户名
> -e RABBITMQ_DEFAULT_PASS=123456 \			#设置密码
> -v mq-plugins:/plugins \					#挂载数据卷mq-plugins到/plugins目录下
> --name mq \								#容器名
> --hostname mq \							#主机名
> -p 15672:15672 \							#端口映射
> -p 5672:5672 \							#端口映射
> --network testnet \						#设置网桥
> -d \
> rabbitmq:3.8-management
46f6028a906ba3376d3eb416af5ec954e1872179691d08cd9320b5aab28f22dd

[root@iZ7xvgwzig5m0o0rnf19bkZ ~]# docker ps
CONTAINER ID   IMAGE                     COMMAND                   CREATED         STATUS         PORTS                                                                                                                                                 NAMES
46f6028a906b   rabbitmq:3.8-management   "docker-entrypoint.s..."   3 minutes ago   Up 3 minutes   4369/tcp, 5671/tcp, 0.0.0.0:5672->5672/tcp, :::5672->5672/tcp, 15671/tcp, 15691-15692/tcp, 25672/tcp, 0.0.0.0:15672->15672/tcp, :::15672->15672/tcp   mq

可以看到在安装命令中有两个映射的端口：

15672：RabbitMQ提供的管理控制台的端口
5672：RabbitMQ的消息发送处理接口

3.浏览器访问 http://ip:15672 ，输入用户账号密码即可登录RabbitMQ的管理页面

RabbitMQ对应的架构图：

publisher：生产者，即发送消息的一方
consumer：消费者，接收消息的一方
queue：队列，负责存储消息。生产者投递的消息会暂存在消息队列中，等待消费者处理
exchange：交换机，负责路由和转发消息，没有存储消息的能力。生产者发送的消息由交换机决定投递到哪个队列。
virtual-host：虚拟主机，起到隔离数据的作用。每个虚拟主机相互独立，有各自不同的交换机、队列

以上这些东西都可以在RabbitMQ的管理控制台操作。

2.2收发消息（交换机、队列）

例子：在RabbitMQ控制台完成收发消息

新建队列hello.queue1和hello.queue2
向默认的amp.fanout交换机发送一条消息
查看消息是否到达两个队列

（1）在控制台Queues页面创建指定的队列hello.queue1和hello.queue2

（2）创建之后如图显示

（3）交换机和队列需要进行绑定，发送到交换机的消息才能理由到对应的队列

点击Exchanges选项卡，点击amq.fanout交换机，进入交换机详情页

（4）然后点击Bindings菜单，在表单中填写要绑定的队列名称：

（5）绑定后显示如下

（6）在绑定的队列中也可以看到绑定交换机信息

（7）在交换机中发送消息测试

（8）消息分别成功到达绑定的两个队列中

（9）进入队列中，可以查看接收的消息

这个时候如果有消费者监听了MQ的hello.queue1或hello.queue2队列，自然就能接收到消息了。

2.3数据隔离

2.3.1用户管理

点击Admin选项卡，可以看到RabbitMQ控制台的用户管理页面。在这里可以创建用户、创建虚拟主机等：

Name：用户名
Tags：权限，administrator代表有超级管理员权限
Can access virtual hosts：可以访问的virtual host，这里默认是 "/"
Has password：是否有密码

为了节约成本，一般来说通常只会搭建一套MQ集群，公司内的多个不同项目同时使用。为了避免相互干扰，会利用virtual host的隔离特性，将不同的项目隔离，一般会做两件事：

给每个项目创建独立的运维账号（用户），将管理权限分离
给每个项目创建不同的virtual host，将每个项目的数据隔离

2.3.2Virtual Host

点击右边的Virtual Hosts选项，可以管理，创建MQ的虚拟主机，或者设置用户对虚拟主机的访问权限。

例子：新建用户，为该用户创建一个虚拟主机，测试不同的虚拟主机之间的数据隔离现象

（1）在Users页面创建新用户test

（2）退出并登录新创建的用户test，在admin的Virtual Host页面创建虚拟主机

创建完后如图：

由于是登录test用户后创建的/test-host，因此回到Users菜单，会发现当前用户已经具备了对这个虚拟主机的访问权限：

（3）点击右上角的Virtual host下拉菜单，选择刚才创建的虚拟主机。然后再次查看queues选项卡，可以发现之间创建的队列已经看不到了：

这就是基于virtual host的隔离效果。

3.SpringAMQP

AMQP：高级消息队列协议（Advanced Message Queuing Protocol），一个提供统一消息服务的应用层标准高级消息队列协议，是应用层协议的一个开放标准，为面向消息的中间件设计。基于此协议的客户端与消息中间件可传递消息，不受客户端中间件的不同产品、不同开发语言等的条件限制。

RabbitMQ采用了AMQP协议，因此具备了跨语言的特性。任何语言只要遵循AMQP协议收发消息，都可以和RabbitMQ交互，并且RabbitMQ官方也提供了各种不同语言的客户端。

Spring AMQP：Spring AMQP是基于AMQP的一套API规范，提供了模板来发送和接收消息。包含两部分，其中spring-amqp是基础抽象，spring-rabbit是底层的默认实现。

由于RabbitMQ提供的Java客户端编码相对复杂（https://www.rabbitmq.com/getstarted.html），一般生产环境下会更多结合Spring来使用。而Spring的官方基于RabbitMQ提供了这样一套消息收发的模板工具：SpringAMQP。并且还基于SpringBoot对其实现了自动装配，使用起来非常方便。

SpringAMQP的官方地址

SpringAMQP提供了三个功能：

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

3.1创建项目

创建一个项目，项目结构如下，包括三部分：

mq-demo：父工程，管理项目依赖
publisher：消息的发送者
consumer：消息的消费者

在mq-demo这个父工程中，已经配置好了SpringAMQP的相关的依赖：

xml 复制代码

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>

    <groupId>cn.itcast.demo</groupId>
    <artifactId>mq-demo</artifactId>
    <version>1.0-SNAPSHOT</version>
    <modules>
        <module>publisher</module>
        <module>consumer</module>
    </modules>
    <packaging>pom</packaging>

    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.7.12</version>
        <relativePath/>
    </parent>

    <properties>
        <maven.compiler.source>8</maven.compiler.source>
        <maven.compiler.target>8</maven.compiler.target>
    </properties>

    <dependencies>
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
        </dependency>
        <!--AMQP依赖，包含RabbitMQ-->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-amqp</artifactId>
        </dependency>
        <!--单元测试-->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
        </dependency>
        <!--Jackson-->
        <dependency>
            <groupId>com.fasterxml.jackson.dataformat</groupId>
            <artifactId>jackson-dataformat-xml</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-logging</artifactId>
        </dependency>
    </dependencies>
</project>

因此，子工程中就可以直接使用SpringAMQP了。

3.2快速入门

例子：利用控制台创建队列simple.queue

在publisher服务中，利用SpringAMQP直接向simple.queue发送消息
在consumer服务中，利用SpringAMQP编写消费者，监听simple.queue队列

正常的情况下都是通过交换机发送消息到队列，这里为了测试方便，直接向队列发送消息，跳过交换机。这种模式一般测试使用，很少在生产中使用。

首先在控制台创建simple.queue队列

3.2.1消息发送

首先配置MQ地址，在publisher服务的application.yml中添加配置

properties 复制代码

spring:
  rabbitmq:
    host: xxx.xxx.xxx.xxx 		#主机IP地址
    port: 5672					#端口			
    virtual-host: /test-host	#虚拟主机
    username: test				#用户名
    password: 123456			#密码

在publisher服务中编写测试类SpringAMQPTest，利用SpringAMQP提供的RabbitTemplate工具类测试发送消息：

java 复制代码

package com.publisher;

import lombok.extern.slf4j.Slf4j;
import org.junit.jupiter.api.Test;
import org.springframework.amqp.rabbit.core.RabbitTemplate;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;

@Slf4j
@SpringBootTest
public class SpringAmqpTest {
    @Autowired
    private RabbitTemplate rabbitTemplate;

    @Test
    public void testSimpleQueue() {
        //队列名称
        String queueName = "simple.queue";
        //消息
        String message = "Hello,Spring AMQP!";
        //发送消息
        rabbitTemplate.convertAndSend(queueName, message);
    }
}

可以在控制台看到已发送的消息：

3.2.2消息接收

SpringAMQP提供声明式的消息监听，只需要通过注解在方法上声明要监听的队列名称，将来SpringAMQP就会把消息传递给当前方法.

（1）在consumer服务的配置文件中同样配置RabbitMQ

（2）编写监听类

java 复制代码

package com.consumer.listeners;

import lombok.extern.slf4j.Slf4j;
import org.springframework.amqp.rabbit.annotation.RabbitListener;
import org.springframework.stereotype.Component;

@Slf4j
@Component
public class MQListener {
    @RabbitListener(queues = "simple.queue")
    public void listenSimpleQueue(String msg) {
        System.out.println("消费者收到simple.queue消息===>【" + msg + "】");
    }
}

启动项目，日志显示：

3.2.3总结

SpringAMQP收发消息：

引入spring-boot-starter-amqp依赖
配置rabbitmq服务端信息
利用RabbitTemplate发送消息
利用@RabbitListener注解声明要监听的队列，监听消息

3.3WorkQueues模型

Work Queues，任务模型，简单地说就是让多个消费者绑定到一个队列，共同消费队列中的消息。

创建一个队列work.queue，在publisher服务一秒发送50条消息到work.queue，在consumer服务中定义两个消息监听者，都监听work.queue队列。让消费者1每秒可以处理50条消息，消费者每秒处理5条消息。

（1）publisher服务定义测试方法

java 复制代码

@Test
public void testWorkQueue() throws InterruptedException {
    //队列名称
    String queueName = "work.queue";
    for (int i = 0; i < 50; i++) {
        //消息
        String message = "Hello, worker, message_" + i;
        //发送消息
        rabbitTemplate.convertAndSend(queueName, message);
        Thread.sleep(20);
    }
}

（2）consumer服务提供两个消费者，分别有不同的消费速度

java 复制代码

package com.consumer.listeners;

import lombok.extern.slf4j.Slf4j;
import org.springframework.amqp.rabbit.annotation.RabbitListener;
import org.springframework.stereotype.Component;

@Slf4j
@Component
public class MQListener {
    @RabbitListener(queues = "work.queue")
    public void listenWorkQueue1(String msg) throws InterruptedException {
        System.out.println("消费者1 收到 work.queue消息===>【" + msg + "】");
        Thread.sleep(20);
    }

    @RabbitListener(queues = "work.queue")
    public void listenWorkQueue2(String msg) throws InterruptedException {
        System.err.println("消费者2 收到 work.queue消息......【" + msg + "】");
        Thread.sleep(200);
    }
}

测试结果：

java 复制代码

消费者2 收到 work.queue消息......【Hello, worker, message_0】
消费者1 收到 work.queue消息===>【Hello, worker, message_1】
消费者1 收到 work.queue消息===>【Hello, worker, message_3】
消费者1 收到 work.queue消息===>【Hello, worker, message_5】
消费者2 收到 work.queue消息......【Hello, worker, message_2】
消费者1 收到 work.queue消息===>【Hello, worker, message_7】
消费者1 收到 work.queue消息===>【Hello, worker, message_9】
消费者1 收到 work.queue消息===>【Hello, worker, message_11】
消费者1 收到 work.queue消息===>【Hello, worker, message_13】
消费者2 收到 work.queue消息......【Hello, worker, message_4】
消费者1 收到 work.queue消息===>【Hello, worker, message_15】
消费者1 收到 work.queue消息===>【Hello, worker, message_17】
消费者1 收到 work.queue消息===>【Hello, worker, message_19】
消费者2 收到 work.queue消息......【Hello, worker, message_6】
消费者1 收到 work.queue消息===>【Hello, worker, message_21】
消费者1 收到 work.queue消息===>【Hello, worker, message_23】
消费者1 收到 work.queue消息===>【Hello, worker, message_25】
消费者2 收到 work.queue消息......【Hello, worker, message_8】
消费者1 收到 work.queue消息===>【Hello, worker, message_27】
消费者1 收到 work.queue消息===>【Hello, worker, message_29】
消费者1 收到 work.queue消息===>【Hello, worker, message_31】
消费者2 收到 work.queue消息......【Hello, worker, message_10】
消费者1 收到 work.queue消息===>【Hello, worker, message_33】
消费者1 收到 work.queue消息===>【Hello, worker, message_35】
消费者1 收到 work.queue消息===>【Hello, worker, message_37】
消费者1 收到 work.queue消息===>【Hello, worker, message_39】
消费者2 收到 work.queue消息......【Hello, worker, message_12】
消费者1 收到 work.queue消息===>【Hello, worker, message_41】
消费者1 收到 work.queue消息===>【Hello, worker, message_43】
消费者1 收到 work.queue消息===>【Hello, worker, message_45】
消费者2 收到 work.queue消息......【Hello, worker, message_14】
消费者1 收到 work.queue消息===>【Hello, worker, message_47】
消费者1 收到 work.queue消息===>【Hello, worker, message_49】
消费者2 收到 work.queue消息......【Hello, worker, message_16】
消费者2 收到 work.queue消息......【Hello, worker, message_18】
消费者2 收到 work.queue消息......【Hello, worker, message_20】
消费者2 收到 work.queue消息......【Hello, worker, message_22】
消费者2 收到 work.queue消息......【Hello, worker, message_24】
消费者2 收到 work.queue消息......【Hello, worker, message_26】
消费者2 收到 work.queue消息......【Hello, worker, message_28】
消费者2 收到 work.queue消息......【Hello, worker, message_30】
消费者2 收到 work.queue消息......【Hello, worker, message_32】
消费者2 收到 work.queue消息......【Hello, worker, message_34】
消费者2 收到 work.queue消息......【Hello, worker, message_36】
消费者2 收到 work.queue消息......【Hello, worker, message_38】
消费者2 收到 work.queue消息......【Hello, worker, message_40】
消费者2 收到 work.queue消息......【Hello, worker, message_42】
消费者2 收到 work.queue消息......【Hello, worker, message_44】
消费者2 收到 work.queue消息......【Hello, worker, message_46】
消费者2 收到 work.queue消息......【Hello, worker, message_48】

可以看到虽然两个消费者的速度不一样，但是仍然每人都消费了25条消息：

消费者1很快处理完25条消息
消费者2却在缓慢处理自己的25条消息

也就是说消息是平均分配给每个消费者，并没有考虑到消费者的处理能力。导致一个消费者空闲，另一个消费者忙得飞起。这显然是不合理的。

3.3.1消费者消息推送限制

默认情况下，RabbitMQ会将消息依次轮询投递给绑定在队列上的每一个消费者。但这并没有考虑到消费者是否已经处理完消息，可能会出现消息堆积。

我们可以通过修改consumer的配置文件，设置preFetch的值为1，确保同一时刻最多投递给消费者1条消息。

properties 复制代码

spring:
  rabbitmq:
    listener:
      simple:
        prefetch: 1 #每次只能获取一条消息，处理完成才能获取下一消息

再次测试，结果如下：

java 复制代码

消费者1 收到 work.queue消息===>【Hello, worker, message_0】
消费者2 收到 work.queue消息......【Hello, worker, message_1】
消费者1 收到 work.queue消息===>【Hello, worker, message_2】
消费者1 收到 work.queue消息===>【Hello, worker, message_3】
消费者1 收到 work.queue消息===>【Hello, worker, message_4】
消费者1 收到 work.queue消息===>【Hello, worker, message_5】
消费者1 收到 work.queue消息===>【Hello, worker, message_6】
消费者1 收到 work.queue消息===>【Hello, worker, message_7】
消费者1 收到 work.queue消息===>【Hello, worker, message_8】
消费者2 收到 work.queue消息......【Hello, worker, message_9】
消费者1 收到 work.queue消息===>【Hello, worker, message_10】
消费者1 收到 work.queue消息===>【Hello, worker, message_11】
消费者1 收到 work.queue消息===>【Hello, worker, message_12】
消费者1 收到 work.queue消息===>【Hello, worker, message_13】
消费者1 收到 work.queue消息===>【Hello, worker, message_14】
消费者1 收到 work.queue消息===>【Hello, worker, message_15】
消费者1 收到 work.queue消息===>【Hello, worker, message_16】
消费者1 收到 work.queue消息===>【Hello, worker, message_17】
消费者2 收到 work.queue消息......【Hello, worker, message_18】
消费者1 收到 work.queue消息===>【Hello, worker, message_19】
消费者1 收到 work.queue消息===>【Hello, worker, message_20】
消费者1 收到 work.queue消息===>【Hello, worker, message_21】
消费者1 收到 work.queue消息===>【Hello, worker, message_22】
消费者1 收到 work.queue消息===>【Hello, worker, message_23】
消费者1 收到 work.queue消息===>【Hello, worker, message_24】
消费者1 收到 work.queue消息===>【Hello, worker, message_25】
消费者1 收到 work.queue消息===>【Hello, worker, message_26】
消费者2 收到 work.queue消息......【Hello, worker, message_27】
消费者1 收到 work.queue消息===>【Hello, worker, message_28】
消费者1 收到 work.queue消息===>【Hello, worker, message_29】
消费者1 收到 work.queue消息===>【Hello, worker, message_30】
消费者1 收到 work.queue消息===>【Hello, worker, message_31】
消费者1 收到 work.queue消息===>【Hello, worker, message_32】
消费者1 收到 work.queue消息===>【Hello, worker, message_33】
消费者2 收到 work.queue消息......【Hello, worker, message_34】
消费者1 收到 work.queue消息===>【Hello, worker, message_35】
消费者1 收到 work.queue消息===>【Hello, worker, message_36】
消费者1 收到 work.queue消息===>【Hello, worker, message_37】
消费者1 收到 work.queue消息===>【Hello, worker, message_38】
消费者1 收到 work.queue消息===>【Hello, worker, message_39】
消费者1 收到 work.queue消息===>【Hello, worker, message_40】
消费者1 收到 work.queue消息===>【Hello, worker, message_41】
消费者2 收到 work.queue消息......【Hello, worker, message_42】
消费者1 收到 work.queue消息===>【Hello, worker, message_43】
消费者1 收到 work.queue消息===>【Hello, worker, message_44】
消费者1 收到 work.queue消息===>【Hello, worker, message_45】
消费者1 收到 work.queue消息===>【Hello, worker, message_46】
消费者1 收到 work.queue消息===>【Hello, worker, message_47】
消费者1 收到 work.queue消息===>【Hello, worker, message_48】
消费者2 收到 work.queue消息......【Hello, worker, message_49】

3.3.2总结

Work模型的使用：

多个消费者绑定到一个队列，可以加快消息处理速度
同一条消息只会被一个消费者处理
通过设置prefetch来控制消费者预取的消息数量，实现能者多劳

3.4交换机

真正生产环境都会经过exchange（交换机）来发送消息，而不是直接发送到队列，交换机的类型有四种：

Fanout：广播，将消息交给所有绑定到交换机的队列。我们最早在控制台使用的正是Fanout交换机
Direct：订阅，基于RoutingKey（路由key）发送给订阅了消息的队列
Topic：通配符订阅，与Direct类似，只不过RoutingKey可以使用通配符
Headers：头匹配，基于MQ的消息头匹配，用的较少。

3.4.1Fanout交换机

Fanout，英文翻译是扇出。Fanout Exchange 会将接受到的消息广播到每一个跟其绑定的queue，所以也叫广播模式。

（1）可以有多个队列

（2）每个队列都要绑定到 Exchange

（3）生产者发送的消息，只能发送到交换机

（4）交换机把消息发送给绑定过的所有队列

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

例子

在RabbitMQ控制台中声明队列fanout.queue1和fanout.queue2，声明交换机test.fanout，将两个队列与该交换机绑定。在consumer服务中，编写两个消费者方法，分别监听两个队列，在publisher中写测试方法，向test.fanout发送消息

创建队列和交换机

绑定队列到交换机

3.消费者consumer服务中创建监听方法，分别监听两个队列

java 复制代码

@RabbitListener(queues = "fanout.queue1")
public void listenFanoutQueue1(String msg) {
    log.info("消费者 1 收到 fanout.queue1 消息 ===>{}", msg);
}

@RabbitListener(queues = "fanout.queue2")
public void listenFanoutQueue2(String msg) {
    log.info("消费者 2 收到 fanout.queue2 消息 ===>{}", msg);
}

4.生产者服务向test.fanout交换机发送一条消息

java 复制代码

@Test
public void testSendFanout() {
    String exchangeName = "test.fanout";
    String message = "hello,every body!!!";
    rabbitTemplate.convertAndSend(exchangeName, null, message);
}

监听的两个队列都收到了test.fanout交换机的同一条消息：

总结

交换机的作用：

接受publisher发送的消息
将消息按照规则路由到与之绑定的队列
Fanout类型的交换机会将消息路由到每个绑定的队列

3.4.2Direct交换机

在Fanout模式中，一条消息，会被所有订阅的队列都消费。但是，在某些场景下，我们希望不同的消息被不同的队列消费。这时就要用到Direct类型的Exchange。Direct Exchange会将接收到的消息根据规则路由到指定的Queue，由此称为定向路由

在Direct模型下：

队列与交换机的绑定，不能是任意绑定了，而是要指定一个RoutingKey（路由key）
消息的发送方在向 Exchange发送消息时，也必须指定消息的 RoutingKey。
Exchange不再把消息交给每一个绑定的队列，而是根据消息的Routing Key进行判断，只有队列的Bindingkey与消息的 Routing key完全一致，才会接收到消息

例子

在RabbitMQ控制台中，声明队列direct.queue1和direct.queue2，声明交换机test.direct，将两队列和其绑定。在consumer服务中，编写两个消费方法，分别监听两队列。在publisher中编写测试方法，利用不用的RoutingKey向test.direct交换机发送消息

1.创建队列和交换机

2.交换机绑定队列，指定RoutingKey

3.consumer服务创建两个监听方法，分别监听两个队列

java 复制代码

@RabbitListener(queues = "direct.queue1")
public void listenDirectQueue1(String msg) {
    System.out.println("消费者 1 收到 direct.queue1 消息 ===>【" + msg + "】");
}

@RabbitListener(queues = "direct.queue2")
public void listenDirectQueue2(String msg) {
    System.err.println("消费者 2 收到 direct.queue1 消息 ===>【" + msg + "】");
}

4.publisher服务向test.direct交换机发送消息

java 复制代码

@Test
public void testSendDirect() {
    String exchangeName = "test.direct";
    String redMsg = "红色警报！！";
    String blueMsg = "蓝色警报！！";
    String yellowMsg = "黄色警报！！";
    rabbitTemplate.convertAndSend(exchangeName, "red", redMsg);
    rabbitTemplate.convertAndSend(exchangeName, "blue", blueMsg);
    rabbitTemplate.convertAndSend(exchangeName, "yellow", yellowMsg);
}

两个队列都指定了bindingkey=red，因此都能收到routingkey=red的消息，其他的key则只有各自对应bindingkey的队列才能收到

3.4.3Topic交换机

Topic类型的交换机和Direct交换机相比，相同之处是它们都可以根据 RoutingKey 把消息路由到不同的队列。只不过Topic类型的交换机可以让队列在绑定 Bindingkey 的时候使用通配符。

BindingKey 一般都是由多个或者一个单词组成，多个单词之间以.分割，例如item.insert

通配符规则：

# 匹配0个或者多个单词
* 只匹配一个单词

例如：

item.# 可以匹配 item.spu.insert 或者 item.spu
item.* 只能匹配 item.spu

例子

在RabbitMQ控制台中，声明队列topic.queue1和topic.queue2，声明交换机test.topic，将两队列和其绑定。在consumer服务中编写两个消费者方法，分别监听topic.queue1和topic.queue2，在publisher中编写测试方法，利用不同的RoutingKey向test.topic交换机发送消息。

1.创建队列和交换机，并绑定队列到交换机

2.consumer服务创建两个方法，分别监听两队列

java 复制代码

@RabbitListener(queues = "topic.queue1")
public void listenTopicQueue1(String msg) {
    System.out.println("消费者 1 收到 topic.queue1 消息 ===>【" + msg + "】");
}

@RabbitListener(queues = "topic.queue2")
public void listenTopicQueue2(String msg) {
    System.err.println("消费者 2 收到 topic.queue1 消息 ===>【" + msg + "】");
}

3.publisher服务向test.topict交换机发送消息

java 复制代码

@Test
public void testSendTopic() {
    String exchangeName = "test.topic";
    String msg = "华尔街金融风暴！";
    String msg2 = "今天多云转晴";
    String msg3 = "生育率再创历史新低！";
    rabbitTemplate.convertAndSend(exchangeName, "china.weather", msg);
    rabbitTemplate.convertAndSend(exchangeName, "USA.news", msg2);
    rabbitTemplate.convertAndSend(exchangeName, "china.news", msg3);
}

总结

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

Topic交换机接收的消息RoutingKey必须是多个单词，以 . 分割
Topic交换机与队列绑定时的bindingKey可以指定通配符
#：代表0个或多个词
*：代表1个词

3.5声明队列和交换机

在实际开发中，队列和交换机不可能都在控制台上手动创建，一但业务需要的队列有数十条甚至几百条，手工创建管理的方式极可能出错。

推荐的做法是由程序启动的时候检查队列和交换机是否存在，如果不存在则自动创建。

3.5.1基本API

SpringAMQP提供了几个类，用来声明队列、交换机及其绑定关系：

Queue：用于声明队列，可以用工厂类QueueBuilder构建
Exchange：用于声明交换机，可以用工厂类ExchangeBuilder构建
Binding：用于声明队列和交换机的绑定关系，可以用工厂类BindingBuilder构建

3.5.2例子

一般来说，交换机、队列以及其关系的声明都在consumer服务创建。

1.consumer服务中编写一个config类，声明交换机、队列，并将两个进行绑定

java 复制代码

package com.consumer.config;

import org.springframework.amqp.core.*;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

@Configuration
public class FanoutConfiguration {

    @Bean
    public FanoutExchange fanoutExchange() {
        //创建一个Fanout类型的交换机，命名为test.fanout
        return ExchangeBuilder.fanoutExchange("test.fanout2").build();
        // 或者 return new FanoutExchange("test.fanout2");
    }

    @Bean
    public Queue fanoutQueue3() {
        //创建一个队列，命名为fanout.queue3
        return QueueBuilder.durable("fanout.queue3").build();
        //或者 return new Queue("fanout.queue3");
    }

    @Bean
    public Binding fanoutBinding() {
        //将fanout.queue3队列绑定到test.fanout交换机中
        return BindingBuilder.bind(fanoutQueue3()).to(fanoutExchange());
        //当代码执行fanoutQueue3()方法时候，spring首先会去查看容器中是否已经存在该Bean，
        //如果不存在才会调用方法创建。fanoutExchange()同理
    }

//和下面的写法同理
//   @Bean
//   public Binding fanoutBinding(Queue fanoutQueue3, FanoutExchange fanoutExchange) {
//      return BindingBuilder.bind(fanoutQueue3).to(fanoutExchange);
//   }
}

重启consumer服务，可以看到自动创建了指定的队列和交换机，并将其进行了绑定：

3.5.3基于注解声明

@Bean的方式创建比较麻烦，如果要创建的是direct类型的交换机，要绑定多个RoutingKey，只能通过如下的方式一个一个绑定，比较麻烦：

java 复制代码

@Bean
public Binding directQueue1Binding(Queue directQueue1, DirectExchange directExchange) {
    //指定RoutingKey
    return BindingBuilder.bind(directQueue1).to(directExchange).with("red");
}

@Bean
public Binding directQueue1Binding(Queue directQueue1, DirectExchange directExchange) {
    //指定RoutingKey
    return BindingBuilder.bind(directQueue1).to(directExchange).with("blue");
}
...

除了这种基于@Bean的方式来创建队列交换机，SpringAMQP还提供了基于@RabbitListener注解来声明队列和交换机的方式：

java 复制代码

//direct模式
@RabbitListener(bindings = @QueueBinding(
        value = @Queue(name = "direct.queue3", durable = "true"),
        exchange = @Exchange(name = "teset.direct2", type = ExchangeTypes.DIRECT),
        key = {"red", "blue", "yellow"}
))
public void listenDirectQueue3(String msg) {
    System.out.println("消费者3收到了direct.queue3的消息 ===>" + msg);
}

总结

声明队列、交换机、绑定关系的Bean：
- Queue
- FanoutExchange，DirectExchange，TopicExchange
- Binding
基于@RabbitListener注解声明队列和交换机有哪些常见注解：
- @Queue
- @Exchange

3.6消息转换器

3.6.1测试默认转换器

创建一个队列 queue.object，并往该队列发送Object类型的消息：

java 复制代码

@Test
public void testSendObject() {
    Map<String, Object> msg = new HashMap<>();
    msg.put("name", "jack");
    msg.put("age", 21);
    rabbitTemplate.convertAndSend("queue.object", msg);
}

可以看到队列中存储的内容是jdk自动序列化后的字节码：

Spring对消息对象的处理是由org.spirngframework.amqp.support.converter.MessageConverter来处理的。而默认实现的是SimpleMessageConverter，基于JDK的ObjectOutputStream完成序列化。

存在如下问题：

JDK的序列化有安全风险
JDK序列化的消息太大
JDK序列化的消息可读性差

3.6.2配置JSON转换器

建议采用JSON序列化代替默认的JDK序列化，要做两件事：

（1）在publisher、consumer服务中都引入Jackson依赖

xml 复制代码

<!--Jackson-->
<dependency>
    <groupId>com.fasterxml.jackson.dataformat</groupId>
    <artifactId>jackson-dataformat-xml</artifactId>
    <version>2.9.10</version>
</dependency>

注意：如果项目中引入了spring-boot-starter-web依赖，则无需再次引入Jackson依赖。

（2）配置消息转换器，在publisher和consumer两个服务的启动类中各自添加一个Bean即可：

java 复制代码

//import org.springframework.amqp.support.converter.Jackson2JsonMessageConverter;
//import org.springframework.amqp.support.converter.MessageConverter;

@Bean
public MessageConverter jacksonMessageConvertor() {
    return new Jackson2JsonMessageConverter();
}

3.6.3消费者接收Object

再次向queue.object队列发送消息，可以看到Object类型的消息成功转成json类型：

在消费者服务中接收，可以指定接收的消息类型：

java 复制代码

@RabbitListener(queues = "queue.object")
public void listenQueueObject(Map<String, Object> msg) {
    System.out.println("消费者收到了queue.object的消息===>" + msg);
}

RabbitMQ入门

RabbitMq入门

1.MQ

1.1同步调用

1.2异步调用

1.3MQ技术选型

2.RabbitMQ

2.1安装

2.2收发消息（交换机、队列）

2.3数据隔离

2.3.1用户管理

2.3.2Virtual Host

3.SpringAMQP

3.1创建项目

3.2快速入门

3.2.1消息发送

3.2.2消息接收

3.2.3总结

3.3WorkQueues模型

3.3.1消费者消息推送限制

3.3.2总结

3.4交换机

3.4.1Fanout交换机

3.4.2Direct交换机

3.4.3Topic交换机

3.5声明队列和交换机

3.5.1基本API

3.5.2例子

3.5.3基于注解声明

3.6消息转换器

3.6.1测试默认转换器

3.6.2配置JSON转换器

3.6.3消费者接收Object