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的配置文件中使用>>声明就可以了。例如使用mybatis访问数据库：

（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）指定要使用的事务管理器实现类，使用
（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）声明事务管理器对象

<bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">

	<property name="dataSource" ref="myDataSource"/>
bean>

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

<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）

<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">

    
    <context:property-placeholder location="classpath:jdbc.properties"/>


    
    <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>


    
    <bean id="sqlSessionFactory" class="org.mybatis.spring.SqlSessionFactoryBean">
        <property name="dataSource" ref="myDataSource"/>
        
        <property name="configLocation" value="classpath:mybatis-config.xml"/>
    bean>

    
    <bean class="org.mybatis.spring.mapper.MapperScannerConfigurer">
        
        <property name="sqlSessionFactoryBeanName" value="sqlSessionFactory"/>
        
        <property name="basePackage" value="com.spring.dao"/>
    bean>

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



    
    
    <bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
        
        <property name="dataSource" ref="myDataSource"/>
    bean>
    
    <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.springframeworkgroupId>
	<artifactId>spring-aspectsartifactId>
	<version>${spring.version}version>
dependency>

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

<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）

<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">

    
    <context:property-placeholder location="classpath:jdbc.properties"/>


    
    <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>


    
    <bean id="sqlSessionFactory" class="org.mybatis.spring.SqlSessionFactoryBean">
        <property name="dataSource" ref="myDataSource"/>
        
        <property name="configLocation" value="classpath:mybatis-config.xml"/>
    bean>

    
    <bean class="org.mybatis.spring.mapper.MapperScannerConfigurer">
        
        <property name="sqlSessionFactoryBeanName" value="sqlSessionFactory"/>
        
        <property name="basePackage" value="com.spring.dao"/>
    bean>

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

    
    
    <bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
        <property name="dataSource" ref="myDataSource"/>
    bean>
    
    <tx:advice id="myAdvice" transaction-manager="transactionManager">
        
        <tx:attributes>
            
            <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*"/>
            
            <tx:method name="*" propagation="SUPPORTS" read-only="true"/>
        tx:attributes>
    tx:advice>

    
    <aop:config>
        
        <aop:pointcut id="servicePt" expression="execution(* *..service..*.*(..))"/>

        
        <aop:advisor advice-ref="myAdvice" pointcut-ref="servicePt"/>
    aop:config>

beans>