Java--Spring事务

事务原本是数据库中的概念，在Dao层。但Spring框架将事务提升到业务层，即 Service 层

Spring事务的本质其实就是数据库对事务的支持

Spring支持编程式事务管理以及声明式事务管理两种方式

一、编程式事务管理

编程式事务管理是侵入性事务管理，使用TransactionTemplate或者直接使用PlatformTransactionManager，对于编程式事务管理，Spring推荐使用TransactionTemplate

二、声明式事务管理

声明式事务管理建立在AOP之上，其本质是对方法前后进行拦截，然后在目标方法开始之前创建或者加入一个事务，执行完目标方法之后根据执行的情况提交或者回滚。

编程式事务每次实现都要单独实现，但业务量大功能复杂时，使用编程式事务无疑是痛苦的，而声明式事务不同，声明式事务属于无侵入式，不会影响业务逻辑的实现，只需要在配置文件中做相关的事务规则声明或者通过注解的方式，便可以将事务规则应用到业务逻辑中。

显然声明式事务管理要优于编程式事务管理，这正是Spring倡导的非侵入式的编程方式。唯一不足的地方就是声明式事务管理的粒度是方法级别，而编程式事务管理是可以到代码块的，但是可以通过提取方法的方式完成声明式事务管理的配置。

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

事务隔离级别

这些常量均是以 ISOLATION_开头。即形如 ISOLATION_XXX

1、DEFAULT：采用 DB 默认的事务隔离级别。MySql 的默认为 REPEATABLE_READ； Oracle默认为 READ_COMMITTED 

2、READ_UNCOMMITTED：读未提交。未解决任何并发问题

3、READ_COMMITTED：读已提交。解决脏读，存在不可重复读与幻读

4、REPEATABLE_READ：可重复读。解决脏读、不可重复读，存在幻读

5、SERIALIZABLE：串行化。不存在并发问题

事务传播行为

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

事务传播行为常量都是以 PROPAGATION_ 开头，形如 PROPAGATION_XXX

1、PROPAGATION_REQUIRED

2、PROPAGATION_REQUIRES_NEW

3、PROPAGATION_SUPPORTS

4、PROPAGATION_MANDATORY

5、PROPAGATION_NESTED

6、PROPAGATION_NEVER

7、PROPAGATION_NOT_SUPPORTED

PROPAGATION_REQUIRED：

指定的方法必须在事务内执行。若当前存在事务，就加入到当前事务中；若当前没有事务，则创建一个新事务。这种传播行为是最常见的选择，也是 Spring 默认的事务传播行为。如该传播行为加在 doOther()方法上。若 doSome()方法在调用 doOther()方法时就是在事务内运行的，则 doOther()方法的执行也加入到该事务内执行。若 doSome()方法在调用doOther()方法时没有在事务内执行，则 doOther()方法会创建一个事务，并在其中执行

PROPAGATION_SUPPORTS

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

PROPAGATION_REQUIRES_NEW

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

事务默认超时时限

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

Spring事务回滚规则

Spring 事务的默认回滚方式是：发生运行时异常和 error 时回滚，发生受查(编译)异常时提交

Throwable 类是 Java 语言中所有错误或异常的超类

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

程序在编译和运行时出现的另一类错误称之为异常，它是 JVM 通知程序员的一种方式

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

运行时异常，是 RuntimeException 类或其子类，即只有在运行时才出现的异常

NullPointerException、ArrayIndexOutOfBoundsException、IllegalArgumentException 等均属于

运行时异常。这些异常由 JVM 抛出，在编译时不要求必须处理（捕获或抛出）

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

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

事务管理器是 PlatformTransactionManager 接口对象

DataSourceTransactionManager：使用 JDBC 或 MyBatis 进行数据库操作时使用

HibernateTransactionManager：使用 Hibernate 进行持久化数据时使用

1、创建数据库，建一张商品good表和商品销售记录sale_good表

  

2、新建一个maven项目

3、加入maven的依赖

（1）spring依赖 （2）mybatis依赖 （3）mysql驱动 （4）spring的事务依赖 （5）mybatis和spring集成依赖

4、创建实体类

public class Goods {
    private Integer id;
    private String goodName;
    private Integer goodAmount;
    private Float price;

    public Integer getId() {
        return id;
    }

    public void setId(Integer id) {
        this.id = id;
    }

    public String getGoodName() {
        return goodName;
    }

    public void setGoodName(String goodName) {
        this.goodName = goodName;
    }

    public Integer getGoodAmount() {
        return goodAmount;
    }

    public void setGoodAmount(Integer goodAmount) {
        this.goodAmount = goodAmount;
    }

    public Float getPrice() {
        return price;
    }

    public void setPrice(Float price) {
        this.price = price;
    }
}


public class Sale {
    private Integer id;
    private Integer gid;
    private Integer nums;

    public Integer getId() {
        return id;
    }

    public void setId(Integer id) {
        this.id = id;
    }

    public Integer getGid() {
        return gid;
    }

    public void setGid(Integer gid) {
        this.gid = gid;
    }

    public Integer getNums() {
        return nums;
    }

    public void setNums(Integer nums) {
        this.nums = nums;
    }
}

5、创建dao接口和mapper文件

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

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


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

 GoodsDao.xml

    
        
        
        
        
    

    
        select id,good_name,good_amount,price
        from good
        where id = #{gid}
    

    
        update good
        set good_amount = good_amount - #{goodAmount}
        where id=#{id}
    

SaleDao.xml

  
    insert into sale_good(gid,nums) values(#{gid},#{nums})
  

6、创建mybatis主配置文件

7、创建service接口和实现类，属性是dao

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

8、创建spring的配置文件：声明mybatis对象交给spring创建 （1）数据源DataSource （2）SqlSessionFactory （3）Dao对象 （4）声明自定义的service

jdbc.properties数据库的属性配置文件

jdbc.driver=com.mysql.jdbc.Driver
jdbc.url=jdbc:mysql://localhost:3306/ssm
jdbc.user=root
jdbc.password=123456
jdbc.maxActive=20

9、创建测试类

public class TestTransaction {
    @Test
    public void testTransaction(){
        String config = "applicationContext.xml";
        ApplicationContext ac = new ClassPathXmlApplicationContext(config);

        //获取容器中所有对象名
        String names[] = ac.getBeanDefinitionNames();
        for (String name:names){
            System.out.println("容器中对象名称：" + name + "    " + ac.getBean(name));
        }

        //从容器获取service
        BuyGoodService service = (BuyGoodService) ac.getBean("buyGoodService");

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

在 Spring 中通常可以通过以下两种方式来实现对事务的管理（如上步骤创建项目或者模块，如下两种方式区别之处在下面使用事务过程中会单独区分说明）

一、使用 Spring 的事务注解管理事务

@Transactional注解方案适合中小项目使用

spring框架用aop实现给业务方法增加事务的功能， 使用@Transactional注解增加事务

使用@Transactional的步骤：

1、需要声明事务管理器对象

2、开启事务注解驱动， 告诉spring框架，我要使用注解的方式管理事务

spring使用aop机制，创建@Transactional所在的类代理对象，给方法加入事务的功能

spring给业务方法加入事务：

在业务方法执行之前，先开启事务，在业务方法之后提交或回滚事务，使用aop的环绕通知

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

通过@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[]，默认值为空

数组。当然，若只有一个异常类时，可以不使用数组

注：

1、@Transactional 若用在方法上，只能用于 public 方法上。对于其他非public方法，如果加上了注解@Transactional，虽然 Spring 不会报错，但不会将指定事务植入到该方法中。Spring 会忽略掉所有非 public 方法上的@Transaction 注解

2、若@Transaction 注解在类上，则表示该类上所有的方法均将在执行时植入事务

第2步加入依赖

        
        
            junit
            junit
            4.11
            test
        

        
        
            org.springframework
            spring-context
            5.2.5.RELEASE
        
        
        
            org.springframework
            spring-tx
            5.2.5.RELEASE
        
        
            org.springframework
            spring-jdbc
            5.2.5.RELEASE
        

        
        
            org.mybatis
            mybatis
            3.5.1
        

        
        
            org.mybatis
            mybatis-spring
            2.0.1
        

        
        
            mysql
            mysql-connector-java
            5.1.9
        

        
        
            com.alibaba
            druid
            1.2.6
        

    

第7步创建service类和实现类；主要使用@Transactional注解

public class BuyGoodServiceImpl implements BuyGoodService {

    private SaleDao saleDao;

    private GoodsDao goodsDao;

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

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

    /**
     rollbackFor：表示发生的指定异常一定回滚
     原理：
     （1）spring框架首先会检查方法抛出的异常是不是在rollbackFor的属性值中
     如果异常在rollbackFor列表中，不管什么类型异常，一定回滚
     （2）如果抛出的异常不在rollbackFor列表中，spring会判断异常是不是RuntimeException
     如果是一定回滚
     */
    /*@Transactional(
            propagation = Propagation.REQUIRED,//事务传播行为
            isolation = Isolation.DEFAULT,//事务隔离级别
            readOnly = false,//对数据库的操作是否是只读
            rollbackFor = {//指定需要回滚的异常类。类型为 Class[]，默认值为空数组
                    NullPointerException.class,
                    NotEnoughException.class
            }
    )*/

    /**
     使用事务控制的默认值，默认传播行为是REQUIRED，默认隔离级别是DEFAULT，默认抛出运行时异常回滚事务
     */
    @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.getGoodAmount() < nums){
            //商品库存不足
            throw new NotEnoughException("编号是："+goodsId+",商品库存不足");
        }
        //修改库存了
        Goods buyGoods = new Goods();
        buyGoods.setId( goodsId);
        buyGoods.setGoodAmount(nums);
        goodsDao.updateGoods(buyGoods);

        System.out.println("=====buy方法的结束====");
    }
}

第8步，创建spring配置文件；主要使用

这里要特别注意的选择

二、使用 AspectJ 的 AOP 配置管理事务

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

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

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

    
        org.springframework
        spring-aspects
        5.2.5.RELEASE
    

2、声明事务管理器对象

3、声明方法需要的事务类型（配置方法的事务属性【隔离级别，传播行为，超时】） 

4、配置aop：指定哪些哪类要创建代理

第2步加入依赖；变化：加入了aspectj依赖

        
        
            junit
            junit
            4.11
            test
        

        
        
            org.springframework
            spring-context
            5.2.5.RELEASE
        
        
        
            org.springframework
            spring-aspects
            5.2.5.RELEASE
        
        
        
            org.springframework
            spring-tx
            5.2.5.RELEASE
        
        
            org.springframework
            spring-jdbc
            5.2.5.RELEASE
        

        
        
            org.mybatis
            mybatis
            3.5.1
        

        
        
            org.mybatis
            mybatis-spring
            2.0.1
        

        
        
            mysql
            mysql-connector-java
            5.1.9
        

        
        
            com.alibaba
            druid
            1.2.6
        

    

第7步创建service类和实现类；没有使用@Transactional注解

public class BuyGoodServiceImpl implements BuyGoodService {

    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.selectGoods(goodsId);
        if( goods == null){
            //商品不存在
            throw new NullPointerException("编号是："+goodsId+",商品不存在");
        } else if(goods.getGoodAmount() < nums){
            //商品库存不足
            throw new NotEnoughException("编号是："+goodsId+",商品库存不足");
        }
        //修改库存了
        Goods buyGoods = new Goods();
        buyGoods.setId( goodsId);
        buyGoods.setGoodAmount(nums);
        goodsDao.updateGoods(buyGoods);

        System.out.println("=====buy方法的结束====");
    }
}

第8步，创建spring配置文件；主要使用和

这里需要注意选择

我们没使用事务，会发现商品库存没有减少，但是新增了销售记录

使用事务机制之后，会发现库存没有减少，但是商品销售记录表的id由12增到了15，是因为中间运行了两次异常，一次为库存不足异常，一次为商品不存在异常