Spring入门第一讲——Spring框架的快速入门

电玩女神 2022-11-27 12:18 258阅读 0赞

# Spring的概述 #

## 什么是Spring？ ##

我们可以从度娘上看到这样有关Spring的介绍：  
![在这里插入图片描述][20190831202738561.png]  
说得更加详细一点，Spring是一个开源框架，Spring是于2003年兴起的一个轻量级的Java开发框架，由Rod Johnson在其著作Expert One-On-One J2EE Development and Design中阐述的部分理念和原型衍生而来。它是为了解决企业应用开发的复杂性而创建的。框架的主要优势之一就是其分层架构，分层架构允许使用者选择使用哪一个组件，同时为J2EE应用程序开发提供集成的框架。Spring使用基本的JavaBean来完成以前只可能由EJB完成的事情。然而，Spring的用途不仅限于服务器端的开发。从简单性、可测试性和松耦合的角度而言，任何Java应用都可以从Spring中受益。**Spring的核心是控制反转（IoC）和面向切面（AOP）。简单来说，Spring是一个分层的JavaSE/EEfull-stack（一站式）轻量级开源框架。**  
为什么说Spring是一个一站式的轻量级开源框架呢？EE开发可分成三层架构，针对JavaEE的三层结构，每一层Spring都提供了不同的解决技术。  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3llcmVueXVhbl9wa3U_size_16_color_FFFFFF_t_70]  
从对Spring的简要介绍中，我们知道了Spring的核心有两部分：

*  IoC：即控制反转。举例来说，在之前的操作中，比方说有一个类，我们想要调用类里面的方法（不是静态方法），就要创建该类的对象，使用对象调用方法来实现。但对于Spring来说，Spring创建对象的过程，不是在代码里面实现的，而是交给Spring来进行配置实现的；
 *  AOP：即面向切面编程。之前，讲Struts2框架的拦截器时，我们就已稍微讲了一下，在Spring后续的学习过程中，我们会着重来讲它，但是本文并不会过多阐述它。

## 为什么学习Spring？ ##

在度娘上查看有关Spring的介绍时，我们可以找到如下一系列Spring的优点，这就是我们要学习Spring框架的原因。  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3llcmVueXVhbl9wa3U_size_16_color_FFFFFF_t_70 1]

# Spring的快速入门 #

## Spring的版本 ##

需要说明的是，本系列入门Spring的教程使用的版本是spring-framework-4.2.4.RELEASE。

## IoC概述 ##

### 什么是IoC？ ###

IoC即Inversion of Control，反应过来就是控制反转。啥是控制反转啊？控制反转指的就是将对象的创建权反转给（交给）了Spring，其作用是实现了程序的解耦合。也可这样解释：获取对象的方式变了，对象创建的控制权不是"使用者"，而是"框架"或者"容器"。用更通俗的话来说，IoC就是指对象的创建，并不是在代码中用new操作new出来的，而是通过Spring进行配置创建的。

### Spring的IoC的底层实现原理 ###

这里先给出结论：Spring的IoC的底层实现原理是**工厂设计模式+反射+XML配置文件。** 就拿持久层（也即dao层，data access object，数据访问对象）的开发来说，官方推荐做法是先创建一个接口，然后再创建接口对应的实现类。所以，这里，我会以dao层的开发为例来证明Spring的IoC的底层实现原理就是工厂设计模式+反射+XML配置文件。  
首先，创建一个Userdao接口。

public interface UserDao { 
    	public void add();
    }
    
      
       
      
       
        1
        2
        3

然后，再创建Userdao接口的一个实现类（UserDaoImpl.java）。

public class UserDaoImpl implements UserDao { 
        public void add() { 
    	    balabala......
        }
    }
    
      
       
      
       
        1
        2
        3
        4
        5

接着，我们在service层中调用dao层，核心代码如下：

// 接口 实例变量 = new 实现类
    UserDao dao = new UserDaoImpl();
    dao.add();
    
      
       
      
       
        1
        2
        3

这时我们便可发现一个缺点：service层和dao层耦合度太高了，即接口和实现类有耦合（它俩之间的联系过于紧密），一旦切换底层实现类，那么就需要修改源代码，这真的不是一个好的程序设计，好的程序设计应当满足OCP原则（也即开闭原则），即在尽量不修改程序源代码的基础上对程序进行扩展。说到这里，我就不得不稍微讲一下面向对象设计的七大原则了，它不必强记，重在理解。  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3llcmVueXVhbl9wa3U_size_16_color_FFFFFF_t_70 2]  
出现的这个问题该如何解决呢？解决方法是使用工厂设计模式进行解耦合操作。所以，我们需要创建一个工厂类，在工厂类中提供一个方法，返回实现类的对象。

public class BeanFactory { 
        // 提供返回实现类对象的方法
        public static UserDao getUserDao() { 
            return new UserDaoImpl();
        }
    }
    
      
       
      
       
        1
        2
        3
        4
        5
        6

这样，在service层中调用dao层的核心代码就变为了下面的样子。

UserDao dao = BeanFactory.getUserDao();
    dao.add();
    
      
       
      
       
        1
        2

如若这样做，会发现又产生了一个缺点：现在接口和实现类之间是没有耦合了，但是service层和工厂类耦合了。如果真正想实现程序之间的解耦合，那么就需要使用到工厂设计模式+反射+XML配置文件了。所以，我们这里提供一个XML配置文件，并且该配置文件中有如下配置信息。

<bean id="userDao" class="com.meimeixia.dao.impl.UserDaoImpl" />
    
      
       
      
       
        1

然后再来创建一个工厂类，在工厂类中提供一个返回实现类对象的方法，但并不是直接new实现类，而是使用SAX解析配置文件，根据标签bean中的id属性值得到对应的class属性值，使用反射创建实现类对象。

public class BeanFactory { 
        public static Object getBean(String id) { 
            // 1.使用SAX解析得到配置文件内容
            // 直接根据id值userDao得到class属性值
            String classvalue = "class属性值";
            // 2.使用反射得到对象
            Class clazz = Class.forName(classvalue);
            UserDaoImpl userDaoImpl = (UserDaoImpl)lazz.newInstance();
            return userDaoImpl;
        }
    }
    
      
       
      
       
        1
        2
        3
        4
        5
        6
        7
        8
        9
        10
        11

以上就是Spring的IoC的底层实现原理。

## Spring的IoC入门 ##

### 下载Spring的开发包 ###

Spring的官网是https://spring.io/，Spring的开发包的下载地址是https://repo.spring.io/libs-release-local/org/springframework/spring/，上面说过，我下载的是spring-framework-4.2.4.RELEASE这个版本的Spring。解压缩之后，可发现Spring开发包的目录结构如下。  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3llcmVueXVhbl9wa3U_size_16_color_FFFFFF_t_70 3]

### 创建web项目，引入Spring的开发包 ###

首先创建一个动态web项目，例如spring\_demo01，然后导入Spring框架相关依赖jar包，要导入哪些jar包呢？这是一个问题。  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3llcmVueXVhbl9wa3U_size_16_color_FFFFFF_t_70 4]  
由于我们只是初次入门Spring，所以也只是使用到了Spring的基本功能，从上图红框框中的部分可知，我们需要使用到下面的这4个jar包。  
![在这里插入图片描述][20190831202849724.png]  
除此之外，还要导入Spring支持的日志jar包，也就是下面两个jar包。  
![在这里插入图片描述][20190831202858234.png]  
关于以上两个jar包，我稍微做一下解释，com.springsource.org.apache.commons.logging-1.1.1.jar它里面都是一些接口，有接口，那当然要有实现类了，恰好，com.springsource.org.apache.log4j-1.2.15.jar里面就是那些接口的实现类。使用Log4j，我们可以查看到当前运行程序中对象创建的过程，也可以看到更详细的信息，Log4j适合使用在程序调试中。  
导入完日志相关的jar包之后，我们还要导入日志记录文件，即在src目录下引入Log4j的配置文件（log4j.properties），该文件内容如下：

### direct log messages to stdout ###
    log4j.appender.stdout=org.apache.log4j.ConsoleAppender
    log4j.appender.stdout.Target=System.err
    log4j.appender.stdout.layout=org.apache.log4j.PatternLayout
    log4j.appender.stdout.layout.ConversionPattern=%d{ABSOLUTE} %5p %c{1}:%L - %m%n
    ### direct messages to file mylog.log ###
    log4j.appender.file=org.apache.log4j.FileAppender
    log4j.appender.file.File=c\:mylog.log
    log4j.appender.file.layout=org.apache.log4j.PatternLayout
    log4j.appender.file.layout.ConversionPattern=%d{ABSOLUTE} %5p %c{1}:%L - %m%n
    ### set log levels - for more verbose logging change 'info' to 'debug' ###
    # error warn info debug trace
    log4j.rootLogger= info, stdout
    
      
       
      
       
        1
        2
        3
        4
        5
        6
        7
        8
        9
        10
        11
        12
        13
        14
        15

对以上日志记录文件，我会粗略讲解一下。  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3llcmVueXVhbl9wa3U_size_16_color_FFFFFF_t_70 5]  
从上图可知，log4j.rootLogger就是用于设置日志的输出级别，那么日志的输出级别有几种呢？有如下5种。  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3llcmVueXVhbl9wa3U_size_16_color_FFFFFF_t_70 6]

### 创建接口和实现类 ###

首先，在src目录下创建一个com.meimeixia.spring.demo01包，并在该包下创建一个名为UserDao的接口。

package com.meimeixia.spring.demo01;
    /** * 用户管理的dao层的接口 * @author liayun * */
    public interface UserDao { 
    	public void save();
    }
    
      
       
      
       
        1
        2
        3
        4
        5
        6
        7
        8
        9
        10
        11
        12

然后，在com.meimeixia.spring.demo01包下创建UserDao接口的一个实现类——UserDaoImpl.java。

package com.meimeixia.spring.demo01;
    /** * 用户管理的dao层接口的实现类 * @author liayun * */
    public class UserDaoImpl implements UserDao { 
    	@Override
    	public void save() { 
    		System.out.println("UserDaoImpl中的save方法执行了......");
    	}
    }
    
      
       
      
       
        1
        2
        3
        4
        5
        6
        7
        8
        9
        10
        11
        12
        13
        14
        15

### 将实现类交给Spring管理 ###

首先，我们需要创建Spring的配置文件，Spring配置文件的名称和位置没有固定要求，一般建议把该文件放到src目录下面，名称可随便写，官方建议写成applicationContext.xml。然后我们还需要在配置文件中引入约束，Spring学习阶段的约束是schema约束。那么问题来了，这个约束又该怎么写呢？可参考docs\\spring-framework-reference\\html目录下的xsd-configuration.html文件，在其内容最后面找到如下内容。  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3llcmVueXVhbl9wa3U_size_16_color_FFFFFF_t_70 7]  
将其复制黏贴到配置文件applicationContext.xml中，这样applicationContext.xml文件的内容就是下面的样子了。

最后，咱还要将实现类交给Spring来管理，即在配置文件中配置对象的创建。

<?xml version="1.0" encoding="UTF-8"?>
    <beans xmlns="http://www.springframework.org/schema/beans" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation=" http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd">
    	
    	<bean id="userDao" class="com.meimeixia.spring.demo01.UserDaoImpl"></bean>	
    </beans>
    
      
       
      
       
        1
        2
        3
        4
        5
        6
        7
        8
        9
        10
        11

### 编写测试类 ###

我们要在Spring中写代码来实现获取applicationContext.xml文件中配置的对象，这段代码不要求大家重点掌握，只是用在测试中而已。这段代码主要用来解析Spring配置文件得到对象，但这个过程不需要我们写代码来实现了，Spring已经封装了一个对象来帮我们进行了这些操作，这个对象叫ApplicationContext，它就能实现这个功能。于是，我们需要在com.meimeixia.spring.demo01包下创建一个SpringDemo01的单元测试类。

然后，运行以上demo02单元测试方法，Eclipse控制台就会打印如下内容。  
![在这里插入图片描述][20190831202915740.png]

## Spring IoC和DI的区别 ##

IoC上面我已经讲过了，它指的就是将对象的创建权反转给（交给）了Spring。那DI又是什么鬼呢？DI，即Dependency Injection，翻译过来就是依赖注入，它指的就是Spring在管理某个类的时候会将该类依赖的属性注入（设置）进来，也就是说在创建对象的过程中，向类里面的属性中设置值。注意：依赖注入不能单独存在，须在控制反转基础之上完成，用更通俗点的话来说，就是注入类里面的属性值，不能直接注入，须创建类的对象再完成注入。  
你还记得在面向对象设计的时候，类和类之间有几种关系吗？有3种，它们分别是：

*  依赖，由于下图中B类的方法用到了A类，所以此时就可以说B类依赖于A类；  
    ![在这里插入图片描述][20190831220502167.png]
 *  继承（is a），这种关系我们应该是见的要吐了；  
    ![在这里插入图片描述][20190831220514792.png]
 *  聚合（has a），它有松散和紧密之分。例如，球队得有一个守门员，即使这个球队没有了这个守门员，它也还是一个球队，所以它是松散的；人得有一个脑袋，此时它就是紧密的。

说了这么多，咱就通过一个案例来看看DI在程序的体现。现在，我们想要给UserDaoImpl这个实现类里面的某一个属性（例如String类型的name）设置值，该咋怎呢？首先，将UserDaoImpl这个实现类修改成下面这个样子。

package com.meimeixia.spring.demo01;
    /** * 用户管理的dao层接口的实现类 * @author liayun * */
    public class UserDaoImpl implements UserDao { 
    	private String name;
    	//提供set方法
    	public void setName(String name) { 
    		this.name = name;
    	}
    	@Override
    	public void save() { 
    		System.out.println("UserDaoImpl中的save方法执行了......" + name);
    	}
    }
    
      
       
      
       
        1
        2
        3
        4
        5
        6
        7
        8
        9
        10
        11
        12
        13
        14
        15
        16
        17
        18
        19
        20
        21
        22

如果使用传统的方式来为UserDaoImpl实现类的name属性设置值，那么SpringDemo01单元测试类中的demo01方法就应该写成下面这个样子。

package com.meimeixia.spring.demo01;
    import org.junit.Test;
    /** * Spring的入门 * @author liayun * */
    public class SpringDemo01 { 
    	/* * 传统方式的调用 */
    	@Test
    	public void demo01() { 
    		/* * 我想给这个类里面的某一个属性设置值，挺麻烦的！ * * 1. 不能面向接口编程了 * 2. 你还得手动调用set方法，也得去改变程序的源代码 */
    		UserDaoImpl userDao = new UserDaoImpl();
    		userDao.setName("李二");
    		userDao.save();
    	}
    }
    
      
       
      
       
        1
        2
        3
        4
        5
        6
        7
        8
        9
        10
        11
        12
        13
        14
        15
        16
        17
        18
        19
        20
        21
        22
        23
        24
        25
        26
        27
        28

这样写，就有两个缺点，一是不能面向接口编程了，二是咱还得手动调用对象的set方法，这必然就涉及到要改变程序的源代码了，这是我们不能接受的！  
如果使用了依赖注入，即在applicationContext.xml文件中为配置好的UserDaoImpl实现类的name属性注入一个值，那么情况就完全不同了，以上两个缺点也就不复存在了。

<?xml version="1.0" encoding="UTF-8"?>
    <beans xmlns="http://www.springframework.org/schema/beans" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation=" http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd">    
    	
    	<bean id="userDao" class="com.meimeixia.spring.demo01.UserDaoImpl">
    		
    		<property name="name" value="李二" />
    	</bean>
    </beans>
    
      
       
      
       
        1
        2
        3
        4
        5
        6
        7
        8
        9
        10
        11
        12
        13
        14

此时，SpringDemo01单元测试类中的demo02方法依然不变，如下。

package com.meimeixia.spring.demo01;
    import org.junit.Test;
    import org.springframework.context.ApplicationContext;
    import org.springframework.context.support.ClassPathXmlApplicationContext;
    import org.springframework.context.support.FileSystemXmlApplicationContext;
    /** * Spring的入门 * @author liayun * */
    public class SpringDemo01 { 
    	/* * 传统方式的调用 */
    	@Test
    	public void demo01() { 		
    		/* * 我想给这个类里面的某一个属性设置值，挺麻烦的！ * * 1. 不能面向接口编程了 * 2. 你还得手动调用set方法，也得去改变程序的源代码 */
    		UserDaoImpl userDao = new UserDaoImpl();
    		userDao.setName("李二");
    		userDao.save();
    	}
    	/* * Spring的方式的调用 */
    	@Test
    	public void demo02() { 
    		//先要创建Spring的工厂
    		ApplicationContext applicationContext = new ClassPathXmlApplicationContext("applicationContext.xml");
    		UserDao userDao = (UserDao) applicationContext.getBean("userDao");
    		userDao.save();
    	}
    }
    
      
       
      
       
        1
        2
        3
        4
        5
        6
        7
        8
        9
        10
        11
        12
        13
        14
        15
        16
        17
        18
        19
        20
        21
        22
        23
        24
        25
        26
        27
        28
        29
        30
        31
        32
        33
        34
        35
        36
        37
        38
        39
        40
        41
        42

运行以上demo02单元测试方法，Eclipse控制台就会打印出如下内容。  
![在这里插入图片描述][201908312205314.png]

## Spring的工厂类 ##

### Spring工厂类的结构图 ###

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3llcmVueXVhbl9wa3U_size_16_color_FFFFFF_t_70 8]  
从上图可以看出ApplicationContext（接口）继承自BeanFactory（接口）。

### BeanFactory：老版本的工厂类 ###

BeanFactory是老版本的工厂类，稍微了解一下就好，这个类在实际开发中我们并不需要用到。需要说明的一点是，它只有在调用getBean方法的时候，才会生成Spring所管理的类的实例。

### ApplicationContext：新版本的工厂类 ###

ApplicationContext是新版本的工厂类，它在加载配置文件的时候，就会将Spring所管理的类都实例化。ApplicationContext这个接口有两个实现类，如下图所示。  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3llcmVueXVhbl9wa3U_size_16_color_FFFFFF_t_70 9]  
ClassPathXmlApplicationContext这个实现类前面用过了，下面咱就来用一下FileSystemXmlApplicationContext这个实现类。首先，拷贝一份applicationContext.xml文件到C盘下，其内容做一点点修改。  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3llcmVueXVhbl9wa3U_size_16_color_FFFFFF_t_70 10]  
然后，在SpringDemo01单元测试类中编写如下一个demo03方法。

package com.meimeixia.spring.demo01;
    import org.junit.Test;
    import org.springframework.context.ApplicationContext;
    import org.springframework.context.support.ClassPathXmlApplicationContext;
    import org.springframework.context.support.FileSystemXmlApplicationContext;
    /** * Spring的入门 * @author liayun * */
    public class SpringDemo01 { 
    	/* * 传统方式的调用 */
    	@Test
    	public void demo01() { 	
    		/* * 我想给这个类里面的某一个属性设置值，挺麻烦的！ * * 1. 不能面向接口编程了 * 2. 你还得手动调用set方法，也得去改变程序的源代码 */
    		UserDaoImpl userDao = new UserDaoImpl();
    		userDao.setName("李二");
    		userDao.save();
    	}
    	/* * Spring的方式的调用 */
    	@Test
    	public void demo02() { 
    		//先要创建Spring的工厂
    		ApplicationContext applicationContext = new ClassPathXmlApplicationContext("applicationContext.xml");
    		UserDao userDao = (UserDao) applicationContext.getBean("userDao");
    		userDao.save();
    	}
    	/* * 加载磁盘上的配置文件 */
    	@Test
    	public void demo03() { 
    		//先要创建Spring的工厂
    		ApplicationContext applicationContext = new FileSystemXmlApplicationContext("C:\\applicationContext.xml");
    		UserDao userDao = (UserDao) applicationContext.getBean("userDao");
    		userDao.save();
    	}
    }
    
      
       
      
       
        1
        2
        3
        4
        5
        6
        7
        8
        9
        10
        11
        12
        13
        14
        15
        16
        17
        18
        19
        20
        21
        22
        23
        24
        25
        26
        27
        28
        29
        30
        31
        32
        33
        34
        35
        36
        37
        38
        39
        40
        41
        42
        43
        44
        45
        46
        47
        48
        49
        50
        51
        52
        53

最后，运行以上demo03单元测试方法，Eclipse控制台就会打印出如下内容。  
![在这里插入图片描述][20190831220606514.png]

[20190831202738561.png]: /images/20221124/839457d5a71646b8b4eb2c04eaf225a2.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3llcmVueXVhbl9wa3U_size_16_color_FFFFFF_t_70]: /images/20221124/adfb27fa230b48eb845759c43663f3c6.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3llcmVueXVhbl9wa3U_size_16_color_FFFFFF_t_70 1]: /images/20221124/fd8dcead2a9a46099504997846695377.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3llcmVueXVhbl9wa3U_size_16_color_FFFFFF_t_70 2]: /images/20221124/ac2f936e52554865ac8fb90e35f9e9ff.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3llcmVueXVhbl9wa3U_size_16_color_FFFFFF_t_70 3]: /images/20221124/935c6ebaaa7b49ec8b1ced9792bebb41.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3llcmVueXVhbl9wa3U_size_16_color_FFFFFF_t_70 4]: /images/20221124/fe87370e3d274997b99342c41d26fe6f.png
[20190831202849724.png]: /images/20221124/f8f1e650ec424820b958c3480e33855c.png
[20190831202858234.png]: /images/20221124/2c0b953809f14972b9808d5659915201.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3llcmVueXVhbl9wa3U_size_16_color_FFFFFF_t_70 5]: /images/20221124/8f1716fbe1d247d1b38b56d35fc66c24.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3llcmVueXVhbl9wa3U_size_16_color_FFFFFF_t_70 6]: /images/20221124/13eff45e60374ee3be916edee08d14e2.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3llcmVueXVhbl9wa3U_size_16_color_FFFFFF_t_70 7]: /images/20221124/5755e41b702c44db8f425423c51758f7.png
[20190831202915740.png]: /images/20221124/bcd7d5bad98640c3a6f6ad11069e0e94.png
[20190831220502167.png]: /images/20221124/07d13652cffc4291a5e0f69d3580ef1e.png
[20190831220514792.png]: /images/20221124/7c263de0c26444e3bc192ab4c0a87ade.png
[201908312205314.png]: /images/20221124/98bd735fb2ff4d7897dcc597f87f8914.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3llcmVueXVhbl9wa3U_size_16_color_FFFFFF_t_70 8]: /images/20221124/9a1b4473a7c0427cb8979f512e853a4c.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3llcmVueXVhbl9wa3U_size_16_color_FFFFFF_t_70 9]: /images/20221124/41aa88d1fbf64b6f8d51832347360ec1.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3llcmVueXVhbl9wa3U_size_16_color_FFFFFF_t_70 10]: /images/20221124/62c4661e4c3f4e2cbbe1040db74bd07c.png
[20190831220606514.png]: /images/20221124/53e093601a4e487a9db1cb3908b23475.png