清晰、明了的@Transcation事务嵌套使用

概述

  事务（Transaction）：指数据库中执行的一系列操作被视为一个逻辑单元，要么全部成功地执行，要么全部失败回滚，保证数据的一致性和完整性。
  @Transactional注解是Spring框架提供的用于声明事务的注解，作用于类和方法上。

@Transcation注解

属性	可选值	作用
propagation	REQUIRED REQUIRES_NEW NESTED NOT_SUPPORTED SUPPORTS	指定事务的传播行为，默认值为Propagation.REQUIRED
isolation	DEFAULT READ_UNCOMMITTED READ_COMMITTED REPEATABLE_READ SERIALIZABLE	指定事务的隔离级别，默认值为Isolation.DEFAULT
readOnly	true false	指定事务是否为只读事务，默认值为false。如果将其设置为true，表示事务只涉及读取操作
timeout	数字（秒）	指定事务的超时时间（秒），默认值为TransactionDefinition.TIMEOUT_DEFAULT。如果事务在指定的时间内未完成，将被自动回滚
rollbackFor	异常类.Class	指定触发事务回滚的异常类型数组，默认为空。当方法抛出指定类型的异常时，事务将回滚
noRollbackFor	异常类.Class	指定不触发事务回滚的异常类型数组，默认为空。当方法抛出指定类型的异常时，事务将不回滚
rollbackForClassName	异常类名	与rollbackFor类似，但是使用异常类型的完全限定名字符串来指定触发事务回滚的异常
noRollbackForClassName	异常类名	与noRollbackFor类似，但是使用异常类型的完全限定名字符串来指定不触发事务回滚的异常

事务实现原理

  Spring的事务是依靠动态代理技术实现的，是在程序运行时给代理对象创建代理类。如果方法或类上添加了@Transcation注解，spring会自动给方法或类创建一个代理类，代理类中包含了开关事务的代码和原始操作。

  示意图如下（原始类指加了@Transcation的类）：

---

@Transcation使用

1、事务生效的情况：

  这里用一个demo举例子：更新一条数据，我们先删除数据，再插入新数据（主键自动递增）。我们希望删除或插入哪一方失败，数据库都能回滚。

1. 外层有事务，内层无事务

  内外层哪一方有异常，全部都会回滚。

    //外层
    @Transactional
    public void update(Category category) {
        this.categoryDao.delete(category);
        this.insert(category);//无事务，但有异常
    }
    
    //内层
    public void insert(Category category) {
    	this.categoryDao.insert(category);
        int a=2/0;
    }

结论：外层有事务，内层也会有事务

---

2. 外层事务（requierd），内层事务（not_supported）

事务隔离级别：not_supported：

  先说说事务隔离级别为not_supported时，事务会被挂起，等于没有事务，有异常也不会回滚。

    @Transactional(propagation = Propagation.NOT_SUPPORTED)
    public boolean deleteById(Integer cid) {
        int i = this.categoryDao.deleteById(cid);
        if(i>0) {
            throw new RuntimeException("xxx"); //有异常也不回滚
        }
        return true;
    }

  如果外层事务为required（不写类型默认required）：内外层哪一方有异常，全部都会回滚。

    //外层
    @Transactional(propagation = Propagation.REQUIRED)
    public void updateById(Category category) {
        this.categoryDao.insert(category);
        this.deleteById(category.getCid());
    }
	
	//内层
    @Transactional(propagation = Propagation.NOT_SUPPORTED)
    public boolean deleteById(Integer cid) {
        int i = this.categoryDao.deleteById(cid);
        if(i>0) {
            throw new RuntimeException("xxx"); 
        }
        return true;
    }

结论：不管内层是什么级别的事务、有没有事务，只以外层事务为准

总结：

  为什么外层有事务，内层就有事务？借用下图就能理解，method1方法上有事务注解，method1调用了method2。
  生成的代理类长什么样子呢：用事务“包”住了这两个方法的原始代码。

---

2、事务不生效的情况：

1. 外层无事务，内层有事务

  内层有异常会回滚，和外层无关。外层有异常不会回滚。

    //外层
    public void update(Category category) {
        this.delete(category);
        this.categoryDao.insert(category);
        //int a=2/0; //外有异常，内无异常，删除成功，插入失败
    }
	
	//内层
	@Transactional
    void delete(Category category) {
        this.categoryDao.delete(category.getId);
        //int a=2/0; //外无异常，内有异常，删除、插入都失败
    }

结论：内层有事务，不影响外层。

---

2. 异常被 catch 住，而且没有再次抛出异常

  无论是外层异常还是内层异常，只要捕获以后没有抛出异常，都不会回滚。总的来说没有异常不会回滚。

	//外层
    @Transactional
    public void updateById(Category category) {
        try {
            this.categoryDao.deleteById(category.getCid());
            this.categoryDao.insert(category);
            int a=2/0;
        }catch (java.lang.Exception e){
            System.out.println("updateById异常");
        }
    }

    //外层
    public void update(Category category) {
        this.delete(category);
        this.categoryDao.insert(category);
    }
	
	//内层
	@Transactional
    void delete(Category category) {
    	try{
	        this.categoryDao.delete(category.getId);
	        int a=2/0;
        }catch(Exception e){

		}
    }

解决办法：
  捕获后再次抛出异常。无论是内层、外层，只要重新抛出异常，就可以回滚。

    //外层
    public void update(Category category) {
        this.delete(category);
        this.categoryDao.insert(category);
    }
	
	//内层
	@Transactional
    void delete(Category category) {
    	try{
	        this.categoryDao.delete(category.getId);
	        int a=2/0;
        }catch(Exception e){
			throw new RuntimeException("service层deleteById方法异常");//可以自定义异常
		}
    }

结论：没有异常不会回滚。

---

3. 抛出RuntimeException或Error以外的异常

  @Transcation有个属性(方法)，管理何种异常会引发回滚。
  默认情况下，事务只在RuntimeException和Error上回滚。

  抛出RuntimeException和Error以外类型的异常，不会回滚。   常见的非运行时异常有：SQLException、IOException、FileNotFoundException、ReflectiveOperationException等等。

	@Transactional
    void delete(Category category) throws SQLException{
        this.categoryDao.delete(category.getId);
        int a=2/0;
       	throw new SQLException("xxx");  //抛出异常也不会回滚
    }

解决办法：
  使用RollbackFor属 添加 要捕获的异常类型，这样除了RuntimeException和Error类型的异常，遇到Exception以及它的子类的异常，也会发生回滚。

	@Transactional(rollbackFor = Exception.class)
    void delete(Category category) throws SQLException{
        this.categoryDao.delete(category.getId);
        int a=2/0;
       	throw new SQLException("xxx");  //这下就回滚了
    }

结论：使用RollbackFor属性添加要捕获的异常类型

---

4. 子线程内异常

  删除操作新开一个线程执行，并且执行中发生异常。结果是删除回滚，插入没回滚。
  多线程环境下，内外层是两个事务，事务具有隔离性，事务之间不会互相干扰。

    //外层
    @Transactional(rollbackFor = java.lang.Exception.class)
    public void update(Category category) {
        Thread thread=new Thread(new Runnable() {
           @Override
           public void run() {
                delete(category);//删除
            }
        });
        this.categoryDao.insert(category);//插入
    }
	
	//内层
	@Transactional(rollbackFor = java.lang.Exception.class)
    void delete(Category category) {
        this.categoryDao.delete(category.getId);
        int a=2/0; //异常
    }

解决办法：
  使用Thread.UncaughtExceptionHandler接口捕获线程异常，主线程发现了异常，也跟着回滚。
  注：事务还是多个事务

1. 创建一个实现了Thread.UncaughtExceptionHandler接口的异常处理器类，该类将负责捕获未被捕获的（没加try-catch的）线程异常并进行处理：

public class CustomUncaughtExceptionHandler implements Thread.UncaughtExceptionHandler {
    @Override
    public void uncaughtException(Thread t, Throwable e) {
        // 在此可以处理未被捕获的线程异常
        System.out.println("线程 " + t.getName() + " 发生了异常: " + e.getMessage());
    }
}

2. 在主线程或创建的子线程中，设置自定义的异常处理器：

    @Transactional(rollbackFor = java.lang.Exception.class)
    public void updateById(Category category){
        Thread.setDefaultUncaughtExceptionHandler(new CustomUncaughtExceptionHandler());//加上这句
        Thread thread=new Thread(new Runnable() {
            @Override
            public void run() {
                deleteById(category.getCid());//删除
            }
        });
        thread.start();
        this.categoryDao.insert(category);//插入
    }

结论：子线程异常抛给主线程，两者一起回滚。

---

5. 事务方法是private、static、final的

  方法不能被重写，就不能生产代理类。

结论：java实现的动态代理的原理是代理类实现被代理类的相同接口，重写相同方法

---

6. 数据库不支持事务

---

总结

  spring相当多的功能都用到了动态代理，还需要对这方面知识做个总结，学无止境啊。