概述

事务（Transaction）：指数据库中执行的一系列操作被视为一个逻辑单元，要么全部成功地执行，要么全部失败回滚，保证数据的一致性和完整性。

@Transactional注解是Spring框架提供的用于声明事务的注解，作用于类和方法上。

@Transcation注解

事务实现原理

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接口捕获线程异常，主线程发现了异常，也跟着回滚。

注：事务还是多个事务

创建一个实现了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());
    }
}

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

    @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相当多的功能都用到了动态代理，还需要对这方面知识做个总结，学无止境啊。

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

概述