MQ的快速入门及RabbitMQ的五种工作模式

缺乏、安全感 2023-10-14 18:11 36阅读 0赞

**目录**

MQ基本知识

MQ基本概念

MQ概述

MQ的优势和劣势

优势

劣势

RabbitMQ 简介

基础架构

相关概念

JMS

RabbitMQ安装

在线拉取镜像

安装MQ

访问控制台（http://ip地址:15672）

工作模式

简单模式（生产者消费者模式）

Work Queues 工作队列模式

Pub/Sub 订阅模式

Routing 路由模式

Topics 通配符模式

Springboot集成RabbitMQ

--------------------

## MQ基本知识 ##

### MQ基本概念 ###

MQ全称 Message Queue（消息队列），是在消息的传输过程中保存消息的容器。多用于分布式系统之间进行通信。

![b41c8eb3039843f081127fb96b0ddc8e.png][]

### MQ概述 ###

*  MQ，消息队列，存储消息的中间件
 *  分布式系统通信两种方式：直接远程调用和借助第三方完成间接通信
 *  发送方称为生产者，接收方称为消费者

### MQ的优势和劣势 ###

#### 优势 ####

*  应用解耦
    
    当我们通过直接通过订单系统下单会进行一系列操作，比如会咨询库存系统，查询对应的商品是否有充足的库存，此时如果库存系统挂了，那整个系统就陷入瘫痪![6d6a133e014949f09afcc345f5b30919.png][]
 *  使用 MQ 使得应用间解耦，提升容错性和可维护性。订单系统此时直接与MQ这一中间件对接，即使后面系统瘫痪，订单系统也不会瘫痪

![0930e3428c664cceb5a2ca416a1a467a.png][]

*  异步提速

一个下单操作耗时：20 + 300 + 300 + 300 = 920ms 用户点击完下单按钮后，需要等待920ms才能得到下单响应，太慢！

![5538341c6dc64a7ea2f615a57cac9309.png][]

使用MQ之后，用户点击完下单按钮后，只需等待25ms就能得到下单响应 (20 + 5 = 25ms)。 提升用户体验和系统吞吐量（单位时间内处理请求的数目）。

![e41b97debb8443a1b7595eec02e2caa9.png][]

*  削峰填谷

在一瞬间面对大量并发请求时，系统可能直接崩溃

![78c309b2cc444db78741379b997dea81.png][]

引入MQ之后，可以先将大量请求都缓冲到MQ中，再通过MQ缓慢向系统发送请求，达到削峰填谷的作用

![8a2327c7648c4d57a9884878849d4801.png][]

#### 劣势 ####

*  系统可用性降低、
    
    系统引入的外部依赖越多，系统稳定性越差。一旦 MQ 宕机，就会对业务造成影响。如何保证MQ的高可用？
 *  系统复杂度提高
    
    MQ 的加入大大增加了系统的复杂度，以前系统间是同步的远程调用，现在是通过 MQ 进行异步调用。如何 保证消息没有被重复消费？怎么处理消息丢失情况？那么保证消息传递的顺序性？
 *  一致性问题
    
    A 系统处理完业务，通过MQ给B、C、D三个系统发消息数据，如果B系统、C系统处理成功，D 系统处理失败。如何保证消息数据处理的一致性？

## RabbitMQ 简介 ##

2007年，Rabbit 技术公司基于 AMQP 标准开发的 RabbitMQ 1.0 发布。RabbitMQ 采用 Erlang 语言开发。 Erlang 语言由 Ericson 设计，专门为开发高并发和分布式系统的一种语言，在电信领域使用广泛。

### 基础架构 ###

![5f5fe8e4af9544868fe359ae54764386.png][]

### 相关概念 ###

*  Broker：接收和分发消息的应用，RabbitMQ Server就是 Message Broker
 *  Virtual host：出于多租户和安全因素设计的，把 AMQP 的基本组件划分到一个虚拟的分组中，类似于网 络中的 namespace 概念。当多个不同的用户使用同一个 RabbitMQ server 提供的服务时，可以划分出多 个vhost，每个用户在自己的 vhost 创建 exchange／queue 等
 *  Connection：publisher／consumer 和 broker 之间的 TCP 连接
 *  Channel：如果每一次访问 RabbitMQ 都建立一个 Connection，在消息量大的时候建立 TCP Connection 的开销将是巨大的，效率也较低。Channel 是在 connection 内部建立的逻辑连接，如果应用程序支持多线 程，通常每个thread创建单独的 channel进行通讯，AMQP method 包含了channel id 帮助客户端和 message broker 识别 channel，所以 channel 之间是完全隔离的。Channel作为轻量级的 Connection 极大减少了操作系统建立 TCP connection 的开销
 *  Exchange：message 到达 broker 的第一站，根据分发规则，匹配查询表中的 routing key，分发消息到 queue 中去。常用的类型有：direct (point-to-point), topic (publish-subscribe) and fanout (multicast)
 *  Queue：消息最终被送到这里等待 consumer 取走
 *  Binding：exchange 和 queue 之间的虚拟连接，binding 中可以包含 routing key。Binding 信息被保存 到 exchange 中的查询表中，用于 message 的分发依据
    
    ### JMS ###
    
    1.  JMS 即 Java 消息服务（JavaMessage Service）应用程序接口，是一个 Java 平台中关于面向消息中间件的API
    2.  JMS 是 JavaEE 规范中的一种，类比JDBC
    3.  很多消息中间件都实现了JMS规范，例如：ActiveMQ。RabbitMQ 官方没有提供 JMS 的实现包，但是开源社区有

## RabbitMQ安装 ##

### 在线拉取镜像 ###

docker pull rabbitmq:3-management

### 安装MQ ###

执行下面的命令来运行MQ容器：

docker run \
     -e RABBITMQ_DEFAULT_USER=itcast \
     -e RABBITMQ_DEFAULT_PASS=123321 \
     --name mq \
     --hostname mq1 \
     -p 15672:15672 \
     -p 5672:5672 \
     -d \
     rabbitmq:3-management

#### 访问控制台（[http://ip地址:15672][http_ip_15672]） ####

![db2ec5aed8424f14880b7edf8df5fe57.png][]

## 工作模式 ##

有五种工作模式分别为简单模式、work queues、Publish/Subscribe 发布与订阅模式、Routing 路由模式、Topics 主题模式

RPC严格意义上不属于RabbitMq的工作模式，这里不做归纳（[RabbitMQ: easy to use, flexible messaging and streaming — RabbitMQ][RabbitMQ_ easy to use_ flexible messaging and streaming _ RabbitMQ]）

### ![da1c06f1d163408580772fd683ae2ba3.png][] ###

### 简单模式（生产者消费者模式） ###

![1640a046cd7c4a61a7c63214cece61cf.png][]

*  P：生产者，也就是要发送消息的程序
 *  C：消费者：消息的接收者，会一直等待消息到来
 *  queue：消息队列，图中红色部分。类似一个邮箱，可以缓存消息；生产者向其中投递消息，消费者从其中取出消息

生产者

ConnectionFactory connectionFactory = new ConnectionFactory();
       //rabbitmq服务的ip地址
       connectionFactory.setHost("192.168.101.133");
       connectionFactory.setPort(5672);
       //连接的虚拟机
       connectionFactory.setVirtualHost("/itcast");
       //用户名
       connectionFactory.setUsername("heima");
       //密码
       connectionFactory.setPassword("heima");
       //建立连接
       Connection connection = connectionFactory.newConnection();
       //再从连接中创建channel建立真正的连接
       Channel channel = connection.createChannel();
    
    /**   
    队列声明
    AMQP.Queue.DeclareOk queueDeclare(String queue, boolean durable, boolean exclusive, boolean autoDelete,
       Map<String, Object> arguments)
     1. queue: 队列名称
     2.durable:是否持久化，如果不持久化，mq重启之后队列就不存在了
     3. exclusive:是否独占。只能有一个消费者监听这队列
     当Connection关闭时，是否删除队列
     4.autoDelete:是否自动删除。当没有Consumer时，自动删除掉
     5.arguments: 参数。
     */
     channel.queueDeclare("hello_world",true,false,false,null);
    //发送的消息
     String body="hello rabbitmq~~~~";
    /**
     void basicPublish(String exchange, String routingKey, BasicProperties props, byte[] body)
     1.exchange:交换机名称。简单模式下交换机会使用默认的""
     2.routingKev: 路由名称，简单模式下就是队列名称
     3.props: 配置信息
     4.body: 发送消息数据
     */
       channel.basicPublish("","hello_world",null,body.getBytes());
       //释放资源
       channel.close();
       connection.close();

消费者

ConnectionFactory connectionFactory = new ConnectionFactory();
    connectionFactory.setHost("192.168.101.133");
    connectionFactory.setPort(5672);
    connectionFactory.setVirtualHost("/itcast");
    connectionFactory.setUsername("heima");
    connectionFactory.setPassword("heima");
    Connection connection = connectionFactory.newConnection();
    Channel channel = connection.createChannel();
    channel.queueDeclare("hello_world",true,false,false,null);
    Consumer consumer =new DefaultConsumer(channel){
    /**
                回调方法，当收到消息后，会自动执行该方法
              1.consumerTag:标识
              2.envelope: 获取一些信息，交换机，路由key...2.
              3.properties:配置信息
              4.body: 数据
              */
        @Override
        public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
            System.out.println("consumerTag:"+consumerTag);
            System.out.println("Exchange:"+envelope.getExchange());
            System.out.println("consumerTag:"+consumerTag);
            System.out.println("bodys:"+new String(body));
        }
    };
     /**
            basicConsume(string queue, boolean autoAck, Consumer callback)参数:
            1. queue:队列名称
            2.autoAck: 是否自动确认
            calLback: 回调对象,对获取到的消息进行处理
             */
    channel.basicConsume("hello_world",true,consumer);

![68fd84a80b9f43b8949e47aa424a81aa.png][]

### Work Queues 工作队列模式 ###

![411091bbf08e43528689d405f21190f0.png][]

*  Work Queues：与入门程序的简单模式相比，多了一个或一些消费端，多个消费端共同消费同一个队列中的消息。多个消费者是竞争关系，因为同一个消息只能由一个消费者消费
 *  应用场景：对于任务过重或任务较多情况使用工作队列可以提高任务处理的速度。例如：短信服务部署多个， 只需要有一个节点成功发送即可

生产者

消费者与简单模式的消费者代码相同，不重复展示，我们可以看到相同的消息只会被消费者消费一次，且两个消费者是竞争关系，采用的轮询的消费方式

![4df6aca9d8ff4a1592e3d2ba07897420.png][]

![a7560e4b870b4090bd7553c3437c33e5.png][]

### Pub/Sub 订阅模式 ###

![63b54dcc26254d5fb37ef722a2b617c6.png][]

在订阅模型中，多了一个 Exchange 角色，而且过程略有变化： 即生产者将消息转发到交换机，交换机再把消息路由分发给不同的队列，消费者监听不同的队列来获取消息

*  Exchange：交换机（X）。一方面，接收生产者发送的消息。另一方面，知道如何处理消息，例如递交给某个特别队列、 递交给所有队列、或是将消息丢弃。到底如何操作，取决于Exchange的类型。
    
    Exchange有常见以下3种类型：
    
    ➢ Fanout：广播，将消息交给所有绑定到交换机的队列
    
    ➢ Direct：定向，把消息交给符合指定routing key 的队列
    
    ➢ Topic：通配符，把消息交给符合routing pattern（路由模式） 的队列
    
    Exchange（交换机）只负责转发消息，不具备存储消息的能力，因此如果没有任何队列与 Exchange 绑定，或者没有符合 路由规则的队列，那么消息会丢失！
    
    生产者
    
         ConnectionFactory connectionFactory = new ConnectionFactory();
                //rabbitmq服务的ip地址
                connectionFactory.setHost("192.168.101.134");
                connectionFactory.setPort(5672);
                //连接的虚拟机
                connectionFactory.setVirtualHost("/itcast");
                //用户名
                connectionFactory.setUsername("heima");
                //密码
                connectionFactory.setPassword("heima");
                //建立连接
                Connection connection = connectionFactory.newConnection();
                //再从连接中创建channel建立真正的连接
                Channel channel = connection.createChannel();
                /**
                 Exchange.DeclareOk exchangeDeclare(String exchange,
                 BuiltinExchangeType type,
                 boolean durable,
                 boolean autoDelete,
                 boolean internal,
                 Map<String, Object> arguments) throws IOException;
                 exchange:交换机名称
                 type:交换机类型
                 DIRECT("direct"),:定向
                 FANOUT(“fanout"),:广播，发送消息到每一个与之绑定队列。
                 TOPIC(“topic"),通配符的方式
                 HEADERS(“headers");参数匹配
                 3.durable:是否持久化
                 4. autoDelete:是否自动删除
                 5.参数列表
                 */
                //创建交换机
                String  exchangeName="test_fanout";
                channel.exchangeDeclare(exchangeName, BuiltinExchangeType.FANOUT,true,false,false,null);
                //创建队列
                String queue1Name="test_fanout_queue1";
                String queue2Name="test_fanout_queue2";
                channel.queueDeclare(queue1Name,true,false,false,null);
                channel.queueDeclare(queue2Name,true,false,false,null);
                channel.queueBind(queue1Name,exchangeName,"");
                channel.queueBind(queue2Name,exchangeName,"");
        String body="日志信息，rabbitmq瘫痪了！！！";
        channel.basicPublish(exchangeName,"",null,body.getBytes());
                //释放资源
                channel.close();
                connection.close();
    
    两个消费者只要改变监听的队列即可
    
        ConnectionFactory connectionFactory = new ConnectionFactory();
        connectionFactory.setHost("192.168.101.134");
        connectionFactory.setPort(5672);
        connectionFactory.setVirtualHost("/itcast");
        connectionFactory.setUsername("heima");
        connectionFactory.setPassword("heima");
        Connection connection = connectionFactory.newConnection();
        Channel channel = connection.createChannel();
        
        Consumer consumer =new DefaultConsumer(channel){
         /**
            回调方法
          */
            @Override
            public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
                System.out.println("bodys:"+new String(body));
                System.out.println("将日志打印在控制台");
            }
        };
        String queue1Name="test_fanout_queue1";
        
        channel.basicConsume(queue1Name,true,consumer);
    
    我们会发现订阅模式，相同的一条消息会分给两条队列让不同的微服务对相同的消息做出不同的业务处理，例如图中相同的消息被不同消费者获取后，进行的操作是不同的

![47b521c52c434416a07722b47b344685.png][]

![3a6868d63e1f43a7bd50faf239c413a1.png][]

### Routing 路由模式 ###

![a7110fcb52144634a7f887c86123257a.png][]

路由模式中队列与交换机的绑定，不能是任意绑定了，而是要指定一个 RoutingKey，Exchange是根据消息的 Routing Key 进行判断，只有队列的 Routingkey 与消息的 Routing key 完全一致，才会接收到消息，而消费者在发送消息时首先就要指定消息的 Routing Key。我们可以通过指定Routing Key从而来确定这个消息让不同的微服务来进行指定操作。

生产者

ConnectionFactory connectionFactory = new ConnectionFactory();
            //rabbitmq服务的ip地址
            connectionFactory.setHost("192.168.101.134");
            connectionFactory.setPort(5672);
            //连接的虚拟机
            connectionFactory.setVirtualHost("/itcast");
            //用户名
            connectionFactory.setUsername("heima");
            //密码
            connectionFactory.setPassword("heima");
            //建立连接
            Connection connection = connectionFactory.newConnection();
            //再从连接中创建channel建立真正的连接
            Channel channel = connection.createChannel();
    
            //创建交换机
            String  exchangeName="test_direct";
            channel.exchangeDeclare(exchangeName, BuiltinExchangeType.DIRECT,true,false,false,null);
            //创建队列
            String queue1Name="test_direct_queue1";
            String queue2Name="test_direct_queue2";
            channel.queueDeclare(queue1Name,true,false,false,null);
            channel.queueDeclare(queue2Name,true,false,false,null);
            //队列绑定交换机，并指定Routing key
            channel.queueBind(queue1Name,exchangeName,"error");
            channel.queueBind(queue2Name,exchangeName,"info");
            channel.queueBind(queue2Name,exchangeName,"error");
            channel.queueBind(queue2Name,exchangeName,"warning");
    String body="日志信息，rabbitmq瘫痪了！！！";
    channel.basicPublish(exchangeName,"info",null,body.getBytes());
            //释放资源
            channel.close();
            connection.close();

消费者

ConnectionFactory connectionFactory = new ConnectionFactory();
    connectionFactory.setHost("192.168.101.134");
    connectionFactory.setPort(5672);
    connectionFactory.setVirtualHost("/itcast");
    connectionFactory.setUsername("heima");
    connectionFactory.setPassword("heima");
    Connection connection = connectionFactory.newConnection();
    Channel channel = connection.createChannel();
    
    Consumer consumer =new DefaultConsumer(channel){
     /**
        回调方法
      */
        @Override
        public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
            System.out.println("bodys:"+new String(body));
            System.out.println("将日志保存到数据库");
        }
    };
    String queue2Name="test_direct_queue2";
    channel.basicConsume(queue2Name,true,consumer);

### Topics 通配符模式 ###

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

生产者

队列1采用error和order的通配符进行key匹配，队列2全能匹配，当key为goods.info时，队列1无法匹配成功。

ConnectionFactory connectionFactory = new ConnectionFactory();
            //rabbitmq服务的ip地址
            connectionFactory.setHost("192.168.101.134");
            connectionFactory.setPort(5672);
            //连接的虚拟机
            connectionFactory.setVirtualHost("/itcast");
            //用户名
            connectionFactory.setUsername("heima");
            //密码
            connectionFactory.setPassword("heima");
            //建立连接
            Connection connection = connectionFactory.newConnection();
            //再从连接中创建channel建立真正的连接
            Channel channel = connection.createChannel();
    
            //创建交换机
            String  exchangeName="test_topic";
            channel.exchangeDeclare(exchangeName, BuiltinExchangeType.TOPIC,true,false,false,null);
            //创建队列
            String queue1Name="test_topic_queue1";
            String queue2Name="test_topic_queue2";
            channel.queueDeclare(queue1Name,true,false,false,null);
            channel.queueDeclare(queue2Name,true,false,false,null);
    //绑定key时，采用*或#进行模糊化
            channel.queueBind(queue1Name,exchangeName,"#.error");
            channel.queueBind(queue1Name,exchangeName,"order.*");
            channel.queueBind(queue2Name,exchangeName,"*.*");
    String body="日志信息，rabbitmq瘫痪了！！！";
    channel.basicPublish(exchangeName,"goods.info",null,body.getBytes());
            //释放资源
            channel.close();
            connection.close();

## ![61bc6e0e720044f6b715f62370995eaf.png][] ##

## Springboot集成RabbitMQ ##

导入AMQP依赖

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

编写yml配置

spring:
      rabbitmq:
        host: 192.168.101.134 #rabbitMQ的ip地址
        port: 5672 #端口
        username: itcast
        password: 123321
        virtual-host: "/"
        listener:
          simple:
            prefetch: 1

RabbitMQ配置类

主要用来声明队列，交换机，完成队列与交换机的绑定，指定Routing Key。

@Configuration
    public class RabbitMQConfig {
        public static final String EXCHANGE_NAME="boot_topic_exchange";
        public static final String QUEUE_NAME="boot_QUEUE";
        //交换机
        @Bean("bootExchange")
        public Exchange bootExchange(){
            return ExchangeBuilder.topicExchange(EXCHANGE_NAME).durable(true).build();
        }
        //队列
        @Bean("bootQueue")
        public Queue bootQueue(){
            return QueueBuilder.durable(QUEUE_NAME).build();
        }
        //队列和交换机绑定
        @Bean
        public Binding bindQueueExchange(
                @Qualifier("bootQueue") Queue queue,@Qualifier("bootExchange") Exchange exchange
        ){
            return BindingBuilder.bind(queue).to(exchange).with("boot.*").noargs();
        }

生产者

直接注入RabbitTemplate，即可方便快速地发送消息

@SpringBootTest
    public class PublishTest {
        @Autowired
        private RabbitTemplate rabbitTemplate;
        @Test
        public void test(){
            rabbitTemplate.convertAndSend(RabbitMQConfig.EXCHANGE_NAME,"boot.haha","helloword,mq");
        }
    }

![c2861a32b53a4a0eb1e8b406352aa958.png][]

消费者

@Component
    public class RabbitMQListener {
        @RabbitListener(queues = "boot_QUEUE")
        public void ListenerQueue(Message message){
            System.out.println(message);
        }
    }

![80069db0ea8646789f0b7ebddfab8fe5.png][]

[b41c8eb3039843f081127fb96b0ddc8e.png]: https://img-blog.csdnimg.cn/b41c8eb3039843f081127fb96b0ddc8e.png
[6d6a133e014949f09afcc345f5b30919.png]: https://img-blog.csdnimg.cn/6d6a133e014949f09afcc345f5b30919.png
[0930e3428c664cceb5a2ca416a1a467a.png]: https://img-blog.csdnimg.cn/0930e3428c664cceb5a2ca416a1a467a.png
[5538341c6dc64a7ea2f615a57cac9309.png]: https://img-blog.csdnimg.cn/5538341c6dc64a7ea2f615a57cac9309.png
[e41b97debb8443a1b7595eec02e2caa9.png]: https://img-blog.csdnimg.cn/e41b97debb8443a1b7595eec02e2caa9.png
[78c309b2cc444db78741379b997dea81.png]: https://img-blog.csdnimg.cn/78c309b2cc444db78741379b997dea81.png
[8a2327c7648c4d57a9884878849d4801.png]: https://img-blog.csdnimg.cn/8a2327c7648c4d57a9884878849d4801.png
[5f5fe8e4af9544868fe359ae54764386.png]: https://img-blog.csdnimg.cn/5f5fe8e4af9544868fe359ae54764386.png
[http_ip_15672]: http://192.168.101.134:15672/
[db2ec5aed8424f14880b7edf8df5fe57.png]: https://img-blog.csdnimg.cn/db2ec5aed8424f14880b7edf8df5fe57.png
[RabbitMQ_ easy to use_ flexible messaging and streaming _ RabbitMQ]: https://www.rabbitmq.com/
[da1c06f1d163408580772fd683ae2ba3.png]: https://img-blog.csdnimg.cn/da1c06f1d163408580772fd683ae2ba3.png
[1640a046cd7c4a61a7c63214cece61cf.png]: https://img-blog.csdnimg.cn/1640a046cd7c4a61a7c63214cece61cf.png
[68fd84a80b9f43b8949e47aa424a81aa.png]: https://img-blog.csdnimg.cn/68fd84a80b9f43b8949e47aa424a81aa.png
[411091bbf08e43528689d405f21190f0.png]: https://img-blog.csdnimg.cn/411091bbf08e43528689d405f21190f0.png
[4df6aca9d8ff4a1592e3d2ba07897420.png]: https://img-blog.csdnimg.cn/4df6aca9d8ff4a1592e3d2ba07897420.png
[a7560e4b870b4090bd7553c3437c33e5.png]: https://img-blog.csdnimg.cn/a7560e4b870b4090bd7553c3437c33e5.png
[63b54dcc26254d5fb37ef722a2b617c6.png]: https://img-blog.csdnimg.cn/63b54dcc26254d5fb37ef722a2b617c6.png
[47b521c52c434416a07722b47b344685.png]: https://img-blog.csdnimg.cn/47b521c52c434416a07722b47b344685.png
[3a6868d63e1f43a7bd50faf239c413a1.png]: https://img-blog.csdnimg.cn/3a6868d63e1f43a7bd50faf239c413a1.png
[a7110fcb52144634a7f887c86123257a.png]: https://img-blog.csdnimg.cn/a7110fcb52144634a7f887c86123257a.png
[61bc6e0e720044f6b715f62370995eaf.png]: https://img-blog.csdnimg.cn/61bc6e0e720044f6b715f62370995eaf.png
[c2861a32b53a4a0eb1e8b406352aa958.png]: https://img-blog.csdnimg.cn/c2861a32b53a4a0eb1e8b406352aa958.png
[80069db0ea8646789f0b7ebddfab8fe5.png]: https://img-blog.csdnimg.cn/80069db0ea8646789f0b7ebddfab8fe5.png