2.Spring Boot 2.x 消息(RabbitMQ)

Spring Boot 2.x 消息(RabbitMQ)

1.简述

大多应用中，可通过消息服务中间件来提升系统异步通信、扩展解耦能力

1.1.消息队列的俩种形式

  • 队列queue: 点对点消息通信point-to-point
  • 主题topic: 发布publish、订阅subscribe消息通信

1.2.应用场景

  • 异步处理:

  • 应用解耦:

  • 流量削峰:

1.3. 常用的架构

  1. JMS(Java Message Servic)JAVA消息服务:
    基于JVM消息代理的规范。ActiveMQ、HornetMQ是JMS实现
  2. AMQP(Advanced Message Queuing Protocol):
    高级消息队列协议，也是一个消息代理的规范，兼容JMS。RabbitMQ是AMQP的实现

1.4. JMS与AMQP区别

JMS AMQP
定义 JAVA API 网络线级协议
跨语言 否 是
跨平台 否 是
Model 提供两种消息模型：
Peer-2-Peer
Pub/sub		 提供了五种消息模型:
direct exchange
fanout exchange
topic change
headers exchange
system exchange
本质来讲，后四种和JMS的pub/sub模型没有太大差别，仅是在路由机制上做了更详细的划分；
支持消息类型 多种消息类型： TextMessage MapMessage BytesMessage StreamMessage ObjectMessage Message(只有消息头和属性) byte[] 当实际应用时，有复杂的消息，可以将消息序列化后发送。
综合评价 JMS定义了JAVA API层面的标准；在JAVA体系中，多个client均可以通过JMS进行交互，不需要应用修改代码，但是其对跨平台的支持较差 AMQP定义了wire-level层的协议标准；天然具有跨平台、跨语言特性。

1.5.Spring Boot自动配置

  • JmsAutoConfiguration
  • RabbitAutoConfiguration

2. RabbitMQ简介

RabbitMQ是一个AMQP的开源实现

2.1.核心概念:

  • Message:
    消息，消息是不具名的，它由消息头和消息体组成。消息体是不透明的，而消息头则由一系列的可选属性组成，这些属性包括routing-key(路由键)、priority(相对于其他消息的优先权)、delivery-mode(指出该消息是否需要持久性存储)等
  • Publisher:
    消息的生产者，也是一个向交换器发布消息的客户端应用程序
  • Exchange:
    交换器，用来接收生产者发送的消息并将这些消息路由给服务器中的队列。 Exchange有4种类型：direct(默认)，fanout, topic, 和headers，不同类型的Exchange转发消息的策略有所区别
  • Queue:
    消息队列，用来保存消息直到发送给消费者。它是消息的容器，也是消息的终点。一个消息 可投入一个或多个队列。消息一直在队列里面，等待消费者连接到这个队列将其取走
  • Binding:
    绑定，用于消息队列和交换器之间的关联。一个绑定就是基于路由键将交换器和消息队列连接起来的路由规则，所以可以将交换器理解成一个由绑定构成的路由表。Exchange和Queue的绑定可以是多对多的关系
  • Connection:
    网络连接
  • Channel:
    信道，多路复用连接中的一条独立的双向数据流通道。信道是建立在真实的TCP连接内的虚拟连接，AMQP 命令都是通过信道发出去的，不管是发布消息、订阅队列还是接收消息，这 些动作都是通过信道完成。因为对于操作系统来说建立和销毁TCP都是非常昂贵的开销，所 以引入了信道的概念，以复用一条TCP 连接
  • Consumer:
    消息的消费者，表示一个从消息队列中取得消息的客户端应用程序
  • Virtual Host:
    虚拟主机，表示一批交换器、消息队列和相关对象。虚拟主机是共享相同的身份认证和加密环境的独立服务器域。每个 vhost 本质上就是一个 mini 版的 RabbitMQ 服务器，拥有 自己的队列、交换器、绑定和权限机制。vhost 是 AMQP 概念的基础，必须在连接时指定， RabbitMQ 默认的 vhost 是 /
  • Broker:
    表示消息队列服务器实体

2.2.运行机制

首先消息生产者Publisher发布消息给消息队列服务器Broker，由服务器指定的虚拟主机Virual Host处理。虚拟主机中交换机Exchange通过比较Message中的routing key以及Binding的binding key关系，将消息Message传递给指定的队列Queue，消息最终到达队列，在通过网络连接Connection传递给消费者Consumer，其中网络连接包含多个信道Channel，以进行多路复用

2.3.Exchange类型

Exchange分发消息时根据类型的不同分发策略有区别，目前共四种类型：direct、fanout、topic、headers 。headers 匹配 AMQP 消息的 header 而不是路由键，headers 交换器和 direct交换器完全一致，但性能差很多， 目前几乎用不到了，所以直接看另外三种类型：

  • direct:
    消息中的路由键routing key如果和 Binding 中的binding key一致， 交换器就将消息发到对应的队列中。路由键与队列名完全匹配，如果一个队列绑定到交换机要求路由键为dog，则只转发routing key标记为dog的消息，不会转发dog.puppy，也不会转发dog.guard等。它是完全匹配、单播的模式。
  • fanout：
    每个发到fanout类型交换器的消息都会分到所有绑定的队列上去。fanout交换器不处理路由键，只是简单的将队列绑定到交换器上，每个发送到交换器的消息都会被转发到与该交换器绑定的所有队列上。类似于子网传播，这种类型转发消息最快。
  • topic:
    topic交换器通过模式匹配分配消息的路由键属性，将路由键和某个模式进行匹配，此时队列需要绑定到一个模式上。它将路由键和绑定键的字符串切分成单词，这些单词之间用点隔开。它同样也会识别两个通配符：符号#和符号。#匹配0个或多个单词，**匹配一个单词。

3. Docker安装RabbitMQ

3.1.安装

  1. 在命令行中使用docker pull rabbitmq:3.8.12-rc.1-management命令安装带有网页管理端的RabbitMQ
  2. 使用命令docker images查看镜像
  3. 使用命令docker run -d -p 5672:5672 -p 15672:15672 --name myrabbitmq b9db03b3ebac运行该镜像
  4. 在浏览器进入RabbitMQ web管理页面，默认用户名密码均为guest
  5. 进入Exchanges即可添加交换器
  6. 进入Queues即可添加队列

3.2.测试

模拟实现下面的结构：
image-20210207132211291

  1. 添加三个交换器exchange.direct、exchange.fanout、exchange.topic
    image-20210207132211291
    在Name中添加交换器名称，Type选择交换器的类型，Durability选择是否持久化改交换器\(Durable\)代表持久化，即重启RabbitMQ后，该交换器依然存在。
    <img src="https://img2020.cnblogs.com/blog/2040836/202102/2040836-20210207175946041-1310975677.png" alt="image-20210207132530143" style="zoom:50%;" /

  2. 创建4个消息队列thoughtful、thoughtful.joker、thoughtful.news、qwe.joker:
    image-20210207132731506
    Type选择Quorum队列

  3. 创建交换器的Binding绑定关系，在Exchanges页面，点击对应的交换器名称，进入交换器配置页面：
    <https://img2020.cnblogs.com/blog/2040836/202102/2040836-20210207180016682-952274045.png" alt="image-20210207132933124" style="zoom:50%;" />

  4. 配置direct类型的交换器：
    image-20210207133002674
    image-20210207133045087

  5. 配置fanout类型的交换器(与direct类似，可以不写Routing key)

  6. 配置topic类型的交换:
    image-20210207133524696

  7. 测试direct交换器:
    点击Exchanges菜单中的exchange.direct，进入exchange.direct交换器的配置页面，选择Publish message选项。
    image-20210207133838343
    在绑定了thoughtful.joker的队列中可以接受到该消息:
    image-20210207134422361
    可以看到绑定的thoughtful.joker已经获取到了一个消息，进去查看:

    image-20210207133939941 `Ack Mode`:可以选择应答模式： `Nack message requeue true`代表获取消息，但是不做`ack`应答确认，消息重新入队。即在消息队列中不清除该消息。 `Ack message requeue false`获取消息，应答确认，消息不重新入队，将会从队列中删除 `reject requeue true`拒绝获取消息，消息重新入队 `reject requeue false`拒绝获取消息，消息不重新入队，将会被删除

  8. 测试fanout交换器:
    image-20210207134714215
    image-20210207134741051
    可以看到每个队列都增加了一条消息，看看:
    image-20210207134816236
    确实每个队列都收到了该消息

  9. 测试topic交换器:
    image-20210207135236134
    image-20210207135256199
    可以看到绑定规则为thoughtful.#的三个队列消息数都增加了，看看:
    image-20210207135415734

4. Spring Boot整合RabbitMQ

4.1. 配置Maven依赖

<?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 https://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>
    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.4.2</version>
        <relativePath/> <!-- lookup parent from repository -->
    </parent>
    <groupId>com.thoughtful</groupId>
    <artifactId>springboot-02-amqp</artifactId>
    <version>0.0.1-SNAPSHOT</version>
    <name>springboot-02-amqp</name>
    <description>Demo project for Spring Boot</description>
    <properties>
        <java.version>1.8</java.version>
    </properties>

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

        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
        </dependency>
        <dependency>
            <groupId>org.springframework.amqp</groupId>
            <artifactId>spring-rabbit-test</artifactId>
            <scope>test</scope>
        </dependency>
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <optional>true</optional>
        </dependency>
    </dependencies>

    <build>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
            </plugin>
        </plugins>
    </build>
</project>

4.2.配置消息格式转换器

package com.thoughtful.amqp.config;

import org.springframework.amqp.support.converter.Jackson2JsonMessageConverter;
import org.springframework.amqp.support.converter.MessageConverter;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

/**
 * @ClassName: MyRabbitMQConfiguration
 * @author: zyx
 * @E-mail: 1377631190@qq.com
 * @DATE: 2021/2/7 15:27
 */
@Configuration
public class MyRabbitMQConfiguration {

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

}

这样就可以将对象序列化为JSON数据保存在消息队列中

4.3.测试简单的消息操作

/**
* 单播(点对点)
* convertAndSend第一个参数是交换器的名称，第二个是绑定规则，最后是消息的内容
*/
@Test
void contextLoads() {
    // Message需要自己构造一个;定义消息体内容和消息头
    // rabbitTemplate.send(exchage, routeKey, message);

    // HashMap<String, String> map = new HashMap<>();
    // map.put("西游记", "吴承恩");
    Book book = new Book("西游记", "吴承恩");
    rabbitTemplate.convertAndSend("exchange.direct", "thoughtful.joker", book);
}

/**
* 广播(广播不需要传递Binding Key)
*/
@Test
public void radio() {
    Book book = new Book("红楼梦", "曹雪芹");
    rabbitTemplate.convertAndSend("exchange.fanout", null, book);
}

/**
* 接收
*/
@Test
public void receive() {
    Object thoughtful = rabbitTemplate.receiveAndConvert("thoughtful");
    System.out.println(thoughtful.getClass());
    System.out.println(thoughtful);
}

/**
 * amqpAdmin操作
 */
@Test
public void testAmqpAdmin() {
    // 创建交换器
     amqpAdmin.declareExchange(new DirectExchange("amqpadmin.direct"));

    // 创建消息队列
     amqpAdmin.declareQueue(new Queue("amqpadmin.queue"));

    // 创建绑定规则
     amqpAdmin.declareBinding(new Binding("amqpadmin.queue", Binding.DestinationType.QUEUE,"amqpadmin.exchange","amqp.haha",null));
     Binding with = BindingBuilder.bind(new Queue("amqpadmin.queue"))
            .to(new DirectExchange("amqpadmin.direct"))
            .with("amqpadmin.hhh");
     amqpAdmin.declareBinding(with);

    // 删除交换器
     System.out.println(amqpAdmin.deleteExchange("amqpadmin.direct"));

    // 删除消息队列
     System.out.println(amqpAdmin.deleteQueue("amqpadmin.queue"));
}

4.4.利用注解设置监听消息队列

  1. 在Spring Boot启动类上添加该注解，开启基于注解的RabbitMQ模式

  2. 编写业务层Service代码

    package com.thoughtful.amqp.service;

import com.thoughtful.amqp.entity.Book;
import org.springframework.amqp.core.Message;
import org.springframework.amqp.rabbit.annotation.RabbitListener;
import org.springframework.stereotype.Service;

/**
 * @ClassName: BookService
 * @author: zyx
 * @E-mail: 1377631190@qq.com
 * @DATE: 2021/2/7 17:36
 */
@Service
public class BookService {

    @RabbitListener(queues = {"thoughtful"})
    public void thoughtful(Book book) {
        System.out.println(book);
    }

    @RabbitListener(queues = "thoughtful.joker")
    public void thoughtfulJoker(Message message) {
        System.out.println(message.getMessageProperties());
        System.out.println(message);
    }

}
posted @ 2021-02-07 18:06  Thoughtful_z  阅读(167)  评论(0)    收藏  举报