Spring框架学习1：Spring 集成 MyBatis、Spring 事务、Spring 与 Web

冷不防 2023-10-14 09:00 95阅读 0赞

## Spring 集成 MyBatis ##

将 MyBatis 与 Spring 进行整合，主要解决的问题就是将 SqlSessionFactory 对象交由 Spring来管理。所以，该整合，只需要将 SqlSessionFactory 的对象生成器 SqlSessionFactoryBean 注册在 Spring 容器中，再将其注入给 Dao 的实现类即可完成整合。

实现 Spring 与 MyBatis 的整合常用的方式：扫描的 Mapper 动态代理

Spring 像插线板一样，mybatis 框架是插头，可以容易的组合到一起。插线板 spring 插 上 mybatis，两个框架就是一个整体。

#### MySQL 创建数据库 springdb,新建表 Student ####

![format_png][]

#### maven 依赖 pom.xml ####

<dependency> 
        <groupId>junit</groupId> 
        <artifactId>junit</artifactId>
         <version>4.11</version>
         <scope>test</scope>
    </dependency>
    
    <dependency> 
        <groupId>org.springframework</groupId> 
        <artifactId>spring-context</artifactId> 
        <version>5.2.5.RELEASE</version>
    </dependency>
    
    <dependency>
        <groupId>org.springframework</groupId> 
        <artifactId>spring-tx</artifactId> 
        <version>5.2.5.RELEASE</version>
    </dependency>
    
    <dependency> 
        <groupId>org.springframework</groupId>
         <artifactId>spring-jdbc</artifactId> 
        <version>5.2.5.RELEASE</version>
    </dependency>
    
    <dependency>
         <groupId>org.mybatis</groupId> 
        <artifactId>mybatis</artifactId>
         <version>3.5.1</version>
    </dependency>
    
    <dependency>
         <groupId>org.mybatis</groupId>
         <artifactId>mybatis-spring</artifactId> 
        <version>1.3.1</version>
    </dependency>
    
    <dependency> 
        <groupId>mysql</groupId>
         <artifactId>mysql-connector-java</artifactId> 
        <version>5.1.9</version>
    </dependency>
    
    <dependency> 
        <groupId>com.alibaba</groupId> 
        <artifactId>druid</artifactId> 
        <version>1.1.12</version>
    </dependency>

插件：

<build>
         <resources>
             <resource>
                 <directory>src/main/java</directory>
                 <includes>
                     <include>**/*.properties</include>
                     <include>**/*.xml</include>
                 </includes>
                 <filtering>false</filtering>
             </resource>
        </resources>
    
        <plugins>
             <plugin>
                 <artifactId>maven-compiler-plugin</artifactId>
                 <version>3.1</version>
                 <configuration>
                     <source>1.8</source>
                     <target>1.8</target>
                 </configuration>
             </plugin>
         </plugins>
     </build>

#### 定义实体类 Student ####

![format_png 1][]

#### 定义 StudentDao 接口 ####

![format_png 2][]

#### 定义映射文件 mapper ####

在 Dao 接口的包中创建 MyBatis 的映射文件 mapper，命名与接口名相同，本例为StudentDao.xml。mapper 中的 namespace 取值也为 Dao 接口的全限定性名。

![format_png 3][]

#### 定义 Service 接口和实现类 ####

接口定义：

![format_png 4][]

实现类定义：

![format_png 5][]

#### 定义 MyBatis 主配置文件 ####

在 src 下定义 MyBatis 的主配置文件，命名为 mybatis.xml。  
这里有两点需要注意：  
（1）主配置文件中不再需要数据源的配置了。因为数据源要交给 Spring 容器来管理了。  
（2）这里对 mapper 映射文件的注册，使用<package/>标签，即只需给出 mapper 映射文件所在的包即可。因为 mapper 的名称与 Dao 接口名相同，可以使用这种简单注册方式。这种方式的好处是，若有多个映射文件，这里的配置也是不用改变的。当然，也可使用原来的<resource/>标签方式。

![format_png 6][]

#### 修改 Spring 配置文件 ####

**（1） 数据源的配置(掌握)**  
使用 JDBC 模板，首先需要配置好数据源，数据源直接以 Bean 的形式配置在 Spring 配置文件中。根据数据源的不同，其配置方式不同：

Druid 数据源 DruidDataSource  
Druid 是阿里的开源数据库连接池。是 Java 语言中最好的数据库连接池。Druid 能够提供强大的监控和扩展功能。Druid 与其他数据库连接池的最大区别是提供数据库的

![format_png 7][]

#### Spring 配置文件： ####

![format_png 8][]

**（2） 从属性文件读取数据库连接信息**  
为了便于维护，可以将数据库连接信息写入到属性文件中，使 Spring 配置文件从中读取数据。  
属性文件名称自定义，但一般都是放在 src 下。

![format_png 9][]

Spring 配置文件从属性文件中读取数据时，需要在<property/>的 value 属性中使用$\{ \}，将在属性文件中定义的 key 括起来，以引用指定属性的值。

![format_png 10][]

该属性文件若要被 Spring 配置文件读取，其必须在配置文件中进行注册。使用<context>标签。

<context:property-placeholder/>方式(掌握)  
该方式要求在 Spring 配置文件头部加入 spring-context.xsd 约束文件

<context:property-placeholder/>标签中有一个属性 location，用于指定属性文件的位置。

![format_png 11][]

**（3） 注册 SqlSessionFactoryBean**

![format_png 12][]

**（4） 定义 Mapper 扫描配置器 MapperScannerConfigurer**  
Mapper 扫描配置器 MapperScannerConfigurer 会自动生成指定的基本包中 mapper 的代理对象。该 Bean 无需设置 id 属性。basePackage 使用分号或逗号设置多个包。

![format_png 13][]

#### 向 Service 注入接口名 ####

向 Service 注入 Mapper 代理对象时需要注意，由于通过 Mapper 扫描配置器MapperScannerConfigurer 生成的 Mapper 代理对象没有名称，所以在向 Service 注入 Mapper代理时，无法通过名称注入。但可通过接口的简单类名注入，因为生成的是这个 Dao 接口的对象。

![format_png 14][]

#### Spring 配置文件全部配置 ####

![format_png 15][]

## Spring 事务 ##

### Spring 的事务管理 ###

事务原本是数据库中的概念，在 Dao 层。但一般情况下，需要将事务提升到业务层，即 Service 层。这样做是为了能够使用事务的特性来管理具体的业务。  
在 Spring 中通常可以通过以下两种方式来实现对事务的管理：  
（1）使用 Spring 的事务注解管理事务  
（2）使用 AspectJ 的 AOP 配置管理事务

### Spring 事务管理 API ###

Spring 的事务管理，主要用到两个事务相关的接口。

#### （1） 事务管理器接口(重点) ####

事务管理器是 PlatformTransactionManager 接口对象。其主要用于完成事务的提交、回滚，及获取事务的状态信息。

![format_png 16][]

**A、常用的两个实现类**

PlatformTransactionManager 接口有两个常用的实现类：  
DataSourceTransactionManager：使用 JDBC 或 MyBatis 进行数据库操作时使用。  
HibernateTransactionManager：使用 Hibernate 进行持久化数据时使用。

**B、 Spring 的回滚方式(理解)**

Spring 事务的默认回滚方式是：发生运行时异常和 error 时回滚，发生受查(编译)异常时提交。不过，对于受查异常，程序员也可以手工设置其回滚方式。

**C、 回顾错误与异常(理解)**

![format_png 17][]

Throwable 类是 Java 语言中所有错误或异常的超类。只有当对象是此类(或其子类之一)的实例时，才能通过 Java 虚拟机或者 Java 的 throw 语句抛出。

Error 是程序在运行过程中出现的无法处理的错误，比如 OutOfMemoryError、ThreadDeath、NoSuchMethodError 等。当这些错误发生时，程序是无法处理（捕获或抛出）的，JVM 一般会终止线程。

程序在编译和运行时出现的另一类错误称之为异常，它是 JVM 通知程序员的一种方式。通过这种方式，让程序员知道已经或可能出现错误，要求程序员对其进行处理。

异常分为运行时异常与受查异常。

运行时异常，是 RuntimeException 类或其子类，即只有在运行时才出现的异常。如，NullPointerException、ArrayIndexOutOfBoundsException、IllegalArgumentException 等均属于运行时异常。这些异常由 JVM 抛出，在编译时不要求必须处理（捕获或抛出）。但，只要代码编写足够仔细，程序足够健壮，运行时异常是可以避免的。

受查异常，也叫编译时异常，即在代码编写时要求必须捕获或抛出的异常，若不处理，则无法通过编译。如 SQLException，ClassNotFoundException，IOException 等都属于受查异常。

RuntimeException 及其子类以外的异常，均属于受查异常。当然，用户自定义的 Exception的子类，即用户自定义的异常也属受查异常。程序员在定义异常时，只要未明确声明定义的为 RuntimeException 的子类，那么定义的就是受查异常。

#### （2） 事务定义接口 ####

事务定义接口 TransactionDefinition 中定义了事务描述相关的三类常量：事务隔离级别、事务传播行为、事务默认超时时限，及对它们的操作。

![format_png 18][]

**A、定义了五个事务隔离级别常量(掌握)**

这些常量均是以 ISOLATION\_开头。即形如 ISOLATION\_XXX。

DEFAULT：采用 DB 默认的事务隔离级别。MySql 的默认为 REPEATABLE\_READ； Oracle默认为 READ\_COMMITTED。 READ\_UNCOMMITTED：读未提交。未解决任何并发问题。  
READ\_COMMITTED：读已提交。解决脏读，存在不可重复读与幻读。  
REPEATABLE\_READ：可重复读。解决脏读、不可重复读，存在幻读  
SERIALIZABLE：串行化。不存在并发问题。

**B、 定义了七个事务传播行为常量(掌握)**

所谓事务传播行为是指，处于不同事务中的方法在相互调用时，执行期间事务的维护情况。如，A 事务中的方法 doSome()调用 B 事务中的方法 doOther()，在调用执行期间事务的维护情况，就称为事务传播行为。事务传播行为是加在方法上的。

事务传播行为常量都是以 PROPAGATION\_ 开头，形如 PROPAGATION\_XXX。

PROPAGATION\_REQUIRED  
PROPAGATION\_REQUIRES\_NEW  
PROPAGATION\_SUPPORTS

PROPAGATION\_MANDATORY  
PROPAGATION\_NESTED  
PROPAGATION\_NEVER  
PROPAGATION\_NOT\_SUPPORTED

**a、 PROPAGATION\_REQUIRED：**

指定的方法必须在事务内执行。若当前存在事务，就加入到当前事务中；若当前没有事务，则创建一个新事务。这种传播行为是最常见的选择，也是 Spring 默认的事务传播行为。

如该传播行为加在 doOther()方法上。若 doSome()方法在调用 doOther()方法时就是在事务内运行的，则 doOther()方法的执行也加入到该事务内执行。若 doSome()方法在调用doOther()方法时没有在事务内执行，则 doOther()方法会创建一个事务，并在其中执行。

![format_png 19][]

**b、PROPAGATION\_SUPPORTS**

指定的方法支持当前事务，但若当前没有事务，也可以以非事务方式执行。

![format_png 20][]

**c、 PROPAGATION\_REQUIRES\_NEW**

总是新建一个事务，若当前存在事务，就将当前事务挂起，直到新事务执行完毕。

![format_png 21][]

**C、 定义了默认事务超时时限**

常量 TIMEOUT\_DEFAULT 定义了事务底层默认的超时时限，sql 语句的执行时长。  
注意，事务的超时时限起作用的条件比较多，且超时的时间计算点较复杂。所以，该值一般就使用默认值即可。

### 程序举例环境搭建 ###

举例：购买商品 trans\_sale 项目  
本例要实现购买商品，模拟用户下订单，向订单表添加销售记录，从商品表减少库存。

实现步骤：

Step0：创建数据库表

创建两个数据库表 sale , goods  
sale 销售表

![format_png 22][]

goods 商品表

![format_png 23][]

goods 表数据

![format_png 24][]

Step1: maven 依赖 pom.xml

<dependency> 
        <groupId>junit</groupId> 
        <artifactId>junit</artifactId>
         <version>4.11</version> 
        <scope>test</scope>
    </dependency>
    
    <dependency> 
        <groupId>org.springframework</groupId> 
        <artifactId>spring-context</artifactId> 
        <version>5.2.5.RELEASE</version>
    </dependency>
    
    <dependency>
        <groupId>org.springframework</groupId>
         <artifactId>spring-tx</artifactId> 
        <version>5.2.5.RELEASE</version>
    </dependency>
    
    <dependency>
         <groupId>org.springframework</groupId> 
        <artifactId>spring-jdbc</artifactId> 
        <version>5.2.5.RELEASE</version>
    </dependency>
    
    <dependency>
         <groupId>org.mybatis</groupId> 
        <artifactId>mybatis</artifactId>
         <version>3.5.1</version>
    </dependency>
    
    <dependency> 
        <groupId>org.mybatis</groupId> 
        <artifactId>mybatis-spring</artifactId>
         <version>1.3.1</version>
    </dependency>
    
    <dependency>
         <groupId>mysql</groupId>
         <artifactId>mysql-connector-java</artifactId> 
        <version>5.1.9</version>
    </dependency>
    
    <dependency> 
        <groupId>com.alibaba</groupId>
         <artifactId>druid</artifactId>
         <version>1.1.12</version>
    </dependency>

插件

<build>
         <resources>
             <resource>
                 <directory>src/main/java</directory>
                 <includes>
                     <include>**/*.properties</include>
                     <include>**/*.xml</include>
                 </includes>
                 <filtering>false</filtering>
             </resource>
         </resources>
        <plugins>
             <plugin>
                 <artifactId>maven-compiler-plugin</artifactId>
                 <version>3.1</version>
                 <configuration>
                     <source>1.8</source>
                     <target>1.8</target>
                 </configuration>
             </plugin>
         </plugins>
    </build>

Step2：创建实体类

创建实体类 Sale 与 Goods

![format_png 25][]

Step3：定义 dao 接口

定义两个 dao 的接口 SaleDao , GoodsDao

![format_png 26][]

Step4：定义 dao 接口对应的 sql 映射文件

SaleDao.xml

![format_png 27][]

GoodsDao.xml

![format_png 28][]

Step5：定义异常类

定义 service 层可能会抛出的异常类 NotEnoughException

![format_png 29][]

Step6：定义 Service 接口

定义 Service 接口 BuyGoodsService

![format_png 30][]

Step7：定义 service 的实现类

定义 service 层接口的实现类 BuyGoodsServiceImpl

1.类定义

![format_png 31][]

2.Dao 属性

![format_png 32][]

3. Buy 方法

![format_png 33][]

Step8：修改 Spring 配置文件内容

声明 Mybatis 对象

![format_png 34][]

声明业务层对象

![format_png 35][]

Step9：定义测试类

定义测试类 MyTest。现在就可以在无事务代理的情况下运行了。

![format_png 36][]

### 使用 Spring 的事务注解管理事务(掌握) ###

通过@Transactional 注解方式，可将事务织入到相应 public 方法中，实现事务管理。

@Transactional 的所有可选属性如下所示：  
➢ propagation：用于设置事务传播属性。该属性类型为 Propagation 枚举，默认值为Propagation.REQUIRED。  
➢ isolation：用于设置事务的隔离级别。该属性类型为 Isolation 枚举，默认值为Isolation.DEFAULT。  
➢ readOnly：用于设置该方法对数据库的操作是否是只读的。该属性为 boolean，默认值为 false。  
➢ timeout：用于设置本操作与数据库连接的超时时限。单位为秒，类型为 int，默认值为-1，即没有时限。  
➢ rollbackFor：指定需要回滚的异常类。类型为 Class\[\]，默认值为空数组。当然，若只有一个异常类时，可以不使用数组。  
➢ rollbackForClassName：指定需要回滚的异常类类名。类型为 String\[\]，默认值为空数组。当然，若只有一个异常类时，可以不使用数组。  
➢ noRollbackFor：指定不需要回滚的异常类。类型为 Class\[\]，默认值为空数组。当然，若只有一个异常类时，可以不使用数组。  
➢ noRollbackForClassName：指定不需要回滚的异常类类名。类型为 String\[\]，默认值为空数组。当然，若只有一个异常类时，可以不使用数组。

需要注意的是，@Transactional 若用在方法上，只能用于 public 方法上。对于其他非 public方法，如果加上了注解@Transactional，虽然 Spring 不会报错，但不会将指定事务织入到该方法中。因为 Spring 会忽略掉所有非 public 方法上的@Transaction 注解。  
若@Transaction 注解在类上，则表示该类上所有的方法均将在执行时织入事务。

实现注解的事务步骤：  
复制 trans\_sale 项目，新项目 trans\_sale\_annotation

1.  声明事务管理器

![format_png 37][]

2. 开启注解驱动

![format_png 38][]

transaction-manager：事务管理器 bean 的 id

3.业务层 public 方法加入事务属性

![format_png 39][]

### 使用 AspectJ 的 AOP 配置管理事务(掌握) ###

使用 XML 配置事务代理的方式的不足是，每个目标类都需要配置事务代理。当目标类较多，配置文件会变得非常臃肿。

使用 XML 配置顾问方式可以自动为每个符合切入点表达式的类生成事务代理。其用法很简单，只需将前面代码中关于事务代理的配置删除，再替换为如下内容即可。

Step1：复制项目  
复制 trans\_sale 项目，并重命名为 trans\_sal\_aspectj。在此基础上修改。

Step2：maven 依赖 pom.xml

新加入 aspectj 的依赖坐标

<dependency> 
        <groupId>org.springframework</groupId> 
        <artifactId>spring-aspects</artifactId> 
        <version>5.2.5.RELEASE</version>
    </dependency>

Step3：在容器中添加事务管理器

![format_png 40][]

Step4：配置事务通知

为事务通知设置相关属性。用于指定要将事务以什么方式织入给哪些方法。  
例如，应用到 buy 方法上的事务要求是必须的，且当 buy 方法发生异常后要回滚业务。

![format_png 41][]

Step5：配置增强器

指定将配置好的事务通知，织入给谁。

![format_png 42][]

Step6：修改测试类

测试类中要从容器中获取的是目标对象。

![format_png 43][]

## Spring 与 Web ##

在 Web 项目中使用 Spring 框架，首先要解决在 web 层（这里指 Servlet）中获取到 Spring容器的问题。只要在 web 层获取到了 Spring 容器，便可从容器中获取到 Service 对象。

### Web 项目使用 Spring 的问题(了解) ###

举例：springWeb 项目（在 spring-mybatis 基础上修改）

Step1：新建一个 Maven Project

类型 maven-archetype-webapp

Step2: 复制代码，配置文件，jar

将 spring-mybatis 项目中以下内容复制到当前项目中：  
（1）Service 层、Dao 层全部代码  
（2）配置文件 applicationContext.xml 及 jdbc.properties，mybatis.xml  
（3）pom.xml  
（4）加入 servlet ,jsp 依赖

在之前原有的 pom.xml 文件中再加入以下的内容：

<dependency>
         <groupId>javax.servlet</groupId>
         <artifactId>javax.servlet-api</artifactId>
         <version>3.1.0</version>
         <scope>provided</scope>
    </dependency>
    
    
    <dependency> 
         <groupId>javax.servlet.jsp</groupId> 
         <artifactId>jsp-api</artifactId> 
         <version>2.2.1-b03</version> 
         <scope>provided</scope>
    </dependency>

Step3：定义 index 页面

![format_png 44][]

Step4：定义 RegisterServlet（重点代码）

![format_png 45][]

Step5：定义 success 页面

![format_png 46][]

Step6：web.xml 注册 Servlet

![format_png 47][]

![Image 1][]

image.png

Step7：运行结果分析

当表单提交，跳转到 success.jsp 后，多刷新几次页面，查看后台输出，发现每刷新一次页面，就 new 出一个新的 Spring 容器。即，每提交一次请求，就会创建一个新的 Spring 容器。对于一个应用来说，只需要一个 Spring 容器即可。所以，将 Spring 容器的创建语句放在 Servlet 的 doGet()或 doPost()方法中是有问题的。

![Image 1][]

![format_png 48][]

此时，可以考虑，将 Spring 容器的创建放在 Servlet 进行初始化时进行，即执行 init()方法时执行。并且，Servlet 还是单例多线程的，即一个业务只有一个 Servlet 实例，所有执行该业务的用户执行的都是这一个 Servlet 实例。这样，Spring 容器就具有了唯一性了。

但是，Servlet 是一个业务一个 Servlet 实例，即 LoginServlet 只有一个，但还会有StudentServlet、TeacherServlet 等。每个业务都会有一个 Servlet，都会执行自己的 init()方法，也就都会创建一个 Spring 容器了。这样一来，Spring 容器就又不唯一了。

### 使用 Spring 的监听器 ContextLoaderListener(掌握) ###

举例：springweb-2 项目（在 spring-web 项目基础上修改）

对于 Web 应用来说，ServletContext 对象是唯一的，一个 Web 应用，只有一个ServletContext 对象，该对象是在 Web 应用装载时初始化的。若将 Spring 容器的创建时机，放在 ServletContext 初始化时，就可以保证 Spring 容器的创建只会执行一次，也就保证了Spring 容器在整个应用中的唯一性。

当 Spring 容器创建好后，在整个应用的生命周期过程中，Spring 容器应该是随时可以被访问的。即，Spring 容器应具有全局性。而放入 ServletContext 对象的属性，就具有应用的全局性。所以，将创建好的 Spring 容器，以属性的形式放入到ServletContext 的空间中，就保证了 Spring 容器的全局性。

上述的这些工作，已经被封装在了如下的 Spring 的 Jar 包的相关 API 中：  
spring-web-5.2.5.RELEASE

Step1：maven 依赖 pom.xml

<dependency> 
        <groupId>org.springframework</groupId>
        <artifactId>spring-web</artifactId> 
        <version>5.2.5.RELEASE</version>
    </dependency>

Step2：注册监听器 ContextLoaderListener

若要在 ServletContext 初 始 化 时 创 建 Spring 容 器 ， 就 需 要 使 用 监 听 器 接 口ServletContextListener 对 ServletContext 进行监听。在 web.xml 中注册该监听器。

![format_png 49][]

Spring 为该监听器接口定义了一个实现类 ContextLoaderListener，完成了两个很重要的工作：创建容器对象，并将容器对象放入到了 ServletContext 的空间中。

打开 ContextLoaderListener 的源码。看到一共四个方法，两个是构造方法，一个初始化方法，一个销毁方法。

![format_png 50][]

所以，在这四个方法中较重要的方法应该就是 contextInitialized()，context 初始化方法。

![format_png 51][]

跟踪 initWebApplicationContext()方法，可以看到，在其中创建了容器对象。

![format_png 52][]

并且，将创建好的容器对象放入到了 ServletContext 的空间中，key 为一个常量：  
WebApplicationContext.ROOT\_WEB\_APPLICATION\_CONTEXT\_ATTRIBUTE。

![format_png 53][]

Step3：指定 Spring 配置文件的位置<context-param>

ContextLoaderListener 在对 Spring 容器进行创建时，需要加载 Spring 配置文件。其默认的 Spring 配置文件位置与名称为：WEB-INF/applicationContext.xml。但，一般会将该配置文件放置于项目的 classpath 下，即 src 下，所以需要在 web.xml 中对 Spring 配置文件的位置及名称进行指定。

![format_png 54][]

从监听器 ContextLoaderListener 的父类 ContextLoader 的源码中可以看到其要读取的配置文件位置参数名称 contextConfigLocation。

![format_png 55][]

Step4：获取 Spring 容器对象

在 Servlet 中获取容器对象的常用方式有两种：  
（1） 直接从 ServletContext 中获取

从对监听器 ContextLoaderListener 的源码分析可知，容器对象在 ServletContext 的中存放的 key 为 WebApplicationContext.ROOT\_WEB\_APPLICATION\_CONTEXT\_ATTRIBUTE。所以，可以直接通过 ServletContext 的 getAttribute()方法，按照指定的 key 将容器对象获取到。

![format_png 56][]

（2） 通过 WebApplicationContextUtils 获取

工具类 WebApplicationContextUtils 有一个方法专门用于从 ServletContext 中获取 Spring容器对象：getRequiredWebApplicationContext(ServletContext sc)

调用 Spring 提供的方法获取容器对象：

![format_png 57][]

查其源码，看其调用关系，就可看到其是从 ServletContext 中读取的属性值，即 Spring容器

![format_png 58][]

以上两种方式，无论使用哪种获取容器对象，刷新 success 页面后，可看到代码中使用的 Spring 容器均为同一个对象。

![format_png 59][]

## 总结 ##

spring全家桶：spring ， springmvc ，spring boot , spring cloud

spring: 出现是在2002左右，解决企业开发的难度。减轻对项目模块之间的管理，类和类之间的管理， 帮助开发人员创建对象，管理对象之间的关系。

spring核心技术 ioc ， aop 。能实现模块之间，类之间的解耦合。

依赖：class A中使用class B的属性或者方法， 叫做class A依赖class B

--------------------

框架怎么学： 框架是一个软件，其它人写好的软件。  
1）知道框架能做什么， mybatis--访问数据库， 对表中的数据执行增删改查。  
2）框架的语法， 框架要完成一个功能，需要一定的步骤支持的，  
3）框架的内部实现， 框架内部怎么做。 原理是什么。  
4）通过学习，可以实现一个框架。

spring的第一个核心功能 ioc

IoC (Inversion of Control) : 控制反转， 是一个理论，概念，思想。  
描述的：把对象的创建，赋值，管理工作都交给代码之外的容器实现， 也就是对象的创建是有其它外部资源完成。

控制： 创建对象，对象的属性赋值，对象之间的关系管理。  
反转： 把原来的开发人员管理，创建对象的权限转移给代码之外的容器实现。 由容器代替开发人员管理对象。创建对象，给属性赋值。

正转：由开发人员在代码中，使用new 构造方法创建对象， 开发人员主动管理对象。

public static void main(String args[]){
         Student student = new Student(); // 在代码中， 创建对象。--正转。
    }

容器：是一个服务器软件， 一个框架（spring）

为什么要使用 ioc ： 目的就是减少对代码的改动， 也能实现不同的功能。 实现解耦合。

java中创建对象有哪些方式：

1.  构造方法 ， new Student（）
2.  反射
3.  序列化
4.  克隆
5.  ioc ：容器创建对象
6.  动态代理

ioc的体现：  
servlet  
1： 创建类继承HttpServelt  
2: 在web.xml 注册servlet ， 使用  
<servlet-name> myservlet </servlet-name>  
<servelt-class>com.bjpwernode.controller.MyServlet1</servlet-class>

1.  没有创建 Servlet对象， 没有 MyServlet myservlet = new MyServlet()
2.  Servlet 是Tomcat服务器它能你创建的。 Tomcat也称为容器  
    Tomcat作为容器：里面存放的有Servlet对象， Listener ， Filter对象

IoC的技术实现 ，  
DI 是ioc的技术实现，  
DI（Dependency Injection） :依赖注入， 只需要在程序中提供要使用的对象名称就可以， 至于对象如何在容器中创建，赋值，查找都由容器内部实现。

spring是使用的di实现了ioc的功能， spring底层创建对象，使用的是反射机制。

spring是一个容器，管理对象，给属性赋值， 底层是反射创建对象。

spring-conetxt 和 spring-webmvc是spring中的两个模块

spring-context：是ioc功能的，创建对象的。  
spring-webmvc做web开发使用的， 是servlet的升级。  
spring-webmvc中也会用到spring-context中创建对象的功能的。

junit : 单元测试， 一个工具类库，做测试方法使用的。  
单元：指定的是方法， 一个类中有很多方法，一个方法称为单元。

使用单元测试  
1.需要加入junit依赖。

<dependency>
          <groupId>junit</groupId>
          <artifactId>junit</artifactId>
          <version>4.11</version>
          <scope>test</scope>
        </dependency>

2.创建测试作用的类：叫做测试类  
src/test/java目录中创建类

3.创建测试方法

1）public 方法  
2）没有返回值 void  
3）方法名称自定义，建议名称是test + 你要测试方法名称  
4）方法没有参数  
5）方法的上面加入 @Test ,这样的方法是可以单独执行的。 不用使用main方法。

--------------------

多个配置优势  
1.每个文件的大小比一个文件要小很多。效率高  
2.避免多人竞争带来的冲突。

如果你的项目有多个模块（相关的功能在一起） ，一个模块一个配置文件。  
学生考勤模块一个配置文件， 张三  
学生成绩一个配置文件， 李四

多文件的分配方式：

1.  按功能模块，一个模块一个配置文件
2.  按类的功能，数据库相关的配置一个文件配置文件， 做事务的功能一个配置文件， 做service功能的一个配置文件等

基于注解的di： 通过注解完成java对象创建，属性赋值。

使用注解的步骤：  
1.加入maven的依赖 spring-context ，在你加入spring-context的同时， 间接加入spring-aop的依赖。  
使用注解必须使用spring-aop依赖

2.在类中加入spring的注解（多个不同功能的注解）

3.在spring的配置文件中，加入一个组件扫描器的标签，说明注解在你的项目中的位置

学习的注解：  
1.@Component  
2.@Respotory  
3.@Service  
4.@Controller  
5.@Value  
6.@Autowired  
7.@Resource

用户处理请求：  
用户form ,参数name ，age-----Servlet(接收请求name，age)---Service类（处理name，age操作）---dao类（访问数据库的）---mysql

==============================================================================================  
第三章 aop

1.动态代理  
实现方式：jdk动态代理，使用jdk中的Proxy，Method，InvocaitonHanderl创建代理对象。

jdk动态代理要求目标类必须实现接口

cglib动态代理：第三方的工具库，创建代理对象，原理是继承。 通过继承目标类，创建子类。

子类就是代理对象。 要求目标类不能是final的， 方法也不能是final的

2.动态代理的作用：  
1）在目标类源代码不改变的情况下，增加功能。  
2）减少代码的重复  
3）专注业务逻辑代码  
4）解耦合，让你的业务功能和日志，事务非业务功能分离。

3.Aop:面向切面编程， 基于动态代理的，可以使用jdk，cglib两种代理方式。  
Aop就是动态代理的规范化， 把动态代理的实现步骤，方式都定义好了， 让开发人员用一种统一的方式，使用动态代理。

1.  AOP（Aspect Orient Programming）面向切面编程  
    Aspect: 切面，给你的目标类增加的功能，就是切面。 像上面用的日志，事务都是切面。

切面的特点： 一般都是非业务方法，独立使用的。  
Orient：面向， 对着。  
Programming：编程

oop: 面向对象编程

怎么理解面向切面编程 ？  
1）需要在分析项目功能时，找出切面。  
2）合理的安排切面的执行时间（在目标方法前， 还是目标方法后）  
3）合理的安全切面执行的位置，在哪个类，哪个方法增加增强功能

术语：  
1）Aspect:切面，表示增强的功能， 就是一堆代码，完成某个一个功能。非业务功能，常见的切面功能有日志， 事务， 统计信息， 参数检查， 权限验证。  
2）JoinPoint:连接点 ，连接业务方法和切面的位置。 就某类中的业务方法  
3）Pointcut : 切入点 ，指多个连接点方法的集合。多个方法  
4）目标对象： 给哪个类的方法增加功能， 这个类就是目标对象  
5）Advice:通知，通知表示切面功能执行的时间。

说一个切面有三个关键的要素：  
1）切面的功能代码，切面干什么  
2）切面的执行位置，使用Pointcut表示切面执行的位置  
3）切面的执行时间，使用Advice表示时间，在目标方法之前，还是目标方法之后。

5.aop的实现  
aop是一个规范，是动态的一个规范化，一个标准  
aop的技术实现框架：  
1)spring：  
spring在内部实现了aop规范，能做aop的工作。  
spring主要在事务处理时使用aop。  
我们项目开发中很少使用spring的aop实现。 因为spring的aop比较笨重。

2)aspectJ: 一个开源的专门做aop的框架。spring框架中集成了aspectj框架，通过spring就能使用aspectj的功能。

aspectJ框架实现aop有两种方式：  
.使用xml的配置文件 ： 配置全局事务  
使用注解，我们在项目中要做aop功能，一般都使用注解， aspectj有5个注解。

6.学习aspectj框架的使用。  
1）切面的执行时间， 这个执行时间在规范中叫做Advice(通知，增强)  
在aspectj框架中使用注解表示的。也可以使用xml配置文件中的标签  
1）@Before  
2）@AfterReturning  
3）@Around  
4）@AfterThrowing  
5）@After

2）表示切面执行的位置，使用的是切入点表达式。

com.service.impl
        com.bjpowrnode.service.impl
        cn.crm.bjpowernode.service
    
    
      execution(* *..service.*.*(..))

====================================================================  
第四章： 把mybatis框架和spring集成在一起，向一个框架一样使用。

用的技术是：ioc 。  
为什么ioc：能把mybatis和spring集成在一起，像一个框架， 是因为ioc能创建对象。  
可以把mybatis框架中的对象交给spring统一创建， 开发人员从spring中获取对象。  
开发人员就不用同时面对两个或多个框架了， 就面对一个spring

mybatis使用步骤，对象  
1.定义dao接口 ，StudentDao  
2.定义mapper文件 StudentDao.xml  
3.定义mybatis的主配置文件 mybatis.xml  
4.创建dao的代理对象， StudentDao dao = SqlSession.getMapper(StudentDao.class);

List<Student> students = dao.selectStudents();

要使用dao对象，需要使用getMapper()方法，  
怎么能使用getMapper()方法，需要哪些条件

1.获取SqlSession对象， 需要使用SqlSessionFactory的openSession()方法。  
2.创建SqlSessionFactory对象。 通过读取mybatis的主配置文件，能创建SqlSessionFactory对象

需要SqlSessionFactory对象， 使用Factory能获取SqlSession ，有了SqlSession就能有dao ， 目的就是获取dao对象

Factory创建需要读取主配置文件

我们会使用独立的连接池类替换mybatis默认自己带的， 把连接池类也交给spring创建。

主配置文件：  
1.数据库信息

1.  mapper文件的位置

==============================================================  
通过以上的说明，我们需要让spring创建以下对象  
1.独立的连接池类的对象， 使用阿里的druid连接池  
2.SqlSessionFactory对象  
3.创建出dao对象

需要学习就是上面三个对象的创建语法，使用xml的bean标签。

连接池：多个连接Connection对象的集合， List<Connection> connlist : connList就是连接池

通常使用Connection访问数据库

Connection conn =DriverManger.getConnection(url,username,password);
    Statemenet stmt = conn.createStatement(sql);
    stmt.executeQuery();
    conn.close();

使用连接池  
在程序启动的时候，先创建一些Connection  
Connection c1 = ...  
Connection c2 = ...  
Connection c3 = ...  
List<Connection> connlist = new ArrayLits();  
connList.add(c1);  
connList.add(c2);  
connList.add(c3);

Connection conn = connList.get(0);  
Statemenet stmt = conn.createStatement(sql);  
stmt.executeQuery();  
把使用过的connection放回到连接池  
connList.add(conn);

Connection conn1 = connList.get(1);  
Statemenet stmt = conn1.createStatement(sql);  
stmt.executeQuery();  
把使用过的connection放回到连接池  
connList.add(conn1);

==================================================================  
spring的事务处理  
回答问题  
1.什么是事务  
讲mysql的时候，提出了事务。 事务是指一组sql语句的集合， 集合中有多条sql语句  
可能是insert ， update ，select ，delete， 我们希望这些多个sql语句都能成功，或者都失败， 这些sql语句的执行是一致的，作为一个整体执行。

2.在什么时候想到使用事务  
当我的操作，涉及得到多个表，或者是多个sql语句的insert，update，delete。需要保证这些语句都是成功才能完成我的功能，或者都失败，保证操作是符合要求的。

在java代码中写程序，控制事务，此时事务应该放在那里呢？  
service类的业务方法上，因为业务方法会调用多个dao方法，执行多个sql语句

3.通常使用JDBC访问数据库， 还是mybatis访问数据库怎么处理事务  
jdbc访问数据库，处理事务 Connection conn ; conn.commit(); conn.rollback();  
mybatis访问数据库，处理事务， SqlSession.commit(); SqlSession.rollback();  
hibernate访问数据库，处理事务， Session.commit(); Session.rollback();

4.3问题中事务的处理方式，有什么不足  
1)不同的数据库访问技术，处理事务的对象，方法不同，  
需要了解不同数据库访问技术使用事务的原理  
2)掌握多种数据库中事务的处理逻辑。什么时候提交事务，什么时候回顾事务  
3)处理事务的多种方法。

总结： 就是多种数据库的访问技术，有不同的事务处理的机制，对象，方法。

5.怎么解决不足  
spring提供一种处理事务的统一模型， 能使用统一步骤，方式完成多种不同数据库访问技术的事务处理。

使用spring的事务处理机制，可以完成mybatis访问数据库的事务处理  
使用spring的事务处理机制，可以完成hibernate访问数据库的事务处理。

6.处理事务，需要怎么做，做什么  
spring处理事务的模型，使用的步骤都是固定的。把事务使用的信息提供给spring就可以了

1）spring内部提交，回滚事务，使用的事务管理器对象，代替你完成commit，rollback  
事务管理器是一个接口和他的众多实现类。  
接口：PlatformTransactionManager ，定义了事务重要方法 commit ，rollback  
实现类：spring把每一种数据库访问技术对应的事务处理类都创建好了。  
mybatis访问数据库---spring创建好的是DataSourceTransactionManager  
hibernate访问数据库----spring创建的是HibernateTransactionManager

怎么使用：你需要告诉spring 你用是那种数据库的访问技术，怎么告诉spring呢？  
声明数据库访问技术对于的事务管理器实现类， 在spring的配置文件中使用<bean>声明就可以了  
例如，你要使用mybatis访问数据库，你应该在xml配置文件中  
<bean id=“xxx" class="...DataSourceTransactionManager">

2）你的业务方法需要什么样的事务，说明需要事务的类型。

说明方法需要的事务：  
事务的隔离级别：有4个值。  
DEFAULT：采用 DB 默认的事务隔离级别。MySql 的默认为 REPEATABLE\_READ； Oracle默认为 READ\_COMMITTED。  
➢ READ\_UNCOMMITTED：读未提交。未解决任何并发问题。  
➢ READ\_COMMITTED：读已提交。解决脏读，存在不可重复读与幻读。  
➢ REPEATABLE\_READ：可重复读。解决脏读、不可重复读，存在幻读  
➢ SERIALIZABLE：串行化。不存在并发问题。

事务的超时时间： 表示一个方法最长的执行时间，如果方法执行时超过了时间，事务就回滚。  
单位是秒， 整数值， 默认是 -1.

事务的传播行为 ： 控制业务方法是不是有事务的， 是什么样的事务的。  
7个传播行为，表示你的业务方法调用时，事务在方法之间是如果使用的。

PROPAGATION_REQUIRED
            PROPAGATION_REQUIRES_NEW
            PROPAGATION_SUPPORTS
            以上三个需要掌握的
    
            PROPAGATION_MANDATORY
            PROPAGATION_NESTED
            PROPAGATION_NEVER
            PROPAGATION_NOT_SUPPORTED

3）事务提交事务，回滚事务的时机

当你的业务方法，执行成功，没有异常抛出，当方法执行完毕，spring在方法执行后提交事务。事务管理器commit

当你的业务方法抛出运行时异常或ERROR， spring执行回滚，调用事务管理器的rollback  
运行时异常的定义： RuntimeException 和他的子类都是运行时异常， 例如NullPointException , NumberFormatException

当你的业务方法抛出非运行时异常， 主要是受查异常时，提交事务  
受查异常：在你写代码中，必须处理的异常。例如IOException, SQLException

总结spring的事务  
1.管理事务的是 事务管理和他的实现类  
2.spring的事务是一个统一模型  
1）指定要使用的事务管理器实现类，使用<bean>  
2）指定哪些类，哪些方法需要加入事务的功能  
3）指定方法需要的隔离级别，传播行为，超时

你需要告诉spring，你的项目中类信息，方法的名称，方法的事务传播行为。

![format_png 60][]

spring框架中提供的事务处理方案

1.适合中小项目使用的， 注解方案。  
spring框架自己用aop实现给业务方法增加事务的功能， 使用@Transactional注解增加事务。  
@Transactional注解是spring框架自己注解，放在public方法的上面，表示当前方法具有事务。  
可以给注解的属性赋值，表示具体的隔离级别，传播行为，异常信息等等

使用@Transactional的步骤：  
1.)需要声明事务管理器对象  
<bean id="xx" class="DataSourceTransactionManager">

2.)开启事务注解驱动， 告诉spring框架，我要使用注解的方式管理事务。  
spring使用aop机制，创建@Transactional所在的类代理对象，给方法加入事务的功能。  
spring给业务方法加入事务：  
在你的业务方法执行之前，先开启事务，在业务方法之后提交或回滚事务，使用aop的环绕通知

@Around("你要增加的事务功能的业务方法名称")
             Object myAround(){
               开启事务，spring给你开启
                  try{
                     buy(1001,10);
                      spring的事务管理器.commit();
                  }catch(Exception e){
                 spring的事务管理器.rollback();
                  }
                 
             }

3).在你的方法的上面加入@Trancational

2.适合大型项目，有很多的类，方法，需要大量的配置事务，使用aspectj框架功能，在spring配置文件中  
声明类，方法需要的事务。这种方式业务方法和事务配置完全分离。

实现步骤： 都是在xml配置文件中实现。

1)要使用的是aspectj框架，需要加入依赖

<dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-aspects</artifactId>
            <version>5.2.5.RELEASE</version>
        </dependency>

2）声明事务管理器对象

1.  声明方法需要的事务类型（配置方法的事务属性【隔离级别，传播行为，超时】）
2.  配置aop：指定哪些哪类要创建代理。

第六章： web项目中怎么使用容器对象。

1.做的是javase项目有main方法的，执行代码是执行main方法的，在main里面创建的容器对象

ApplicationContext ctx = new ClassPathXmlApplicationContext("applicationContext.xml");

2.web项目是在tomcat服务器上运行的。 tomcat一起动，项目一直运行的。

需求：  
web项目中容器对象只需要创建一次， 把容器对象放入到全局作用域ServletContext中。

怎么实现：  
使用监听器 当全局作用域对象被创建时 创建容器 存入ServletContext

监听器作用：  
1）创建容器对象，执行 ApplicationContext ctx = new ClassPathXmlApplicationContext("applicationContext.xml");

2）把容器对象放入到ServletContext， ServletContext.setAttribute(key,ctx)

监听器可以自己创建，也可以使用框架中提供好的ContextLoaderListener

private WebApplicationContext context;
     public interface WebApplicationContext extends ApplicationContext

ApplicationContext:javase项目中使用的容器对象  
WebApplicationContext：web项目中的使用的容器对象

把创建的容器对象，放入到全局作用域  
key： WebApplicationContext.ROOT\_WEB\_APPLICATION\_CONTEXT\_ATTRIBUTE  
value：this.context

servletContext.setAttribute(WebApplicationContext.ROOT\_WEB\_APPLICATION\_CONTEXT\_ATTRIBUTE, this.context);

![format_png 61][]

![format_png 62][]

![format_png 63][]

![format_png 64][]

![format_png 65][]

![format_png 66][]

![format_png 67][]

[format_png]: https://img-blog.csdnimg.cn/img_convert/3e14700936b4282cf0bbf9912bdc0580.webp?x-oss-process=image/format,png
[format_png 1]: https://img-blog.csdnimg.cn/img_convert/a428649b2a7345407d074794ac3018f8.webp?x-oss-process=image/format,png
[format_png 2]: https://img-blog.csdnimg.cn/img_convert/d3796fc7ee310f12abdfd2a739886452.webp?x-oss-process=image/format,png
[format_png 3]: https://img-blog.csdnimg.cn/img_convert/16bbd47a645e31c277528fe13f0c870e.webp?x-oss-process=image/format,png
[format_png 4]: https://img-blog.csdnimg.cn/img_convert/d32204c2f677e08ce50f4bef06975dc7.webp?x-oss-process=image/format,png
[format_png 5]: https://img-blog.csdnimg.cn/img_convert/086dd4cfe177576500611eab98dab202.webp?x-oss-process=image/format,png
[format_png 6]: https://img-blog.csdnimg.cn/img_convert/2c980aaccae8b67f3b377933e38e4736.webp?x-oss-process=image/format,png
[format_png 7]: https://img-blog.csdnimg.cn/img_convert/3a7b42a2ec72750ea0652621861b7301.webp?x-oss-process=image/format,png
[format_png 8]: https://img-blog.csdnimg.cn/img_convert/f7dc161f5c2a22e8bc0d46ec5d2dff71.webp?x-oss-process=image/format,png
[format_png 9]: https://img-blog.csdnimg.cn/img_convert/0b83740e29273c64688ecce36009e4b1.webp?x-oss-process=image/format,png
[format_png 10]: https://img-blog.csdnimg.cn/img_convert/23fae3508fa4b30ddcee13a58d4e4fed.webp?x-oss-process=image/format,png
[format_png 11]: https://img-blog.csdnimg.cn/img_convert/62bb007b8e563e34948acc6049c309f1.webp?x-oss-process=image/format,png
[format_png 12]: https://img-blog.csdnimg.cn/img_convert/def2257a1f5101887fdfd760ef6571d8.webp?x-oss-process=image/format,png
[format_png 13]: https://img-blog.csdnimg.cn/img_convert/9876c71186868bfba4e5f1fd89049eee.webp?x-oss-process=image/format,png
[format_png 14]: https://img-blog.csdnimg.cn/img_convert/01dbce2f7b1837f33a91c025cccaed84.webp?x-oss-process=image/format,png
[format_png 15]: https://img-blog.csdnimg.cn/img_convert/8a267b298f5d323c4a000d99b6a071d9.webp?x-oss-process=image/format,png
[format_png 16]: https://img-blog.csdnimg.cn/img_convert/3ce7cf1ca23636c937b51c13925f9546.webp?x-oss-process=image/format,png
[format_png 17]: https://img-blog.csdnimg.cn/img_convert/c494260d66bc768e5f9c1c8d0314e03b.webp?x-oss-process=image/format,png
[format_png 18]: https://img-blog.csdnimg.cn/img_convert/7fd3e0d40281ac57cbe6d16f5b483a65.webp?x-oss-process=image/format,png
[format_png 19]: https://img-blog.csdnimg.cn/img_convert/23b80cacc758088fc253adb1a0c08155.webp?x-oss-process=image/format,png
[format_png 20]: https://img-blog.csdnimg.cn/img_convert/4989526ad42bb41561fa7165a2a0ea2e.webp?x-oss-process=image/format,png
[format_png 21]: https://img-blog.csdnimg.cn/img_convert/d83d8ed83cb5533ac2b39b2d39e2f9fe.webp?x-oss-process=image/format,png
[format_png 22]: https://img-blog.csdnimg.cn/img_convert/f23385639eb8eab577b652b8dfd9891a.webp?x-oss-process=image/format,png
[format_png 23]: https://img-blog.csdnimg.cn/img_convert/8feb8a6f574f574eaae200c61f7fe5c4.webp?x-oss-process=image/format,png
[format_png 24]: https://img-blog.csdnimg.cn/img_convert/55779e5760112dbacc5ebe5aa50560da.webp?x-oss-process=image/format,png
[format_png 25]: https://img-blog.csdnimg.cn/img_convert/35163b7fb1793bcadf792649fe544c00.webp?x-oss-process=image/format,png
[format_png 26]: https://img-blog.csdnimg.cn/img_convert/4fd2fddccbc9cf86213c28718407d124.webp?x-oss-process=image/format,png
[format_png 27]: https://img-blog.csdnimg.cn/img_convert/565f98fe2da12cd98264acc40aaf1882.webp?x-oss-process=image/format,png
[format_png 28]: https://img-blog.csdnimg.cn/img_convert/29cdc2b42d4f25eab67887d9f48bf8e5.webp?x-oss-process=image/format,png
[format_png 29]: https://img-blog.csdnimg.cn/img_convert/cbdaebd580fcf9c5a8290ac29437697e.webp?x-oss-process=image/format,png
[format_png 30]: https://img-blog.csdnimg.cn/img_convert/9d7de9c9c00a1304f5512cde114a19a7.webp?x-oss-process=image/format,png
[format_png 31]: https://img-blog.csdnimg.cn/img_convert/f41738e2f6fc3f0d9754d0b02b3c6868.webp?x-oss-process=image/format,png
[format_png 32]: https://img-blog.csdnimg.cn/img_convert/ec8daf5e64a28124726537a6ca578bfd.webp?x-oss-process=image/format,png
[format_png 33]: https://img-blog.csdnimg.cn/img_convert/df3950b436a70cc4f4e5547317ac7bf7.webp?x-oss-process=image/format,png
[format_png 34]: https://img-blog.csdnimg.cn/img_convert/f69b207f3cec1e9e022fd4c9633c0e2d.webp?x-oss-process=image/format,png
[format_png 35]: https://img-blog.csdnimg.cn/img_convert/1d9a48ad3249954297d95c3fbe41eba5.webp?x-oss-process=image/format,png
[format_png 36]: https://img-blog.csdnimg.cn/img_convert/d9df0efb732084b413c52a45f58c5706.webp?x-oss-process=image/format,png
[format_png 37]: https://img-blog.csdnimg.cn/img_convert/be430e0f48c95e47107a2baf10c8fc44.webp?x-oss-process=image/format,png
[format_png 38]: https://img-blog.csdnimg.cn/img_convert/1493ad402cf4ba1828b77a1db5d20fb4.webp?x-oss-process=image/format,png
[format_png 39]: https://img-blog.csdnimg.cn/img_convert/26dd8505d53d0cbcb20d925627198078.webp?x-oss-process=image/format,png
[format_png 40]: https://img-blog.csdnimg.cn/img_convert/1a80ace17db8aa6e1932c388905c5a5d.webp?x-oss-process=image/format,png
[format_png 41]: https://img-blog.csdnimg.cn/img_convert/db5f4e63f9d093f9d0d523fba5097da5.webp?x-oss-process=image/format,png
[format_png 42]: https://img-blog.csdnimg.cn/img_convert/14fdd1889554c776fc5183714a938815.webp?x-oss-process=image/format,png
[format_png 43]: https://img-blog.csdnimg.cn/img_convert/487fbbc2f7f5dafc8ba3f3d10fa1aa12.webp?x-oss-process=image/format,png
[format_png 44]: https://img-blog.csdnimg.cn/img_convert/cbd68ac96cfa5a02ada7a716771152d5.webp?x-oss-process=image/format,png
[format_png 45]: https://img-blog.csdnimg.cn/img_convert/2d20f3b0f73169bfe9e2831243a99265.webp?x-oss-process=image/format,png
[format_png 46]: https://img-blog.csdnimg.cn/img_convert/ad942af427325f8736f03f63bf18b998.webp?x-oss-process=image/format,png
[format_png 47]: https://img-blog.csdnimg.cn/img_convert/d8f440795674613ac6975e51adbca38b.webp?x-oss-process=image/format,png
[Image 1]: 
[format_png 48]: https://img-blog.csdnimg.cn/img_convert/3b7959f81e326f2b3e4133734d7b1e01.webp?x-oss-process=image/format,png
[format_png 49]: https://img-blog.csdnimg.cn/img_convert/990ca836e736c6768f7480664f4ccc8e.webp?x-oss-process=image/format,png
[format_png 50]: https://img-blog.csdnimg.cn/img_convert/db8cdb2220c730f0a1610ce348869a56.webp?x-oss-process=image/format,png
[format_png 51]: https://img-blog.csdnimg.cn/img_convert/463a3ad75efdaf0df26e17a5bc3f71b4.webp?x-oss-process=image/format,png
[format_png 52]: https://img-blog.csdnimg.cn/img_convert/d99b04f6ebb07a2743fde4aaaf63d2ae.webp?x-oss-process=image/format,png
[format_png 53]: https://img-blog.csdnimg.cn/img_convert/d425cbdf686225afbb7ee9745d9c3b30.webp?x-oss-process=image/format,png
[format_png 54]: https://img-blog.csdnimg.cn/img_convert/916094052ac05e3fdd59b41c0680ceb7.webp?x-oss-process=image/format,png
[format_png 55]: https://img-blog.csdnimg.cn/img_convert/1ece56e43c85ac635bdcd0e281620e28.webp?x-oss-process=image/format,png
[format_png 56]: https://img-blog.csdnimg.cn/img_convert/a6a6159a7d5885edae9d7f4237d4ff09.webp?x-oss-process=image/format,png
[format_png 57]: https://img-blog.csdnimg.cn/img_convert/2009460ad0fa94eee79a003052b914be.webp?x-oss-process=image/format,png
[format_png 58]: https://img-blog.csdnimg.cn/img_convert/80825ce900a632f758378f2fc1a9e604.webp?x-oss-process=image/format,png
[format_png 59]: https://img-blog.csdnimg.cn/img_convert/66d849a1f449917206b5c5ec8301f405.webp?x-oss-process=image/format,png
[format_png 60]: https://img-blog.csdnimg.cn/img_convert/f867bcb9629a43416a64407fd8ab00bd.webp?x-oss-process=image/format,png
[format_png 61]: https://img-blog.csdnimg.cn/img_convert/d892f344182901ba2736f23e085a9545.webp?x-oss-process=image/format,png
[format_png 62]: https://img-blog.csdnimg.cn/img_convert/df28efbadbdf01f90268ce5dca982442.webp?x-oss-process=image/format,png
[format_png 63]: https://img-blog.csdnimg.cn/img_convert/1a2d29008629b727b26690b8d6e723a4.webp?x-oss-process=image/format,png
[format_png 64]: https://img-blog.csdnimg.cn/img_convert/5e4193c341ceb80598ac33186fb743ee.webp?x-oss-process=image/format,png
[format_png 65]: https://img-blog.csdnimg.cn/img_convert/2b4e2df3e4abc45c6d1638930f8bdad5.webp?x-oss-process=image/format,png
[format_png 66]: https://img-blog.csdnimg.cn/img_convert/760a2ec6af07f341bd010057448039ef.webp?x-oss-process=image/format,png
[format_png 67]: https://img-blog.csdnimg.cn/img_convert/009f0025ff477d75846acf11d736ea97.webp?x-oss-process=image/format,png