Spring学习笔记

痛定思痛。 2022-09-08 11:55 143阅读 0赞

### 文章目录 ###

*   *  Spring学习笔记
     *   *  Spring 框架两大核心机制（IoC、AOP）
     *  如何使用 IoC
     *   *  配置文件
         *  IoC 底层原理
         *  通过运行时类获取 bean
         *  通过有参构造创建 bean
         *  给 bean 注入集合
         *  scope 作用域
         *  Spring 的继承
         *  Spring 的依赖
         *  Spring 的 p 命名空间
         *  Spring 的工厂方法
         *  IoC 自动装载（Autowire）
     *  AOP
     *   *  如何使用AOP

## Spring学习笔记 ##

### Spring 框架两大核心机制（IoC、AOP） ###

*  **IoC**（控制反转）/ **DI**（依赖注入）
 *  **AOP**（面向切面编程）

Spring 是一个企业级开发框架，是软件设计层面的框架，优势在于可以将应用程序进行分层，开发者可以自主选择组件。

MVC：Struts2、Spring MVC

ORMapping：Hibernate、MyBatis、Spring Data  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_Q1NETiBAbW9ua2V5aGxq_size_21_color_FFFFFF_t_70_g_se_x_16]  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_Q1NETiBAbW9ua2V5aGxq_size_28_color_FFFFFF_t_70_g_se_x_16]  
**Spring体系结构：**  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_Q1NETiBAbW9ua2V5aGxq_size_17_color_FFFFFF_t_70_g_se_x_16]  
图中将spring分为5个部分：core、aop、data access、web、test，图中每个圆角矩形都对应一个jar，如果在maven中配置，所有这些jar的“groupId”都是“org.springframework”，每个jar有一个不同的“artifactId”，另外，“instrumentation”有两个jar，还有一个“spring-context-support”图中没有列出，所以spring3的jar包一共是19个。  
【参见】[https://www.cnblogs.com/Zz-maker/p/11199331.html][https_www.cnblogs.com_Zz-maker_p_11199331.html]  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_Q1NETiBAbW9ua2V5aGxq_size_20_color_FFFFFF_t_70_g_se_x_16]  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_Q1NETiBAbW9ua2V5aGxq_size_28_color_FFFFFF_t_70_g_se_x_16 1]  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_Q1NETiBAbW9ua2V5aGxq_size_26_color_FFFFFF_t_70_g_se_x_16]

## 如何使用 IoC ##

*  创建 Maven 工程，pom.xml 添加依赖

<?xml version="1.0" encoding="UTF-8"?>
    <project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
        <modelVersion>4.0.0</modelVersion>
    
        <groupId>com.southwind</groupId>
        <artifactId>aispringioc</artifactId>
        <version>1.0-SNAPSHOT</version>
    
        <dependencies>
            <dependency>
                <groupId>org.springframework</groupId>
                <artifactId>spring-context</artifactId>
                <version>5.0.11.RELEASE</version>
            </dependency>
        </dependencies>
    
    </project>

*  创建实体类 Student

package com.southwind.entity;
    
    import lombok.Data;
    
    @Data
    public class Student { 
        private long id;
        private String name;
        private int age;
    }

*  传统的开发方式，手动 new Student

Student student = new Student();
    student.setId(1L);
    student.setName("张三");
    student.setAge(22);
    System.out.println(student);

*  通过 IoC 创建对象，在配置文件中添加需要管理的对象，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:p="http://www.springframework.org/schema/p" xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-3.2.xsd http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-4.3.xsd ">
    
        <bean id="student" class="com.southwind.entity.Student">
            <property name="id" value="1"></property>
            <property name="name" value="张三"></property>
            <property name="age" value="22"></property>
        </bean>
    
    </beans>

*  从 IoC 中获取对象，通过 id 获取。

//加载配置文件
    ApplicationContext applicationContext = new ClassPathXmlApplicationContext("spring.xml");
    Student student = (Student) applicationContext.getBean("student");
    System.out.println(student);

### 配置文件 ###

*  通过配置 `bean` 标签来完成对象的管理。
    
     *  `id`：对象名。
     *  `class`：对象的模版类（所有交给 IoC 容器来管理的类必须有无参构造函数，因为 Spring 底层是通过反射机制来创建对象，调用的是无参构造）
 *  对象的成员变量通过 `property` 标签完成赋值。
    
     *  `name`：成员变量名。
     *  `value`：成员变量值（基本数据类型，String 可以直接赋值，如果是其他引用类型，不能通过 value 赋值）
     *  `ref`：将 IoC 中的另外一个 bean 赋给当前的成员变量（DI）
    
        <bean id="student" class="com.southwind.entity.Student">
            <property name="id" value="1"></property>
            <property name="name" value="张三"></property>
            <property name="age" value="22"></property>
            <property name="address" ref="address"></property>
        </bean>
        
        <bean id="address" class="com.southwind.entity.Address">
            <property name="id" value="1"></property>
            <property name="name" value="科技路"></property>
        </bean>

### IoC 底层原理 ###

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

*  读取配置文件，解析 XML。
 *  通过反射机制实例化配置文件中所配置所有的 bean。

package com.southwind.ioc;
    
    import org.dom4j.Document;
    import org.dom4j.DocumentException;
    import org.dom4j.Element;
    import org.dom4j.io.SAXReader;
    
    import java.lang.reflect.Constructor;
    import java.lang.reflect.Field;
    import java.lang.reflect.InvocationTargetException;
    import java.lang.reflect.Method;
    import java.util.HashMap;
    import java.util.Iterator;
    import java.util.Map;
    
    public class ClassPathXmlApplicationContext implements ApplicationContext { 
        private Map<String,Object> ioc = new HashMap<String, Object>();
        public ClassPathXmlApplicationContext(String path){ 
            try { 
                SAXReader reader = new SAXReader();
                Document document = reader.read("./src/main/resources/"+path);
                Element root = document.getRootElement();
                Iterator<Element> iterator = root.elementIterator();
                while(iterator.hasNext()){ 
                    Element element = iterator.next();
                    String id = element.attributeValue("id");
                    String className = element.attributeValue("class");
                    //通过反射机制创建对象
                    Class clazz = Class.forName(className);
                    //获取无参构造函数，创建目标对象
                    Constructor constructor = clazz.getConstructor();
                    Object object = constructor.newInstance();
                    //给目标对象赋值
                    Iterator<Element> beanIter = element.elementIterator();
                    while(beanIter.hasNext()){ 
                        Element property = beanIter.next();
                        String name = property.attributeValue("name");
                        String valueStr = property.attributeValue("value");
                        String ref = property.attributeValue("ref");
                        if(ref == null){ 
                            String methodName = "set"+name.substring(0,1).toUpperCase()+name.substring(1);
                            Field field = clazz.getDeclaredField(name);
                            Method method = clazz.getDeclaredMethod(methodName,field.getType());
                            //根据成员变量的数据类型将 value 进行转换
                            Object value = null;
                            if(field.getType().getName() == "long"){ 
                                value = Long.parseLong(valueStr);
                            }
                            if(field.getType().getName() == "java.lang.String"){ 
                                value = valueStr;
                            }
                            if(field.getType().getName() == "int"){ 
                                value = Integer.parseInt(valueStr);
                            }
                            method.invoke(object,value);
                        }
                        ioc.put(id,object);
                    }
                }
            } catch (DocumentException e) { 
                e.printStackTrace();
            } catch (ClassNotFoundException e){ 
                e.printStackTrace();
            } catch (NoSuchMethodException e){ 
                e.printStackTrace();
            } catch (InstantiationException e){ 
                e.printStackTrace();
            } catch (IllegalAccessException e){ 
                e.printStackTrace();
            } catch (InvocationTargetException e){ 
                e.printStackTrace();
            } catch (NoSuchFieldException e){ 
                e.printStackTrace();
            }
        }
    
        public Object getBean(String id) { 
            return ioc.get(id);
        }
    }

### 通过运行时类获取 bean ###

ApplicationContext applicationContext = new ClassPathXmlApplicationContext("spring.xml");
    Student student = (Student) applicationContext.getBean(Student.class);
    System.out.println(student);

这种方式存在一个问题，配置文件中一个数据类型的对象只能有一个实例，否则会抛出异常，因为没有唯一的 bean。

### 通过有参构造创建 bean ###

*  在实体类中创建对应的有参构造函数。
 *  配置文件

### 给 bean 注入集合 ###

### scope 作用域 ###

Spring 管理的 bean 是根据 scope 来生成的，表示 bean 的作用域，共4种，默认值是 singleton。

*  singleton：单例，表示通过 IoC 容器获取的 bean 是唯一的。
 *  prototype：原型，表示通过 IoC 容器获取的 bean 是不同的。
 *  request：请求，表示在一次 HTTP 请求内有效。
 *  session：会话，表示在一个用户会话内有效。

request 和 session 只适用于 Web 项目，大多数情况下，使用单例和原型较多。

prototype 模式当业务代码获取 IoC 容器中的 bean 时，Spring 才去调用无参构造创建对应的 bean。

singleton 模式无论业务代码是否获取 IoC 容器中的 bean，Spring 在加载 spring.xml 时就会创建 bean。

### Spring 的继承 ###

与 Java 的继承不同，Java 是类层面的继承，子类可以继承父类的内部结构信息；Spring 是对象层面的继承，子对象可以继承父对象的属性值。

Spring 的继承关注点在于具体的对象，而不在于类，即不同的两个类的实例化对象可以完成继承，前提是子对象必须包含父对象的所有属性，同时可以在此基础上添加其他的属性。

### Spring 的依赖 ###

与继承类似，依赖也是描述 bean 和 bean 之间的一种关系，配置依赖之后，被依赖的 bean 一定先创建，再创建依赖的 bean，A 依赖于 B，先创建 B，再创建 A。

<?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-3.2.xsd ">
    
        <bean id="student" class="com.southwind.entity.Student" depends-on="user"></bean>
    
        <bean id="user" class="com.southwind.entity.User"></bean>
    
    </beans>

### Spring 的 p 命名空间 ###

p 命名空间是对 IoC / DI 的简化操作，使用 p 命名空间可以更加方便的完成 bean 的配置以及 bean 之间的依赖注入。

<?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:p="http://www.springframework.org/schema/p" xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-3.2.xsd http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-4.3.xsd ">
    
        <bean id="student" class="com.southwind.entity.Student" p:id="1" p:name="张三" p:age="22" p:address-ref="address"></bean>
    
        <bean id="address" class="com.southwind.entity.Address" p:id="2" p:name="科技路"></bean>
    
    </beans>

### Spring 的工厂方法 ###

IoC 通过工厂模式创建 bean 的方式有两种：

*  静态工厂方法
 *  实例工厂方法

> 静态工厂方法

package com.southwind.entity;
    
    import lombok.AllArgsConstructor;
    import lombok.Data;
    import lombok.NoArgsConstructor;
    
    @Data
    @AllArgsConstructor
    @NoArgsConstructor
    public class Car { 
        private long id;
        private String name;
    }

package com.southwind.factory;
    
    import com.southwind.entity.Car;
    
    import java.util.HashMap;
    import java.util.Map;
    
    public class StaticCarFactory { 
        private static Map<Long, Car> carMap;
        static{ 
            carMap = new HashMap<Long, Car>();
            carMap.put(1L,new Car(1L,"宝马"));
            carMap.put(2L,new Car(2L,"奔驰"));
        }
    
        public static Car getCar(long id){ 
            return carMap.get(id);
        }
    }

<bean id="car" class="com.southwind.factory.StaticCarFactory" factory-method="getCar">
        <constructor-arg value="2"></constructor-arg>
    </bean>

> 实例工厂方法

package com.southwind.factory;
    
    import com.southwind.entity.Car;
    
    import java.util.HashMap;
    import java.util.Map;
    
    public class InstanceCarFactory { 
        private Map<Long, Car> carMap;
        public InstanceCarFactory(){ 
            carMap = new HashMap<Long, Car>();
            carMap.put(1L,new Car(1L,"宝马"));
            carMap.put(2L,new Car(2L,"奔驰"));
        }
    
        public Car getCar(long id){ 
            return carMap.get(id);
        }
    }

<bean id="carFactory" class="com.southwind.factory.InstanceCarFactory"></bean>
    
    
    <bean id="car2" factory-bean="carFactory" factory-method="getCar">
        <constructor-arg value="1"></constructor-arg>
    </bean>

### IoC 自动装载（Autowire） ###

IoC 负责创建对象，DI 负责完成对象的依赖注入，通过配置 property 标签的 ref 属性来完成，同时 Spring 提供了另外一种更加简便的依赖注入方式：自动装载，不需要手动配置 property，IoC 容器会自动选择 bean 完成注入。

自动装载有两种方式：

*  byName：通过属性名自动装载
 *  byType：通过属性的数据类型自动装载

> byName

> byType

byType 需要注意，如果同时存在两个及以上的符合条件的 bean 时，自动装载会抛出异常。

## AOP ##

AOP：Aspect Oriented Programming 面向切面编程。

AOP 的优点：

*  降低模块之间的耦合度。
 *  使系统更容易扩展。
 *  更好的代码复用。
 *  非业务代码更加集中，不分散，便于统一管理。
 *  业务代码更加简洁存粹，不参杂其他代码的影响。

AOP 是对面向对象编程的一个补充，在运行时，动态地将代码切入到类的指定方法、指定位置上的编程思想就是面向切面编程。将不同方法的同一个位置抽象成一个切面对象，对该切面对象进行编程就是 AOP。  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_Q1NETiBAbW9ua2V5aGxq_size_19_color_FFFFFF_t_70_g_se_x_16]  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_Q1NETiBAbW9ua2V5aGxq_size_27_color_FFFFFF_t_70_g_se_x_16]

### 如何使用AOP ###

*  创建 Maven 工程，pom.xml 添加

<dependencies>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-context</artifactId>
            <version>5.0.11.RELEASE</version>
        </dependency>
        
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-aop</artifactId>
            <version>5.0.11.RELEASE</version>
        </dependency>
    
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-aspects</artifactId>
            <version>5.0.11.RELEASE</version>
        </dependency>
    </dependencies>

*  创建一个计算器接口 Cal，定义4个方法。

package com.southwind.utils;
    
    public interface Cal { 
        public int add(int num1,int num2);
        public int sub(int num1,int num2);
        public int mul(int num1,int num2);
        public int div(int num1,int num2);
    }

*  创建接口的实现类 CalImpl。

package com.southwind.utils.impl;
    
    import com.southwind.utils.Cal;
    
    public class CalImpl implements Cal { 
        public int add(int num1, int num2) { 
            System.out.println("add方法的参数是["+num1+","+num2+"]");
            int result = num1+num2;
            System.out.println("add方法的结果是"+result);
            return result;
        }
    
        public int sub(int num1, int num2) { 
            System.out.println("sub方法的参数是["+num1+","+num2+"]");
            int result = num1-num2;
            System.out.println("sub方法的结果是"+result);
            return result;
        }
    
        public int mul(int num1, int num2) { 
            System.out.println("mul方法的参数是["+num1+","+num2+"]");
            int result = num1*num2;
            System.out.println("mul方法的结果是"+result);
            return result;
        }
    
        public int div(int num1, int num2) { 
            System.out.println("div方法的参数是["+num1+","+num2+"]");
            int result = num1/num2;
            System.out.println("div方法的结果是"+result);
            return result;
        }
    }

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_Q1NETiBAbW9ua2V5aGxq_size_32_color_FFFFFF_t_70_g_se_x_16]  
上述代码中，日志信息和业务逻辑的耦合性很高，不利于系统的维护，使用 AOP 可以进行优化，如何来实现 AOP？使用动态代理的方式来实现。

给业务代码找一个代理，打印日志信息的工作交个代理来做，这样的话业务代码就只需要关注自身的业务即可。

package com.southwind.utils;
    
    import java.lang.reflect.InvocationHandler;
    import java.lang.reflect.Method;
    import java.lang.reflect.Proxy;
    import java.util.Arrays;
    
    public class MyInvocationHandler implements InvocationHandler { 
        //接收委托对象
        private Object object = null;
    
        //返回代理对象
        public Object bind(Object object){ 
            this.object = object;
            return Proxy.newProxyInstance(object.getClass().getClassLoader(),object.getClass().getInterfaces(),this);
        }
    
        public Object invoke(Object proxy, Method method, Object[] args) throws Throwable { 
            System.out.println(method.getName()+"方法的参数是："+ Arrays.toString(args));
            Object result = method.invoke(this.object,args);
            System.out.println(method.getName()+"的结果是"+result);
            return result;
        }
    }

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_Q1NETiBAbW9ua2V5aGxq_size_36_color_FFFFFF_t_70_g_se_x_16]  
以上是通过动态代理实现 AOP 的过程，比较复杂，不好理解，Spring 框架对 AOP 进行了封装，使用 Spring 框架可以用面向对象的思想来实现 AOP。

Spring 框架中不需要创建 InvocationHandler，只需要创建一个切面对象，将所有的非业务代码在切面对象中完成即可，Spring 框架底层会自动根据切面类以及目标类生成一个代理对象。

LoggerAspect

package com.southwind.aop;
    
    import org.aspectj.lang.JoinPoint;
    import org.aspectj.lang.annotation.*;
    import org.springframework.stereotype.Component;
    
    import java.util.Arrays;
    
    @Aspect
    @Component
    public class LoggerAspect { 
    
        @Before(value = "execution(public int com.southwind.utils.impl.CalImpl.*(..))")
        public void before(JoinPoint joinPoint){ 
            //获取方法名
            String name = joinPoint.getSignature().getName();
            //获取参数
            String args = Arrays.toString(joinPoint.getArgs());
            System.out.println(name+"方法的参数是："+ args);
        }
    
        @After(value = "execution(public int com.southwind.utils.impl.CalImpl.*(..))")
        public void after(JoinPoint joinPoint){ 
            //获取方法名
            String name = joinPoint.getSignature().getName();
            System.out.println(name+"方法执行完毕");
        }
    
        @AfterReturning(value = "execution(public int com.southwind.utils.impl.CalImpl.*(..))",returning = "result")
        public void afterReturning(JoinPoint joinPoint,Object result){ 
            //获取方法名
            String name = joinPoint.getSignature().getName();
            System.out.println(name+"方法的结果是"+result);
        }
    
        @AfterThrowing(value = "execution(public int com.southwind.utils.impl.CalImpl.*(..))",throwing = "exception")
        public void afterThrowing(JoinPoint joinPoint,Exception exception){ 
            //获取方法名
            String name = joinPoint.getSignature().getName();
            System.out.println(name+"方法抛出异常："+exception);
        }
    
    }

LoggerAspect 类定义处添加的两个注解：

*  `@Aspect`：表示该类是切面类。
 *  `@Component`：将该类的对象注入到 IoC 容器。

具体方法处添加的注解：

`@Before`：表示方法执行的具体位置和时机。

CalImpl 也需要添加 `@Component`，交给 IoC 容器来管理。

package com.southwind.utils.impl;
    
    import com.southwind.utils.Cal;
    import org.springframework.stereotype.Component;
    
    @Component
    public class CalImpl implements Cal { 
        public int add(int num1, int num2) { 
            int result = num1+num2;
            return result;
        }
    
        public int sub(int num1, int num2) { 
            int result = num1-num2;
            return result;
        }
    
        public int mul(int num1, int num2) { 
            int result = num1*num2;
            return result;
        }
    
        public int div(int num1, int num2) { 
            int result = num1/num2;
            return result;
        }
    }

spring.xml 中配置 AOP。

<?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:aop="http://www.springframework.org/schema/aop" xmlns:p="http://www.springframework.org/schema/p" xsi:schemaLocation="http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-4.3.xsd http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-4.3.xsd http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-4.3.xsd ">
    
        
        <context:component-scan base-package="com.southwind"></context:component-scan>
    
        
        <aop:aspectj-autoproxy></aop:aspectj-autoproxy>
    
    </beans>

`context:component-scan` 将 `com.southwind` 包中的所有类进行扫描，如果该类同时添加了 `@Component`，则将该类扫描到 IoC 容器中，即 IoC 管理它的对象。

`aop:aspectj-autoproxy` 让 Spring 框架结合切面类和目标类自动生成动态代理对象。

*  切面：横切关注点被模块化的抽象对象。
 *  通知：切面对象完成的工作。
 *  目标：被通知的对象，即被横切的对象。
 *  代理：切面、通知、目标混合之后的对象。
 *  连接点：通知要插入业务代码的具体位置。
 *  切点：AOP 通过切点定位到连接点。

测试：

public static void main(String[] args){ 
    	//加载配置文件
    	ApplicationContext applicationContext = new ClassPathXmlApplicationContext("spring.xml");
    	//获取代理对象
    	Cal proxy = (Cal)applicationContext.getBean("calImpl");
    	proxy.add(1,1);
    	proxy.sub(2,1);
    }

【代码来源】参考楠哥教学视频：[https://www.bilibili.com/video/BV1Gt411N7HF][https_www.bilibili.com_video_BV1Gt411N7HF]

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_Q1NETiBAbW9ua2V5aGxq_size_21_color_FFFFFF_t_70_g_se_x_16]: /images/20220829/67640e3900c1468a82ce0f2ba7448772.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_Q1NETiBAbW9ua2V5aGxq_size_28_color_FFFFFF_t_70_g_se_x_16]: /images/20220829/f56c70a802fe4b018006df92bb6954ae.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_Q1NETiBAbW9ua2V5aGxq_size_17_color_FFFFFF_t_70_g_se_x_16]: /images/20220829/e4306e33e5484c468df4822a2143b9bd.png
[https_www.cnblogs.com_Zz-maker_p_11199331.html]: https://www.cnblogs.com/Zz-maker/p/11199331.html
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_Q1NETiBAbW9ua2V5aGxq_size_20_color_FFFFFF_t_70_g_se_x_16]: /images/20220829/c75f8780dde7423ba4df8bcd567d1030.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_Q1NETiBAbW9ua2V5aGxq_size_28_color_FFFFFF_t_70_g_se_x_16 1]: /images/20220829/5cee7edbbcd944f0aa8339efebcc57f0.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_Q1NETiBAbW9ua2V5aGxq_size_26_color_FFFFFF_t_70_g_se_x_16]: /images/20220829/e919343a4dff4e7495d1b72d00bdb86f.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_Q1NETiBAbW9ua2V5aGxq_size_15_color_FFFFFF_t_70_g_se_x_16]: /images/20220829/e7a38caba2c04299b647f961e03e942e.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_Q1NETiBAbW9ua2V5aGxq_size_19_color_FFFFFF_t_70_g_se_x_16]: /images/20220829/c3a2994eeb1246b8bfa3659b1fe9a947.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_Q1NETiBAbW9ua2V5aGxq_size_27_color_FFFFFF_t_70_g_se_x_16]: /images/20220829/d1cc0eb6588549caa910de65201d2091.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_Q1NETiBAbW9ua2V5aGxq_size_32_color_FFFFFF_t_70_g_se_x_16]: /images/20220829/cb7e95ac9b794a10bea0445d761ac73d.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_Q1NETiBAbW9ua2V5aGxq_size_36_color_FFFFFF_t_70_g_se_x_16]: /images/20220829/512cdbab58374014979d856a794cc337.png
[https_www.bilibili.com_video_BV1Gt411N7HF]: https://www.bilibili.com/video/BV1Gt411N7HF