SpringBoot整合

约定不等于承诺〃 2022-04-25 06:10 327阅读 0赞

**开发环境**  
开发工具：IntelliJ IDEA  
框架：springboot、Maven、Mybatis（也可以用JPA）  
JDK：1.8  
**一、首先你要知道什么是SpringBoot**  
在Spring框架这个大家族中，产生了很多衍生框架，比如 Spring、SpringMvc框架等，Spring的核心内容在于控制反转(IOC)和依赖注入(DI),所谓控制反转并非是一种技术，而是一种思想，在操作方面是指在spring配置文件中创建，依赖注入即为由spring容器为应用程序的某个对象提供资源，比如 引用对象、常量数据等。  
SpringBoot是一个框架，一种全新的编程规范，他的产生简化了框架的使用，所谓简化是指简化了Spring众多框架中所需的大量且繁琐的配置文件，所以 SpringBoot是一个服务于框架的框架，服务范围是简化配置文件。  
SpringBoot最明显的特点是，让文件配置变的相当简单、让应用部署变的简单（SpringBoot内置服务器，并装备启动类代码），可以快速开启一个Web容器进行开发。

**二、IDEA 创建SpringBoot项目**  
1、打开idea→File→New→Project  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3VzZXJsaGo_size_16_color_FFFFFF_t_70]  
2、Spring Initializr→选择Project SDK→Next  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3VzZXJsaGo_size_16_color_FFFFFF_t_70 1]  
3、填写好内容后点击Next  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3VzZXJsaGo_size_16_color_FFFFFF_t_70 2]  
4、点击Web→勾选Web→Next  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3VzZXJsaGo_size_16_color_FFFFFF_t_70 3]  
5、点击Finish  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3VzZXJsaGo_size_16_color_FFFFFF_t_70 4]  
6、首先我们需要依赖SpringBoot的父工程，这是每个项目都要有的  
①

<parent>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-parent</artifactId>
            <version>2.1.3.RELEASE</version>
            <relativePath/>
        </parent>
        
        <properties>
            <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
            <project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>
            <java.version>1.8</java.version>
        </properties>

②启动WEB模块要引入WEB模块的依赖

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

③然后需要创建SpringBoot的启动类

import org.springframework.boot.SpringApplication;
    import org.springframework.boot.autoconfigure.SpringBootApplication;
    import org.springframework.context.annotation.ComponentScan;
    
    @SpringBootApplication
    @ComponentScan("com.quotation")
    public class QuotationApplication { 
        public static void main(String[] args) { 
            SpringApplication.run(QuotationApplication.class, args);
        }

@SpringBootApplication是一个复合注解，包括@ComponentScan，和@SpringBootConfiguration，@EnableAutoConfiguration。

1.  @SpringBootConfiguration继承自@Configuration，二者功能也一致，标注当前类是配置类，并会将当前类内声明的一个或多个以@Bean注解标记的方法的实例纳入到srping容器中，并且实例名就是方法名。
2.  @EnableAutoConfiguration的作用启动自动的配置，@EnableAutoConfiguration注解的意思就是Springboot根据你添加的jar包来配置你项目的默认配置，比如根据spring-boot-starter-web ，来判断你的项目是否需要添加了webmvc和tomcat，就会自动的帮你配置web项目中所需要的默认配置。在下面博客会具体分析这个注解，快速入门的demo实际没有用到该注解。
3.  @ComponentScan，扫描当前包及其子包下被@Component，@Controller，@Service，@Repository注解标记的类并纳入到spring容器中进行管理。是以前的context:component-scan（以前使用在xml中使用的标签，用来扫描包配置的平行支持）。所以本demo中的User为何会被spring容器管理。

然后需要配置application.yml（或者application.properties）

#设置端口号和context path
    server:
      port: 8088
      servlet:
        context-path: /quotation
        
    #使用thymeleaf
    spring:
      thymeleaf:
        cache: false
        suffix: .html
        prefix: classpath:/templates/

（注意：使用thymeleaf，需要引入thymeleaf依赖，你也可以用Spring Boot支持的其他模板技术，具体请自行查找资料）

④创建Controller

@RestController
    @RequestMapping("hello")
    public class HelloController { 
    
        @RequestMapping("helloworld")
        public String say(){ 
            return "hello world";
        }
        
        @RequestMapping("/test")
        public ModelAndView test(){ 
            return new ModelAndView("index");
        }
    
    }

![在这里插入图片描述][20190506111959258.png]  
**三、集成Mybatis**  
接下来我会集成logback（日志）和Druid（阿里开源的数据库连接池）  
1、首先要引入jar包(数据库使用的是Oracle，若不用Oracle引入其它对应的依赖即可)

<dependency>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-starter-jdbc</artifactId>
            </dependency>
            
            <dependency>
                <groupId>org.mybatis.spring.boot</groupId>
                <artifactId>mybatis-spring-boot-starter</artifactId>
                <version>1.2.2</version>
            </dependency>
             
            <dependency>
                <groupId>ojdbc</groupId>
                <artifactId>ojdbc6</artifactId>
                <version>11.2.0.3</version>
            </dependency>
         
           
            <dependency>
                <groupId>com.alibaba</groupId>
                <artifactId>druid-spring-boot-starter</artifactId>
                <version>1.1.10</version>
            </dependency>

2、使用logback日志  
直接在resources目录下创建logback.xml文件。（也可以在application.yml中做普通的配置，关于日志文件的命名格式，可以百度下springboot所支持的日志命名格。）  
**logback.xml**

<?xml version="1.0" encoding="UTF-8"?>
    
    
    
    
    <configuration>
        <contextName>logback</contextName>
        
        <property name="log.path" value="../customlogs" />
    
        
        <appender name="CONSOLE" class="ch.qos.logback.core.ConsoleAppender">
            <encoder class="ch.qos.logback.classic.encoder.PatternLayoutEncoder">
               
                <pattern>%d{yyyy-MM-dd HH:mm:ss.SSS} [%thread] %-5level %logger{50} - %msg%n</pattern>
            </encoder>
        </appender>
    
        
        
        <appender name="DEBUG_FILE" class="ch.qos.logback.core.rolling.RollingFileAppender">
            
            <file>${log.path}/log_debug.log</file>
            
            <encoder>
                <pattern>%d{yyyy-MM-dd HH:mm:ss.SSS} [%thread] %-5level %logger{50} - %msg%n</pattern>
                <charset>UTF-8</charset> 
            </encoder>
            
            <rollingPolicy class="ch.qos.logback.core.rolling.TimeBasedRollingPolicy">
                
                <fileNamePattern>${log.path}/debug/log-debug-%d{yyyy-MM-dd}.%i.log</fileNamePattern>
                <timeBasedFileNamingAndTriggeringPolicy class="ch.qos.logback.core.rolling.SizeAndTimeBasedFNATP">
                    <maxFileSize>100MB</maxFileSize>
                </timeBasedFileNamingAndTriggeringPolicy>
                
                <maxHistory>15</maxHistory>
            </rollingPolicy>
            
            <filter class="ch.qos.logback.classic.filter.LevelFilter">
                <level>debug</level>
                <onMatch>ACCEPT</onMatch>
                <onMismatch>DENY</onMismatch>
            </filter>
        </appender>
    
        
        <appender name="INFO_FILE" class="ch.qos.logback.core.rolling.RollingFileAppender">
            
            <file>${log.path}/log_info.log</file>
            
            <encoder>
                <pattern>%d{yyyy-MM-dd HH:mm:ss.SSS} [%thread] %-5level %logger{50} - %msg%n</pattern>
                <charset>UTF-8</charset>
            </encoder>
            
            <rollingPolicy class="ch.qos.logback.core.rolling.TimeBasedRollingPolicy">
                
                <fileNamePattern>${log.path}/info/log-info-%d{yyyy-MM-dd}.%i.log</fileNamePattern>
                <timeBasedFileNamingAndTriggeringPolicy class="ch.qos.logback.core.rolling.SizeAndTimeBasedFNATP">
                    <maxFileSize>100MB</maxFileSize>
                </timeBasedFileNamingAndTriggeringPolicy>
                
                <maxHistory>15</maxHistory>
            </rollingPolicy>
            
            <filter class="ch.qos.logback.classic.filter.LevelFilter">
                <level>info</level>
                <onMatch>ACCEPT</onMatch>
                <onMismatch>DENY</onMismatch>
            </filter>
        </appender>
    
        
        <appender name="WARN_FILE" class="ch.qos.logback.core.rolling.RollingFileAppender">
            
            <file>${log.path}/log_warn.log</file>
            
            <encoder>
                <pattern>%d{yyyy-MM-dd HH:mm:ss.SSS} [%thread] %-5level %logger{50} - %msg%n</pattern>
                <charset>UTF-8</charset> 
            </encoder>
            
            <rollingPolicy class="ch.qos.logback.core.rolling.TimeBasedRollingPolicy">
                <fileNamePattern>${log.path}/warn/log-warn-%d{yyyy-MM-dd}.%i.log</fileNamePattern>
                <timeBasedFileNamingAndTriggeringPolicy class="ch.qos.logback.core.rolling.SizeAndTimeBasedFNATP">
                    <maxFileSize>100MB</maxFileSize>
                </timeBasedFileNamingAndTriggeringPolicy>
                
                <maxHistory>15</maxHistory>
            </rollingPolicy>
            
            <filter class="ch.qos.logback.classic.filter.LevelFilter">
                <level>warn</level>
                <onMatch>ACCEPT</onMatch>
                <onMismatch>DENY</onMismatch>
            </filter>
        </appender>
    
    
        
        <appender name="ERROR_FILE" class="ch.qos.logback.core.rolling.RollingFileAppender">
            
            <file>${log.path}/log_error.log</file>
            
            <encoder>
                <pattern>%d{yyyy-MM-dd HH:mm:ss.SSS} [%thread] %-5level %logger{50} - %msg%n</pattern>
                <charset>UTF-8</charset> 
            </encoder>
            
            <rollingPolicy class="ch.qos.logback.core.rolling.TimeBasedRollingPolicy">
                <fileNamePattern>${log.path}/error/log-error-%d{yyyy-MM-dd}.%i.log</fileNamePattern>
                <timeBasedFileNamingAndTriggeringPolicy class="ch.qos.logback.core.rolling.SizeAndTimeBasedFNATP">
                    <maxFileSize>100MB</maxFileSize>
                </timeBasedFileNamingAndTriggeringPolicy>
                
                <maxHistory>15</maxHistory>
            </rollingPolicy>
            
            <filter class="ch.qos.logback.classic.filter.LevelFilter">
                <level>ERROR</level>
                <onMatch>ACCEPT</onMatch>
                <onMismatch>DENY</onMismatch>
            </filter>
        </appender>
    
        
        
        
        
    
    
        
    
        <root level="info">
            <appender-ref ref="CONSOLE" />
            <appender-ref ref="DEBUG_FILE" />
            <appender-ref ref="INFO_FILE" />
            <appender-ref ref="WARN_FILE" />
            <appender-ref ref="ERROR_FILE" />
        </root>
    </configuration>

在application.yml中添加以下代码可以打印SQL语句

#打印SQL，把level下的路径换成你对应mapper包路径
    logging:
      level:
        com:
          vtech:
            quotation:
              mapper: debug

![控制台输出][20190513173038251.png]  
（PS：解析一下为什么不需要引入jar包。因为springboot本身就内置了日志功能，springboot的pom文件都会引一个parent，里面就包含了日志包。）

3、使用Druid连接池  
①application.yml加入以下配置

spring:
      datasource:
        type: com.alibaba.druid.pool.DruidDataSource
        # 配置Druid的其他参数，以下配置必须增加一个配置文件才能有效
        # 初始化大小，最小，最大
        druid:
         url: jdbc:oracle:thin:#你oracle数据库系统的地址
         username: #数据库登录名
         password: #密码
         driver-class-name: oracle.jdbc.OracleDriver
         # 连接池配置
         initial-size: 1
         max-active: 20
         min-idle: 1
         max-wait: 10000
         pool-prepared-statements: true
         max-open-prepared-statements: 20
         validation-query: SELECT 1 FROM DUAL
         validation-query-timeout: 5000
         test-on-borrow: false
         test-on-return: false
         test-while-idle: true
         time-between-eviction-runs-millis: 60000
         min-evictable-idle-time-millis: 30000
         max-evictable-idle-time-millis: 60000
         removeAbandoned: true
         removeAbandonedTimeout: 1800
         connectionProperties: druid.stat.mergeSql=true;druid.stat.slowSqlMillis=5000
         max-pool-prepared-statement-per-connection-size: 20
         filters: stat,wall #filters: #配置多个英文逗号分隔(统计，sql注入，log4j过滤)

②创建DruidConfig.java  
（其中@Slf4j是使用了lombok插件，详情请看[lombok安装][lombok]，使用了该注解输出日志直接log. 即可，替代了private static final Logger logger = LoggerFactory.getLogger(DruidConfig.class);）

import com.alibaba.druid.pool.DruidDataSource;
    import com.alibaba.druid.support.http.StatViewServlet;
    import com.alibaba.druid.support.http.WebStatFilter;
    import lombok.extern.slf4j.Slf4j;
    import org.springframework.beans.factory.annotation.Value;
    import org.springframework.boot.web.servlet.FilterRegistrationBean;
    import org.springframework.boot.web.servlet.ServletRegistrationBean;
    import org.springframework.context.annotation.Bean;
    import org.springframework.context.annotation.Configuration;
    import org.springframework.context.annotation.Primary;
    import javax.sql.DataSource;
    import java.util.HashMap;
    import java.util.Map;
    
    @Configuration
    @Slf4j
    public class DruidConfig { 
    
        @Value("${spring.datasource.druid.url}")
        private String dbUrl;
    
        @Value("${spring.datasource.druid.username}")
        private String username;
    
        @Value("${spring.datasource.druid.password}")
        private String password;
    
        @Value("${spring.datasource.druid.driver-class-name}")
        private String driverClassName;
    
        @Value("${spring.datasource.druid.initial-size}")
        private int initialSize;
    
        @Value("${spring.datasource.druid.min-idle}")
        private int minIdle;
    
        @Value("${spring.datasource.druid.max-active}")
        private int maxActive;
    
        @Value("${spring.datasource.druid.max-wait}")
        private int maxWait;
    
        @Value("${spring.datasource.druid.time-between-eviction-runs-millis}")
        private int timeBetweenEvictionRunsMillis;
    
        @Value("${spring.datasource.druid.min-evictable-idle-time-millis}")
        private int minEvictableIdleTimeMillis;
    
        @Value("${spring.datasource.druid.validation-query}")
        private String validationQuery;
    
        @Value("${spring.datasource.druid.test-while-idle}")
        private boolean testWhileIdle;
    
        @Value("${spring.datasource.druid.test-on-borrow}")
        private boolean testOnBorrow;
    
        @Value("${spring.datasource.druid.test-on-return}")
        private boolean testOnReturn;
    
        @Value("${spring.datasource.druid.pool-prepared-statements}")
        private boolean poolPreparedStatements;
    
        @Value("${spring.datasource.druid.max-pool-prepared-statement-per-connection-size}")
        private int maxPoolPreparedStatementPerConnectionSize;
    
        @Value("${spring.datasource.druid.filters}")
        private String filters;
    
        @Value("{spring.datasource.druid.connection-properties}")
        private String connectionProperties;
    
        @Bean     //声明其为Bean实例
        @Primary  //在同样的DataSource中，首先使用被标注的DataSource
        public DataSource dataSource() { 
            DruidDataSource datasource = new DruidDataSource();
            datasource.setUrl(dbUrl);
            datasource.setUsername(username);
            datasource.setPassword(password);
            datasource.setDriverClassName(driverClassName);
            //configuration
            datasource.setInitialSize(initialSize);
            datasource.setMinIdle(minIdle);
            datasource.setMaxActive(maxActive);
            datasource.setMaxWait(maxWait);
            datasource.setTimeBetweenEvictionRunsMillis(timeBetweenEvictionRunsMillis);
            datasource.setMinEvictableIdleTimeMillis(minEvictableIdleTimeMillis);
            datasource.setValidationQuery(validationQuery);
            datasource.setTestWhileIdle(testWhileIdle);
            datasource.setTestOnBorrow(testOnBorrow);
            datasource.setTestOnReturn(testOnReturn);
            datasource.setPoolPreparedStatements(poolPreparedStatements);
            datasource.setMaxPoolPreparedStatementPerConnectionSize(maxPoolPreparedStatementPerConnectionSize);
            try { 
                datasource.setFilters(filters);
            } catch (Exception e) { 
                log.error("druid configuration initialization filter", e);
            }
            datasource.setConnectionProperties(connectionProperties);
    
            return datasource;
        }
    
        @Bean
        public ServletRegistrationBean druidServlet() { 
            //logger.info("init Druid Servlet Configuration ");
            ServletRegistrationBean servletRegistrationBean = new ServletRegistrationBean();
            servletRegistrationBean.setServlet(new StatViewServlet());
            servletRegistrationBean.addUrlMappings("/druid/*");
            Map<String, String> initParameters = new HashMap<>();
            initParameters.put("loginUsername", "admin");// 用户名
            initParameters.put("loginPassword", "admin");// 密码
            //initParameters.put("resetEnable", "");// 禁用HTML页面上的“Reset All”功能
            initParameters.put("allow", ""); // IP白名单 (没有配置或者为空，则允许所有访问)
            //initParameters.put("deny", "192.168.20.38");// IP黑名单 (存在共同时，deny优先于allow)
            servletRegistrationBean.setInitParameters(initParameters);
            return servletRegistrationBean;
        }
    
    
        @Bean
        public FilterRegistrationBean druidWebStatViewFilter() { 
            FilterRegistrationBean registrationBean = new FilterRegistrationBean(new WebStatFilter());
            registrationBean.addInitParameter("urlPatterns", "/*");
            registrationBean.addInitParameter("exclusions", "*.js,*.gif,*.jpg,*.bmp,*.png,*.css,*.ico,/druid/*");
            return registrationBean;
        }
    
    }

4、集成mybatis  
![目录结构][20190513182638305.png]  
①分别如图创建两个mapper文件夹，一个放interface（src/main/java），一个放xml(resources)

创建Users.java

@Data
    public class Users { 
        private BigDecimal userId;
        private String userName;
        private String password;
        }

创建UsersMapper.java  
（@Repository 加上这个注解在使用@Autowired时就不会报错,@Mapper声明这是一个mapper）

@Mapper
    @Repository
    public interface UsersMapper { 
        List<Users> findAll();
    }

创建UsersMapper.xml

<?xml version="1.0" encoding="UTF-8"?>
    <!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
    <mapper namespace="com.vtech.quotation.mapper.UsersMapper">
        <resultMap id="BaseResultMap" type="com.vtech.quotation.pojo.Users">
            <id column="USER_ID" jdbcType="DECIMAL" property="userId"/>
            <result column="USER_NAME" jdbcType="VARCHAR" property="userName"/>
            <result column="PASSWORD" jdbcType="VARCHAR" property="password"/>
        </resultMap>
        <sql id="result_Internal_User">
            USER_ID, USER_NAME, FIRST_NAME, LAST_NAME, STATUS, EMAIL_ADDRESS, ISMANAGER,
            BU, CREATE_BY, CREATION_DATE, MODIFIED_BY,
            MODIFIED_DATE
        </sql>
    
        <select id="findAll" resultMap="BaseResultMap">
            select
            <include refid="result_Internal_User"/>
            from USERS
        </select>
    </mapper>

②application.yml添加mybatis配置

mybatis:
      #config-location: classpath:mybatis-config.xml  # mybatis配置文件所在路径
      mapper-locations: classpath:mapper/*.xml   # 所有的mapper映射文件
      type-aliases-package: com.vtech.quotation.mapper # 定义所有操作类的别名所在包

③springboot启动类添加  
@MapperScan(value = “com.vtech.quotation.mapper”)添加了这个注解就不用每个mapper类都添加@Mapper了  
@ComponentScan(basePackages = “com.vtech”)

@SpringBootApplication
    @MapperScan(value = "com.vtech.quotation.mapper")
    @ComponentScan(basePackages = "com.vtech")
    public class QuotationApplication { 
        public static void main(String[] args) { 
            SpringApplication.run(QuotationApplication.class, args);
        }
    
    }

④测试HelloController .java

@RestController
    @RequestMapping("hello")
    @Slf4j
    public class HelloController { 
        @Autowired
        UsersMapper usersMapper；
    
        @RequestMapping("findAll")
        public JsonResult findall(){ 
            return new JsonResult(usersMapper.findAll());
        }
    
    }

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3VzZXJsaGo_size_16_color_FFFFFF_t_70 5]  
⑤测试Druid  
在浏览其中输入http://localhost:端口号/你的context-path/druid 即可访问  
例如：http://localhost:8088/quotation/druid  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3VzZXJsaGo_size_16_color_FFFFFF_t_70 6]  
输入你配置的druid账号密码登录，即可查看监控。

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3VzZXJsaGo_size_16_color_FFFFFF_t_70 7]

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3VzZXJsaGo_size_16_color_FFFFFF_t_70]: /images/20220205/ab3658ee73684615bc22e22d77bbcf81.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3VzZXJsaGo_size_16_color_FFFFFF_t_70 1]: /images/20220205/5143e4b6e03440e3a6fdd5fde896c07f.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3VzZXJsaGo_size_16_color_FFFFFF_t_70 2]: /images/20220205/126a250e48a94fb3aabeab94fee9afe5.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3VzZXJsaGo_size_16_color_FFFFFF_t_70 3]: /images/20220205/7d46324f69ec47dda477b24970651841.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3VzZXJsaGo_size_16_color_FFFFFF_t_70 4]: /images/20220205/5334b5490870487587e35d1f5a93da22.png
[20190506111959258.png]: /images/20220205/14ad470c0b85447d95997084e7b4ff8c.png
[20190513173038251.png]: /images/20220205/547a0fcc860e4ca8b147e50ad1e61429.png
[lombok]: https://blog.csdn.net/userlhj/article/details/88229213
[20190513182638305.png]: /images/20220205/f172906263d24e3887bf6ad58536aac1.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3VzZXJsaGo_size_16_color_FFFFFF_t_70 5]: /images/20220205/33a619f99f1244c5981d37568d4f8302.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3VzZXJsaGo_size_16_color_FFFFFF_t_70 6]: /images/20220205/097a538146324cbe9110afe1ed567bf1.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3VzZXJsaGo_size_16_color_FFFFFF_t_70 7]: /images/20220205/4802119046034e81a1a8798c7c7044f6.png