什么是事务？

1. Atomicity（原子性）：事务中的所有操作，或者全部完成，或者全部不完成，不会结束在中间某个环节。
2. 一致性（Consistency）：在事务开始之前和事务结束以后，数据库的完整性没有被破坏。
3. 事务隔离（Isolation）：多个事务之间是独立的，不相互影响的。
4. 持久性（Durability）：事务处理结束后，对数据的修改就是永久的，即便系统故障也不会丢失。

为什么要有 Spring 事务？

1. 将张三的账户余额减少 10 元。
2. 将李四的账户余额增加 10 元。

编程式事务

1. 使用 <font style="color:rgb(1, 1, 1);">TransactionTemplate</font> 对象实现编程式事务；
2. 使用更加底层的 <font style="color:rgb(1, 1, 1);">TransactionManager</font> 对象实现编程式事务。

TransactionTemplate

@Autowired
private TransactionTemplate transactionTemplate;
@Test
public void testTransactionTemplate(){
    BjBook book = new BjBook();
    book.setId(1);
    book.setName("西游记");
    book.setAuthor("吴承恩");
    transactionTemplate.execute(status -> {
        int  result = 0;
        try {
            result = bjBookMapper.insert(book);
                      //int i = 1/0;
        }catch (Exception e){
            status.setRollbackOnly();
        }
        return result;
    });
}

TransactionManager

<font style="color:rgb(74, 74, 74);">TransactionManager</font> 实现编程式事务相对麻烦一点，它需要使用两个对象：<font style="color:rgb(74, 74, 74);">TransactionManager</font> 的子类，加上 <font style="color:rgb(74, 74, 74);">TransactionDefinition</font> 事务定义对象，再通过调用 <font style="color:rgb(74, 74, 74);">TransactionManager</font> 的 <font style="color:rgb(74, 74, 74);">getTransaction</font> 获取并开启事务，然后调用 <font style="color:rgb(74, 74, 74);">TransactionManager</font> 提供的 <font style="color:rgb(74, 74, 74);">commit</font> 方法提交事务，或使用它的另一个方法 <font style="color:rgb(74, 74, 74);">rollback</font> 回滚事务，它的具体实现代码如下：

@Autowired
private DataSourceTransactionManager transactionManager;
@Autowired
private TransactionDefinition transactionDefinition;
@Test
public void testTransactionManager(){
    BjBook book = new BjBook();
    book.setId(1);
    book.setName("西游记");
    book.setAuthor("吴承恩");
    //获取事务（1. 开启事务）
    TransactionStatus transaction = transactionManager.getTransaction(transactionDefinition);
    int result = bjBookMapper.insert(book);
    //2. 提交事务
    transactionManager.commit(transaction);
    //3. 回滚事务
    //transactionManager.rollback(transaction);
}

使用编程式事务更加灵活，但写法比较麻烦。

声明式事务

@Autowired
private BjBookService bjBookService;
//注意，不能子在单元测试上使用此注解。否则操作的数据会回滚无法提交。
//如果你就想直接提交，可以直接在方法上加上 @Rollback(false) 或者 @Commit ，这样事务就不会回滚了
// 我这里通过调用service的add方法进行测试的
@Test
public void testTransactional(){
    BjBook book = new BjBook();
    book.setId(1);
    book.setName("西游记");
    book.setAuthor("吴承恩");
    bjBookService.add(book);
}
@Service
public class BjBookServiceImpl implements BjBookService {
    @Autowired
    private BjBookMapper bjBookMapper;
    @Transactional
    @Override
    public int add(BjBook book) {
        int result = bjBookMapper.insert(book);
        result = 1/0;
        return result;
    }
}

**<font style="color:rgb(74, 74, 74);">@Transactional</font>**参数

@Transactional(propagation = Propagation.NESTED)

事务传播类型

1. 子事务与父事务的关系，是否会启动一个新的事务？
2. 子事务异常时，父事务是否会回滚？
3. 父事务异常时，子事务是否会回滚？
4. 父事务捕捉异常后，父事务是否还会回滚？

REQUIRED

@Override
public void testA() {
    System.out.println("testA ~~~");
    bjBookMapper.insert(new BjBook(1,"西游记","吴承恩"));
    shBookService.testB();
}
@Transactional
@Override
public void testB() {
    System.out.println("testB ~~~");
    shBookMapper.insert(new ShBook(2,"三体","刘慈欣"));
    throw new RuntimeException("测试异常");
}

@Transactional
@Override
public void testA() {
    System.out.println("testA ~~~");
    bjBookMapper.insert(new BjBook(1,"西游记","吴承恩"));
    shBookService.testB();
    throw new RuntimeException("测试异常");
}
@Transactional
@Override
public void testB() {
    System.out.println("testB ~~~");
    shBookMapper.insert(new ShBook(2,"三体","刘慈欣"));
}

@Transactional
@Override
public void testA() {
    System.out.println("testA ~~~");
    bjBookMapper.insert(new BjBook(1,"西游记","吴承恩"));
    shBookService.testB();
}
@Transactional
@Override
public void testB() {
    System.out.println("testB ~~~");
    shBookMapper.insert(new ShBook(2,"三体","刘慈欣"));
    throw new RuntimeException("测试异常");
}

@Transactional
@Override
public void testA() {
    System.out.println("testA ~~~");
    bjBookMapper.insert(new BjBook(1,"西游记","吴承恩"));
    try {
        shBookService.testB();
    }catch (Exception e){
        System.out.println(e);
    }
}
@Transactional
@Override
public void testB() {
    System.out.println("testB ~~~");
    shBookMapper.insert(new ShBook(2,"三体","刘慈欣"));
    throw new RuntimeException("测试异常");
}

@Transactional
@Override
public void testA() {
    System.out.println("testA ~~~");
    bjBookMapper.insert(new BjBook(1,"西游记","吴承恩"));
    shBookService.testB();
    throw new RuntimeException("测试异常");
}
@Transactional(propagation = Propagation.REQUIRES_NEW)
@Override
public void testB() {
    System.out.println("testB ~~~");
    shBookMapper.insert(new ShBook(2,"三体","刘慈欣"));
}

@Transactional
@Override
public void testA() {
    System.out.println("testA ~~~");
    bjBookMapper.insert(new BjBook(1,"西游记","吴承恩"));
    shBookService.testB();
}
@Transactional(propagation = Propagation.REQUIRES_NEW)
@Override
public void testB() {
    System.out.println("testB ~~~");
    shBookMapper.insert(new ShBook(2,"三体","刘慈欣"));
    throw new RuntimeException("测试异常");
}

@Transactional
@Override
public void testA() {
    System.out.println("testA ~~~");
    bjBookMapper.insert(new BjBook(1,"西游记","吴承恩"));
    //捕获异常
    try {
        shBookService.testB();
    }catch (Exception e){
        System.out.println(e);
    }
}
@Transactional(propagation = Propagation.REQUIRES_NEW)
@Override
public void testB() {
    System.out.println("testB ~~~");
    shBookMapper.insert(new ShBook(2,"三体","刘慈欣"));
    throw new RuntimeException("测试异常");
}

NESTED

@Transactional
@Override
public void testA() {
    System.out.println("testA ~~~");
    bjBookMapper.insert(new BjBook(1,"西游记","吴承恩"));
    shBookService.testB();
    throw new RuntimeException("测试异常");
}
@Transactional(propagation = Propagation.NESTED)
@Override
public void testB() {
    System.out.println("testB ~~~");
    shBookMapper.insert(new ShBook(2,"三体","刘慈欣"));
}

@Transactional
@Override
public void testA() {
    System.out.println("testA ~~~");
    bjBookMapper.insert(new BjBook(1,"西游记","吴承恩"));
    shBookService.testB();
}
@Transactional(propagation = Propagation.NESTED)
@Override
public void testB() {
    System.out.println("testB ~~~");
    shBookMapper.insert(new ShBook(2,"三体","刘慈欣"));
    throw new RuntimeException("测试异常");
}

@Transactional
@Override
public void testA() {
    System.out.println("testA ~~~");
    bjBookMapper.insert(new BjBook(1,"西游记","吴承恩"));
    //捕获异常
    try {
        shBookService.testB();
    }catch (Exception e){
        System.out.println(e);
    }
}
@Transactional(propagation = Propagation.NESTED)
@Override
public void testB() {
    System.out.println("testB ~~~");
    shBookMapper.insert(new ShBook(2,"三体","刘慈欣"));
    throw new RuntimeException("测试异常");
}

什么时候 Spring 事务会失效？

1. 若同一类中的其他没有 <font style="color:black;">@Transactional</font> 注解的方法内部调用有 <font style="color:black;">@Transactional</font> 注解的方法，有 <font style="color:black;">@Transactional</font> 注解的方法的事务会失效。这是由于 Spring AOP 代理的原因造成的，因为只有当 <font style="color:black;">@Transactional</font> 注解的方法在类以外被调用的时候，Spring 事务管理才生效。
2. 另外，如果直接调用，不通过对象调用，也是会失效的。因为 Spring 事务是通过 AOP 实现的。
3. <font style="color:black;">@Transactional</font> 注解只有作用到 <font style="color:black;">public</font> 方法上事务才生效。
4. 被 <font style="color:black;">@Transactional</font> 注解的方法所在的类必须被 Spring 管理。
5. 底层使用的数据库必须支持事务机制，否则不生效。

其他四个需要了解

PROPAGATION_MANDATORY：如果当前存在事务，则加入该事务；如果当前没有事务，则抛出异常。

PROPAGATION_SUPPORTS：如果当前存在事务，则加入该事务；如果当前没有事务，则以非事务的方式继续运行。

PROPAGATION_NOT_SUPPORTED：以非事务方式运行，如果当前存在事务，则把当前事务挂起。

PROPAGATION_NEVER：以非事务方式运行，如果当前存在事务，则抛出异常。

事务隔离级别

隔离级别是指若干个并发的事务之间的隔离程度，与我们开发时候主要相关的场景包括：脏读取、重复读、幻读。

Isolation 的 Enum类中定义了五个表示隔离级别的值，如下：

Isolation.DEFAULT：使用各个数据库默认的隔离级别【默认】。MySQL 默认采用的是 REPEATABLE_READ，也就是可重复读。
Isolation.READ_UNCOMMITTED：读取未提交数据（会出现脏读, 不可重复读）（基本不使用）
Isolation.READ_COMMITTED：读取已提交数据（会出现不可重复读和幻读）
Isolation.REPEATABLE_READ：可重复读（会出现幻读）
Isolation.SERIALIZABLE：串行化。最高的隔离级别，虽然可以阻止脏读、幻读和不可重复读，但会严重影响程序性能。

简单解释下什么是脏读、不可重复读、幻读：

• 脏读：一个事务读取到另一事务未提交的更新数据；
• 不可重复读： 在同一事务中，多次读取同一数据返回的结果有所不同。换句话说：后续读取可以读到另一事务已提交的更新数据。相反，”可重复读”在同一事务中多次读取数据时，能够保证所读数据一样，也就是后续读取不能读到另一事务已提交的更新数据；
• 幻读： 一个事务读到另一个事务已提交的 insert 数据；

事务超时时间

事务只读属性

事务的回滚策略

@Transactional(rollbackFor=MyException.class)

指定使用的事务管理器

value 主要用来指定不同的事务管理器，主要用来满足在同一个系统中，存在不同的事务管理器的场景需要。

比如，在Spring中声明了两种事务管理器txManager1，txManager2。然后，用户可以根据需要，修改这个参数来指定特定的txManager。

存在多个事务管理器的情况：在一个系统中，需要访问多个数据源，则必然会配置多个事务管理器。