【Spring】（8）Spring事务处理详解

两个月前跟着b站动力节点王鹤老师的Spring框架教程视频学习完了Spring框架，在学习过程中我将视频中涉及的代码都一行一行手敲了一遍，并且把Spring入门相关的资料整理了一下，在这里记录一下我在Spring框架学习过程中的笔记和一些心得，希望能帮助到想要通过文字教程入门Spring这一框架的小伙伴哦！

视频地址：2020最新Spring框架教程【IDEA版】-Spring框架从入门到精通

Spring 事务

1. 问题引出

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 访问数据库的事务处理。

2. Spring 事务管理 API

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

事务管理器接口

spring 内部提交、回滚事务，使用的是事务管理器对象，代替你完成 commit、rollback 及获取事务的状态信息。

事务管理器是一个接口和它的众多实现类：
接口：PlatformTransactionManager，定义了事务的重要方法 commit、rollback
实现类：spring 把每一种数据库访问技术对应的事务处理类都创建好了。
mybatis 访问数据库----spring 创建的是 DataSourceTransactionManager
hibernate 访问数据库----spring 创建的是 HibernateTransactionManager

如何使用：

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

Spring 的回滚方式：

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

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

  当你的业务方法抛出运行时异常或ERROR，spring执行回滚，调用事务管理器的rollback
     运行时异常的定义： RuntimeException 和他的子类都是运行时异常，例如 NullPointException, NumberFormatException
  
  当你的业务方法抛出非运行时异常，主要是受查异常时，提交事务
     受查异常：在你写代码中，必须处理的异常。例如IOException, SQLException

回顾错误与异常：

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

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

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

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

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

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

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

事务定义接口

你的业务方法需要什么样的事务，说明需要的事务的类型。
说明方法需要的事务：事务定义接口 TransactionDefinition 中定义了事务描述相关的三类常量：事务隔离级别、事务传播行为、事务默认超时时限，及对它们的操作。

a. 事务的隔离级别

​ 有4个值。这些常量均是以 ISOLATION_ 开头。即形如 ISOLATION_XXX。
​ DEFAULT：采用 DB 默认的事务隔离级别。MySql 的默认为 REPEATABLE_READ； Oracle默认为 READ_COMMITTED。

		➢ READ_UNCOMMITTED：读未提交。未解决任何并发问题。
		➢ READ_COMMITTED：读已提交。解决脏读，存在不可重复读与幻读。
		➢ REPEATABLE_READ：可重复读。解决脏读、不可重复读，存在幻读
		➢ SERIALIZABLE：串行化。不存在并发问题。

b. 事务的超时时间

​ 常量 TIMEOUT_DEFAULT 定义了事务底层默认的超时时限，sql 语句的执行时长。 表示一个方法最长的执行时间，如果方法执行时超过了时间，事务就回滚。
​ 单位是秒，整数值， 默认是 -1.

事务的超时时限起作用的条件比较多，且超时的时间计算点较复杂。所以，该值一般就使用默认值即可。

c. 事务的传播行为

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

7个传播行为，表示你的业务方法调用时，事务在方法之间是如何使用的。事务传播行为常量都是以 PROPAGATION_ 开头，形如 PROPAGATION_XXX。

​ PROPAGATION_REQUIRED
​ PROPAGATION_REQUIRES_NEW
​ PROPAGATION_SUPPORTS

​ PROPAGATION_MANDATORY
​ PROPAGATION_NESTED
​ PROPAGATION_NEVER
​ PROPAGATION_NOT_SUPPORTED

（1）PROPAGATION_REQUIRED

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

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

（2）PROPAGATION_SUPPORTS

指定的方法支持当前事务，但若当前没有事务，也可以以非事务方式执行。 （适合查询操作）

（3）PROPAGATION_REQUIRES_NEW

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

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

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

3. 程序示例

举例：购买商品 trans_sale 项目

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

实现步骤：

创建 maven 工程，模板使用 quickstart

3.1 创建数据库表

创建两个数据库表 sale , goods

sale 销售订单表：

goods 商品表 ：

goods 表数据

3.2 配置 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.kaho</groupId>
  <artifactId>ch07-spring-mybatis</artifactId>
  <version>1.0-SNAPSHOT</version>

  <properties>
    <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
    <maven.compiler.source>1.8</maven.compiler.source>
    <maven.compiler.target>1.8</maven.compiler.target>
  </properties>

  <dependencies>
    <!--junit单元测试依赖-->
    <dependency>
      <groupId>junit</groupId>
      <artifactId>junit</artifactId>
      <version>4.11</version>
      <scope>test</scope>
    </dependency>
    <!--spring核心ioc依赖-->
    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-context</artifactId>
      <version>5.2.5.RELEASE</version>
    </dependency>
    <!--spring事务相关依赖-->
    <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>
    <!--mybatis依赖-->
    <dependency>
      <groupId>org.mybatis</groupId>
      <artifactId>mybatis</artifactId>
      <version>3.5.1</version>
    </dependency>
    <!--mybatis-spring集成的依赖-->
    <dependency>
      <groupId>org.mybatis</groupId>
      <artifactId>mybatis-spring</artifactId>
      <version>1.3.1</version>
    </dependency>
    <!--mysql驱动-->
    <dependency>
      <groupId>mysql</groupId>
      <artifactId>mysql-connector-java</artifactId>
      <version>5.1.9</version>
    </dependency>
    <!--druid数据库连接池-->
    <dependency>
      <groupId>com.alibaba</groupId>
      <artifactId>druid</artifactId>
      <version>1.1.12</version>
    </dependency>
  </dependencies>

  <build>
    <!--目的是把src/main/java目录中的xml文件包含到输出结果中。输出到classes目录中-->
    <resources>
      <resource>
        <directory>src/main/java</directory><!--所在的目录-->
        <includes><!--包括目录下的.properties,.xml 文件都会扫描到-->
          <include>**/*.properties</include>
          <include>**/*.xml</include>
        </includes>
        <filtering>false</filtering>
      </resource>
    </resources>
    <!--指定jdk版本-->
    <plugins>
      <plugin>
        <artifactId>maven-compiler-plugin</artifactId>
        <version>3.1</version>
        <configuration>
          <source>1.8</source>
          <target>1.8</target>
        </configuration>
      </plugin>
    </plugins>
  </build>
</project>

3.3 定义实体类 Sale,Goods

在 main.java.com.kaho 下创建一个包 domain，用于存放实体类：Sale.java , Goods.java

Sale类：

package com.kaho.domain;

public class Sale {
    private Integer id;//订单号
    private Integer gid;//商品编号
    private Integer nums;//购买数量
	//get、set方法
}

Goods类：

package com.kaho.domain;

public class Goods {
    private Integer id;//商品编号
    private String name;//商品名
    private Integer amount;//库存量
    private float price;//价格
	//get、set方法    
}

3.4 定义 Dao 接口

在 main.java.com.kaho 下创建一个包 dao，用于存放 dao接口：SaleDao ，GoodsDao

SaleDao：

package com.kaho.dao;

import com.kaho.domain.Sale;

public interface SaleDao {
    //增加销售记录
    int insertSale(Sale sale);
}

GoodsDao：

package com.kaho.dao;

import com.kaho.domain.Goods;

public interface GoodsDao {
    //更新库存
    //goods表示本次用户购买的商品信息：id、购买数量
    int updateGoods(Goods goods);

    //查询商品信息
    Goods selectGoods(Integer id);
}

3.5 定义映射文件 mapper.xml

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

SaleDao.xml：

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE mapper
        PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
        "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="com.kaho.dao.SaleDao">
    <insert id="insertSale">
        insert into sale(gid,nums) values(#{gid},#{nums})
    </insert>
</mapper>

GoodsDao.xml：

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE mapper
        PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
        "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="com.kaho.dao.GoodsDao">
    
    <select id="selectGoods" resultType="com.kaho.domain.Goods">
        select id,name,amount,price from goods where id=#{id}
    </select>
    
    <update id="updateGoods">
        update goods set amount = amount - #{amount} where id=#{id}
    </update>
    
</mapper>

3.6 定义 MyBatis 主配置文件

在 src 下创建 resources 包，定义 MyBatis 的主配置文件，命名为 mybatis.xml

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE configuration
        PUBLIC "-//mybatis.org//DTD Config 3.0//EN"
        "http://mybatis.org/dtd/mybatis-3-config.dtd">
<configuration>
    <!--设置别名-->
    <typeAliases>
        <!--name:实体类所在的包名，设置后可直接用类名作为别名-->
        <package name="com.kaho.domain"/>
    </typeAliases>

    <!-- sql mapper(sql映射文件)的位置 -->
    <mappers>
        <!--
            name : 是包名，这个包中的所有mapper.xml文件一次都能加载
        -->
        <package name="com.kaho.dao"/>
    </mappers>
</configuration>

3.7 自定义异常类

创建一个 excep 包，在其中定义 service 层可能会抛出的异常类 NotEnoughException （运行时异常）

package com.kaho.excep;

//自定义的运行时异常
public class NotEnoughException extends RuntimeException{
    public NotEnoughException() {
        super();
    }

    public NotEnoughException(String message) {
        super(message);
    }
}

3.8 定义 Service 接口和实现类

BuyGoodsService接口：

package com.kaho.service;

public interface BuyGoodsService {
    //购买商品的方法 goodsId：购买商品的编号    nums：购买的数量
    void buy(Integer goodsId, Integer nums);
}

BuyGoodsServiceImpl实现类：

package com.kaho.service.impl;

import com.kaho.dao.GoodsDao;
import com.kaho.dao.SaleDao;
import com.kaho.domain.Goods;
import com.kaho.domain.Sale;
import com.kaho.excep.NotEnoughException;
import com.kaho.service.BuyGoodsService;

public class BuyGoodsServiceImpl implements BuyGoodsService {

    private SaleDao saleDao;
    private GoodsDao goodsDao;

    public BuyGoodsServiceImpl() {
    }

    //set注入
    public void setSaleDao(SaleDao saleDao) {
        this.saleDao = saleDao;
    }

    public void setGoodsDao(GoodsDao goodsDao) {
        this.goodsDao = goodsDao;
    }

    @Override
    public void buy(Integer goodsId, Integer nums) {
        System.out.println("======buy方法的开始======");

        //记录销售信息，向sale表添加记录
        Sale sale = new Sale();
        sale.setGid(goodsId);
        sale.setNums(nums);
        saleDao.insertSale(sale);

        //更新库存
        Goods goods = goodsDao.selectGoods(goodsId);
        if (goods == null){
            //商品不存在
            throw new NullPointerException("编号是：" + goodsId + " 的商品不存在");
        } else if (goods.getAmount() < nums){
            //商品库存不足
            throw new NotEnoughException("编号是：" + goodsId + " 的商品库存不足");
        }
        //修改库存
        Goods buyGoods =new Goods();
        buyGoods.setId(goodsId);
        buyGoods.setAmount(nums);
        goodsDao.updateGoods(buyGoods);

        System.out.println("======buy方法的完成======");
    }
}

3.9 修改 Spring 配置文件

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       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 https://www.springframework.org/schema/context/spring-context.xsd">

    <!--
        把数据库的配置信息写在一个独立的文件，便于修改数据库的配置内容
        需要让spring知道jdbc.properties文件的位置——使用<context:property-placeholder>标签，属性是location
    -->
    <context:property-placeholder location="classpath:jdbc.properties"/>

    <!--
        声明数据源DataSource，作用是连接数据库
        无需在此配置驱动，可以根据url检测出驱动
    -->
    <bean id="myDataSource" class="com.alibaba.druid.pool.DruidDataSource" init-method="init" destroy-method="close">
        <!--set注入给DruidDataSource提供连接数据库的信息-->
        <!--使用属性配置文件中的数据，语法: ${key} -->
        <property name="url" value="${jdbc.url}" />
        <property name="username" value="${jdbc.username}" />
        <property name="password" value="${jdbc.password}" />
        <property name="maxActive" value="${jdbc.max}" /><!--最大连接数-->
    </bean>

    <!--声明mybatis中所提供的SqlSessionFactoryBean类，这个类内部会创建SqlSessionFactory-->
    <bean id="sqlSessionFactory" class="org.mybatis.spring.SqlSessionFactoryBean">
        <!--set注入，把数据库连接池赋给dataSource属性-->
        <property name="dataSource" ref="myDataSource" />
        <!--mybatis主配置文件的位置
            configLocation属性是Resource类型，用来读取配置文件
            使用value来赋值，指定文件的路径，使用classpath:表示文件的位置
        -->
        <property name="configLocation" value="classpath:mybatis.xml" />
    </bean>

    <!--创建dao对象，使用SqlSession的getMapper(StudentDao.xml)
        MapperScannerConfigurer:在内部调用getMapper()生成每个dao接口的代理对象
    -->
    <bean class="org.mybatis.spring.mapper.MapperScannerConfigurer">
        <!--指定SqlSessionFactory对象的id-->
        <property name="sqlSessionFactoryBeanName" value="sqlSessionFactory" />
        <!--指定包名，包名是dao接口所在的包名。
            MapperScannerConfigurer会扫描这个包中的所有接口，把每个接口都执行一次getMapper()方法，得到每个接口的dao对象。
            创建好的dao对象会放入到spring容器中。dao对象的默认名称是 首字母小写的接口名
        -->
        <property name="basePackage" value="com.kaho.dao" />
    </bean>

    <!--注册BuyGoodsService对象，给其属性Dao注入值-->
    <bean id="buyGoodsService" class="com.kaho.service.impl.BuyGoodsServiceImpl">
        <property name="saleDao" ref="saleDao" />
        <property name="goodsDao" ref="goodsDao" />
    </bean>
</beans>

3.10 测试

    @Test
    public void test(){
        String config = "applicationContext.xml";
        ApplicationContext ctx = new ClassPathXmlApplicationContext(config);
        //从容器中获取service
        BuyGoodsService service = (BuyGoodsService) ctx.getBean("buyService");

        //调用方法
        service.buy(1001,10);
    }

注意：以上程序示例还未添加事务功能，所以出现异常后方法并没有整体回滚，会导致sale表增加了一条记录而goods表没有更新的情况出现。

---

下面采取两种方案为项目添加事务功能

4. 使用 Spring 的事务注解管理事务（方案一）

用 spring 注解的方式来管理事务——适合中小项目使用。

4.1 @Transactional 的介绍

spring 框架用 aop 实现给业务方法增加事务的功能，使用 @Transactional 注解增加事务。@Transactional 注解是 spring 框架自带的事务注解，放在 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 注解在类上，则表示该类上所有的方法均将在执行时织入事务。

---

4.2 实现注解的事务步骤

将上面 trans_sale 程序示例的项目拷贝一份，在其基础上为业务方法加上事务功能。

4.2.1 声明事务管理器对象

    <!--使用spring的事务处理-->
    <!--1.声明事务管理器-->
    <bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
        <!--连接的数据库，指定数据源-->
        <property name="dataSource" ref="myDataSource" />
    </bean>

4.2.2 开启事务注解驱动

告诉 spring 框架，我要使用注解的方式管理事务。

在 applicationContext.xml 中加入下面代码：

    <!--2.开启事务注解驱动，告诉Spring使用注解管理事务，创建代理对象
		这里使用的<tx:annotation-driven>标签要选择springframework...tx
        transaction-manager:事务管理器对象的id
    -->
    <tx:annotation-driven transaction-manager="transactionManager"/>

完整的 applicationContext.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 https://www.springframework.org/schema/context/spring-context.xsd http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx.xsd">

    <!--
        把数据库的配置信息写在一个独立的文件，便于修改数据库的配置内容
        需要让spring知道jdbc.properties文件的位置——使用<context:property-placeholder>标签，属性是location
    -->
    <context:property-placeholder location="classpath:jdbc.properties"/>

    <!--
        声明数据源DataSource，作用是连接数据库
        无需在此配置驱动，可以根据url检测出驱动
    -->
    <bean id="myDataSource" class="com.alibaba.druid.pool.DruidDataSource" init-method="init" destroy-method="close">
        <!--set注入给DruidDataSource提供连接数据库的信息-->
        <!--使用属性配置文件中的数据，语法: ${key} -->
        <property name="url" value="${jdbc.url}" />
        <property name="username" value="${jdbc.username}" />
        <property name="password" value="${jdbc.password}" />
        <property name="maxActive" value="${jdbc.max}" /><!--最大连接数-->
    </bean>

    <!--声明mybatis中所提供的SqlSessionFactoryBean类，这个类内部会创建SqlSessionFactory-->
    <bean id="sqlSessionFactory" class="org.mybatis.spring.SqlSessionFactoryBean">
        <!--set注入，把数据库连接池赋给dataSource属性-->
        <property name="dataSource" ref="myDataSource" />
        <!--mybatis主配置文件的位置
            configLocation属性是Resource类型，用来读取配置文件
            使用value来赋值，指定文件的路径，使用classpath:表示文件的位置
        -->
        <property name="configLocation" value="classpath:mybatis.xml" />
    </bean>

    <!--创建dao对象，使用SqlSession的getMapper(StudentDao.xml)
        MapperScannerConfigurer:在内部调用getMapper()生成每个dao接口的代理对象
    -->
    <bean class="org.mybatis.spring.mapper.MapperScannerConfigurer">
        <!--指定SqlSessionFactory对象的id-->
        <property name="sqlSessionFactoryBeanName" value="sqlSessionFactory" />
        <!--指定包名，包名是dao接口所在的包名。
            MapperScannerConfigurer会扫描这个包中的所有接口，把每个接口都执行一次getMapper()方法，得到每个接口的dao对象。
            创建好的dao对象会放入到spring容器中。dao对象的默认名称是 首字母小写的接口名
        -->
        <property name="basePackage" value="com.kaho.dao" />
    </bean>

    <!--注册BuyGoodsService对象，给其属性Dao注入值-->
    <bean id="buyService" class="com.kaho.service.impl.BuyGoodsServiceImpl">
        <property name="saleDao" ref="saleDao" />
        <property name="goodsDao" ref="goodsDao" />
    </bean>
<!-------------------------------以下是新加入的内容-------------------------------------->
    <!--使用spring的事务处理-->
    <!--1.声明事务管理器-->
    <bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
        <!--连接的数据库，指定数据源-->
        <property name="dataSource" ref="myDataSource" />
    </bean>

    <!--2.开启事务注解驱动，告诉Spring使用注解管理事务，创建代理对象
        transaction-manager:事务管理器对象的id
    -->
    <tx:annotation-driven transaction-manager="transactionManager"/>
</beans>

4.2.3 在业务层的 public 方法中加入@Transaction 注解和相应属性

BuyGoodsServiceImpl 实现类：buy方法部分

    /**
     *  在 service 层下的 public 方法上面加上 @Transactional 注解
     *      rollbackFor : 表示发生指定的异常一定回滚
     *       处理逻辑：
     *		(1)spring框架会首先检查方法抛出的异常是否在rollbackFor的属性值中，如果异常在列表中，不管是什么类型的异常，一定回滚。
     *      (2)如果你抛出的异常不在rollbackFor列表中，spring会判断是不是RuntimeException，如果是，一定回滚。
     */
/*
    @Transactional(
            propagation = Propagation.REQUIRED,
            isolation = Isolation.DEFAULT,
            readOnly = false,
            rollbackFor = {
                    NullPointerException.class, NotEnoughException.class
            }
    )
*/
	@Transactional //默认写法就行
    @Override
    public void buy(Integer goodsId, Integer nums) {
        System.out.println("======buy方法的开始======");

        //记录销售信息，向sale表添加记录
        Sale sale = new Sale();
        sale.setGid(goodsId);
        sale.setNums(nums);
        saleDao.insertSale(sale);

        //更新库存
        Goods goods = goodsDao.selectGoods(goodsId);
        if (goods == null){
            //商品不存在
            throw new NullPointerException("编号是：" + goodsId + " 的商品不存在");
        } else if (goods.getAmount() < nums){
            //商品库存不足
            throw new NotEnoughException("编号是：" + goodsId + " 的商品库存不足");
        }
        //修改库存
        Goods buyGoods =new Goods();
        buyGoods.setId(goodsId);
        buyGoods.setAmount(nums);
        goodsDao.updateGoods(buyGoods);

        System.out.println("======buy方法的完成======");
    }

4.2.4 测试

在进行测试前，两表中的数据：

goods表：

sale表：

会报空指针异常的测试代码：

测试后表中数据：

goods表：

sale表：

---

接下来再测试一下出现自定义异常类 NotEnoughException 的情况

查看两表发现都没有变化

由以上两个测试结果可知，在出现了异常过后，代码都执行了回滚！在未加入事务时，程序出现异常后 sale 表还是创建了新的订单，而加入事务功能之后，这个创建新订单的行为因为事务的整体回滚而被撤销了！

4.3 原理

spring 使用 aop 机制，创建 @Transactional 所在的类代理对象，给方法加入事务的功能。
spring给业务方法加入事务：
在业务方法执行之前，先开启事务，在业务方法之后提交或回滚事务，使用 aop 的环绕通知

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

5. 使用 AspectJ 的 AOP 配置管理事务（方案二）

5.1 说明

使用 AspectJ 框架配置事务——适合大型项目使用

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

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

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

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

2）声明事务管理器对象

	<bean id="xx" class="DataSourceTransactionManager">

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

5.2 具体实现步骤

继续将上面 trans_sale 程序示例的项目再拷贝一份，在其基础上为业务方法加上事务功能。

由于用 AspectJ 框架实现事务方式下，业务方法和事务配置完全分离，所以对于拷贝后的项目，其业务方法代码不需要进行改动，全部改动都在 applicationContext.xml 配置文件中。

5.2.1 添加 AspectJ 依赖

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

5.2.2 在容器中添加事务管理器

    <!--声明式事务处理 : 和源代码完全分离-->
    <!--1.声明事务管理器对象-->
    <bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
        <property name="dataSource" ref="myDataSource"/>
    </bean>

5.2.3 配置事务通知

为事务通知设置相关属性。用于指定要将事务以什么方式织入给哪些方法。

例如，应用到 buy 方法上的事务要求是必须的，且当 buy 方法发生异常后要回滚业务。

    <!--2.声明加在业务方法上的事务属性(隔离级别、传播行为、超时时限)
          id:自定义名称，表示<tx:advice>和</tx:advice>之间的配置内容
          transaction-manager:事务管理器对象的id
    -->
	<tx:advice id="myAdvice" transaction-manager="transactionManager">
        <!--tx:attributes : 配置事务属性-->
        <tx:attributes>
            <!--tx:method : 给具体的方法配置事务属性，method可以有多个，分别给不同的方法设置事务属性
                name：方法名称，（1）完整的方法名称，不带有包和类
                              （2）方法可以使用通配符：* 表示任意字符
                propagation：传播行为，枚举值
                isolation：隔离级别
                rollback-for：指定的异常类名，全限定类名。发生异常一定回滚
            -->
            <tx:method name="buy" propagation="REQUIRED" isolation="DEFAULT"
                       rollback-for="java.lang.NullPointerException,com.kaho.excep.NotEnoughException"/>
        </tx:attributes>
    </tx:advice>

注意：<tx:advice> 标签同样选用以"tx"结尾的。

还可以使用通配符来同时为多个方法配上事务功能：

注意：spring内部先是识别完整方法名的方法，再识别带通配符的方法【从精确到模糊】

5.2.4 配置增强器

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

    <!--3.配置aop:通知应用的切入点-->
    <aop:config>
        <!--配置切入点表达式：指定哪些包中的类需要使用事务
            id:切入点表达式的名称，唯一值
            expression:切入点表达式，指定哪些类要使用事务，aspectj会创建代理对象
        -->
        <aop:pointcut id="servicePt" expression="execution(* *..service..*.*(..))"/>
        <!--配置增强器：关联advice和pointcut
            advice-ref:通知，上面tx:advice那里的配置
            pointcut-ref:切入点表达式的id
        -->
        <aop:advisor advice-ref="myAdvice" pointcut-ref="servicePt"/>
    </aop:config>

完整的 applicationContext.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"
       xmlns:aop="http://www.springframework.org/schema/aop"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
       http://www.springframework.org/schema/beans/spring-beans.xsd
       http://www.springframework.org/schema/context
       https://www.springframework.org/schema/context/spring-context.xsd
       http://www.springframework.org/schema/tx
       http://www.springframework.org/schema/tx/spring-tx.xsd http://www.springframework.org/schema/aop https://www.springframework.org/schema/aop/spring-aop.xsd">

    <!--
        把数据库的配置信息写在一个独立的文件，便于修改数据库的配置内容
        需要让spring知道jdbc.properties文件的位置——使用<context:property-placeholder>标签，属性是location
    -->
    <context:property-placeholder location="classpath:jdbc.properties"/>

    <!--
        声明数据源DataSource，作用是连接数据库
        无需在此配置驱动，可以根据url检测出驱动
    -->
    <bean id="myDataSource" class="com.alibaba.druid.pool.DruidDataSource" init-method="init" destroy-method="close">
        <!--set注入给DruidDataSource提供连接数据库的信息-->
        <!--使用属性配置文件中的数据，语法: ${key} -->
        <property name="url" value="${jdbc.url}" />
        <property name="username" value="${jdbc.username}" />
        <property name="password" value="${jdbc.password}" />
        <property name="maxActive" value="${jdbc.max}" /><!--最大连接数-->
    </bean>

    <!--声明mybatis中所提供的SqlSessionFactoryBean类，这个类内部会创建SqlSessionFactory-->
    <bean id="sqlSessionFactory" class="org.mybatis.spring.SqlSessionFactoryBean">
        <!--set注入，把数据库连接池赋给dataSource属性-->
        <property name="dataSource" ref="myDataSource" />
        <!--mybatis主配置文件的位置
            configLocation属性是Resource类型，用来读取配置文件
            使用value来赋值，指定文件的路径，使用classpath:表示文件的位置
        -->
        <property name="configLocation" value="classpath:mybatis.xml" />
    </bean>

    <!--创建dao对象，使用SqlSession的getMapper(StudentDao.xml)
        MapperScannerConfigurer:在内部调用getMapper()生成每个dao接口的代理对象
    -->
    <bean class="org.mybatis.spring.mapper.MapperScannerConfigurer">
        <!--指定SqlSessionFactory对象的id-->
        <property name="sqlSessionFactoryBeanName" value="sqlSessionFactory" />
        <!--指定包名，包名是dao接口所在的包名。
            MapperScannerConfigurer会扫描这个包中的所有接口，把每个接口都执行一次getMapper()方法，得到每个接口的dao对象。
            创建好的dao对象会放入到spring容器中。dao对象的默认名称是 首字母小写的接口名
        -->
        <property name="basePackage" value="com.kaho.dao" />
    </bean>

    <!--注册BuyGoodsService对象，给其属性Dao注入值-->
    <bean id="buyService" class="com.kaho.service.impl.BuyGoodsServiceImpl">
        <property name="saleDao" ref="saleDao" />
        <property name="goodsDao" ref="goodsDao" />
    </bean>
<!-------------------------------以下是新加入的内容-------------------------------------->
    <!--声明式事务处理 : 和源代码完全分离-->
    <!--1.声明事务管理器对象-->
    <bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
        <property name="dataSource" ref="myDataSource"/>
    </bean>

    <!--2.声明加在业务方法上的事务属性(隔离级别、传播行为、超时时限)
          id:自定义名称，表示<tx:advice>和</tx:advice>之间的配置内容
          transaction-manager:事务管理器对象的id
    -->
    <tx:advice id="myAdvice" transaction-manager="transactionManager">
        <!--tx:attributes : 配置事务属性-->
        <tx:attributes>
            <!--tx:method : 给具体的方法配置事务属性，method可以有多个，分别给不同的方法设置事务属性
                name：方法名称，（1）完整的方法名称，不带有包和类
                              （2）方法可以使用通配符：* 表示任意字符
                propagation：传播行为，枚举值
                isolation：隔离级别
                rollback-for：指定的异常类名，全限定类名。发生异常一定回滚
            -->
            <tx:method name="buy" propagation="REQUIRED" isolation="DEFAULT"
                       rollback-for="java.lang.NullPointerException,com.kaho.excep.NotEnoughException"/>
        </tx:attributes>
    </tx:advice>

    <!--3.配置aop:通知应用的切入点-->
    <aop:config>
        <!--配置切入点表达式：指定哪些包中的类需要使用事务
            id:切入点表达式的名称，唯一值
            expression:切入点表达式，指定哪些类要使用事务，aspectj会创建代理对象
        -->
        <aop:pointcut id="servicePt" expression="execution(* *..service..*.*(..))"/>
        <!--配置增强器：关联advice和pointcut
            advice-ref:通知，上面tx:advice那里的配置
            pointcut-ref:切入点表达式的id
        -->
        <aop:advisor advice-ref="myAdvice" pointcut-ref="servicePt"/>
    </aop:config>
</beans>

5.2.5 测试

正常情况：

---

会报空指针异常的测试代码：

两数据库表内容不变，证明程序确实回滚了！

---

自定义异常类 NotEnoughException 的情况：

两数据库表内容不变，证明程序确实回滚了！