Spring的事务（Transaction）

事务的相关问题

1、什么是事务？

事务是指一组SQL语句的集合，集合中有多条SQL语句，可以是insert、update、select、delete，希望这些SQL语句执行是一致的，作为一个整体执行。要么都成功，要么都失败。

2、事务的特点（ACID）

原子性（Atomicity）：事务是一个原子操作，由一系列动作组成。事务的原子性确保动作要么全部完成，要么完全不起作用。
一致性（Consistency）：一旦事务完成（不管成功还是失败），系统必须确保它所建模的业务处于一致的状态，而不会是部分完成部分失败。在现实中的数据不应该被破坏。
隔离性（Isolation）：可能有许多事务会同时处理相同的数据，因此每个事务都应该与其他事务隔离开来，防止数据损坏。
持久性（Durability）：一旦事务完成，无论发生什么系统错误，它的结果都不应该受到影响，这样就能从任何系统崩溃中恢复过来。通常情况下，事务的结果被写到持久化存储器中。

3、什么时候想到使用事务？

（1）当操作设计多个表，或者是多个SQL语句的insert、update、delete。需要保证这些语句都是成功才能完成功能，或者都失败是符合要求的。（要么都成功，要么都失败）
（2）事务在java开发中如何运用？

1、事务放在service类的业务方法中，因为业务方法会调用多个dao，执行多条SQL语句

4、通常使用JDBC访问数据库，还是mybatis访问数据库，怎么处理事务？

（1）jdbc访问数据，处理事务。Connection conn；conn.commit();conn.rollback();
（2）mybatis访问数据库，处理事务。SqlSession.commit() ;SqlSession.rollback();
（3）hibernate访问数据库，处理事务，Session.commit(); Session.rollback();

5、4问题中事务处理的方式有什么不足？

（1）不同数据库访问技术，处理事务的对象、方法不同。需要了解不同数据库使用事务的原理。
（2）需要掌握多种数据库事务的处理逻辑，什么时候提交事务，什么时候回滚事务。
（3）处理事务的方法种类多。
总结：就是多种数据库访问技术，不同的事务处理的机制、对象、方法。较难掌握。

6、怎么解决不足？

spring提供了处理事务的统一模型，能够使用统一的步骤、方式完成多种不同数据库访问技术的事务处理。使用spring的事务处理机制可以完成mybatis、hibernate访问数据库的事务处理。

7、处理事务，需要怎么做，做什么？

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

（1）事务内部提交、回滚事务使用的是事务管理器对象，代替手动commit、rollback。事务管理器是一个接口和其众多的实现类。

接口：PlatformTransactionManager，定义了事务的重要方法 commit、rollback
实现类：spring把每一种数据库访问技术对应的事务处理累都创建好了。
a、mybatis访问数据库—spring创建好的是DataSourceTransactionManager
b、hibernate访问数据库—spring创建好的是HibernateTransactionManager

怎么使用？
只需告诉spring使用哪种数据库的访问技术（框架），声明数据库访问技术对应的事务管理器的实现类，在spring的配置文件中使用<bean>声明就可以了。例如使用mybatis访问数据库：

<bean id = "xxx" class = "...DataSourceTransactionManager"/>

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

事务的隔离级别

有 5 个值，其中一个是默认。这些常量军事以ISOLATION_开头，即形如：ISOLATION_XXX。
1、DEFAULT：采用DB默认的事务隔离级别。MySQL的默认隔离级别：REPEATABLE_READ（可重复读）；Oracle默认的隔离级别：READ_COMMITTED（读已提交）
2、READ_UNCOMMITTED：读未提交，未解决任何并发问题。
3、READ_COMMITTED：读已提交。解决度脏数据，存在不可重复读与幻读。
4、REPEATABLE_READ：可重复度。解决脏读、不可重复读，存在幻读。
5、SERIALIZABLE：串行化。不存在并发问题。

事务的超时时间

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

事务的传播行为

控制业务方法是不是有事务的，是什么样的事务的。共有 7 个传播行为。（标红常用需掌握）
（1）PROPAGATION_REQUIRED：指定的方法必须在事务内执行。若当前存在事务，就加入当前事务中；若当前没有事务，则创建一个新事务。这种创博行为时最常见的选择，也是spring默认的事务传播行为。
（2）PROPAGATION_REQUIRED_NEW：总是新建一个事务，若当前存在事务，就将当前事务挂起，知道新事物执行完毕。
（3）PROPAGATION_SUPPORTS：指定方法支持当前事务，但若当前没有事务，也可以以非事务的方式执行。
（4）PROPAGATION_MANDATORY
（5）PROPAGATION_NESTED
（6）PROPAGATION_NEVER
（7）PROPAGATION_NOT_SUPPORTED

（3）提交事务、回滚事务的时机

1、当业务方法执行成功，没有异常抛出，且方法执行完毕时，spring在方法执行后提交事务。事务管理器commit。
2、当业务代码抛出运行时异常或ERROR，spring执行回滚，调用事务管理器rollback。
3、当业务方法抛出非运行时异常，主要是受查异常时，默认是提交事务。
受查异常：写代码是必须处理的异常，例如：IOException、SQLException

总结spring事务

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

spring框架中提供的事务处理方案（基于AOP）

1、项目的构建可参考：https://blog.csdn.net/qq_36763419/article/details/113925334

基于注解的方案：（@Transactional）：适用于中小型项目 >>【关键代码】

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

isolation：用于设置隔离级别，该属性类型为isolation枚举，默认值为 Isolation.DEFUALT。
readOnly：用于设置方法对数据库的操作是否制度的，该属性为boolean，默认值为false。
timeout：用于设置本操作与数据库连接超时时限。单位为妙，类型为int，默认值为-1，即没有时限。
rollbackFor：指定需要回滚的异常嘞，类型为Class[]，默认值为空数组。当然，若只有一个异常类，可以不使用数组。
rollbackForClassName：指定需要回滚的异常类类名。类型为String[]，默认值为空数组。当然，若只有一个异常类，可以不使用数组。
noRollbackFor：指定不需要回滚的异常类，类型为Class[]，默认值为空数组。当然，若只有一个异常类，可以不使用数组。（与rollbackFor相反）
noRollbackForClassName：指定不需要回滚的异常类类名，类型为Class[]，默认值为空数组。当然，若只有一个异常类，可以不使用数组。（与rollbackForClassName相反）

使用注解的步骤：
（1）声明事务管理器对象

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

（2）开启事务注解驱动，告诉spring，使用注解的方式管理事务。spring使用aop机制，创建@Transactional所在的类代理对象，给方法加入事务功能。

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

spring给业务方法加入事务：
在业务方法执行之前，开启事务；在业务方法之后，提交或回滚事务。使用的是 aop的环绕通知。环绕通知由spring完成。

@Around("增加事务功能的业务方法名称")
Object myAround(){
     
     
	//开启事务，spring开启
	try{
     
     
	<!--业务代码-->
	//spring的事务管理 .rollback()
	}catch(Exception e){
     
     
	//spring的事务管理 .rollback()
	}
	//开启事务，spring开启
}

（3）在目标方法（需要增加事务功能的）方法上面加入@Transactional注解

spring配置文件（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">

    <!--引入properties属性文件-->
    <context:property-placeholder location="classpath:jdbc.properties"/>


    <!--使用阿里云的druid连接池-->
    <bean id="myDataSource" class="com.alibaba.druid.pool.DruidDataSource" init-method="init" destroy-method="close">
        <property name="url" value="${jdbc.url}"/>
        <property name="username" value="${jdbc.username}"/>
        <property name="password" value="${jdbc.password}"/>
        <property name="maxActive" value="${maxActive}"/>
    </bean>


    <!--
        声明的是mybatis中提供的SqlSessionFactoryBean类，
        这个类内部创建SqlSessionFactory的
    -->
    <bean id="sqlSessionFactory" class="org.mybatis.spring.SqlSessionFactoryBean">
        <property name="dataSource" ref="myDataSource"/>
        <!--mybatis主配置文件的位置
            configLocation的属性是Resource类型，读取外部的配置文件的
            它的赋值，使用value，指定配置文件的路径，使用classpath:配置文件
        -->
        <property name="configLocation" value="classpath:mybatis-config.xml"/>
    </bean>

    <!--创建dao对象，使用SqlSession.getMapper(Student.class)
        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.spring.dao"/>
    </bean>

    <!--buyGoodsService-->
    <bean id="buyService" class="com.spring.service.BuyGoodsServiceImpl">
        <property name="saleDao" ref="saleDao"/>
        <property name="goodsDao" ref="goodsDao"/>
    </bean>



    <!--使用spring的事务处理-->
    <!--1、声明spring的事务管理器,id自定义-->
    <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>

使用@Transactional 业务层方法添加事务

package com.spring.service;

import com.spring.dao.GoodsDao;
import com.spring.dao.SaleDao;
import com.spring.entity.Goods;
import com.spring.entity.Sale;
import com.spring.exception.NotEnoughException;
import org.springframework.transaction.annotation.Isolation;
import org.springframework.transaction.annotation.Propagation;
import org.springframework.transaction.annotation.Transactional;

public class BuyGoodsServiceImpl implements BuyGoodsService {
    
    

    private SaleDao saleDao;
    private GoodsDao goodsDao;

    public void setSaleDao(SaleDao saleDao) {
    
    
        this.saleDao = saleDao;
    }

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


    /**
     * propagation 传播行为
     * isolation 隔离级别
     * rollbackFor  表示发生数组中包含的异常一定会回滚
     *     处理逻辑：
     *     （1）spring框架首先会检查方法抛出的异常是否在rollbackFor属性值中，
     *     如果异常在rollbackFor列表中，不论时候是你么类型的异常，一定会回滚
     *     （2）如果抛出的异常不在rollbackFor属性之中，spring会判断异常是不是RuntimeException，
     *     如果是一定会滚。
     *
     * @param goodsId
     * @param nums
     */
    /*@Transactional(
            propagation = Propagation.REQUIRED,
            isolation = Isolation.DEFAULT,
            readOnly = false,
            rollbackFor = {
                    NullPointerException.class,
                    NotEnoughException.class
            }
    )*/
    
    
    /*@Transactional的默认值
    * 同上注释的配置
    * 默认当发生运行时异常时，事务回滚
    *
    *
    * */
    @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.selectGoodsById(goodsId);
        System.out.println(goods.toString());
        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方法完成 ======");

    }
}

基于XML配置文件方案（AspectJ框架）：适用大型项目 >>【关键代码】

1、大型项目中有很多类，方法，需要大量的配置事务，使用aspectj框架功能，在spring配置文件中声明类，方法需要的事务。这种方式业务方法和事务配置完全分离。
2、实现步骤：都是在xml配置文件中实现的。
（1）要使用的是aspectj框架，加入依赖

<dependency>
	<groupId>org.springframework</groupId>
	<artifactId>spring-aspects</artifactId>
	<version>${spring.version}</version>
</dependency>

（2）声明事务管理器对象

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

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

业务代码

package com.spring.service;

import com.spring.dao.GoodsDao;
import com.spring.dao.SaleDao;
import com.spring.entity.Goods;
import com.spring.entity.Sale;
import com.spring.exception.NotEnoughException;
import org.springframework.transaction.annotation.Transactional;

public class BuyGoodsServiceImpl implements BuyGoodsService {
    
    

    private SaleDao saleDao;
    private GoodsDao goodsDao;

    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.selectGoodsById(goodsId);
        System.out.println(goods.toString());
        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方法完成 ======");

    }
}

spring的配置文件（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">

    <!--引入properties属性文件-->
    <context:property-placeholder location="classpath:jdbc.properties"/>


    <!--使用阿里云的druid连接池-->
    <bean id="myDataSource" class="com.alibaba.druid.pool.DruidDataSource" init-method="init" destroy-method="close">
        <property name="url" value="${jdbc.url}"/>
        <property name="username" value="${jdbc.username}"/>
        <property name="password" value="${jdbc.password}"/>
        <property name="maxActive" value="${maxActive}"/>
    </bean>


    <!--
        声明的是mybatis中提供的SqlSessionFactoryBean类，
        这个类内部创建SqlSessionFactory的
    -->
    <bean id="sqlSessionFactory" class="org.mybatis.spring.SqlSessionFactoryBean">
        <property name="dataSource" ref="myDataSource"/>
        <!--mybatis主配置文件的位置
            configLocation的属性是Resource类型，读取外部的配置文件的
            它的赋值，使用value，指定配置文件的路径，使用classpath:配置文件
        -->
        <property name="configLocation" value="classpath:mybatis-config.xml"/>
    </bean>

    <!--创建dao对象，使用SqlSession.getMapper(Student.class)
        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.spring.dao"/>
    </bean>

    <!--buyGoodsService-->
    <bean id="buyService" class="com.spring.service.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.spring.exception.NotEnoughException"/>
            <!--使用通配符，指定很多方法-->
            <!--添加方法-->
            <tx:method name="add*" propagation="REQUIRES_NEW"/>
            <!--修改方法-->
            <tx:method name="modify*"/>
            <!--删除方法-->
            <tx:method name="remove*"/>
            <!--查询方法,query、search、find-->
            <tx:method name="*" propagation="SUPPORTS" read-only="true"/>
        </tx:attributes>
    </tx:advice>

    <!--配置aop-->
    <aop:config>
        <!--配置切入点表达式：指定那些包中的类，要使用事务
            id：切入点表达式的名称，唯一值
            expression：切入点表达式，指定哪些类要使用事务，aspectj会创建代理对象
        -->
        <aop:pointcut id="servicePt" expression="execution(* *..service..*.*(..))"/>

        <!--配置增强器：关联advice和pointCut
            advice-ref：通知，上面tx:advice
            pointcut-ref：切入点表达式
        -->
        <aop:advisor advice-ref="myAdvice" pointcut-ref="servicePt"/>
    </aop:config>

</beans>