Spring框架之注解编程

Dear 丶 2022-09-10 03:09 203阅读 0赞

### 代码和配置 ###

代码结构  
![在这里插入图片描述][watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBA54Wn54mp5Y2O_size_14_color_FFFFFF_t_70_g_se_x_16]

maven依赖

<properties>
        <java.version>1.8</java.version>
        <spring.verson>5.3.9</spring.verson>
        <junit.version>5.7.2</junit.version>
    </properties>
    <dependencies>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-context</artifactId>
            <version>${spring.verson}</version>
        </dependency>
    
        <dependency>
            <groupId>org.junit.jupiter</groupId>
            <artifactId>junit-jupiter-engine</artifactId>
            <version>${junit.version}</version>
            <scope>test</scope>
        </dependency>
    
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <version>1.18.20</version>
            <scope>provided</scope>
        </dependency>
    </dependencies>
    <build>
        <plugins>
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-surefire-plugin</artifactId>
                <version>2.22.2</version>
            </plugin>
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-compiler-plugin</artifactId>
                <version>3.8.1</version>
                <configuration>
                    <source>${java.version}</source>
                    <target>${java.version}</target>
                </configuration>
            </plugin>
        </plugins>
    </build>

`User.java` 代码

package org.spring.ss.pojo;
    
    import lombok.Data;
    import lombok.NoArgsConstructor;
    
    import java.util.Map;
    import java.util.Properties;
    
    @Data
    @NoArgsConstructor
    public class User { 
        private String name;
        private Integer age;
        private String[] favorites;
        private Map<String, Object> map;
        private Properties props;
    
        public User(String name, Integer age) { 
            this.name = name;
            this.age = age;
        }
    }

`UserDao.java`代码

package org.spring.ss.dao;
    
    import org.spring.ss.pojo.User;
    import org.springframework.stereotype.Repository;
    
    @Repository
    public class UserDao { 
        public User find() { 
            return new User("赵小八", 30);
        }
    }

`UserService.java` 代码

package org.spring.ss.service;
    
    import org.spring.ss.dao.UserDao;
    import org.spring.ss.pojo.User;
    import org.springframework.stereotype.Service;
    
    import javax.annotation.Resource;
    
    @Service
    public class UserService { 
        @Resource
        public UserDao userDao;
    
        public User find() { 
            return userDao.find();
        }
    }

`UserController.java`代码

package org.spring.ss.controller;
    
    import org.spring.ss.pojo.User;
    import org.spring.ss.service.UserService;
    import org.springframework.beans.factory.annotation.Autowired;
    import org.springframework.stereotype.Controller;
    
    @Controller
    public class UserController { 
        @Autowired
        public UserService userService;
    
        public void find() { 
            User userBean = userService.find();
            System.out.println(userBean);
        }
    }

UserTest.java 代码：

package org.spring.ss.pojo;
    
    import org.junit.jupiter.api.Test;
    import org.spring.ss.controller.UserController;
    import org.springframework.context.ApplicationContext;
    import org.springframework.context.annotation.AnnotationConfigApplicationContext;
    import org.springframework.context.support.ClassPathXmlApplicationContext;
    
    public class UserTest { 
    }

### 基于XML方式的实现 ###

新建`Spring`的配置文件`applicationContext.xml`，并添加包扫描路径。

> 如果`xmlns:context`不存在，注意添加

在`UserTest.java`里添加测试代码：

@Test
    public void testBySpringXML() { 
        // ioc 容器初始化
        ApplicationContext applicationContext = new ClassPathXmlApplicationContext("applicationContext.xml");
        // ioc 通过bean 的 id 获取指定的bean
        UserController userController = applicationContext.getBean("userController", UserController.class);
        // 使用bean
        userController.find();
    }

输出`User(name=赵小八, age=30, favorites=null, map=null, props=null)`

#### 限制指定包可以使用的注解 ####

修改`applicationContext.xml`配置文件：

<?xml version="1.0" encoding="UTF-8"?>
    <beans xmlns="http://www.springframework.org/schema/beans" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:context="http://www.springframework.org/schema/context" xsi:schemaLocation=" http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context.xsd ">
        
        
        
        
        
        
        
    
        
    
        
        <context:component-scan base-package="org.spring.ss.controller" use-default-filters="false">
            <context:include-filter type="annotation" expression="org.springframework.stereotype.Controller"/>
        </context:component-scan>
        <context:component-scan base-package="org.spring.ss.service,org.spring.ss.dao">
            
            <context:exclude-filter type="annotation" expression="org.springframework.stereotype.Controller" />
        </context:component-scan>
    </beans>

这个时候尝试修改`UserController`上面的注解为`@Component`。

package org.spring.ss.controller;
    
    import org.spring.ss.pojo.User;
    import org.spring.ss.service.UserService;
    import org.springframework.beans.factory.annotation.Autowired;
    import org.springframework.stereotype.Component;
    import org.springframework.stereotype.Controller;
    
    @Component
    public class UserController { 
        @Autowired
        public UserService userService;
    
        public void find() { 
            User userBean = userService.find();
            System.out.println(userBean);
        }
    }

重新运行测试用例`testBySpringXML`，可以看到下面的错误提示。  
![在这里插入图片描述][watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBA54Wn54mp5Y2O_size_20_color_FFFFFF_t_70_g_se_x_16]

### 基于java类配置实现 ###

添加`SpringConfig.java`文件，代码如下，以下代码实现了和上面`xml`代码配置一样的功能

添加测试代码：

@Test
    public void testBySpringConfig() { 
        // ioc 容器初始化
        ApplicationContext applicationContext = new AnnotationConfigApplicationContext(SpringConfig.class);
        // ioc 获取配置类中设置的 bean
        User userBean = (User) applicationContext.getBean("aaa");
        // 使用bean
        System.out.println(userBean);
        // 获取容器中被扫描标记的
        UserController userController = applicationContext.getBean("userController", UserController.class);
        // 使用bean
        userController.find();
    }

输出

User(name=王小六, age=null, favorites=null, map=null, props=null)
    User(name=赵小八, age=30, favorites=null, map=null, props=null)

#### 限制指定包可以使用的注解 ####

修改`spring`配置类`SpringConfig.java`：

package org.spring.ss;
    
    import org.spring.ss.pojo.User;
    import org.springframework.context.annotation.Bean;
    import org.springframework.context.annotation.ComponentScan;
    import org.springframework.context.annotation.ComponentScans;
    import org.springframework.context.annotation.Configuration;
    import org.springframework.stereotype.Controller;
    
    /* * java配置类，相当于 applicationContext.xml * */
    @Configuration
    /* * @ComponentScan 如果不去指定扫描的路基，默认是会扫描当前目录及其子目录下的所有的 * 被@Componenet @Controller @Service @Repository标注的类型 * */
    @ComponentScans({ 
            @ComponentScan(
                    value = "org.spring.ss.controller",
                    useDefaultFilters = false,
                    includeFilters = { @ComponentScan.Filter(Controller.class)}),
            @ComponentScan(
                    value = { "org.spring.ss.service","org.spring.ss.dao"},
                    excludeFilters = { @ComponentScan.Filter(Controller.class)}),
    })
    public class SpringConfig { 
        /** * @return * @Bean 作用和我们在applicationContext.xml中添加的<bean> 效果一样</> * 默认的name是方法名称 * 自定义的name 可以通过value属性或者name属性来指定 */
        @Bean(name = { "aaa", "bbb"})
        public User getUser() { 
            User user = new User();
            user.setName("王小六");
            return user;
        }
    }

这个时候尝试修改`UserController`上面的注解为`@Component`。

package org.spring.ss.controller;
    
    import org.spring.ss.pojo.User;
    import org.spring.ss.service.UserService;
    import org.springframework.beans.factory.annotation.Autowired;
    import org.springframework.stereotype.Component;
    import org.springframework.stereotype.Controller;
    
    @Component
    public class UserController { 
        @Autowired
        public UserService userService;
    
        public void find() { 
            User userBean = userService.find();
            System.out.println(userBean);
        }
    }

重新运行测试用例`testBySpringConfig`，可以看到下面的错误提示。  
![在这里插入图片描述][watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBA54Wn54mp5Y2O_size_20_color_FFFFFF_t_70_g_se_x_16]

#### `@Autowired`和`@Resource`的区别 ####

`@Autowired`：默认只能根据类型来查找，可以结合`@Qualifier("abc")`注解来实现通过`name`查找

`@Resource`：默认同样是根据类型来查找，但是提供的有`type`和`name`属性类实现不同的查找方式

### `@Value`注解的使用 ###

修改`SpringConfig.java`添加对`org.spring.ss.pojo`包的扫描。

package org.spring.ss;
    
    import org.spring.ss.pojo.User;
    import org.springframework.context.annotation.Bean;
    import org.springframework.context.annotation.ComponentScan;
    import org.springframework.context.annotation.ComponentScans;
    import org.springframework.context.annotation.Configuration;
    import org.springframework.stereotype.Controller;
    
    /* * java配置类，相当于 applicationContext.xml * */
    @Configuration
    /* * @ComponentScan 如果不去指定扫描的路基，默认是会扫描当前目录及其子目录下的所有的 * 被@Componenet @Controller @Service @Repository标注的类型 * */
    @ComponentScans({ 
            @ComponentScan("org.spring.ss.pojo"),
            @ComponentScan(
                    value = { "org.spring.ss.controller"},
                    useDefaultFilters = false,
                    includeFilters = { @ComponentScan.Filter(Controller.class)}),
            @ComponentScan(
                    value = { "org.spring.ss.service","org.spring.ss.dao"},
                    excludeFilters = { @ComponentScan.Filter(Controller.class)}),
    })
    public class SpringConfig { 
        /** * @return * @Bean 作用和我们在applicationContext.xml中添加的<bean> 效果一样</> * 默认的name是方法名称 * 自定义的name 可以通过value属性或者name属性来指定 */
        @Bean(name = { "aaa", "bbb"})
        public User getUser() { 
            User user = new User();
            user.setName("王小六");
            return user;
        }
    }

添加`Account.java`

package org.spring.ss.pojo;
    
    import lombok.Data;
    import org.springframework.beans.factory.annotation.Value;
    import org.springframework.core.io.Resource;
    import org.springframework.stereotype.Component;
    
    @Data
    @Component
    public class Account { 
        @Value("bobo") // 注入普通的字符串
        private String userName;
    
        @Value("#{systemProperties['os.name']}")
        private String systemPropertiesName; // 注入操作系统的信息
    
        @Value("#{T(java.lang.Math).random()*100}")
        private double randomNumber; // 注入表达式的结果
    
        // 注入其他Bean的属性, aaa 来自于 SpringConfig，是通过 java 配置类注入的
        @Value("#{aaa.name}")
        private String fromPersonName;
    
        @Value("classpath:test.txt")
        private Resource resourceFile;
    
        @Value("http://www.baidu.com")
        private Resource baiduFile;
    }

添加测试方法

@Test
    public void testBySpringConfig2() { 
        // ioc 容器初始化
        ApplicationContext applicationContext = new AnnotationConfigApplicationContext(SpringConfig.class);
        // ioc 通过bean 的 id 获取指定的bean
        Account account = applicationContext.getBean("account", Account.class);
        // 使用bean
        System.out.println(account);
    }

输出`Account(userName=bobo, systemPropertiesName=Windows 10, randomNumber=16.667755826649376, fromPersonName=王小六, resourceFile=class path resource [test.txt], baiduFile=URL [http://www.baidu.com])`

### `@PropertySouce`引入属性文件 ###

添加属性文件  
![在这里插入图片描述][watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBA54Wn54mp5Y2O_size_20_color_FFFFFF_t_70_g_se_x_16 1]  
在`Java`配置类中通过`@PropertySouce`注解来显示的引入属性文件  
![在这里插入图片描述][watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBA54Wn54mp5Y2O_size_20_color_FFFFFF_t_70_g_se_x_16 2]  
效果  
![在这里插入图片描述][watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBA54Wn54mp5Y2O_size_20_color_FFFFFF_t_70_g_se_x_16 3]

### @Import注解 ###

添加`Cat.java`

package org.spring.ss.pojo;
    
    import lombok.Data;
    import org.springframework.beans.factory.annotation.Value;
    
    @Data
    public class Cat { 
        @Value("加菲猫")
        private String color;
        private String nick;
    }

#### 静态使用 ####

在`@Import`注解中将前面创建的`Cat.java`引入到`IOC`容器，这种方式的缺点是：无法灵活的指定引入的类型。  
![在这里插入图片描述][watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBA54Wn54mp5Y2O_size_20_color_FFFFFF_t_70_g_se_x_16 4]

测试代码：

@Test
    public void testBySpringConfig3() {
        // ioc 容器初始化
        ApplicationContext applicationContext = new AnnotationConfigApplicationContext(SpringConfig.class);
        // ioc 通过bean 的 id 获取指定的bean
        Cat cat = applicationContext.getBean(Cat.class);
        // 使用bean
        System.out.println(cat);
    }

结果：`Cat(color=加菲猫, nick=null)`

#### 动态使用 ####

动态可以通过一定的逻辑来指定加入 IOC 容器中的对象。  
LoggerService.java

package org.spring.ss.service;
    
    public class LoggerService { 
    }

CacheService .java

package org.spring.ss.service;
    
    public class CacheService { 
    }

##### ImportSelector #####

通过实现接口 `ImportSelector` 的 selectImports 方法，来灵活控制引入的类型。

package org.spring.ss;
    
    import org.spring.ss.service.CacheService;
    import org.spring.ss.service.LoggerService;
    import org.springframework.context.annotation.ImportSelector;
    import org.springframework.core.type.AnnotationMetadata;
    
    public class ImportSelectorImpl implements ImportSelector { 
        /** * * @param annotationMetadata * @return * IoC 要加载的类型的全路径的字符串数组 */
        @Override
        public String[] selectImports(AnnotationMetadata annotationMetadata) { 
            // 在此处实现不同的业务逻辑控制
            return new String[]{ LoggerService.class.getName(), CacheService.class.getName()};
        }
    }

修改`SpringConfig.java`  
![在这里插入图片描述][watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBA54Wn54mp5Y2O_size_20_color_FFFFFF_t_70_g_se_x_16 5]  
测试代码

@Test
    public void testBySpringConfigImport() { 
        // ioc 容器初始化
        ApplicationContext applicationContext = new AnnotationConfigApplicationContext(SpringConfig.class);
        // 获取 IOC 容器中所有 bean 的名字
        String[] beanDefinitionNames = applicationContext.getBeanDefinitionNames();
        for (String beanDefinitionName : beanDefinitionNames) { 
            System.out.println(beanDefinitionName);
        }
    }

![在这里插入图片描述][watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBA54Wn54mp5Y2O_size_20_color_FFFFFF_t_70_g_se_x_16 6]

##### ImportBeanDefinitionRegistrar #####

通过重写 `ImportBeanDefinitionRegistrar` 的 `registerBeanDefinitions` 方法，来灵活控制引入的类型。

package org.spring.ss;
    
    import org.spring.ss.service.CacheService;
    import org.spring.ss.service.LoggerService;
    import org.springframework.beans.factory.support.BeanDefinitionRegistry;
    import org.springframework.beans.factory.support.RootBeanDefinition;
    import org.springframework.context.annotation.ImportBeanDefinitionRegistrar;
    import org.springframework.core.type.AnnotationMetadata;
    
    public class ImportBeanDefinitionRegistrarImpl implements ImportBeanDefinitionRegistrar { 
    
        /** * * @param annotationMetadata * @param beanDefinitionRegistry IoC容器中管理对象的一个注册器 */
        public void registerBeanDefinitions(AnnotationMetadata annotationMetadata, BeanDefinitionRegistry beanDefinitionRegistry) { 
            // 需要将添加的对象包装为一个RootBeanDefinition对象
            RootBeanDefinition cache = new RootBeanDefinition(CacheService.class);
            beanDefinitionRegistry.registerBeanDefinition("cache",cache);
    
            RootBeanDefinition logger = new RootBeanDefinition(LoggerService.class);
            beanDefinitionRegistry.registerBeanDefinition("logger",logger);
        }
    }

修改`SpringConfig.java`  
![在这里插入图片描述][watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBA54Wn54mp5Y2O_size_20_color_FFFFFF_t_70_g_se_x_16 7]  
执行测试用例  
![在这里插入图片描述][watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBA54Wn54mp5Y2O_size_20_color_FFFFFF_t_70_g_se_x_16 8]

### SpringBoot中的ConditionalXXX ###

<table> 
 <thead> 
  <tr> 
   <th align="left">@Conditional扩展注解</th> 
   <th align="left">作用(判断是否满足当前指定条件)</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td align="left">@ConditionalOnJava</td> 
   <td align="left">系统的Java版本是否符合要全</td> 
  </tr> 
  <tr> 
   <td align="left">@ConditionalOnBean</td> 
   <td align="left">容器中存在指定的Bean</td> 
  </tr> 
  <tr> 
   <td align="left">@ConditionalOnMissingBean</td> 
   <td align="left">容器中不存在指定的Bean</td> 
  </tr> 
  <tr> 
   <td align="left">@ConditionalOnExpression</td> 
   <td align="left">满足SpEL表达式</td> 
  </tr> 
  <tr> 
   <td align="left">@ConditionalOnClass</td> 
   <td align="left">系统中有指定的类</td> 
  </tr> 
  <tr> 
   <td align="left">@ConditionalOnMissingClass</td> 
   <td align="left">系统中没有指定的类</td> 
  </tr> 
  <tr> 
   <td align="left">@ConditionalOnSingleCandidate</td> 
   <td align="left">容器中只有一个指定的Bean，或者这个Bean是首选Bean</td> 
  </tr> 
  <tr> 
   <td align="left">@ConditionalOnProperty</td> 
   <td align="left">系统中指定的属性是否有指定的值</td> 
  </tr> 
  <tr> 
   <td align="left">@ConditionalOnResource</td> 
   <td align="left">类路径下是否存在指定的资源文件</td> 
  </tr> 
  <tr> 
   <td align="left">@ConditionalOnWebApplication</td> 
   <td align="left">当前是Web环境</td> 
  </tr> 
  <tr> 
   <td align="left">@ConditionalOnNotWebApplication</td> 
   <td align="left">当前不是Web环境</td> 
  </tr> 
  <tr> 
   <td align="left">@ConditionalOnJndi</td> 
   <td align="left">JNDI存在指定项</td> 
  </tr> 
 </tbody> 
</table>

具体案例

import org.springframework.context.annotation.Condition;
    import org.springframework.context.annotation.ConditionContext;
    import org.springframework.core.type.AnnotatedTypeMetadata;
    
    public class ConditionalOnClass implements Condition { 
        public boolean matches(ConditionContext conditionContext, AnnotatedTypeMetadata annotatedTypeMetadata) { 
            try { 
                Class<?> aClass = conditionContext.getClassLoader().loadClass("com.gupaoedu.test.Test1");
                return aClass==null?false:true;
            } catch (ClassNotFoundException e) { 
                e.printStackTrace();
            }
            return false;
        }
    }

import org.springframework.context.annotation.Condition;
    import org.springframework.context.annotation.ConditionContext;
    import org.springframework.core.type.AnnotatedTypeMetadata;
    
    
    public class ConditionalOnBean implements Condition { 
        /** * 如果IoC容器中有Person对象就返回true 否在返回false * * @param conditionContext * @param annotatedTypeMetadata * @return * true 表示IoC容器加载该类型 * false 表示IoC容器不加载该类型 */
        public boolean matches(ConditionContext conditionContext, AnnotatedTypeMetadata annotatedTypeMetadata) { 
            boolean flag = conditionContext.getRegistry().containsBeanDefinition("person");
            System.out.println(flag + " **** ");
            return flag;
        }
    }

### 多环境下的解决方案之`Profile` ###

`Profile`本质就是`Conditional`的实现。  
添加`DataSource`类：

package org.spring.ss.pojo;
    
    import lombok.AllArgsConstructor;
    import lombok.Data;
    
    @Data
    @AllArgsConstructor
    public class DataSource { 
        private String username;
    
        private String password;
    
        private String url;
    }

在`SpringConfig.java`中添加环境配置。

@Bean
    @Profile("pro") // 其实Profile注解本质上就是Conditional的一种实现
    public DataSource proDataSource() { 
        DataSource ds = new DataSource("root", "123", "192.168.11.190");
        return ds;
    }
    
    @Bean
    @Profile("dev")
    public DataSource devDataSource() { 
        DataSource ds = new DataSource("admin", "456", "192.168.12.190");
        return ds;
    }

添加测试代码：

public void testByProfile() { 
       AnnotationConfigApplicationContext ac = new AnnotationConfigApplicationContext();
    
        ac.getEnvironment().setActiveProfiles("pro");
        ac.register(SpringConfig.class);
        ac.refresh();
        System.out.println(ac.getBean(DataSource.class));
    }

输出`DataSource(username=root, password=123, url=192.168.11.190)`

### Bean对象的作用域 ###

<table> 
 <thead> 
  <tr> 
   <th align="left">作用域</th> 
   <th align="left">说明</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td align="left">prototype</td> 
   <td align="left">每次请求，都是一个新的Bean（ <a href="https://blog.csdn.net/qq_38526573/article/details/87633257" rel="nofollow">java原型模式</a> ）</td> 
  </tr> 
  <tr> 
   <td align="left">singleton</td> 
   <td align="left">bean是单例的（<a href="https://blog.csdn.net/qq_38526573/article/details/87740745" rel="nofollow">Java单例模式</a>）</td> 
  </tr> 
  <tr> 
   <td align="left">request</td> 
   <td align="left">在一次请求中，bean的声明周期和request同步</td> 
  </tr> 
  <tr> 
   <td align="left">session</td> 
   <td align="left">bean的生命周期和session同步</td> 
  </tr> 
 </tbody> 
</table>

默认的情况是 `singleton`

@Bean
    @Scope("prototype")
    public Person person(){ 
        return new Person();
    }

@Bean
    @Scope("singleton")
    public Person person(){ 
        return new Person();
    }

[watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBA54Wn54mp5Y2O_size_14_color_FFFFFF_t_70_g_se_x_16]: /images/20220829/d51efddf7a9646a1aeadc5294582b80b.png
[watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBA54Wn54mp5Y2O_size_20_color_FFFFFF_t_70_g_se_x_16]: /images/20220829/0b4cd51d837a48548f9fa03a07adf185.png
[watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBA54Wn54mp5Y2O_size_20_color_FFFFFF_t_70_g_se_x_16 1]: /images/20220829/c589145834734285ab06b972b3bc47d2.png
[watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBA54Wn54mp5Y2O_size_20_color_FFFFFF_t_70_g_se_x_16 2]: /images/20220829/772ad0caa0e748f7a875acfdc77189fa.png
[watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBA54Wn54mp5Y2O_size_20_color_FFFFFF_t_70_g_se_x_16 3]: /images/20220829/700f4740323d4d4a85fc182c3a5831b8.png
[watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBA54Wn54mp5Y2O_size_20_color_FFFFFF_t_70_g_se_x_16 4]: /images/20220829/1b668172b7774de88526327b9b285656.png
[watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBA54Wn54mp5Y2O_size_20_color_FFFFFF_t_70_g_se_x_16 5]: /images/20220829/89023de0a1d64a44a0f1308784562863.png
[watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBA54Wn54mp5Y2O_size_20_color_FFFFFF_t_70_g_se_x_16 6]: /images/20220829/bc46e4291ee2484da1826657ea647208.png
[watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBA54Wn54mp5Y2O_size_20_color_FFFFFF_t_70_g_se_x_16 7]: /images/20220829/08625ab64bdd41e4bee331758cb07851.png
[watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBA54Wn54mp5Y2O_size_20_color_FFFFFF_t_70_g_se_x_16 8]: /images/20220829/17cc39d98e8c41e9bf1b4f1589de8fa0.png