RabbitMQ学习（二）-- 工作模式

淡淡的烟草味﹌ 2022-12-27 12:37 211阅读 0赞

**目录**

一、普通通道

二、工作队列

工作原理如图

源码如下

测试情况

控制台打印

二、发布/订阅模式

工作原理图

源码如下

测试情况：

三、routing模式

工作原理

源码

测试情况

四、topic模式

工作原理

源码

测试情况

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

# 一、普通通道 #

代码已经在[RabbitMQ学习（一）-- producer&&consumer][RabbitMQ_-- producer_consumer] 写了，这里不在多言

# 二、工作队列 #

## 工作原理如图 ##

![20201210225300287.png][]

## 源码如下 ##

生产者

package com.wayne;
    
    import com.rabbitmq.client.Channel;
    import com.rabbitmq.client.Connection;
    import com.rabbitmq.client.ConnectionFactory;
    
    import java.io.IOException;
    import java.util.concurrent.TimeoutException;
    import java.util.stream.IntStream;
    
    public class Producer_work_queues {
    
        public static void main(String[] args) throws IOException, TimeoutException {
            //1,创建连接工厂
            ConnectionFactory factory = new ConnectionFactory();
            //2，设置参数(host,port,virtual host,username,guest)
            factory.setHost("10.211.55.7");
            factory.setPort(5672);
            factory.setVirtualHost("/");
            factory.setUsername("guest");
            factory.setPassword("guest");
    
            //3，创建连接
            Connection connection = factory.newConnection();
    
            //4，创建channel
            Channel channel = connection.createChannel();
    
            //5，创建队列Queue
            //String queue--队列名称,
            // boolean durable--是否持久化,
            // boolean exclusive--是否独占（只有一个消费者）当connection关闭时，是否删除队列, boolean autoDelete--是否允许自动删除（没有消费者时）,
            // Map<String, Object> arguments-- 参数
            channel.queueDeclare("work_queue", true, false, false, null);
    
            //6，发送消息
            //String exchange--交换机名称,简单模式下，使用默认值 ""空字符串
            // String routingKey--路由名称,当使用默认的 ""（空字符串）的exchange时，和队列名称保持一致。
            // BasicProperties props--属性,
            // byte[] body--实际发送消息内容
            IntStream.range(1,101).forEach(i->{
                StringBuffer body = new StringBuffer();
                body.append(i).append(":hello rabbitmq!!!!!!");
                try {
                    channel.basicPublish("","work_queue",null,body.toString().getBytes());
                } catch (IOException e) {
                    e.printStackTrace();
                }
            });
    
    
            //7，关闭连接，释放资源
            channel.close();
            connection.close();
        }
    }

消费者

package com.wayne;
    
    import com.rabbitmq.client.*;
    
    import java.io.IOException;
    import java.util.concurrent.TimeoutException;
    
    public class Consumer_work_queue {
    
        public static void main(String[] args) throws IOException, TimeoutException {
            //1,创建连接工厂
            ConnectionFactory factory = new ConnectionFactory();
            //2，设置参数(host,port,virtual host,username,guest)
            factory.setHost("10.211.55.7");
            factory.setPort(5672);
            factory.setVirtualHost("/");
            factory.setUsername("guest");
            factory.setPassword("guest");
    
            //3，创建连接
            Connection connection = factory.newConnection();
    
            //4，创建channel
            Channel channel = connection.createChannel();
    
            //5，创建队列Queue
            //String queue--队列名称,
            // boolean durable--是否持久化,
            // boolean exclusive--是否独占（只有一个消费者）当connection关闭时，是否删除队列, boolean autoDelete--是否允许自动删除（没有消费者时）,
            // Map<String, Object> arguments-- 参数
            channel.queueDeclare("work_queue", true, false, false, null);
    
            //6，创建消费者
            //String queue--队列名称, boolean autoAck--是否发送自动确认信息, Consumer callback--回调对象)
            channel.basicConsume("work_queue",true,new DefaultConsumer(channel){
    
                //糊掉对象中的方法
                //String consumerTag, -- 消费者标签
                // Envelope envelope, -- 一些信息 例如交换机、路由信息
                // AMQP.BasicProperties properties, 配置信息
                // byte[] body --实际的消息体
                @Override
                public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
                    System.out.println("body:"+new String(body));
                }
            });
    
    
        }
    }

同时启动两个消费者

## 测试情况 ##

## ![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2E4MEM1MQ_size_16_color_FFFFFF_t_70][]控制台打印 ##

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2E4MEM1MQ_size_16_color_FFFFFF_t_70 1][]![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2E4MEM1MQ_size_16_color_FFFFFF_t_70 2][]

# 二、发布/订阅模式 #

## 工作原理图 ##

![20201210231748916.png][]

## 源码如下 ##

生产者

package com.wayne;
    
    import com.rabbitmq.client.BuiltinExchangeType;
    import com.rabbitmq.client.Channel;
    import com.rabbitmq.client.Connection;
    import com.rabbitmq.client.ConnectionFactory;
    
    import java.io.IOException;
    import java.util.concurrent.TimeoutException;
    import java.util.stream.IntStream;
    
    public class Producer_publish {
    
        public static void main(String[] args) throws IOException, TimeoutException {
            //1，创建工厂
            ConnectionFactory factory = new ConnectionFactory();
    
            //2，设置参数
            factory.setHost("10.211.55.7");
            factory.setPort(5672);
            factory.setVirtualHost("/");
            factory.setUsername("guest");
            factory.setPassword("guest");
    
            //3，创建连接
            Connection connection = factory.newConnection();
    
            //4，创建channel
            Channel channel = connection.createChannel();
    
            //5，创建交换机Exchange
            /*
                String exchange, --交换机名称
                BuiltinExchangeType type, --交换机类型
                        DIRECT("direct"),--定向
                        FANOUT("fanout"),--广播，所有跟这个交换机绑定的队列，多能收到消息
                        TOPIC("topic"),-- 通配符，主题方式
                        HEADERS("headers");--参数匹配
                boolean durable, --是否持久化
                boolean autoDelete, --是否在没有客户端的时候，自动删除
                boolean internal, -- 是否针对rabbitMQ内部
                Map<String, Object> arguments -- 参数
             */
            String exchangeName = "test_fanout";
            channel.exchangeDeclare(exchangeName, BuiltinExchangeType.FANOUT,true,false,false,null);
    
            //6，创建队列
            /*
                String queue, --队列名称
                boolean durable, --是否持久化
                boolean exclusive, --是否某个客户端独占
                boolean autoDelete, --是否在没有客户端的时候，自动删除
                Map<String, Object> arguments 参数
             */
            String queue1Name = "test_fanout_queue1";
            String queue2Name = "test_fanout_queue2";
            channel.queueDeclare(queue1Name,true,false,false,null);
            channel.queueDeclare(queue2Name,true,false,false,null);
    
            //7，绑定交换机和队列
            /*
            String queue, --队列名称
            String exchange, -- 交换机
            String routingKey, -- 路由，在fanout模式下，这个为空
             */
            channel.queueBind(queue1Name,exchangeName,"");
            channel.queueBind(queue2Name,exchangeName,"");
    
            //8，发布消息
            String body="日志信息：张三调用的findAll方法，日志级别为info～～～～～～～";
            /*
            String exchange, --交换机名称
            String routingKey, --路由
            BasicProperties props, --属性
            byte[] body -- 消息体
             */
            channel.basicPublish(exchangeName,"",null,body.getBytes());
            //9，关闭连接
            channel.close();
            connection.close();
        }
    }

消费者

两个消费者分别监听test\_fanout\_queue1和test\_fanout\_queue2

package com.wayne;
    
    import com.rabbitmq.client.*;
    
    import java.io.IOException;
    import java.util.concurrent.TimeoutException;
    
    public class Consumer_publish_subscribe2 {
    
        public static void main(String[] args) throws IOException, TimeoutException {
            //1,创建连接工厂
            ConnectionFactory factory = new ConnectionFactory();
            //2，设置参数(host,port,virtual host,username,guest)
            factory.setHost("10.211.55.7");
            factory.setPort(5672);
            factory.setVirtualHost("/");
            factory.setUsername("guest");
            factory.setPassword("guest");
    
            //3，创建连接
            Connection connection = factory.newConnection();
    
            //4，创建channel
            Channel channel = connection.createChannel();
    
            //5，创建队列Queue
            //String queue--队列名称,
            // boolean durable--是否持久化,
            // boolean exclusive--是否独占（只有一个消费者）当connection关闭时，是否删除队列, boolean autoDelete--是否允许自动删除（没有消费者时）,
            // Map<String, Object> arguments-- 参数
            channel.queueDeclare("test_fanout_queue1", true, false, false, null);
            //channel.queueDeclare("test_fanout_queue2", true, false, false, null);
    
            //6，创建消费者
            //String queue--队列名称, boolean autoAck--是否发送自动确认信息, Consumer callback--回调对象)
            channel.basicConsume("test_fanout_queue1",true,new DefaultConsumer(channel){
            //channel.basicConsume("test_fanout_queue2",true,new DefaultConsumer(channel){
                //糊掉对象中的方法
                //String consumerTag, -- 消费者标签
                // Envelope envelope, -- 一些信息 例如交换机、路由信息
                // AMQP.BasicProperties properties, 配置信息
                // byte[] body --实际的消息体
                @Override
                public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
                    System.out.println("body:"+new String(body));
                    System.out.println("保存到日志数据库中。。。。。");
                    //System.out.println("保存到日志文件中。。。。。");
                }
            });
    
    
        }
    }

## 测试情况： ##

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2E4MEM1MQ_size_16_color_FFFFFF_t_70 3][]

控制台测试情况

![2020121023523878.png][]

![20201210235252738.png][]

# 三、routing模式 #

## 工作原理 ##

![20201211001056984.png][]

## 源码 ##

生产者

package com.wayne;
    
    import com.rabbitmq.client.BuiltinExchangeType;
    import com.rabbitmq.client.Channel;
    import com.rabbitmq.client.Connection;
    import com.rabbitmq.client.ConnectionFactory;
    
    import java.io.IOException;
    import java.util.concurrent.TimeoutException;
    
    public class Producer_routing {
    
        public static void main(String[] args) throws IOException, TimeoutException {
            //1，创建工厂
            ConnectionFactory factory = new ConnectionFactory();
    
            //2，设置参数
            factory.setHost("10.211.55.7");
            factory.setPort(5672);
            factory.setVirtualHost("/");
            factory.setUsername("guest");
            factory.setPassword("guest");
    
            //3，创建连接
            Connection connection = factory.newConnection();
    
            //4，创建channel
            Channel channel = connection.createChannel();
    
            //5，创建交换机Exchange
            /*
                String exchange, --交换机名称
                BuiltinExchangeType type, --交换机类型
                        DIRECT("direct"),--定向
                        FANOUT("fanout"),--广播，所有跟这个交换机绑定的队列，多能收到消息
                        TOPIC("topic"),-- 通配符，主题方式
                        HEADERS("headers");--参数匹配
                boolean durable, --是否持久化
                boolean autoDelete, --是否在没有客户端的时候，自动删除
                boolean internal, -- 是否针对rabbitMQ内部
                Map<String, Object> arguments -- 参数
             */
            String exchangeName = "test_direct";
            channel.exchangeDeclare(exchangeName, BuiltinExchangeType.DIRECT,true,false,false,null);
    
            //6，创建队列
            /*
                String queue, --队列名称
                boolean durable, --是否持久化
                boolean exclusive, --是否某个客户端独占
                boolean autoDelete, --是否在没有客户端的时候，自动删除
                Map<String, Object> arguments 参数
             */
            String queue1Name = "test_direct_queue1";
            String queue2Name = "test_direct_queue2";
            channel.queueDeclare(queue1Name,true,false,false,null);
            channel.queueDeclare(queue2Name,true,false,false,null);
    
            //7，绑定交换机和队列
            /*
            String queue, --队列名称
            String exchange, -- 交换机
            String routingKey, -- 路由，在fanout模式下，这个为空
             */
            channel.queueBind(queue1Name,exchangeName,"error");
            channel.queueBind(queue2Name,exchangeName,"info");
            channel.queueBind(queue2Name,exchangeName,"error");
            channel.queueBind(queue2Name,exchangeName,"warning");
    
            //8，发布消息
            String body1="日志信息：张三调用的delete方法，出错了日志级别为error～～～～～～～";
            /*
            String exchange, --交换机名称
            String routingKey, --路由
            BasicProperties props, --属性
            byte[] body -- 消息体
             */
            channel.basicPublish(exchangeName,"error",null,body1.getBytes());
            String body2="日志信息：张三调用的findAll方法，出错了日志级别为info～～～～～～～";
            channel.basicPublish(exchangeName,"info",null,body2.getBytes());
    
            //9，关闭连接
            channel.close();
            connection.close();
        }
    }

消费者1

package com.wayne;
    
    import com.rabbitmq.client.*;
    
    import java.io.IOException;
    import java.util.concurrent.TimeoutException;
    
    public class Consumer_routing1 {
    
        public static void main(String[] args) throws IOException, TimeoutException {
            //1,创建连接工厂
            ConnectionFactory factory = new ConnectionFactory();
            //2，设置参数(host,port,virtual host,username,guest)
            factory.setHost("10.211.55.7");
            factory.setPort(5672);
            factory.setVirtualHost("/");
            factory.setUsername("guest");
            factory.setPassword("guest");
    
            //3，创建连接
            Connection connection = factory.newConnection();
    
            //4，创建channel
            Channel channel = connection.createChannel();
    
            //5，创建队列Queue
            //String queue--队列名称,
            // boolean durable--是否持久化,
            // boolean exclusive--是否独占（只有一个消费者）当connection关闭时，是否删除队列, boolean autoDelete--是否允许自动删除（没有消费者时）,
            // Map<String, Object> arguments-- 参数
            channel.queueDeclare("test_direct_queue1", true, false, false, null);
    
            //6，创建消费者
            //String queue--队列名称, boolean autoAck--是否发送自动确认信息, Consumer callback--回调对象)
            channel.basicConsume("test_direct_queue1",true,new DefaultConsumer(channel){
    
                //糊掉对象中的方法
                //String consumerTag, -- 消费者标签
                // Envelope envelope, -- 一些信息 例如交换机、路由信息
                // AMQP.BasicProperties properties, 配置信息
                // byte[] body --实际的消息体
                @Override
                public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
                    System.out.println("body:"+new String(body));
                    System.out.println("保存日志到数据库。。。");
                }
            });
    
    
        }
    }

消费者2

package com.wayne;
    
    import com.rabbitmq.client.*;
    
    import java.io.IOException;
    import java.util.concurrent.TimeoutException;
    
    public class Consumer_routing2 {
    
        public static void main(String[] args) throws IOException, TimeoutException {
            //1,创建连接工厂
            ConnectionFactory factory = new ConnectionFactory();
            //2，设置参数(host,port,virtual host,username,guest)
            factory.setHost("10.211.55.7");
            factory.setPort(5672);
            factory.setVirtualHost("/");
            factory.setUsername("guest");
            factory.setPassword("guest");
    
            //3，创建连接
            Connection connection = factory.newConnection();
    
            //4，创建channel
            Channel channel = connection.createChannel();
    
            //5，创建队列Queue
            //String queue--队列名称,
            // boolean durable--是否持久化,
            // boolean exclusive--是否独占（只有一个消费者）当connection关闭时，是否删除队列, boolean autoDelete--是否允许自动删除（没有消费者时）,
            // Map<String, Object> arguments-- 参数
            channel.queueDeclare("test_direct_queue2", true, false, false, null);
    
            //6，创建消费者
            //String queue--队列名称, boolean autoAck--是否发送自动确认信息, Consumer callback--回调对象)
            channel.basicConsume("test_direct_queue2",true,new DefaultConsumer(channel){
    
                //糊掉对象中的方法
                //String consumerTag, -- 消费者标签
                // Envelope envelope, -- 一些信息 例如交换机、路由信息
                // AMQP.BasicProperties properties, 配置信息
                // byte[] body --实际的消息体
                @Override
                public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
                    System.out.println("body:"+new String(body));
                    System.out.println("保存日志到日志文件中。。。");
                }
            });
    
    
        }
    }

## 测试情况 ##

消费者1

![20201211001414983.png][]

消费者2

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2E4MEM1MQ_size_16_color_FFFFFF_t_70 4][]

# 四、topic模式 #

## 工作原理 ##

![20201211003033841.png][]

其中 \* 代表一个单词；\# 代表0个或者多个单词

## 源码 ##

生产者

package com.wayne;
    
    import com.rabbitmq.client.BuiltinExchangeType;
    import com.rabbitmq.client.Channel;
    import com.rabbitmq.client.Connection;
    import com.rabbitmq.client.ConnectionFactory;
    
    import java.io.IOException;
    import java.util.concurrent.TimeoutException;
    
    public class Producer_topic {
    
        public static void main(String[] args) throws IOException, TimeoutException {
            //1，创建工厂
            ConnectionFactory factory = new ConnectionFactory();
    
            //2，设置参数
            factory.setHost("10.211.55.7");
            factory.setPort(5672);
            factory.setVirtualHost("/");
            factory.setUsername("guest");
            factory.setPassword("guest");
    
            //3，创建连接
            Connection connection = factory.newConnection();
    
            //4，创建channel
            Channel channel = connection.createChannel();
    
            //5，创建交换机Exchange
            /*
                String exchange, --交换机名称
                BuiltinExchangeType type, --交换机类型
                        DIRECT("direct"),--定向
                        FANOUT("fanout"),--广播，所有跟这个交换机绑定的队列，多能收到消息
                        TOPIC("topic"),-- 通配符，主题方式
                        HEADERS("headers");--参数匹配
                boolean durable, --是否持久化
                boolean autoDelete, --是否在没有客户端的时候，自动删除
                boolean internal, -- 是否针对rabbitMQ内部
                Map<String, Object> arguments -- 参数
             */
            String exchangeName = "test_topic";
            channel.exchangeDeclare(exchangeName, BuiltinExchangeType.TOPIC,true,false,false,null);
    
            //6，创建队列
            /*
                String queue, --队列名称
                boolean durable, --是否持久化
                boolean exclusive, --是否某个客户端独占
                boolean autoDelete, --是否在没有客户端的时候，自动删除
                Map<String, Object> arguments 参数
             */
            String queue1Name = "test_topic_queue1";
            String queue2Name = "test_topic_queue2";
            channel.queueDeclare(queue1Name,true,false,false,null);
            channel.queueDeclare(queue2Name,true,false,false,null);
    
            //7，绑定交换机和队列
            /*
            String queue, --队列名称
            String exchange, -- 交换机
            String routingKey, -- 路由，在fanout模式下，这个为空
             */
            channel.queueBind(queue1Name,exchangeName,"#.error");
            channel.queueBind(queue1Name,exchangeName,"order.*");
            channel.queueBind(queue2Name,exchangeName,"*.*");
    
            //8，发布消息
            /*
            String exchange, --交换机名称
            String routingKey, --路由
            BasicProperties props, --属性
            byte[] body -- 消息体
             */
            String body1="日志信息：张三order.error";
            channel.basicPublish(exchangeName,"order.error",null,body1.getBytes());
            String body2="日志信息：张三goods.info";
            channel.basicPublish(exchangeName,"goods.info",null,body2.getBytes());
    
            //9，关闭连接
            channel.close();
            connection.close();
        }
    }

消费者1

package com.wayne;
    
    import com.rabbitmq.client.*;
    
    import java.io.IOException;
    import java.util.concurrent.TimeoutException;
    
    public class Consumer_topic1 {
    
        public static void main(String[] args) throws IOException, TimeoutException {
            //1,创建连接工厂
            ConnectionFactory factory = new ConnectionFactory();
            //2，设置参数(host,port,virtual host,username,guest)
            factory.setHost("10.211.55.7");
            factory.setPort(5672);
            factory.setVirtualHost("/");
            factory.setUsername("guest");
            factory.setPassword("guest");
    
            //3，创建连接
            Connection connection = factory.newConnection();
    
            //4，创建channel
            Channel channel = connection.createChannel();
    
            //5，创建队列Queue
            //String queue--队列名称,
            // boolean durable--是否持久化,
            // boolean exclusive--是否独占（只有一个消费者）当connection关闭时，是否删除队列, boolean autoDelete--是否允许自动删除（没有消费者时）,
            // Map<String, Object> arguments-- 参数
            channel.queueDeclare("test_topic_queue1", true, false, false, null);
    
            //6，创建消费者
            //String queue--队列名称, boolean autoAck--是否发送自动确认信息, Consumer callback--回调对象)
            channel.basicConsume("test_topic_queue1",true,new DefaultConsumer(channel){
    
                //糊掉对象中的方法
                //String consumerTag, -- 消费者标签
                // Envelope envelope, -- 一些信息 例如交换机、路由信息
                // AMQP.BasicProperties properties, 配置信息
                // byte[] body --实际的消息体
                @Override
                public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
                    System.out.println("body:"+new String(body));
                    System.out.println("保存日志到数据库。。。");
                }
            });
    
    
        }
    }

消费者2

package com.wayne;
    
    import com.rabbitmq.client.*;
    
    import java.io.IOException;
    import java.util.concurrent.TimeoutException;
    
    public class Consumer_topic2 {
    
        public static void main(String[] args) throws IOException, TimeoutException {
            //1,创建连接工厂
            ConnectionFactory factory = new ConnectionFactory();
            //2，设置参数(host,port,virtual host,username,guest)
            factory.setHost("10.211.55.7");
            factory.setPort(5672);
            factory.setVirtualHost("/");
            factory.setUsername("guest");
            factory.setPassword("guest");
    
            //3，创建连接
            Connection connection = factory.newConnection();
    
            //4，创建channel
            Channel channel = connection.createChannel();
    
            //5，创建队列Queue
            //String queue--队列名称,
            // boolean durable--是否持久化,
            // boolean exclusive--是否独占（只有一个消费者）当connection关闭时，是否删除队列, boolean autoDelete--是否允许自动删除（没有消费者时）,
            // Map<String, Object> arguments-- 参数
            channel.queueDeclare("test_topic_queue2", true, false, false, null);
    
            //6，创建消费者
            //String queue--队列名称, boolean autoAck--是否发送自动确认信息, Consumer callback--回调对象)
            channel.basicConsume("test_topic_queue2",true,new DefaultConsumer(channel){
    
                //糊掉对象中的方法
                //String consumerTag, -- 消费者标签
                // Envelope envelope, -- 一些信息 例如交换机、路由信息
                // AMQP.BasicProperties properties, 配置信息
                // byte[] body --实际的消息体
                @Override
                public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
                    System.out.println("body:"+new String(body));
                    System.out.println("保存日志到日志。。。");
                }
            });
    
    
        }
    }

## 测试情况 ##

消费者1

![20201211003223883.png][]

消费者2

![20201211003243898.png][]

[RabbitMQ_-- producer_consumer]: https://blog.csdn.net/a80C51/article/details/110914489
[20201210225300287.png]: /images/20221120/fca56b753b8640e38535f950428e2345.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2E4MEM1MQ_size_16_color_FFFFFF_t_70]: /images/20221120/8bf7173d8b594c8593811e833eb56777.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2E4MEM1MQ_size_16_color_FFFFFF_t_70 1]: https://img-blog.csdnimg.cn/20201210230413172.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2E4MEM1MQ==,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2E4MEM1MQ_size_16_color_FFFFFF_t_70 2]: /images/20221120/3a8c02fe2e5745918ff3f49b836bd042.png
[20201210231748916.png]: /images/20221120/deb486edafbf443e8b7758bb93985120.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2E4MEM1MQ_size_16_color_FFFFFF_t_70 3]: /images/20221120/a7dd5f1834b444a1bef2fc3b11dea0ee.png
[2020121023523878.png]: /images/20221120/a577823e68c84ed2af00e0dbd3c22294.png
[20201210235252738.png]: https://img-blog.csdnimg.cn/20201210235252738.png
[20201211001056984.png]: https://img-blog.csdnimg.cn/20201211001056984.png
[20201211001414983.png]: https://img-blog.csdnimg.cn/20201211001414983.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2E4MEM1MQ_size_16_color_FFFFFF_t_70 4]: https://img-blog.csdnimg.cn/20201211001432224.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2E4MEM1MQ==,size_16,color_FFFFFF,t_70
[20201211003033841.png]: https://img-blog.csdnimg.cn/20201211003033841.png
[20201211003223883.png]: https://img-blog.csdnimg.cn/20201211003223883.png
[20201211003243898.png]: https://img-blog.csdnimg.cn/20201211003243898.png