Spring知识总结

向右看齐 2022-10-12 12:16 31阅读 0赞

## 1.IOC：反转控制 ##

**1)DI:依赖注入**  
**2)IOC在spring容器的实现：**  
a).通过IOC容器读取Bean的实例之前，需要先将IOC容器本身实例化  
b)Spring提供了IOC容器的两种实现方式.  
BeanFactory：IOC容器的基本实现，是Spring内部的基础设施，是面向Spring本身的，不是提供给开发人员使用的。

ApplicationContext：BeanFactory的子接口，提供了更多高级特性。面向Spring的使用者，几乎所有场合都使用ApplicationContext而不是底层的BeanFactory。

**3）ApplicationContext有两个主要实现类：**  
a) ClassPathXmlApplicationContext：对应类路径下的XML格式的配置文件

b) FileSystemXmlApplicationContext：对应文件系统中的XML格式的配置文件

**4)bean:**  
同一个类型的bean在XML文件中配置了多个，则获取时会抛出异常，所以同一个类型的bean在容器中必须是唯一的。

***a)通过setXXX()方式赋值：***

XML配置

<bean id="student" class="first.bean.Student">
            
            <property name="studentId" value="1001"/>
            <property name="stuName" value="Tom2015"/>
            <property name="age" value="20"/>
        </bean>

代码实现：

//1创建IOC容器
            ClassPathXmlApplicationContext classPathXmlApplicationContext = new ClassPathXmlApplicationContext("helloWorld.xml");
            //2根据id值得到bean实例
            Student student  = (Student) classPathXmlApplicationContext.getBean("student");
    
            System.out.println(student);

***b)通过构造的方式赋值***  
XML

代码实现：

@Test
        public void test(){ 
    
            //1创建IOC容器
            ClassPathXmlApplicationContext classPathXmlApplicationContext = new ClassPathXmlApplicationContext("helloWorld.xml");
            //2根据id值得到bean实例
            Student student  = (Student) classPathXmlApplicationContext.getBean("student1");
    
            System.out.println(student);
    
            //2根据id值得到bean实例
            Student student11  = (Student) classPathXmlApplicationContext.getBean("student11");
    
            System.out.println(student11);
    
        }

c）bean给属性赋null值，ref标签赋值以及属性里面有对象，集合，map，properties等属性；

xml

代码：

@Test
        public void test01(){ 
    
            //1创建IOC容器
            ClassPathXmlApplicationContext classPathXmlApplicationContext = new ClassPathXmlApplicationContext("helloWorld.xml");
            //2根据id值得到bean实例
            Student student  = (Student) classPathXmlApplicationContext.getBean("student2");
    
            System.out.println(student);
    
    
        }

输出：  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MjA2MzgyMA_size_16_color_FFFFFF_t_70]  
d）级联赋值：为对象的对象的属性赋值  
xml

<bean id="student3" class="first.bean.Student">
            <property name="dog" ref="secondog">
            </property>
            <property name="dog.name" value="新的大黄"></property>
        </bean>

e)通过继承实现bean配置信息的重用  
（指的是配置信息的继承，并非类的继承）

加了一个parent的属性；  
当加了一个abstract的属性的时候，就意味着只能继承，不能被调用获取数据

f)bean的创建顺序默认就是配置文件的配置顺序  
，可以通过depends-on改变创建顺序  
意思是等bean容器secondog,student3执行完成再执行student1

f) bean的作用域，指定bean是否单实例，默认是单实例  
scope属性：有四种值：  
**prototype：多实例**：当获取bean实例时候才会被创建，且每一次获取将得到一个新的实例。  
**singleton:单实例**，单实例在容器启动完成就已经创建好对象，保存在容器中，构造器只调一次。  
request：在web环境同一次请求创建一个bean实例（通常没用）  
session：在web环境同一次会话创建一个bean实例（通常没用）

g）配置通过静态工厂方法创建bean，实例工厂创建bean、FactoryBean

**bean的创建默认就是框架通过反射new出来的bean实例，**  
**工厂模式：工厂帮我们创建对象**  
静态工厂：工厂本身不用创建对象，通过静态方法调用，对象=工厂类.工厂方法名（）；  
实例工厂：工厂本身需要创建对象，工厂类 对象 = new 工厂类，工程类.getAirPlane();

**静态工厂XML：**  
这里并非要创建AirPlaneStaitcFactory实例，所以指定factory-method属性表名是个工厂，返回的不是工厂的对象而是该方法的对象

<bean id="staitcAirPlane" class="first.bean.AirPlaneStaitcFactory" factory-method="getAirPlane">
            <constructor-arg name="name" value="歼20">
            </constructor-arg>
        </bean>

java代码：

package first.bean;
    
    public class AirPlaneStaitcFactory { 
        public static AirPlane getAirPlane(String name){ 
            AirPlane airPlane = new AirPlane();
            airPlane.setName(name);
            airPlane.setDriverName("机长名字");
            airPlane.setLength("100m");
    
            return airPlane;
    
        }
    }

**实例工厂：**  
xml：  
ii）先创建InstancePlaneFactory bean实例  
ii）配置我们要创建的AirPlane使用哪个工厂  
factory-bean指定哪个工厂实例  
factory-method使用哪个工厂方法

<bean id="InstancePlaneFactory" class="first.bean.AirPlaneInstanceFactory">
        </bean>
    
        <bean id="InstancePlane" class="first.bean.AirPlane"
        factory-bean="InstancePlaneFactory"
        factory-method="getAirPlane">
            <constructor-arg name="name" value="实例飞机"></constructor-arg>
        </bean>

java

public void test2(){ 
    
            //1创建IOC容器
            ClassPathXmlApplicationContext classPathXmlApplicationContext = new ClassPathXmlApplicationContext("bean.xml");
    
            AirPlaneInstanceFactory airPlaneInstanceFactory = (AirPlaneInstanceFactory)classPathXmlApplicationContext.getBean("InstancePlaneFactory");
            AirPlane AirPlane = airPlaneInstanceFactory.getAirPlane("实例机长");
    
            System.out.println(AirPlane);
    
        }

FactoryBean\*（是spring规定的接口）  
这个接口的实现类都是工厂类  
xml：

实现类：  
getObject相当于工厂方法；  
getObjectType返回工厂类型  
isSingleton：是否单例；false不是单例

package first.bean;
    
    import org.springframework.beans.factory.FactoryBean;
    
    public class MyFactoryBeanImple  implements FactoryBean<AirPlane>{ 
        /**\ * 返回创建的对象 * @return * @throws Exception */
        @Override
        public AirPlane getObject() throws Exception { 
            System.out.println("进来getObject方法。。。");
            AirPlane airPlane = new AirPlane();
            airPlane.setName("自带工厂方法的名字");
            return airPlane;
        }
    
        /** * 返回对象的类型 * spring会自带调用，来确定创建对象的类型 * @return */
        @Override
        public Class<?> getObjectType() { 
            System.out.println("进来getObjectType方法" +
                    "。。。");
            return null;
        }
    
        /** * false为单例 * @return */
        @Override
        public boolean isSingleton() { 
            return true;
        }
    }

测试结果：  
因为该工厂是spring认识的工厂，当容器一被创建的时候，  
当isSingleton（）方法返回false的时候，为多例，  
当isSingleton()方法返回值为true时候，为单例子，；  
不管是单实例还是多实例，只有bean被调用才创建。

**h）创建带有生命周期方法的bean  
生命周期：bean的创建到销毁**  
**ioc容器中注册bean:**  
ii)、单例bean，容器启动的时候创建好，容器关闭时候销毁；  
ii）多例bean，获取的时候才创建；  
可以为bean自定义一些生命周期方法，在创建和销毁就可以自动调用；  
bean里面可以指定destroy-method（销毁），和init-method（创建）属性

![在这里插入图片描述][20210705121837220.png]  
**i）bean的后置处理器BeanPostProcessor，在bean的初始化前后调用方法**

xml：

java：

@Test
        public void test3(){ 
    
            //1创建IOC容器
            ConfigurableApplicationContext classPathXmlApplicationContext = new ClassPathXmlApplicationContext("bean2.xml");
    
            classPathXmlApplicationContext.close();
    // System.out.println(AirPlane);
    
        }

运行结果：

before和after方法分别在初始化之前和后初始化之后调用  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MjA2MzgyMA_size_16_color_FFFFFF_t_70 1]

**执行顺序：**  
构造器—》后置处理器before—》初始化方法–》后置处理器after–》初始化完成

**无论bean是否有初始化方法，后置处理器都会默认有，还有继续工作**

**j）引用外部属性文件**  
数据库连接池作为单实例是最好的，一个项目就一个连接池，连接池里面有很多连接，可以让spring帮忙创建

xml  
方式一：直接在xml配置；  
方式二：引入外部的配置文件  
<context:property-placeholder location=“classpath:dbconfig.properties”/>  
并加上命名空间：  
xmlns:context="http://www.springframework.org/schema/context

http://www.springframework.org/schema/context  
http://www.springframework.org/schema/context/spring-context-4.3.xsd  
，为了防止和spring的属性重复，通常在配置的时候，加个前缀。eg：jdbc.username

<?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-4.3.xsd">
    
        <bean id="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource">
    
            <property name="user" value="root"></property>
            <property name="password" value="hhh"></property>
            <property name="jdbcUrl" value="jdbc:mysql://192.168.10.**:3306/xx?useUnicode=true&characterEncoding=utf8"></property>
            <property name="driverClass" value="com.mysql.jdbc.Driver"></property>
        </bean>
    
        <bean id="processor" class="first.bean.MyBeanPostProcessor">
    
        </bean>
    
        
        <context:property-placeholder location="classpath:dbconfig.properties"/>
    
        <bean id="dataSource2" class="com.mchange.v2.c3p0.ComboPooledDataSource">
    
            <property name="user" value="${jdbc.username}"></property>
            <property name="password" value="${jdbc.password}"></property>
            <property name="jdbcUrl" value="${jdbc.jdbcUrl}"></property>
            <property name="driverClass" value="${jdbc.driverClass}"></property>
        </bean>
    
    
    </beans>

java可以根据类型拿或者根据id去拿取；  
根据类型拿到连接池，可以获得该类型的所有实现子类等等

@Test
        public void test4(){ 
    
            //1创建IOC容器
            ClassPathXmlApplicationContext classPathXmlApplicationContext = new ClassPathXmlApplicationContext("application.xml");
            //拿到连接池
            DataSource dataSource = (DataSource)classPathXmlApplicationContext.getBean("dataSource");
    
            //根据类型拿到连接池，可以获得该类型的所有实现子类等等
           DataSource dataSource11 = (DataSource)classPathXmlApplicationContext.getBean(DataSource.class);
    
            DataSource dataSource2 = (DataSource)classPathXmlApplicationContext.getBean("dataSource2");
    
    
    
        }

**k)基于xml的自动装配**  
autowire=“defaut/no”  
三种规则自动装配：  
在bean中加入autowire的属性；

例如：  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MjA2MzgyMA_size_16_color_FFFFFF_t_70 2]  
有参数构造器：  
![在这里插入图片描述][20210707130431674.png]  
**L）SPEL**  
\#\{1\*12\}//可以运算  
\#\{book.name\}//可以引用其他bean的属性或者直接引用其他bean  
\#（T(全类名).(静态方法)）//调用静态方法  
\#\{book1.getBookName()\}//调用非静态 对象.方法名

**M）使用注解快速加入容器的几步：**  
ii)加上controller,service,repository,component  
ii)加上spring，自动扫描组件，依赖context名称空间  
ii）id默认是类名首字母小写，（记得需要导入aop包）

xml

<context:component-scan base-package="first.controller">
    
        </context:component-scan>

java  
（也可以修改默认名称）

@Controller
    //@Controller("hh")
    public class bookController { 
        public void getBook(){ 
            System.out.println("getBook");
        }
    
    
    
    }

**N）@Autowired的原理：**  
ii）先按照类型去找，找到一个就赋值  
ii）没找到抛出异常  
ii）找到如果有多个就按照id去找  
@Qualifier指定变量名称进行找

## 2.AOP ##

面向切面编程：将某段代码动态切入到方法指定位置运行的这种编程方式，面向切面编程；

**1）前奏：使用jdk默认的动态代理的方式写入日志：**

**代理类：**  
代理对象传入实现接口，是为了让代理对象也实现与之相同的接口；使之能够调用相关的方法：Calculator proxy = CalculatorProxy.getProxy(calculator);  
**所以有个缺点：如果没有实现接口的话是没有办法使用jdk默认的动态代理；**

package AOP;
    
    import java.lang.reflect.InvocationHandler;
    import java.lang.reflect.Method;
    import java.lang.reflect.Proxy;
    
    public class CalculatorProxy {
        /**
         * 为传入的参数创建一个动态代理对象
         * @param calculator
         * @return
         */
        public static Calculator getProxy(Calculator calculator) {
            //方法执行器，帮我们目标对象执行目标方法
            InvocationHandler h = new InvocationHandler() {
                /**
                 *
                 * @param proxy：代理对象，给jdk使用，任何时候都不要动这个对象
                 * @param method：当前要执行的目标对象的方法
                 * @param args：这个方法调用时候，外界的参入的参数值
                 * @return
                 * @throws Throwable
                 */
                @Override
                public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
                    System.out.println("目标方法执行之前。。。");
                    //目标方法执行后的返回值
                    Object invoke = method.invoke(calculator,args);
                    System.out.println("目标方法执行之后。。。");
                    return invoke;
                }
            };
            //实现了哪些接口
            Class<?>[] interfaces = calculator.getClass().getInterfaces();
            //被代理对象的类加载器
            ClassLoader loader = calculator.getClass().getClassLoader();
            //proxy为目标对象创建代理对象
            Object proxy = Proxy.newProxyInstance(loader,interfaces,h);
            return (Calculator) proxy;
        }
    }

CalculatorImpl类

package AOP;
    
    public class CalculatorImpl implements Calculator {
    
        @Override
        public double add(double a, double b) {
            System.out.println("加法运算结果："+(a+b));
            return a+b;
        }
    }

**test类**

package AOP;
    
    import org.junit.Test;
    
    public class AOPTest {
    
        @Test
        public void test(){
            Calculator calculator = new CalculatorImpl();
            calculator.add(1,1);
            Calculator proxy = CalculatorProxy.getProxy(calculator);
            proxy.add(3,1);
        }
    }

**2）spring的aop简单使用**（aop底层是动态代理）（cglib）

//Cglib动态代理，实现MethodInterceptor接口  
//重写拦截方法intercept

![在这里插入图片描述][watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBAc2Nhbm5lcuWwj-mcuOeOiw_size_20_color_FFFFFF_t_70_g_se_x_16]

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

面向切面编程的专业术语：  
ii）导包  
ii）写配置：  
将目标和切面类（封装了通知方法（在目标方法执行前后执行的方法））加入到ioc容器中；  
**切面类**  
加上注解：  
**@Aspect  
@Component**

package Spring_AOP;
    
    import org.aspectj.lang.annotation.*;
    import org.springframework.stereotype.Component;
    
    import java.lang.reflect.Method;
    import java.util.Arrays;
    
    @Aspect
    @Component
    public class LogUtils {
        /**
         * try{
         *     @before
         *     method.invoke(obj,agrs);
         *     @AfterReturning
         * }catch(e){
         *     @AfterThrowing
         * }finally{
         *     @After
         * }
         * before目标方法执行之前   前置通知
         * after目标方法结束之后   后置通知
         * AfterReturn 在目标方法返回之后  返回通知
         * @AfterThrowing在目标方法抛出异常之后  异常通知
         * @Around 环绕通知
         */
        //目标方法执行之前，写入切入点表达式
        //execution(返回权限符 返回值类型 方法签名)
        @Before("execution( public  double Spring_AOP.Calculator.add(double ,double ))")
        public static void logStart(){
            System.out.println("开始执行");
    //        System.out.println("["+method.getName()+"]方法开始执行，用的参数列表["+ Arrays.toString(args)+"]");
        }
        //目标方法出现异常时候执行
        @AfterThrowing("execution( public  double Spring_AOP.Calculator.*(double ,double ))")
        public static void logException(){
            System.out.println("抛出异常之后");
    //        System.out.println("["+method.getName()+"]方法正常执行，用的参数列表["+ Arrays.toString(args)+"]");
        }
    
        //
        @AfterReturning("execution( public  double Spring_AOP.Calculator.*(double ,double ))")
        public static void logReturn(){
            System.out.println("正常执行之后");
    //        System.out.println("["+method.getName()+"]方法正常执行，用的参数列表["+ Arrays.toString(args)+"]");
        }
    
        @After("execution( public  double Spring_AOP.Calculator.add(double ,double ))")
        public static void logAfter(){
            System.out.println("方法结束之后");
    //        System.out.println("["+method.getName()+"]方法正常执行，用的参数列表["+ Arrays.toString(args)+"]");
        }
    }

**目标类的实现类**

package Spring_AOP;
    
    import org.springframework.stereotype.Component;
    
    @Component
    public class CalculatorImpl implements Calculator {
    
        @Override
        public double add(double a, double b) {
            System.out.println("加法运算结果："+(a+b));
            return a+b;
        }
    
        @Override
        public double ChuFa(double a, double b) {
            return a/b;
        }
    }

还要告诉spring哪个是切面类@Aspect，何时执行  
ii）在配置文件开启基于注解的aop功能

**导入aop的空间名称以及注解扫描**

**通知：**

/\*\*  
\* try\{  
\* @before  
\* method.invoke(obj,agrs);  
\* @AfterReturning  
\* \}catch(e)\{  
\* @AfterThrowing  
\* \}finally\{  
\* @After  
\* \}  
\* before目标方法执行之前 前置通知  
\* after目标方法结束之后 后置通知  
\* AfterReturn 在目标方法返回之后 返回通知  
\* @AfterThrowing在目标方法抛出异常之后 异常通知  
\* @Around 环绕通知  
\*/

//目标方法执行之前，写入切入点表达式  
//execution(返回权限符 返回值类型 方法签名)  
@Before(“execution( public double Spring\_AOP.Calculator.add(double ,double ))”)

**测试类**

@Test
        public void test2(){
            try{
                Calculator calculator = (Calculator)ioc.getBean(Calculator.class);
    //            Calculator calculator = new CalculatorImpl();
    //            calculator.add(1,1);
    //            int i = 1/0;
    
                calculator.ChuFa(1,0);
    //            int i = 1/0;
            }catch (Exception e){
                System.out.println(e.getMessage());
            }finally {
    
            }
        }

**注：容器加在接口时候是不创建对象的（spring比较智能），所以通常是加载实现类上**

**3）切入点表达式的写法**  
ii）匹配一个或者多个字符  
@Before(“execution( public double Spring\_AOP.Calculator.\*(double ,double ))”)  
ii）匹配任意一个参数，第一个是int类型，第二个参数任意类型（匹配任意类型）

execution( public double Spring\_AOP.Calculator.*(int ,*))  
ii)匹配任意多个参数，任意类型参数  
execution( public double Spring\_AOP.Calculator.*(…))  
ii)匹配任意多次路径  
execution( public double Spring\_AOP1…Spring\_AOP12Calculator.*(…))

ii)权限位置*不能代表任意，权限位置不写就表示任意；  
execution( double Spring\_AOP1…Spring\_AOP12Calculator.*(…))  
ii）全权限，任意返回类型，任意路径，任意参数  
execution( \* \*(…))

**4）在通知方法运行的时候，拿到目标方法的详细信息**  
只需要在通知方法的参数列表写上一个参数  
JoinPoint joinPoint

@Before("execution( public  double Spring_AOP.Calculator.add(double ,double ))")
        public static void logStart(JoinPoint joinPoint){
            System.out.println("开始执行");
            Object[] args = joinPoint.getArgs();
            System.out.println("方法参数："+Arrays.toString(args));
    //        System.out.println("["+method.getName()+"]方法开始执行，用的参数列表["+ Arrays.toString(args)+"]");
        }

**5)在通知方法运行的时候，拿到目标方法的详细信息，（拿到返回值，异常）**

**ii）返回值**  
当Object result改为double result的时候，就只能接收浮点类型

@AfterReturning(value="execution( public  double Spring_AOP.Calculator.*(double ,double ))",returning = "result")
        public static void logReturn(JoinPoint joinPoint,Object result){
            System.out.println("正常执行之后");
            System.out.println("result:"+result);
    //        System.out.println("["+method.getName()+"]方法正常执行，用的参数列表["+ Arrays.toString(args)+"]");
        }

**ii）异常信息**

//目标方法出现异常时候执行
        @AfterThrowing(value = "execution( public  double Spring_AOP.Calculator.*(double ,double ))",throwing ="exception" )
        public static void logException(JoinPoint joinPoint,Exception exception){
            System.out.println("抛出异常之后");
    //        System.out.println("["+method.getName()+"]方法正常执行，用的参数列表["+ Arrays.toString(args)+"]");
        }

**6）也可以把表达式抽取出来，实现可重入，**  
@Pointcut(“execution( public double Spring\_AOP.Calculator.add(double ,double ))”)

@Pointcut("execution( public  double Spring_AOP.Calculator.add(double ,double ))")
        public void hahaaMyPoint(){
    
        }
    
        //目标方法执行之前，写入切入点表达式
        //execution(返回权限符 返回值类型 方法签名)
        @Before(value = "hahaaMyPoint()")
        public static void logStart(JoinPoint joinPoint){
            System.out.println("开始执行");
            Object[] args = joinPoint.getArgs();
            System.out.println("方法参数："+Arrays.toString(args));
    //        System.out.println("["+method.getName()+"]方法开始执行，用的参数列表["+ Arrays.toString(args)+"]");
        }

7）环绕通知：  
执行顺序：  
环绕通知优先于其他普通通知  
环绕前置–》环绕后置—》方法返回–》环绕正常返回/方法异常–》环绕后置–》普通后置  
环绕通知有个参数ProceedingJoinPoint ，环绕通知是“四合一”的通知  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MjA2MzgyMA_size_16_color_FFFFFF_t_70_pic_center 1]

@Around("hahaaMyPoint()")
        public Object myAround(ProceedingJoinPoint proceedingJoinPoint) throws Throwable {
            Object[] args = proceedingJoinPoint.getArgs();
    
            Object proceed = null;
    
           try {
               System.out.println("myAround开始");
               //利用反射执行目标方法
               proceed = proceedingJoinPoint.proceed(args);
               System.out.println("myAround正常执行结束");
    
           }catch (Exception e){
               System.out.println("myAround抛出异常");
           }finally {
               System.out.println("myAround最后");
           }
    
           return proceed;
    
        }

**注：当有多个切面的时候，默认按照字母文件的首字母的字母表顺序，也可以通过加上@Order（1）来改变顺序，数字越小，优先级越高**

## 3基于xml的aop ##

1）加到ioc容器  
![在这里插入图片描述][20210713215334247.png_pic_center]  
2）需要名称空间，告诉哪个是切面类，以及相对应的通知方法

## 4.JdbcTemplate ##

**xml配置数据源：**

**java代码：**  
![在这里插入图片描述][20210713223044269.png_pic_center]

## 5.声明式事务 ##

**四个关键特性：**  
原子性：要么都执行，要么都不执行  
一致性；数据一致性，例如：我转一百，对方也将收到一百，不可能我转了1百对方没收到啥的；  
隔离性；多事务并发执行互不干扰  
持久性；对数据的修改永久保存下去。

事务切面===事务管理器

**为某个方法添加事务管理器：**  
1）配置事务管理器让其进行事务控制，需要面向切面编程的包

2）开启基于注解的事务控制模式，依赖tx名称空间  
3）给事务方法加注解

**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"
           xmlns:tx="http://www.springframework.org/schema/tx"
           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-4.3.xsd
            http://www.springframework.org/schema/tx
            http://www.springframework.org/schema/tx/spring-tx.xsd">
    
    
    
        <context:component-scan base-package="TX">
    
        </context:component-scan>
        
        <context:property-placeholder location="classpath:dbconfig.properties"/>
    
        <bean id="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource">
    
            <property name="user" value="${jdbc.username}"></property>
            <property name="password" value="${jdbc.password}"></property>
            <property name="jdbcUrl" value="${jdbc.jdbcUrl}"></property>
            <property name="driverClass" value="${jdbc.driverClass}"></property>
        </bean>
    
        <bean id="jdbcTemplate" class="org.springframework.jdbc.core.JdbcTemplate">
            <constructor-arg name="dataSource" ref="dataSource"></constructor-arg>
        </bean>
    
        
        
        <bean id="tm" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
            <property name="dataSource" ref="dataSource"></property>
        </bean>
        
        <tx:annotation-driven transaction-manager="tm"/>
        
    
    </beans>

**BookDao**

package TX;
    
    import org.junit.Test;
    import org.springframework.beans.factory.annotation.Autowired;
    import org.springframework.jdbc.core.JdbcTemplate;
    import org.springframework.stereotype.Repository;
    
    import javax.annotation.Resource;
    
    @Repository
    public class BookDao {
    
    //    @Autowired
        @Resource(name = "jdbcTemplate")
        JdbcTemplate jdbcTemplate;
    
        @Test
        public void test(){
            System.out.println(jdbcTemplate);
            String sql ="select price from book where isbn = 'ISBN-001'";
            int price = jdbcTemplate.queryForObject(sql,Integer.class);
            System.out.println(price);
        }
    
        void updateStock(String isbn){
            String sql ="update book_stock set stock=stock-1 where isbn = ?";
            jdbcTemplate.update(sql,isbn);
        }
    
        void updateAccount(String username,int balance){
            String sql ="update account set balance=balance-? where username = ?";
            jdbcTemplate.update(sql,balance,username);
        }
    
        int getPrice(String isbN){
            String sql ="select price from book where isbn = 'ISBN-001'";
            int price = jdbcTemplate.queryForObject(sql,Integer.class);
            return price;
        }
    }

BookService

package TX;
    
    import org.springframework.beans.factory.annotation.Autowired;
    import org.springframework.stereotype.Service;
    import org.springframework.transaction.annotation.Transactional;
    
    @Service
    public class BookService {
        @Autowired
        BookDao bookDao;
    
        @Transactional
        public void checkOut(String username,String isbn){
    //        1减去库存
            bookDao.updateStock(isbn);
    
            int price = bookDao.getPrice(isbn);
            int i=1/0;
            //2减去余额
            bookDao.updateAccount(username,price);
    
        }
    
    }

**测试代码：**

*（采用Junit无法调用到注解的jdbcTemplate，这里采用spring自带的测试@RunWith(SpringJUnit4ClassRunner.class)  
@ContextConfiguration(locations = \{ “classpath:tx.xml” \})）*

package TX;
    
    import Spring_AOP.Calculator;
    import Spring_AOP.CalculatorImpl;
    import Spring_AOP.CalculatorProxy;
    import org.junit.Test;
    import org.junit.runner.RunWith;
    import org.springframework.beans.factory.annotation.Autowired;
    import org.springframework.context.support.ClassPathXmlApplicationContext;
    import org.springframework.jdbc.core.JdbcTemplate;
    import org.springframework.stereotype.Component;
    import org.springframework.test.context.ContextConfiguration;
    import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;
    
    import javax.sql.DataSource;
    
    @RunWith(SpringJUnit4ClassRunner.class)
    @ContextConfiguration(locations = { "classpath:tx.xml" })
    //@Component
    public class JDBCTemplateTest {
        //1创建IOC容器
        ClassPathXmlApplicationContext ioc = new ClassPathXmlApplicationContext("tx.xml");
        JdbcTemplate jdbcTemplate = ioc.getBean(JdbcTemplate.class);
    
        @Autowired
        private BookService bookService;
    
        @Autowired
        private BookDao bookDao;
    
    
    
        @Test
        public void test(){
    //        System.out.println(jdbcTemplate);
    //        String sql ="select price from book where isbn = 'ISBN-001'";
    //        int price = jdbcTemplate.queryForObject(sql,Integer.class);
    //        System.out.println(price);
    
    //        1减去库存
           bookService.checkOut("Tom","ISBN-001");
    
    //        int count= bookDao.getPrice("ISBN-001");
    //        System.out.println("数量："+count);
    
    
        }
    
    
    }

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MjA2MzgyMA_size_16_color_FFFFFF_t_70 3]

## 6.事务细节 ##

**isolation**：事务的隔离级别  
**propagation**：事务的传播行为  
**timeOut**：超时，自动终止并且回滚  
**readOnly**：设置事务为只读事务，可以进行事务优化，为true  
时候，加快查询速度，不用管事务一堆操作，默认是false

**运行时异常**：可以不处理，默认都回滚；  
**编译时异常**：要么try-catch，要么在方法声明throw，默认不回滚

**noRollbackFor**：哪些异常可以不回滚（可以让默认回滚的异常不回滚）  
**noRollbackForName**：  
**rollbackFor**：哪些不回滚的异常可以回滚  
**rollbackForName**：

**1）隔离级别：**  
**并发问题：**  
ii）脏读：（只有脏读是一定不能发生）  
ii）不可重复读：（指的是更新的数据）  
ii）幻读：（指的是插入的记录）  
![ii）][ii]  
**四种隔离级别：**  
（肯定是一个在读，一个在写才会出现这个问题）  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MjA2MzgyMA_size_16_color_FFFFFF_t_70 4]  
**四种隔离级别分别有什么问题：**![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MjA2MzgyMA_size_16_color_FFFFFF_t_70 5]  
**2）模拟并发问题：**

ii）默认隔离级别  
SELECT @@tx\_isolation;  
REPEATABLE-READ  
ii）修改为读取未提交的  
set session transaction isolation level read uncommitted;（当前会话）  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MjA2MzgyMA_size_16_color_FFFFFF_t_70 6]

ii）模拟脏读  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MjA2MzgyMA_size_16_color_FFFFFF_t_70 7]  
ii）模拟不可重复读  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MjA2MzgyMA_size_16_color_FFFFFF_t_70 8]

ii)可重复读：repeatable read  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MjA2MzgyMA_size_16_color_FFFFFF_t_70 9]

**并发修改数据的时候，底层将会进行排队**  
**3）传播行为**  
如果多个事务进行嵌套运行，子事务是否要和大事务共用一个事务

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MjA2MzgyMA_size_16_color_FFFFFF_t_70 10]  
eg：@transactional（propagation=Propagation.REQUIRED,timeout=3）  
当使用Propagation.REQUIRED，所有的子事务将继承于大事务  
**（REQUIRED和REQUIRED\_NEW最常见）**

**情况分析**  
ii）当大事务里面嵌套了两个小事务  
当大事务抛出异常的时候，第一个事务REQUIRED\_NEW可以成功执行，第二个REQUIRED执行失败  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MjA2MzgyMA_size_16_color_FFFFFF_t_70 11]

ii）当第一个子事务发生异常时候，虽然传播行为是REQUIRED\_NEW，但是产生的异常会往外抛，导致大事务也发生异常，并且第二个子事务是REQUIRED，所以第二个子事务也执行不成功  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MjA2MzgyMA_size_16_color_FFFFFF_t_70 12]

ii）当第二个事务发生异常时候，并不影响第一个成功执行  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MjA2MzgyMA_size_16_color_FFFFFF_t_70 13]

## 7.基于xml的事务控制配置 ##

1)配置事务管理器  
2)卡配置事务方法  
3）告诉spring哪些是事务方法（事务切面按照我们切入表达式切入事务方法）

**xml配置**

<aop:config>
            <aop:pointcut id="point" expression="execution(* TX(..))"/>
            
            <aop:advisor advice-ref="mtTx" pointcut-ref="point"></aop:advisor>
        </aop:config>
    
        
        <tx:advice  id="mtTx" transaction-manager="tm">
            <tx:attributes>
                
                <tx:method name="find*" read-only="true"/>
                <tx:method name="get*" read-only="true"/>
                <tx:method name="checkOut2"
                           isolation="READ_COMMITTED"
                           no-rollback-for="java.lang.ArithmeticException,java.lang.NullPointerException"
                           propagation="REQUIRED"
                           read-only="false"
                           timeout="10"/>
            </tx:attributes>
    
        </tx:advice>

## 8.源码分析 ##

//1创建IOC容器
        ClassPathXmlApplicationContext ioc = new ClassPathXmlApplicationContext("bean.xml");

**当执行这语句之后，所有的bean将创建并初始化完成。**  
**1） AbstractApplicationContext有一个Refresh（）实现单实例bean的创建**

public void refresh() throws BeansException, IllegalStateException {
        Object var1 = this.startupShutdownMonitor;
        synchronized(this.startupShutdownMonitor) {
            this.prepareRefresh();
    //解析xml配置文件，将bean的配置信息保存起来
            ConfigurableListableBeanFactory beanFactory = this.obtainFreshBeanFactory();
            this.prepareBeanFactory(beanFactory);
    
            try {
                this.postProcessBeanFactory(beanFactory);
                this.invokeBeanFactoryPostProcessors(beanFactory);
                this.registerBeanPostProcessors(beanFactory);
    //国际化功能
                this.initMessageSource();
                this.initApplicationEventMulticaster();
    //空方法，留给子类
                this.onRefresh();
                this.registerListeners();
    //初始化所有单实例bean
                this.finishBeanFactoryInitialization(beanFactory);
                this.finishRefresh();
            } catch (BeansException var9) {
                if (this.logger.isWarnEnabled()) {
                    this.logger.warn("Exception encountered during context initialization - cancelling refresh attempt: " + var9);
                }
    
                this.destroyBeans();
                this.cancelRefresh(var9);
                throw var9;
            } finally {
                this.resetCommonCaches();
            }
    
        }
    }

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MjA2MzgyMA_size_16_color_FFFFFF_t_70 14]  
**2）DefaultListableBeanFactory：preInstantiateSingletons()创建bean**

public void preInstantiateSingletons() throws BeansException {
        if (this.logger.isTraceEnabled()) {
            this.logger.trace("Pre-instantiating singletons in " + this);
        }
    
    //拿到所有需要创建的bean的名字
        List<String> beanNames = new ArrayList(this.beanDefinitionNames);
        Iterator var2 = beanNames.iterator();
    //按照顺序创建bean
        while(true) {
            String beanName;
            Object bean;
            do {
                while(true) {
                    RootBeanDefinition bd;
                    do {
                        do {
                            do {
                                if (!var2.hasNext()) {
                                    var2 = beanNames.iterator();
    
                                    while(var2.hasNext()) {
                                        beanName = (String)var2.next();
                                        Object singletonInstance = this.getSingleton(beanName);
                                        if (singletonInstance instanceof SmartInitializingSingleton) {
                                            SmartInitializingSingleton smartSingleton = (SmartInitializingSingleton)singletonInstance;
                                            if (System.getSecurityManager() != null) {
                                                AccessController.doPrivileged(() -> {
                                                    smartSingleton.afterSingletonsInstantiated();
                                                    return null;
                                                }, this.getAccessControlContext());
                                            } else {
                                                smartSingleton.afterSingletonsInstantiated();
                                            }
                                        }
                                    }
    
                                    return;
                                }
    
                                beanName = (String)var2.next();
    //根据beanId获取bean的定义信息
                                bd = this.getMergedLocalBeanDefinition(beanName);
                            } while(bd.isAbstract());
                        } while(!bd.isSingleton());
                    } while(bd.isLazyInit());
    
                    if (this.isFactoryBean(beanName)) {
                        bean = this.getBean("&" + beanName);
                        break;
                    }
    
                    this.getBean(beanName);
                }
            } while(!(bean instanceof FactoryBean));
    
            FactoryBean<?> factory = (FactoryBean)bean;
            boolean isEagerInit;
            if (System.getSecurityManager() != null && factory instanceof SmartFactoryBean) {
                SmartFactoryBean var10000 = (SmartFactoryBean)factory;
                ((SmartFactoryBean)factory).getClass();
                isEagerInit = (Boolean)AccessController.doPrivileged(var10000::isEagerInit, this.getAccessControlContext());
            } else {
                isEagerInit = factory instanceof SmartFactoryBean && ((SmartFactoryBean)factory).isEagerInit();
            }
    
            if (isEagerInit) {
    //创建对象
                this.getBean(beanName);
            }
        }
    }

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MjA2MzgyMA_size_16_color_FFFFFF_t_70 15]  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MjA2MzgyMA_size_16_color_FFFFFF_t_70 16]  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MjA2MzgyMA_size_16_color_FFFFFF_t_70 17]

**3）AbstractBeanFactory：getBean（）**

所有getBean调用的是AbstractBeanFactory  
的dogetBean（）

protected <T> T doGetBean(String name, @Nullable Class<T> requiredType, @Nullable Object[] args, boolean typeCheckOnly) throws BeansException {
        String beanName = this.transformedBeanName(name);
    //试着从已经注册的所有单实例bean中看有没有这个bean，第一次创建bean是没有的
        Object sharedInstance = this.getSingleton(beanName);
        Object bean;
        if (sharedInstance != null && args == null) {
            if (this.logger.isTraceEnabled()) {
                if (this.isSingletonCurrentlyInCreation(beanName)) {
                    this.logger.trace("Returning eagerly cached instance of singleton bean '" + beanName + "' that is not fully initialized yet - a consequence of a circular reference");
                } else {
                    this.logger.trace("Returning cached instance of singleton bean '" + beanName + "'");
                }
            }
    
            bean = this.getObjectForBeanInstance(sharedInstance, name, beanName, (RootBeanDefinition)null);
        } else {
            if (this.isPrototypeCurrentlyInCreation(beanName)) {
                throw new BeanCurrentlyInCreationException(beanName);
            }
    
            BeanFactory parentBeanFactory = this.getParentBeanFactory();
            if (parentBeanFactory != null && !this.containsBeanDefinition(beanName)) {
                String nameToLookup = this.originalBeanName(name);
                if (parentBeanFactory instanceof AbstractBeanFactory) {
                    return ((AbstractBeanFactory)parentBeanFactory).doGetBean(nameToLookup, requiredType, args, typeCheckOnly);
                }
    
                if (args != null) {
                    return parentBeanFactory.getBean(nameToLookup, args);
                }
    
                if (requiredType != null) {
                    return parentBeanFactory.getBean(nameToLookup, requiredType);
                }
    
                return parentBeanFactory.getBean(nameToLookup);
            }
    
            if (!typeCheckOnly) {
                this.markBeanAsCreated(beanName);
            }
    
            try {
                RootBeanDefinition mbd = this.getMergedLocalBeanDefinition(beanName);
                this.checkMerge，dBeanDefinition(mbd, beanName, args);
    //拿到所有依赖的bean，depends-on属性
                String[] dependsOn = mbd.getDependsOn();
                String[] var11;
                if (dependsOn != null) {
                    var11 = dependsOn;
                    int var12 = dependsOn.length;
    
                    for(int var13 = 0; var13 < var12; ++var13) {
                        String dep = var11[var13];
                        if (this.isDependent(beanName, dep)) {
                            throw new BeanCreationException(mbd.getResourceDescription(), beanName, "Circular depends-on relationship between '" + beanName + "' and '" + dep + "'");
                        }
    
                        this.registerDependentBean(dep, beanName);
    
                        try {
                            this.getBean(dep);
                        } catch (NoSuchBeanDefinitionException var24) {
                            throw new BeanCreationException(mbd.getResourceDescription(), beanName, "'" + beanName + "' depends on missing bean '" + dep + "'", var24);
                        }
                    }
                }
    
                if (mbd.isSingleton()) {
                    sharedInstance = this.getSingleton(beanName, () -> {
                        try {
                            return this.createBean(beanName, mbd, args);
                        } catch (BeansException var5) {
                            this.destroySingleton(beanName);
                            throw var5;
                        }
                    });
                    bean = this.getObjectForBeanInstance(sharedInstance, name, beanName, mbd);
                } else if (mbd.isPrototype()) {
                    var11 = null;
    
                    Object prototypeInstance;
                    try {
                        this.beforePrototypeCreation(beanName);
                        prototypeInstance = this.createBean(beanName, mbd, args);
                    } finally {
                        this.afterPrototypeCreation(beanName);
                    }
    
                    bean = this.getObjectForBeanInstance(prototypeInstance, name, beanName, mbd);
                } else {
                    String scopeName = mbd.getScope();
                    Scope scope = (Scope)this.scopes.get(scopeName);
                    if (scope == null) {
                        throw new IllegalStateException("No Scope registered for scope name '" + scopeName + "'");
                    }
    
                    try {
                        Object scopedInstance = scope.get(beanName, () -> {
                            this.beforePrototypeCreation(beanName);
    
                            Object var4;
                            try {
                                var4 = this.createBean(beanName, mbd, args);
                            } finally {
                                this.afterPrototypeCreation(beanName);
                            }
    
                            return var4;
                        });
                        bean = this.getObjectForBeanInstance(scopedInstance, name, beanName, mbd);
                    } catch (IllegalStateException var23) {
                        throw new BeanCreationException(beanName, "Scope '" + scopeName + "' is not active for the current thread; consider defining a scoped proxy for this bean if you intend to refer to it from a singleton", var23);
                    }
                }
            } catch (BeansException var26) {
                this.cleanupAfterBeanCreationFailure(beanName);
                throw var26;
            }
        }
    
        if (requiredType != null && !requiredType.isInstance(bean)) {
            try {
                T convertedBean = this.getTypeConverter().convertIfNecessary(bean, requiredType);
                if (convertedBean == null) {
                    throw new BeanNotOfRequiredTypeException(name, requiredType, bean.getClass());
                } else {
                    return convertedBean;
                }
            } catch (TypeMismatchException var25) {
                if (this.logger.isTraceEnabled()) {
                    this.logger.trace("Failed to convert bean '" + name + "' to required type '" + ClassUtils.getQualifiedName(requiredType) + "'", var25);
                }
    
                throw new BeanNotOfRequiredTypeException(name, requiredType, bean.getClass());
            }
        } else {
            return bean;
        }
    }

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MjA2MzgyMA_size_16_color_FFFFFF_t_70 18]

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MjA2MzgyMA_size_16_color_FFFFFF_t_70 19]

**4）getSingleton(beanName);**

protected Object getSingleton(String beanName, boolean allowEarlyReference) {
        Object singletonObject = this.singletonObjects.get(beanName);
        if (singletonObject == null && this.isSingletonCurrentlyInCreation(beanName)) {
            Map var4 = this.singletonObjects;
            synchronized(this.singletonObjects) {
    //创建对象
                singletonObject = this.earlySingletonObjects.get(beanName);
                if (singletonObject == null && allowEarlyReference) {
                    ObjectFactory<?> singletonFactory = (ObjectFactory)this.singletonFactories.get(beanName);
                    if (singletonFactory != null) {
    //创建好的对象最终保存在earlySingletonObjects中
                        singletonObject = singletonFactory.getObject();
                        this.earlySingletonObjects.put(beanName, singletonObject);
                        this.singletonFactories.remove(beanName);
                    }
                }
            }
        }
    
        return singletonObject;
    }

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MjA2MzgyMA_size_16_color_FFFFFF_t_70 20]

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MjA2MzgyMA_size_16_color_FFFFFF_t_70]: /images/20221005/e41ac98ca86440e5a08e7757664dced4.png
[20210705121837220.png]: /images/20221005/0ba817679cb24e4293d8500d7c99be80.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MjA2MzgyMA_size_16_color_FFFFFF_t_70 1]: /images/20221005/24391cfaed8c45f3ba666fa73a277304.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MjA2MzgyMA_size_16_color_FFFFFF_t_70 2]: /images/20221005/edb6976c9d2e4254b6da74301a5d2e81.png
[20210707130431674.png]: /images/20221005/5494f23587924f8ba3770712a242cced.png
[watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBAc2Nhbm5lcuWwj-mcuOeOiw_size_20_color_FFFFFF_t_70_g_se_x_16]: /images/20221005/1cb6cea29e6f4e27be4a93fe6a222c92.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MjA2MzgyMA_size_16_color_FFFFFF_t_70_pic_center]: /images/20221005/73d9cd543cfa4584aa465a6b45937aac.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MjA2MzgyMA_size_16_color_FFFFFF_t_70_pic_center 1]: /images/20221005/e8f0162ad48647b49aeb6d3638aec2fd.png
[20210713215334247.png_pic_center]: /images/20221005/fa0519dc2ab6470c91916388f6b32731.png
[20210713223044269.png_pic_center]: /images/20221005/2947de5c485742858d008dc286604866.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MjA2MzgyMA_size_16_color_FFFFFF_t_70 3]: /images/20221005/456be5da0e5a4a139e0b575e5a05f1a0.png
[ii]: /images/20221005/fe7354e92c9e4005b7ad29dcf2f12ad3.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MjA2MzgyMA_size_16_color_FFFFFF_t_70 4]: /images/20221005/714f6ded204046dc8047c0d4c0d6cba5.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MjA2MzgyMA_size_16_color_FFFFFF_t_70 5]: /images/20221005/46856dcfbdcc4731b22109f16a5e8ede.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MjA2MzgyMA_size_16_color_FFFFFF_t_70 6]: /images/20221005/9ae8eb261b494aa6bc1ca59c541927bf.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MjA2MzgyMA_size_16_color_FFFFFF_t_70 7]: /images/20221005/7e95d9ad0d864662bb2611713fd4ed7b.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MjA2MzgyMA_size_16_color_FFFFFF_t_70 8]: /images/20221005/b97894437c354fa6a237118cf349b1a3.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MjA2MzgyMA_size_16_color_FFFFFF_t_70 9]: /images/20221005/8f0c6acbf12b4793ac3683982c631d47.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MjA2MzgyMA_size_16_color_FFFFFF_t_70 10]: /images/20221005/450f2571184c482481e327981c443427.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MjA2MzgyMA_size_16_color_FFFFFF_t_70 11]: /images/20221005/fc75c85386194d35a02dad03dfe7f4f8.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MjA2MzgyMA_size_16_color_FFFFFF_t_70 12]: /images/20221005/87bfdf3c6fa5469fa64ba0c1a44046dd.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MjA2MzgyMA_size_16_color_FFFFFF_t_70 13]: /images/20221005/758299e3a19043d4af4d910b260f2cc7.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MjA2MzgyMA_size_16_color_FFFFFF_t_70 14]: /images/20221005/7a072b7fe28e41b686e8f7efda06402f.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MjA2MzgyMA_size_16_color_FFFFFF_t_70 15]: /images/20221005/6b596e37a4474ad28bc9c4e0ea13ace2.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MjA2MzgyMA_size_16_color_FFFFFF_t_70 16]: /images/20221005/dd791d91198047c8b33a770d2d4883fa.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MjA2MzgyMA_size_16_color_FFFFFF_t_70 17]: /images/20221005/14cf532969454796a84d57171d123957.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MjA2MzgyMA_size_16_color_FFFFFF_t_70 18]: /images/20221005/cae58594e686410882b0d22b490a7442.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MjA2MzgyMA_size_16_color_FFFFFF_t_70 19]: /images/20221005/da4e0b5c0713413da993474465a97deb.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MjA2MzgyMA_size_16_color_FFFFFF_t_70 20]: /images/20221005/327120e19a3143a0aebb593e26b3bac3.png