Spring 声明式事务

- 1.Spring 事务管理概述
- - 1.1 事务管理的重要性
  - 1.2 Spring事务管理的两种方式
  - - 1.2.1 编程式事务管理
    - 1.2.2 声明式事务管理
  - 1.3 为什么选择声明式事务管理
- 2. 声明式事务管理
- - 2.1 基本用法
  - 2.2 常用属性
  - - 2.2.1 propagation（传播行为）
    - 2.2.2 isolation（隔离级别）
    - 2.2.3 readOnly（只读事务）
    - 2.2.4 timeout（超时时间）
    - 2.2.5 rollbackFor（回滚异常）
- 3. Spring事务失效
- 4. 案例
- - 4.1 前期准备
  - - 4.1.1 依赖引入
    - 4.1.2 数据库建表语句
    - 4.1.3 实体类以及相关代码
  - 4.2 转账案例
  - - 4.2.1 测试成功
    - 4.2.2 测试回滚
    - 4.2.3 测试受检异常
    - 4.2.4 测试 rollBackFor 属性
    - 4.2.5 测试隔离级别

Spring 提供了两个事务管理方式一种是编程式(很少用)，一种是声明式事务。声明式事务管理将事务管理的代码从业务逻辑中分离出来，使得代码更清晰、可维护。使得开发者可以通过配置而不是编写大量的代码来管理事务。

使用这里我们只介绍声明式事务

1.Spring 事务管理概述

1.1 事务管理的重要性

在应用程序中，事务管理是确保数据操作的一致性、隔离性、持久性和原子性的关键机制。当多个数据库操作必须作为一个不可分割的单元执行时，事务管理变得至关重要。对于复杂的业务逻辑，事务能够确保在并发和异常情况下，数据库始终保持一致性。

1.2 Spring事务管理的两种方式

Spring框架提供了两种主要的事务管理方式，分别是编程式事务管理和声明式事务管理。

1.2.1 编程式事务管理

编程式事务管理要求开发者通过编写代码来管理事务的开始、提交和回滚。虽然具有灵活性，但容易导致代码冗余和可读性差。

try {
    // 开始事务
    transactionManager.beginTransaction();
    
    // 执行业务逻辑
    
    // 提交事务
    transactionManager.commit();
} catch (Exception e) {
    // 发生异常，回滚事务
    transactionManager.rollback();
    throw e;
}

1.2.2 声明式事务管理

相比之下，声明式事务管理通过配置文件或注解的方式实现事务控制，将事务逻辑从业务代码中分离出来。这种方式更加简洁、可维护，并提供更好的可读性。

@Transactional
public void performBusinessLogic() {
    // 业务逻辑
}

1.3 为什么选择声明式事务管理

选择声明式事务管理有以下优势：

简洁性： 通过注解或XML配置，开发者无需编写冗长的事务管理代码，使代码更加简洁清晰。
可维护性： 事务逻辑与业务逻辑分离，易于维护和理解。
可读性： 使用注解或XML配置，事务逻辑与业务逻辑在代码中更易于辨认，提高代码的可读性。
一致性： 通过统一的配置方式，整个应用程序可以保持一致的事务管理策略，减少错误和不一致性。
集成性： 声明式事务更好地与Spring的其他特性（如AOP）集成，提供更全面的解决方案。

综合而言，声明式事务管理是Spring中推荐的事务管理方式，它能够提高代码的可维护性、可读性，并与其他Spring特性协同工作，使得开发者能够更专注于业务逻辑的实现而不是事务的管理。

2. 声明式事务管理

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

Spring 根据类或者方法上是否有@transactional注解来判断是否开启事务。

2.1 基本用法

在类上使用

@Transactional
public class TestService {
    // 类中所有方法都将使用默认的事务配置
}

在方法上使用

public class TestService {

    @Transactional
    public void method1() {
        // 这个方法将使用默认的事务配置
    }

    @Transactional(propagation = Propagation.REQUIRED, isolation = Isolation.READ_COMMITTED)
    public void method2() {
        // 这个方法将使用指定的事务配置
    }
}

2.2 常用属性

2.2.1 propagation（传播行为）

@Transactional 注解的 propagation 属性用于定义事务的传播行为，它指定在方法被调用时，当前方法的事务如何与现有的事务进行交互。

@Transactional(propagation = Propagation.*)
public void method1() {
    // ...
}

定义事务的传播行为，包括：

REQUIRED：默认，如果当前存在事务，则加入该事务，如果不存在事务，则新建一个事务。
REQUIRES_NEW：无论当前是否存在事务，都会创建一个新的事务，如果存在事务，则将其挂起。
SUPPORTS：如果当前存在事务，则加入该事务，如果不存在事务，则以非事务的方式执行。
MANDATORY：该传播行为要求当前方法必须在一个事务中执行，否则将抛出异常。
NOT_SUPPORTED：以非事务的方式执行，如果当前存在事务，则将其挂起。
NEVER：以非事务的方式执行，如果当前存在事务，则抛出异常。
NESTED：如果当前存在事务，则创建一个嵌套事务，并在嵌套事务内执行。嵌套事务是外部事务的一部分，但有独立的提交和回滚。

2.2.2 isolation（隔离级别）

@Transactional 注解中的 isolation 属性用于指定事务的隔离级别。隔离级别定义了多个事务并发执行时，彼此之间的可见性和影响的程度。

@Transactional(isolation = Isolation.*)
public void method1() {
    // ...
}

Spring 支持以下五个隔离级别：

DEFAULT：默认，使用底层数据库的默认隔离级别。通常为数据库的默认配置，比如 MySQL 默认的是 REPEATABLE_READ，而 Oracle 默认的是 READ_COMMITTED。
READ_UNCOMMITTED（读未提交）：允许一个事务读取另一个事务未提交的数据。这是最低的隔离级别，可能导致脏读、不可重复读和幻读的问题。
READ_COMMITTED（读已提交）：保证一个事务提交后才能被其他事务读取。这是大多数数据库的默认隔离级别，可以避免脏读，但仍可能存在不可重复读和幻读的问题。
REPEATABLE_READ（可重复读）：对相同字段的多次读取结果是一致的，除非自己进行了数据更新。避免了不可重复读的问题，但仍可能存在幻读的问题。
SERIALIZABLE（串行化）：最高的隔离级别，确保每个事务都完全看不到其他事务的操作，包括读取和写入。可以避免脏读、不可重复读和幻读的问题，但也降低了并发性能。

2.2.3 readOnly（只读事务）

标识事务是否为只读，可以提高事务的性能。

@Transactional(readOnly = true)
public void method1() {
    // ...
}

2.2.4 timeout（超时时间）

指定事务的超时时间，单位为秒。

@Transactional(timeout = 60)
public void method1() {
    // ...
}

2.2.5 rollbackFor（回滚异常）

指定哪些异常触发事务回滚。@Transactional 注解默认只对运行时异常进行事务回滚，对检查时异常不回滚。

@Transactional(rollbackFor = {SQLException.class, MyCustomException.class})
public void method1() {
    // ...
}

3. Spring事务失效

哪些情况下会导致Spring事务失效，对应的原因是什么？

1.方法内的自调用：Spring事务是基于AOP的，只要使用代理对象调用某个方法时，Spring事务才能生效，而在一个方法中调用使用this.xxxO调用方法时，this并不是代理对象，所以会导致事务失效。
- 解决办法1：将需要在同一事务中执行的方法抽取到一个独立的Bean中，通过依赖注入的方式调用该Bean。确保方法调用经过代理对象，从而激活事务。
- 解决办法2：在类内部通过依赖注入的方式，将当前类注入到自己中，然后通过注入的对象调用方法。这样确保调用经过代理对象，从而使事务生效。
- 解决办法3：使用AopContext.currentProxy()获取当前代理对象，通过这个代理对象调用方法。结合@EnableAspectJAutoProxy(exposeProxy=true)注解开启对当前代理对象的暴露，确保事务能够正确地被激活。
2.方法是private的：Spring事务会基于CGLIB来进行AOP，而CGLIB会基于父子类来失效，子类是代理类，父类是被代理类，如果父类中的某个方法是private的，那么子类就没有办法重写它，也就没有办法额外增加Spring事务的逻辑。
3.方法是final的：原因和private是了样的，也是由于子类不能重写父类中的final的方法
4.单独的线程调用方法：当Mybatis或JdbcTemplate执行SQL时，会从ThreadLocal中去获取数据库连接对象，如果开启事务的线程和执行SQL的线程是同一个，那么就能拿到数据库连接对象，如果不是同一个线程，那就拿到不到数据库连接对象，这样，Mybatis或JdbcTemplate就会自己去新建一个数据库连接用来执行SQL，此数据库连接的autocommit为true，那么执行完SQL就会提交，后续再抛异常也就不能再回滚之前已经提交了的SQL了。
5.没加@Configuration注解：如果用SpringBoot基本没有这个问题，但是如果用的Spring，那么可能会有这个问题，这个问题的原因其实也是由于Mybatis或JdbcTemplate会从ThreadLocal中去获取数据库连接，但是ThreadLocal中存储的是一个MAP，MAP的key为DataSource对象，value为连接对象，而如果我们没有在AppConfig上添加@Configuration注解的话，会导致MAP中存的DataSource对象和Mybatis和JdbcTemplate中的DataSource对象不相等，从而也拿不到数据库连接，导致自己去创建数据库连接了。
6.异常被吃掉：如果Spring事务没有捕获到异常，那么也就不会回滚了，默认情况下Spring会捕获RuntimeException和Error。
7.类没有被Spring管理
8.数据库不支持事务

4. 案例

4.1 前期准备

4.1.1 依赖引入

    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
        </dependency>
        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>druid</artifactId>
            <version>1.1.16</version>
        </dependency>
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
        </dependency>
        <!-- 使用Plus 简化开发 -->
        <dependency>
            <groupId>com.baomidou</groupId>
            <artifactId>mybatis-plus-boot-starter</artifactId>
            <version>3.5.1</version>
        </dependency>
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>8.0.17</version>
        </dependency>
    </dependencies>

4.1.2 数据库建表语句

CREATE TABLE `users`  (
  `id` int NOT NULL AUTO_INCREMENT,
  `user_name` varchar(18)  NOT NULL,
  `balance` decimal(10, 2) NULL DEFAULT NULL,
  PRIMARY KEY (`id`) USING BTREE
)

4.1.3 实体类以及相关代码

User

@Data
public class User {
    private int id;
    private String userName;
    private Double balance;
}

UserMapper

@Mapper
public interface UserMapper extends BaseMapper<User> {
}

UserService

public interface UserService extends IService<User> {
}

UserServiceImpl

@Service
public class UserServiceImpl extends ServiceImpl<UserMapper, User> implements UserService {
}

application.yml

Spring:
  datasource:
    url: jdbc:mysql://localhost:3306/test?useUnicode=true&characterEncoding=utf-8
    driver-class-name: com.mysql.cj.jdbc.Driver
    username: root
    password: 120125hzy.
    type:  com.alibaba.druid.pool.DruidDataSource
mybatis-plus: # MyBatis Plus配置
  configuration: 
    map-underscore-to-camel-case: true # 驼峰下划线转换
logging: # 控制台打印 SQL
  level:
    com:
      example:
        mapper: debug

4.2 转账案例

在Spring中，你可以使用@Transactional注解来实现声明式事务。这个注解可以应用于类级别或方法级别，具体取决于你想要控制事务的粒度。

接口编写

    /**
     * 测试转账
     */
    String Transfer(Integer fromId, Integer toId, Double money);

生成单元测试，每次测试前两人余额都调整为 10000.00

@SpringBootTest
class UserServiceImplTest {
    @Autowired
    private UserService userService;

    @Test
    void transfer() {
       String  ans =  userService.Transfer(1,2,600.0);
       assert ans.equals("转账成功");
    }
}

4.2.1 测试成功

 @Override
    @Transactional
    public String Transfer(Integer fromId, Integer toId, Double money) {
        try {
            // 查询转出账户
            User fromUser = getById(fromId);
            if (fromUser == null) {
                throw new RuntimeException("转出账户不存在");
            }

            // 查询转入账户
            User toUser = getById(toId);
            if (toUser == null) {
                throw new RuntimeException("转入账户不存在");
            }

            // 检查余额是否足够
            if (fromUser.getBalance() < money) {
                throw new RuntimeException("余额不足");
            }

            // 更新转出账户余额
            fromUser.setBalance(fromUser.getBalance() - money);
            updateById(fromUser);

            // 更新转入账户余额
            toUser.setBalance(toUser.getBalance() + money);
            updateById(toUser);
 			log.info("转账成功");
            return "转账成功";
        } catch (Exception e) {
            throw new RuntimeException("转账失败: " + e.getMessage());
        }
    }

测试通过

在这里插入图片描述

数据库也成功修改

在这里插入图片描述

4.2.2 测试回滚

   @Override
    @Transactional
    public String Transfer(Integer fromId, Integer toId, Double money) {
        try {
            // 查询转出账户
            User fromUser = getById(fromId);
            if (fromUser == null) {
                throw new RuntimeException("转出账户不存在");
            }

            // 查询转入账户
            User toUser = getById(toId);
            if (toUser == null) {
                throw new RuntimeException("转入账户不存在");
            }

            // 检查余额是否足够
            if (fromUser.getBalance() < money) {
                throw new RuntimeException("余额不足");
            }

            // 更新转出账户余额
            fromUser.setBalance(fromUser.getBalance() - money);
            updateById(fromUser);

            // 手动抛出异常，测试事务回滚
            if (1 == 1) throw new RuntimeException("转账异常，事务回滚");
            
            // 更新转入账户余额
            toUser.setBalance(toUser.getBalance() + money);
            updateById(toUser);

            log.info("转账成功");
            return "转账成功";
        } catch (Exception e) {
            throw new RuntimeException("转账失败: " + e.getMessage());
        }
    }

测试未通过

在这里插入图片描述

数据库也没有改变

4.2.3 测试受检异常

    @Override
    @Transactional
    public String Transfer(Integer fromId, Integer toId, Double money) throws SQLException {
        try {
            // 查询转出账户
            User fromUser = getById(fromId);
            if (fromUser == null) {
                throw new RuntimeException("转出账户不存在");
            }

            // 查询转入账户
            User toUser = getById(toId);
            if (toUser == null) {
                throw new RuntimeException("转入账户不存在");
            }

            // 检查余额是否足够
            if (fromUser.getBalance() < money) {
                throw new RuntimeException("余额不足");
            }

            // 更新转出账户余额
            fromUser.setBalance(fromUser.getBalance() - money);
            updateById(fromUser);

            // 手动抛出异常，测试事务回滚
            if (1 == 1) throw new RuntimeException("转账异常，事务回滚");

            // 更新转入账户余额
            toUser.setBalance(toUser.getBalance() + money);
            updateById(toUser);

            log.info("转账成功");
            return "转账成功";
        } catch (Exception e) {
            throw new SQLException("转账失败: " + e.getMessage());
        }
    }

测试未通过

在这里插入图片描述

事务未回滚

在这里插入图片描述

4.2.4 测试 rollBackFor 属性

@Transactional(rollbackFor = SQLException.class)

这次成功回滚了。

在这里插入图片描述

4.2.5 测试隔离级别

添加一个接口

    /**
     *  测试付款
     */
    String payment(Integer id,Double money);

    @Override
    @Transactional()
    public String payment(Integer id, Double money) {
        try {
            User user = getById(id);
            if (user == null) {
                throw new RuntimeException("支付账户不存在");
            }
            // 更新转出账户余额
            user.setBalance(user.getBalance()-money);
            updateById(user);
            Thread.sleep(5000);
            if (1 == 1) throw new RuntimeException("转账异常，事务回滚");
            log.info("支付成功");
        }catch (RuntimeException e){
            throw new RuntimeException("支付失败");
        }catch (Exception e){

        }
        return "支付成功";
    }

修改 Transfer()

@Override
    @Transactional(isolation = Isolation.READ_UNCOMMITTED)
    public String Transfer(Integer fromId, Integer toId, Double money){
        try {
            // 查询转出账户
            User fromUser = getById(fromId);
            if (fromUser == null) {
                throw new RuntimeException("转出账户不存在");
            }
            log.info("id: {}的余额:{}",fromUser.getId(),fromUser.getBalance());
            // 查询转入账户
            User toUser = getById(toId);
            if (toUser == null) {
                throw new RuntimeException("转入账户不存在");
            }

            // 检查余额是否足够
            if (fromUser.getBalance() < money) {
                throw new RuntimeException("余额不足");
            }

            // 更新转出账户余额
            fromUser.setBalance(fromUser.getBalance() - money);
            updateById(fromUser);

            // 更新转入账户余额
            toUser.setBalance(toUser.getBalance() + money);
            updateById(toUser);

            log.info("转账成功");
            return "转账成功";
        } catch (Exception e) {
            throw new RuntimeException("转账失败: " + e.getMessage());
        }
    }

测试函数

    @Test
    void test() throws InterruptedException {
        Thread t1 = new Thread(()->{
            userService.payment(1,500.0);
        });
        t1.start();
        Thread.sleep(2000);
        userService.Transfer(1,2,600.0);
    }