ActiveMQ之JMS规范

阳光穿透心脏的1/2处 2023-07-17 15:48 9阅读 0赞

### 什么是JMS？ ###

JMS即Java消息服务（Java Message Service）应用程序接口，指的是两个应用程序之间进行异步通信的API，它为标准协议和消息服务提供了一组通用接口，包括创建、发送、读取消息等，用于支持Java应用程序开发。在JavaEE中，当两个应用程序使用JMS进行通信时，它们之间不是直接相连的，而是通过一个共同的消息收发服务组件关联起来以达到解耦/异步削峰的效果。  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2NoZW5fY2hhbmd5aW5n_size_16_color_FFFFFF_t_70]

### JMS组成结构 ###

*  JMS Provider：实现JSM接口和规范的消息中间件，也就是我们所说的MQ服务端
 *  JMS Producer：消息生产者，创建和发送JSM消息的客户端应用
 *  JMS Consumer：消息消费者，接收和处理JSM消息的客户端应用
 *  JSM Message：通过JSM传递的消息
    
     *  消息头
     *  消息体
     *  消息属性

### 消息头 ###

JMS消息头常用属性：

*  JMSDestination：消息发送的目的地，主要是之Queue和Topic
 *  JMSDeliveryMode：消息持久化模式
 *  JMSExpiration：消息过期时间
 *  JMSPriority：消息优先级
 *  JMSMessageID：消息id，消息的唯一标识符

生产者在发送消息的时候可以设置这些属性，消费者在消费消息的时候可以获取到这些属性；  
代码示例：

TextMessage textMessage = session.createTextMessage("hello_activeMQ_Server" + i);
    // 单独设置消息的目的地，可以是queue或topic
    textMessage.setJMSDestination(queue);
    
    /**
    * 设置消息持久化模式
    * 持久模式：DeliveryMode.PERSISTENT
    * 非持久化模式：DeliveryMode.NON_PERSISTENT
    * 消息默认是持久化的
    *
    * 一条持久化的消息：应该被传送“一次仅仅一次”，这就意味着如果JMS提供者出现故障，该消息并不会丢失，它会在服务器恢复之后再次传递。
    * 一条非持久的消息：最多会传递一次，这意味着服务器出现故障，该消息将会永远丢失。
    */
    textMessage.setJMSDeliveryMode(DeliveryMode.NON_PERSISTENT);
    
    /**
    * 设置消息在一定时间后过期，默认是永不过期。
    * 消息过期时间，等于Destination的send方法中的timeToLive值加上发送时刻的GMT时间值。
    * 如果timeToLive值等于0，则JMSExpiration被设为0，表示该消息永不过期。
    *  如果发送后，在消息过期时间之后还没有被发送到目的地，则该消息会被清除。
    */
    textMessage.setJMSExpiration(1000);
    
    /**
    * 设置消息优先级
    * 从0-9十个级别，0-4是普通消息，5-9是加急消息
    * JMS不要求MQ严格按照这十个优先级发送消息但必须保证加急消息要先于普通消息到达。默认是4级。
    */
    textMessage.setJMSPriority(9);
    
    /**
    * 消息唯一标识符，MQ会给我们默认生成一个，也可以自己指定，需全局唯一
    */
    textMessage.setJMSMessageID("123");
    
    messageProducer.send(textMessage);

### 消息体 ###

JMS可以创建五种类型的消息，接收时的消息类型必须与发送时的消息一一对应；  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2NoZW5fY2hhbmd5aW5n_size_16_color_FFFFFF_t_70 1]

*  TextMessage：字符串消息，包含一个string；
 *  MapMessage：Map类型的消息，键值对，key为String类型，值为Java的基础类型；
 *  BytesMessage：二进制数组消息，包含一个byte\[\]；
 *  StreamMessage：Java数据流消息，用标准的数据流来顺序的填充和读取
 *  ObjectMessage：对象型消息，包含一个可序列化的对象

常用的也就TextMessage和MapMessage，下面我们来演示这两种类型的消息用法：

// 发送
    TextMessage textMessage = session.createTextMessage("hello_activeMQ_Server" + i);
    messageProducer.send(textMessage);
    
    MapMessage mapMessage = session.createMapMessage();
    mapMessage.setString("k1","mapMessage");
    mapMessage.setInt("k2",1);
    
    messageProducer.send(mapMessage);
    
    // 接收
    messageConsumer.setMessageListener((message) -> {
        if (message != null) {
            if (message instanceof TextMessage) {
                TextMessage textMessage = (TextMessage) message;
                try {
                    System.out.println("消费掉的消息 -> " + textMessage.getText());
                } catch (JMSException e) {
                    e.printStackTrace();
                }
            } else if (message instanceof MapMessage) {
                MapMessage mapMessage = (MapMessage) message;
                try {
                    System.out.println("消费掉的Map消息 -> " + mapMessage.getString("k1"));
                    System.out.println("消费掉的Map消息 -> " + mapMessage.getInt("k2"));
                } catch (JMSException e) {
                    e.printStackTrace();
                }
            }
    
        }
    });

### 消息属性 ###

如果消息头携带的信息还不够满足你的需要的话，那么还可以通过消息属性来携带更多的信息，常用于识别/去重/重点标注等操作；

他们是以属性名和属性值对的形式制定的。可以将属性是为消息头得扩展，属性指定一些消息头没有包括的附加信息，比如可以在属性里指定消息选择器。消息的属性就像可以分配给一条消息的附加消息头一样。它们允许开发者添加有关消息的不透明附加信息。它们还用于暴露消息选择器在消息过滤时使用的数据。

根据自己携带消息属性数据类型，选择相应的设置方法  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2NoZW5fY2hhbmd5aW5n_size_16_color_FFFFFF_t_70 2]

// 发送
    TextMessage textMessage = session.createTextMessage("hello_activeMQ_Server" + i);
    textMessage.setStringProperty("user","zhangsan");
    textMessage.setBooleanProperty("isLogin", true);
    messageProducer.send(textMessage);
    
    // 获取
    TextMessage textMessage = (TextMessage) message;
    try {
        System.out.println("消费掉的消息 -> " + textMessage.getText());
        System.out.println("消费掉的消息属性 -> " + textMessage.getStringProperty("user"));
        System.out.println("消费掉的消息属性 -> " + textMessage.getBooleanProperty("isLogin"));
    } catch (JMSException e) {
        e.printStackTrace();
    }

### 消息的持久化 ###

消息持久化就是在消息发送至目的地时，消息服务器会将其持久化存储，假如消费者还没来得及消费的时候，服务器出现故障、宏机了，当服务再次恢复时，此消息不会丢失，会依旧存在，并能够保证（topic要之前注册过，queue不用）消息消费者能成功消费之前未消费的消息，通过这种方式就保证了消息的可靠性；

Queue：queue非持久，当服务器宕机，消息不存在（消息丢失了）。即便是非持久，消费者在不在线的话，消息也不会丢失，等待消费者在线，还是能够收到消息的。  
queue持久化，当服务器宕机，消息依然存在。queue消息默认是持久化的。  
持久化消息，保证这些消息只被传送一次和成功使用一次。对于这些消息，可靠性是优先考虑的因素。  
可靠性的另一个重要方面是确保持久性消息传送至目标后，消息服务在向消费者传送它们之前不会丢失这些消息。

Queue消息持久化只需要设置生产者，代码如下：

// 根据session创建队列
    Queue queue = session.createQueue(QUEUE_NAME);
    
    // 创建消息的生产者并指定队列
    messageProducer = session.createProducer(queue);
    
    // 持久化：当服务器出现故障，服务恢复后消息依然存在
    // messageProducer.setDeliveryMode(DeliveryMode.PERSISTENT);
    // 非持久化：当服务器出现故障，服务恢复后消息不存在
    // messageProducer.setDeliveryMode(DeliveryMode.NON_PERSISTENT);

Topic：topic默认就是非持久化的，因为生产者生产消息时，消费者也要在线，这样消费者才能消费到消息。topic消息持久化，只要消费者向MQ服务器注册过，所有生产者发布成功的消息，该消费者都能收到，不管是MQ服务器宕机还是消费者不在线。

Topic消息持久化,，生产者和消费者都需要设置，代码如下：  
生产者：

// 根据session创建主题
    Topic topic = session.createTopic(TOPIC_NAME);
    
    // 创建消息的生产者并指定队列
    messageProducer = session.createProducer(topic);
    
    // 设置持久化topic 
     messageProducer.setDeliveryMode(DeliveryMode.PERSISTENT);
     // 设置持久化topic之后再启动连接
     connection.start();

消费者：

// 通过连接工厂,获得connection，持久化的topic必须在消费者创建并创建好订阅者完成后调用start
    connection = activeMQConnection.createConnection();
    // 设置客户端id，向MQ服务器注册自己
    connection.setClientID("Consumer_Persistence");
    /**
     * 创建session，得到会话
     * 两个参数transacted=事务,acknowledgeMode=确认模式(签收)
     */
    session = connection.createSession(false, Session.AUTO_ACKNOWLEDGE);
    // 根据session创建主题
    Topic topic = session.createTopic(TOPIC_NAME);
    // 创建一个topic订阅者对象，参数以：topic；参数二：订阅者名称
    session.createDurableSubscriber(topic,"订阅者");
    
    //  打开连接
    connection.start();

当有消费者订阅了一个持久化主题，可以在activeMQ控制台中的`Subscribers`页面看到：  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2NoZW5fY2hhbmd5aW5n_size_16_color_FFFFFF_t_70 3]  
此时我们停掉消费者程序，启动生产者发送消息：  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2NoZW5fY2hhbmd5aW5n_size_16_color_FFFFFF_t_70 4]  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2NoZW5fY2hhbmd5aW5n_size_16_color_FFFFFF_t_70 5]  
从上图可以看到有一个消费者，入队消息数量为3，出对消息数量为0，也就是没有消费者消费消息，消息订阅者也是离线状态；

此时我们来启动消息订阅者，看能否收到消息：  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2NoZW5fY2hhbmd5aW5n_size_16_color_FFFFFF_t_70 6]  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2NoZW5fY2hhbmd5aW5n_size_16_color_FFFFFF_t_70 7]  
可以看到消费者能够收到了生产者发送的消息，出对消息数量由0变为了3

### 消息的事物 ###

说到事物，大家可能都不陌生，我们在日常项目开发中，数据的插入，修改，都会涉及到事物，同理，activeMQ也有事物的支持；

生产者开启事务后，执行commit方法，这批消息才真正的被提交。不执行commit方法，这批消息不会提交。执行rollback方法，之前的消息会回滚掉。生产者的事务机制，要高于签收机制，当生产者开启事务，签收机制不再重要。

消费者开启事务后，执行commit方法，这批消息才算真正的被消费。不执行commit方法，这些消息不会标记已消费，下次还会被消费。执行rollback方法，是不能回滚之前执行过的业务逻辑，但是能够回滚之前的消息，回滚后的消息，下次还会被消费。消费者利用commit和rollback方法，甚至能够违反一个消费者只能消费一次消息的原理。

生产者和消费者事物各自独立，可独立开启，没有关联

生产者代码示例：

package com.chaytech.activemq.transaction;
    
    import org.apache.activemq.ActiveMQConnectionFactory;
    
    import javax.jms.*;
    
    /**
     * 消息生产者(开启事物)
     *
     * @author Chency
     * @email chaytech@163.com
     * @Date 2020/03/21 22:20
     */
    public class JmsProducer {
    
        private static final String BROKER_URL = "tcp://192.168.0.166:61616"; // activeMQ服务地址
        private static final String QUEUE_NAME = "test_queue_1"; // 消息队列名称
    
        public static void main(String[] args) {
            /**
             * 根据我们指定activeMQ服务地址来创建activeMQ工厂
             * 如果我们自己不指定activeMQ服务地址则默认为本机
             */
            ActiveMQConnectionFactory activeMQConnection = new ActiveMQConnectionFactory(BROKER_URL);
            Connection connection = null;
            Session session = null;
            MessageProducer messageProducer = null;
            try {
                // 通过连接工厂,获得connection
                connection = activeMQConnection.createConnection();
                //  打开连接
                connection.start();
                /**
                 * 创建session，得到会话
                 * 两个参数transacted=事务，true开启,acknowledgeMode=确认模式(签收)
                 */
                session = connection.createSession(true, Session.AUTO_ACKNOWLEDGE);
                // 根据session创建队列
                Queue queue = session.createQueue(QUEUE_NAME);
    
                // 创建消息的生产者并指定队列
                messageProducer = session.createProducer(queue);
                // 通过使用消息生产者,生产消息,发送到MQ的队列里面
                for (int i = 1; i <= 3; i++) {
                    TextMessage textMessage = session.createTextMessage("hello_activeMQ_Server" + i);
                    messageProducer.send(textMessage);
                }
    
                // 开启事务后，使用commit提交事务，这样这批消息才能真正的被提交。
                session.commit();
                System.out.println("**********msg send sucess**********");
            } catch (JMSException e) {
                e.printStackTrace();
                // 当出现异常了，我们可以在catch代码块中回滚。这样这批发送的消息就能回滚。
                try {
                    session.rollback();
                } catch (JMSException e1) {
                }
            } finally {
                try {
                    messageProducer.close();
                    session.close();
                    connection.close();
                } catch (JMSException e) {
                    e.printStackTrace();
                }
            }
        }
    }

消费者代码示例：

package com.chaytech.activemq.transaction;
    
    import org.apache.activemq.ActiveMQConnectionFactory;
    
    import javax.jms.*;
    
    /**
     * 消息消费者（开启事物）
     *
     * @author Chency
     * @email chaytech@163.com
     * @Date 2020/03/22 10:45
     */
    public class JmsConsumer {
        private static final String BROKER_URL = "tcp://192.168.0.166:61616"; // activeMQ服务地址
        private static final String QUEUE_NAME = "test_queue_1"; // 消息队列名称
    
        public static void main(String[] args) {
            /**
             * 根据我们指定activeMQ服务地址来创建activeMQ工厂
             * 如果我们自己不指定activeMQ服务地址则默认为本机
             */
            ActiveMQConnectionFactory activeMQConnection = new ActiveMQConnectionFactory(BROKER_URL);
            Connection connection = null;
            Session session = null;
            MessageConsumer messageConsumer = null;
            try {
                // 通过连接工厂,获得connection
                connection = activeMQConnection.createConnection();
                //  打开连接
                connection.start();
                /**
                 * 创建session，得到会话
                 * 两个参数transacted=事务,true 开启，acknowledgeMode=确认模式(签收)
                 * 消费者开启了事务就必须手动提交，不然会出现消息重复消费
                 */
                session = connection.createSession(true, Session.AUTO_ACKNOWLEDGE);
                // 根据session创建队列
                Queue queue = session.createQueue(QUEUE_NAME);
                // 创建消息消费者并指定消费的队列
                messageConsumer = session.createConsumer(queue);
    
                /**
                 * 通过监听的方式来消费消息，是以异步非阻塞的方式来消费消息
                 * 通过messageConsumer 的setMessageListener 注册一个监听器，当有消息发送来时，系统自动调用MessageListener 的 onMessage 方法处理消息
                 */
                messageConsumer.setMessageListener((message) -> {
                    if (message != null) {
                        if (message instanceof TextMessage) {
                            TextMessage textMessage = (TextMessage) message;
                            try {
                                System.out.println("消费掉的消息 -> " + textMessage.getText());
                                System.out.println("消费掉的消息属性 -> " + textMessage.getStringProperty("user"));
                                System.out.println("消费掉的消息属性 -> " + textMessage.getBooleanProperty("isLogin"));
                            } catch (JMSException e) {
                                e.printStackTrace();
                            }
                        } else if (message instanceof MapMessage) {
                            MapMessage mapMessage = (MapMessage) message;
                            try {
                                System.out.println("消费掉的Map消息 -> " + mapMessage.getString("k1"));
                                System.out.println("消费掉的Map消息 -> " + mapMessage.getInt("k2"));
                            } catch (JMSException e) {
                                e.printStackTrace();
                            }
                        }
    
                    }
                });
    
                // 开启事务后，使用commit提交事务，这样这批消息才会真正的被消费掉。
                session.commit();
                /**
                 * 此处是为了不让主线程结束，因为一旦主线程结束了，其他的线程（如此处的监听消息的线程）也都会被迫结束。
                 * 实际开发中不需要
                 */
                System.in.read();
            } catch (Exception e) {
                e.printStackTrace();
                try {
                    // // 当出现异常了，我们可以在catch代码块中回滚。这样就可以再次消费此消息
                    session.rollback();
                } catch (JMSException e1) {
                }
            } finally {
                try {
                    messageConsumer.close();
                    session.close();
                    connection.close();
                } catch (JMSException e) {
                    e.printStackTrace();
                }
            }
        }
    }

### 消息的签收机制 ###

前面我们讲生产者和消费者在创建session的时候，需要传两个参数，第一个是是否开启事物，第二个是消息签收方式，本次我们将来聊一聊activeMQ的消息签收机制；

消息签收方式，一共分以下几种：

1.  Session.AUTO\_ACKNOWLEDGE（自动签收）：此方式是默认的。无需我们程序做任何操作，会帮我们自动签收收到的消息。
2.  Session.CLIENT\_ACKNOWLEDGE（手动签收）：此方式需要我们手动调用`Message.acknowledge()`方法来签收消息。如果不签收消息，该消息会被我们反复消费，直到被签收。
3.  Session.DUPS\_OK\_ACKNOWLEDGE（允许重复消息）：多线程或多个消费者同时消费到一个消息，因为线程不安全，可能会重复消费。该种方式很少使用到。
4.  Session.SESSION\_TRANSACTED（事物下的签收）：开始事务的情况下，可以使用该方式。该种方式很少使用到。

事物和消息签收的关系：

*  在事务性会话中，当一个事务被成功提交则消息被自动签收。如果事务回滚，则消息会被再次传送。事务优先于签收，开始事务后，签收机制不再起任何作用。
 *  非事务性会话中，消息何时被签收取决于创建会话时的应答模式。
 *  生产者事务开启，只有commit后才能将全部消息变为已消费
 *  事务偏向生产者，签收偏向消费者。也就是说，生产者使用事务更好点，消费者使用签收机制更好点。

下面我们来演示一下，非事物下的消费者手动签收消息：

package com.chaytech.activemq.queue;
    
    import org.apache.activemq.ActiveMQConnectionFactory;
    
    import javax.jms.*;
    
    /**
     * 消息消费者
     *
     * @author Chency
     * @email chaytech@163.com
     * @Date 2020/03/22 10:45
     */
    public class JmsConsumer {
        private static final String BROKER_URL = "tcp://192.168.0.166:61616"; // activeMQ服务地址
        private static final String QUEUE_NAME = "test_queue_1"; // 消息队列名称
    
        public static void main(String[] args) {
            /**
             * 根据我们指定activeMQ服务地址来创建activeMQ工厂
             * 如果我们自己不指定activeMQ服务地址则默认为本机
             */
            ActiveMQConnectionFactory activeMQConnection = new ActiveMQConnectionFactory(BROKER_URL);
            Connection connection = null;
            Session session = null;
            MessageConsumer messageConsumer = null;
            try {
                // 通过连接工厂,获得connection
                connection = activeMQConnection.createConnection();
                //  打开连接
                connection.start();
                /**
                 * 创建session，得到会话
                 * 两个参数transacted=事务,acknowledgeMode=确认模式(签收)
                 */
                session = connection.createSession(false, Session.CLIENT_ACKNOWLEDGE);
                // 根据session创建队列
                Queue queue = session.createQueue(QUEUE_NAME);
                // 创建消息消费者并指定消费的队列
                messageConsumer = session.createConsumer(queue);
                /**
                 * 通过监听的方式来消费消息，是以异步非阻塞的方式来消费消息
                 * 通过messageConsumer 的setMessageListener 注册一个监听器，当有消息发送来时，系统自动调用MessageListener 的 onMessage 方法处理消息
                 */
                messageConsumer.setMessageListener((message) -> {
                    if (message != null) {
                        if (message instanceof TextMessage) {
                            TextMessage textMessage = (TextMessage) message;
                            try {
                                System.out.println("消费掉的消息 -> " + textMessage.getText());
                                System.out.println("消费掉的消息属性 -> " + textMessage.getStringProperty("user"));
                                System.out.println("消费掉的消息属性 -> " + textMessage.getBooleanProperty("isLogin"));
    
                                /**
                                 * 设置为Session.CLIENT_ACKNOWLEDGE后，要调用该方法，标志着该消息已被签收（消费）。
                                 * 如果不调用该方法，该消息的标志还是未消费，下次启动消费者或其他消费者还会收到此消息。
                                 */
                                textMessage.acknowledge();
                            } catch (JMSException e) {
                                e.printStackTrace();
                            }
                        } else if (message instanceof MapMessage) {
                            MapMessage mapMessage = (MapMessage) message;
                            try {
                                System.out.println("消费掉的Map消息 -> " + mapMessage.getString("k1"));
                                System.out.println("消费掉的Map消息 -> " + mapMessage.getInt("k2"));
                            } catch (JMSException e) {
                                e.printStackTrace();
                            }
                        }
    
                    }
                });
    
                /**
                 * 此处是为了不让主线程结束，因为一旦主线程结束了，其他的线程（如此处的监听消息的线程）也都会被迫结束。
                 * 实际开发中不需要
                 */
                System.in.read();
            } catch (Exception e) {
                e.printStackTrace();
            } finally {
                try {
                    messageConsumer.close();
                    session.close();
                    connection.close();
                } catch (JMSException e) {
                    e.printStackTrace();
                }
            }
        }
    }

### 总结 ###

点对点（queue）：

*  点对点模型是基于队列的，生产者发消息到队列，消费者从队列消费消息，队列的存在使得消息的异步传输成为可能。和我们平时给朋友发送短信类似；
 *  如果在Session关闭时有部分消息己被收到但还没有被签收(acknowledged)，那当消费者下次连接到相同的队列时，这些消息还会被再次接收；
 *  队列可以长久地保存消息直到消费者收到消息。消费者不需要因为担心消息会丢失而时刻和队列保持激活的连接状态，充分体现了异步传输模式的优势；

发布订阅（topic）：

*  JMS Pub/Sub 模型定义了如何向一个内容节点发布和订阅消息，这些节点被称作topic；
 *  主题可以被认为是消息的传输中介，发布者（publisher）发布消息到主题，订阅者（subscribe）从主题订阅消息；
 *  主题使得消息订阅者和消息发布者保持互相独立不需要解除即可保证消息的传送
 *  订阅方式：
    
     *  持久化订阅：
        
         *  客户端首先向MQ注册一个自己的身份ID识别号，当这个客户端处于离线时，生产者会为这个ID保存所有发送到主题的消息，当客户再次连接到MQ的时候，会根据消费者的ID得到所有当自己处于离线时发送到主题的消息
         *  当持久订阅状态下，不能恢复或重新派送一个未签收的消息；
         *  持久订阅才能恢复或重新派送一个未签收的消息；
     *  非持久化订阅：
        
         *  非持久订阅只有当客户端处于激活状态，也就是和MQ保持连接状态才能收发到某个主题的消息；
         *  如果消费者处于离线状态，生产者发送的主题消息将会丢失作废，消费者永远不会收到；
         *  先订阅注册才能接收的到，只给订阅者发布消息
 *  如何选用：当所有的消息必须被接收，则用持久化订阅。当消息丢失能够被容忍，则用非持久订阅

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2NoZW5fY2hhbmd5aW5n_size_16_color_FFFFFF_t_70]: /images/20230528/9e4c21c789994292b972067d49ba2732.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2NoZW5fY2hhbmd5aW5n_size_16_color_FFFFFF_t_70 1]: /images/20230528/2ae6f60807b9464bba634bbcbda7da34.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2NoZW5fY2hhbmd5aW5n_size_16_color_FFFFFF_t_70 2]: /images/20230528/057dcac5d60c4ceaa2044f036849c5d9.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2NoZW5fY2hhbmd5aW5n_size_16_color_FFFFFF_t_70 3]: /images/20230528/609ebdbb157d4b4bbe321de27f41ef1d.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2NoZW5fY2hhbmd5aW5n_size_16_color_FFFFFF_t_70 4]: /images/20230528/a43f6f4e55ef43548990734ca8ffdd6e.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2NoZW5fY2hhbmd5aW5n_size_16_color_FFFFFF_t_70 5]: /images/20230528/8e8eac7779564ba099e0b18ad4a34c73.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2NoZW5fY2hhbmd5aW5n_size_16_color_FFFFFF_t_70 6]: /images/20230528/75b6e72cd5f644b593d60ba917854394.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2NoZW5fY2hhbmd5aW5n_size_16_color_FFFFFF_t_70 7]: /images/20230528/b80babdcae314381876caec77463e40a.png