一、SpringBoot 事务传播
以下是关于Spring Boot事务传播的详细解析以及相应的案例代码：
事务传播行为概述
事务传播行为定义了多个包含事务的方法在相互调用时，事务是如何在这些方法间进行传播的。例如，一个方法调用另一个带有事务的方法时，新方法是沿用调用者的事务，还是开启新的事务，亦或是不使用事务等情况，Spring 提供了多种事务传播行为的选项来应对不同的业务场景需求。
Spring 中常用的事务传播行为有以下几种（定义在 org.springframework.transaction.annotation.Propagation 枚举中）：
- REQUIRED（默认值）：如果当前存在事务，则加入该事务；如果当前没有事务，则创建一个新的事务。
- SUPPORTS：如果当前存在事务，则加入该事务；如果当前没有事务，则以非事务的方式执行方法。
- MANDATORY：如果当前存在事务，则加入该事务；如果当前没有事务，则抛出异常，要求必须在一个事务中执行。
- REQUIRES_NEW：总是创建一个新的事务，如果当前已经存在事务，则将当前事务挂起，等新事务执行完毕后再恢复原事务。
- NOT_SUPPORTED：以非事务方式执行操作，如果当前存在事务，则将当前事务挂起，执行完该方法后再恢复事务。
- NEVER：以非事务方式执行，如果当前存在事务，则抛出异常，表明该方法不应在事务环境中运行。
- NESTED：如果当前存在事务，则在嵌套事务内执行；如果当前没有事务，则行为与
REQUIRED类似，创建一个新事务。嵌套事务是外部事务的一个子事务，嵌套事务回滚不会导致外部事务回滚，但外部事务回滚会导致嵌套事务回滚。
案例代码示例
以下基于Spring Boot项目（使用Spring Data JPA操作数据库为例）演示不同事务传播行为的效果，假设有两个服务层方法，一个调用另一个，来观察事务的传播情况。
- 引入依赖
在pom.xml文件中添加必要的依赖，主要包括Spring Boot Web、Spring Data JPA以及数据库驱动（这里以MySQL为例）等：
<dependency><groupId>org.springframework.boot</groupId><artifactId>spring-boot-starter-web</artifactId>
</dependency>
<dependency><groupId>org.springframework.boot</groupId><artifactId>spring-boot-starter-data-jpa</artifactId>
</dependency>
<dependency><groupId>mysql</groupId><artifactId>mysql-connector-java</artifactId><scope>runtime</scope>
</dependency>
- 配置数据库连接
在application.properties（或application.yml）文件中配置数据库连接相关信息：
spring.datasource.url=jdbc:mysql://localhost:3306/your_database_name?useSSL=false&serverTimezone=UTC
spring.datasource.username=your_username
spring.datasource.password=your_password
spring.datasource.driver-class-name=com.mysql.cj.Driverspring.jpa.show-sql=true
spring.jpa.hibernate.ddl-auto=update
- 实体类定义
创建一个简单的实体类，例如User实体：
import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;@Entity
public class User {@Id@GeneratedValue(strategy = GenerationType.IDENTITY)private Long id;private String username;private String password;// 构造函数、Getter和Setter方法省略
}
- 数据访问层接口（Repository）
创建UserRepository接口来操作User实体：
import org.springframework.data.jpa.repository.JpaRepository;
import com.example.demo.model.User;public interface UserRepository extends JpaRepository<User, Long> {
}
- 服务层接口及实现类（演示事务传播行为）
定义服务层接口UserService：
import com.example.demo.model.User;public interface UserService {void saveUser(User user);void saveUserWithAnotherMethod(User user);
}
服务层实现类 UserServiceImpl，这里演示 REQUIRED 和 REQUIRES_NEW 两种传播行为（可以自行修改为其他传播行为进行测试）：
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Propagation;
import org.springframework.transaction.annotation.Transactional;
import com.example.demo.model.User;
import com.example.demo.repository.UserRepository;
import com.example.demo.service.UserService;import javax.annotation.Resource;@Service
public class UserServiceImpl implements UserService {@Resourceprivate UserRepository userRepository;// 默认传播行为（REQUIRED）@Transactional@Overridepublic void saveUser(User user) {userRepository.save(user);}// REQUIRES_NEW传播行为示例@Transactional(propagation = Propagation.REQUIRES_NEW)@Overridepublic void saveUserWithAnotherMethod(User user) {userRepository.save(user);}
}
- 控制器类（用于触发服务层方法调用）
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RestController;
import com.example.demo.model.User;
import com.example.demo.service.UserService;import javax.annotation.Resource;@RestController
public class UserController {@Resourceprivate UserService userService;@PostMapping("/saveUser")public void saveUser(@RequestBody User user) {userService.saveUser(user);}@PostMapping("/saveUserWithAnotherMethod")public void saveUserWithAnotherMethod(@RequestBody User user) {try {userService.saveUserWithAnotherMethod(user);} catch (Exception e) {// 这里可以处理异常情况，只是简单打印异常栈信息e.printStackTrace();}}
}
在上述代码中：
saveUser方法使用默认的事务传播行为REQUIRED，如果外部有事务调用它，就加入外部事务，如果没有则自己创建事务来执行数据库保存操作。saveUserWithAnotherMethod方法设置了REQUIRES_NEW传播行为，意味着无论外部是否存在事务，它都会开启一个新的事务来执行userRepository.save(user)操作，并且新事务的提交或回滚与外部事务是独立的（如果外部有事务，外部事务会被挂起，等这个新事务执行完再恢复）。
你可以通过发送HTTP请求到对应的接口（比如使用 Postman 等工具）来测试这些方法，观察在不同事务传播行为下数据库操作以及事务的执行情况，比如通过故意在 saveUserWithAnotherMethod 方法中抛出异常来验证事务的回滚以及与外部事务的交互情况等。
希望通过上述解析和案例代码能帮助你更好地理解Spring Boot中的事务传播行为。实际应用中可以根据具体的业务逻辑和需求来合理选择不同的事务传播方式。
二、SpringBoot 事务的隔离性
以下是关于Spring Boot事务隔离性的详细解析以及相关案例代码：
事务隔离性概述
事务隔离性是指多个并发事务之间相互隔离的程度，目的是防止数据的不一致性等问题。在数据库中，常见的事务隔离级别有以下几种：
-
Read Uncommitted（读未提交）：允许一个事务读取另一个未提交事务修改的数据，这是最低的隔离级别，可能会导致脏读（Dirty Read）问题，即读取到了其他事务尚未提交的数据，而这些数据后续可能会回滚更改。
-
Read Committed（读已提交）：一个事务只能读取另一个事务已经提交的数据，避免了脏读，但可能会出现不可重复读（Non-Repeatable Read）问题，即同一事务内多次读取同一数据，在两次读取之间如果有其他事务对该数据进行了修改并提交，那么两次读取结果会不同。
-
Repeatable Read（可重复读）：确保在同一个事务中多次读取同样的数据时，结果始终保持一致，即使有其他事务对该数据进行修改并提交，也不会影响当前事务内的多次读取结果。不过，此级别可能会出现幻读（Phantom Read）问题，即同一事务内多次执行相同的查询语句，后续查询可能会返回之前查询中不存在的新行（比如其他事务插入了新数据）。
-
Serializable（可串行化）：这是最高的隔离级别，通过强制事务串行执行（即一个接一个地顺序执行），避免了脏读、不可重复读和幻读等所有并发问题，但会严重影响系统的并发性能。
Spring Boot中配置事务隔离级别
在Spring Boot项目中，使用@Transactional注解来管理事务，并且可以在该注解中指定事务的隔离级别。示例代码如下：
- 引入依赖：
首先确保项目的pom.xml（如果是Maven项目）中引入了必要的Spring Data JPA（以使用JPA进行数据持久化为例）和数据库驱动等依赖，比如：
<dependency><groupId>org.springframework.boot</groupId><artifactId>spring-boot-starter-data-jpa</artifactId>
</dependency>
<dependency><groupId>mysql</groupId><artifactId>mysql-connector-java</artifactId><scope>runtime</scope>
</dependency>
- 配置数据库连接及相关属性（application.properties）：
spring.datasource.url=jdbc:mysql://localhost:3306/your_database_name
spring.datasource.username=your_username
spring.datasource.password=your_password
spring.datasource.driver-class-name=com.mysql.cj.jdbc.Driver# 配置JPA相关属性（可选，根据实际情况调整）
spring.jpa.show-sql=true
spring.jpa.hibernate.ddl-auto=update
- 编写实体类、数据访问层接口及实现类（以简单的用户实体为例）：
用户实体类 User.java：
import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;@Entity
public class User {@Id@GeneratedValue(strategy = GenerationType.IDENTITY)private Long id;private String username;private String password;// 构造函数、Getter和Setter方法等省略，可自行添加
}
数据访问层接口 UserRepository.java（继承自 JpaRepository）：
import org.springframework.data.jpa.repository.JpaRepository;public interface UserRepository extends JpaRepository<User, Long> {
}
- 在服务层方法中配置事务隔离级别：
服务层接口 UserService.java：
import org.springframework.transaction.annotation.Isolation;
import org.springframework.transaction.annotation.Transactional;public interface UserService {@Transactional(isolation = Isolation.READ_COMMITTED) // 这里指定了读已提交隔离级别，可按需修改void updateUser(Long userId, String newUsername);
}
服务层实现类 UserServiceImpl.java：
import org.springframework.stereotype.Service;
import javax.persistence.EntityManager;
import javax.persistence.PersistenceContext;
import org.springframework.transaction.annotation.Transactional;@Service
public class UserServiceImpl implements UserService {@PersistenceContextprivate EntityManager entityManager;@Override@Transactional(isolation = Isolation.READ_COMMITTED)public void updateUser(Long userId, String newUsername) {User user = entityManager.find(User.class, userId);user.setUsername(newUsername);entityManager.merge(user);}
}
- 在控制器中调用服务层方法（简单示例）：
import org.springframework.web.bind.annotation.*;
import org.springframework.beans.factory.annotation.Autowired;@RestController
@RequestMapping("/users")
public class UserController {@Autowiredprivate UserService userService;@PutMapping("/{id}")public void updateUser(@PathVariable Long id, @RequestParam String newUsername) {userService.updateUser(id, newUsername);}
}
上述代码展示了如何在Spring Boot中配置事务隔离级别，在实际应用场景中，可以根据业务需求选择合适的隔离级别。例如，如果对数据一致性要求较高，不容许出现脏读情况，可以选择Read Committed或更高的隔离级别；如果系统并发性能要求优先，并且业务可以容忍一定程度的数据读取不一致（在合理范围内），则可以考虑较低的隔离级别并通过合适的业务逻辑来弥补可能出现的问题。
请注意，不同的数据库对事务隔离级别的具体实现细节和支持程度可能略有不同，实际使用中需要结合具体数据库进行测试和调整。同时，不当的隔离级别设置可能会影响系统整体性能，需要综合权衡考虑。
三、SpringBoot 事务的回滚
- 事务回滚的概念
- 在Spring Boot应用中，事务回滚是一种机制，用于在事务执行过程中出现异常或错误时，将已经执行的部分操作撤销，使数据库状态恢复到事务开始之前的状态。这样可以保证数据的一致性，避免因为部分操作成功而部分操作失败导致的数据不一致问题。
- 基于异常的事务回滚（默认行为）
- Spring Boot中的事务管理默认是基于运行时异常（RuntimeException）进行回滚的。当在一个被
@Transactional注解标记的方法中抛出运行时异常时，事务会自动回滚。 - 示例代码如下：
- 首先是实体类
Product.java（假设这是一个产品实体，用于演示数据库操作）：import javax.persistence.Entity; import javax.persistence.GeneratedValue; import javax.persistence.GenerationType; import javax.persistence.Id;@Entity public class Product {@Id@GeneratedValue(strategy = GenerationType.IDENTITY)private Long id;private String name;private double price;// 构造函数、Getter和Setter方法等省略 } - 数据访问层接口
ProductRepository.java（继承自JpaRepository）：import org.springframework.data.jpa.repository.JpaRepository;public interface ProductRepository extends JpaRepository<Product, Long> { } - 服务层接口
ProductService.java：import org.springframework.transaction.annotation.Transactional;public interface ProductService {@Transactionalvoid updateProductPrice(Long productId, double newPrice) throws Exception; } - 服务层实现类
ProductServiceImpl.java：import org.springframework.stereotype.Service; import javax.persistence.EntityManager; import javax.persistence.PersistenceContext; import org.springframework.transaction.annotation.Transactional; import java.util.Optional;@Service public class ProductServiceImpl implements ProductService {@PersistenceContextprivate EntityManager entityManager;@Override@Transactionalpublic void updateProductPrice(Long productId, double newPrice) throws Exception {Optional<Product> productOptional = Optional.ofNullable(entityManager.find(Product.class, productId));if (productOptional.isPresent()) {Product product = productOptional.get();product.setPrice(newPrice);entityManager.merge(product);// 模拟抛出运行时异常，导致事务回滚throw new RuntimeException("模拟事务回滚异常");} else {throw new Exception("产品不存在");}} } - 控制器类
ProductController.java：import org.springframework.beans.factory.annotation.Autowired; import org.springframework.web.bind.annotation.PathVariable; import org.springframework.web.bind.annotation.PutMapping; import org.springframework.web.bind.annotation.RestController;@RestController public class ProductController {@Autowiredprivate ProductService productService;@PutMapping("/products/{id}/price/{newPrice}")public void updateProductPrice(@PathVariable Long id, @PathVariable double newPrice) {try {productService.updateProductPrice(id, newPrice);} catch (Exception e) {e.printStackTrace();}} }
- 首先是实体类
- 在上述代码中，
updateProductPrice方法被@Transactional注解标记。在方法内部，当更新产品价格后抛出RuntimeException时，事务会自动回滚，数据库中的产品价格不会被更新。
- Spring Boot中的事务管理默认是基于运行时异常（RuntimeException）进行回滚的。当在一个被
- 自定义事务回滚规则
- 可以通过
@Transactional注解的rollbackFor和noRollbackFor属性来定制事务回滚规则。 rollbackFor属性用于指定哪些异常类型会导致事务回滚。例如，如果想让Exception（包括检查异常）也导致事务回滚，可以这样设置：- 服务层接口
ProductService.java：import org.springframework.transaction.annotation.Transactional;public interface ProductService {@Transactional(rollbackFor = Exception.class)void updateProductPrice(Long productId, double newPrice) throws Exception; }
- 服务层接口
noRollbackFor属性用于指定哪些异常类型不会导致事务回滚。例如，如果不想让IllegalArgumentException导致事务回滚，可以这样设置：- 服务层接口
ProductService.java：import org.springframework.transaction.annotation.Transactional;public interface ProductService {@Transactional(noRollbackFor = IllegalArgumentException.class)void updateProductPrice(Long productId, double newPrice) throws Exception; }
- 服务层接口
- 可以通过
- 编程式事务回滚（不常用）
- 在一些特殊情况下，也可以通过编程方式手动回滚事务。这需要通过
TransactionAspectSupport.currentTransactionStatus().setRollbackOnly()方法来实现。 - 示例代码如下：
- 服务层实现类
ProductServiceImpl.java（部分修改）：import org.springframework.stereotype.Service; import javax.persistence.EntityManager; import javax.persistence.PersistenceContext; import org.springframework.transaction.annotation.Transactional; import org.springframework.transaction.interceptor.TransactionAspectSupport; import java.util.Optional;@Service public class ProductServiceImpl implements ProductService {@PersistenceContextprivate EntityManager entityManager;@Override@Transactionalpublic void updateProductPrice(Long productId, double newPrice) throws Exception {Optional<Product> productOptional = Optional.ofNullable(entityManager.find(Product.class, productId));if (productOptional.isPresent()) {Product product = productOptional.get();product.setPrice(newPrice);entityManager.merge(product);// 模拟根据条件手动回滚事务if (newPrice < 0) {TransactionAspectSupport.currentTransactionStatus().setRollbackOnly();}} else {throw new Exception("产品不存在");}} }
- 服务层实现类
- 在上述代码中，如果更新后的产品价格小于0，就通过编程方式手动回滚事务。这种方式比较灵活，但也增加了代码的复杂性，一般在简单的应用场景中不推荐使用，更多地用于一些复杂的业务逻辑中，需要根据特定条件来精确控制事务回滚。
- 在一些特殊情况下，也可以通过编程方式手动回滚事务。这需要通过
四、SpringBoot 事务的嵌套
-
事务嵌套的概念
- 在Spring Boot中，事务嵌套是指一个事务方法调用另一个事务方法的情况。Spring Boot使用声明式事务管理，通过
@Transactional注解来控制事务。当存在事务嵌套时，事务的行为会根据事务传播行为（Propagation）的设置而有所不同。
- 在Spring Boot中，事务嵌套是指一个事务方法调用另一个事务方法的情况。Spring Boot使用声明式事务管理，通过
-
事务传播行为介绍
- Spring提供了多种事务传播行为，这些行为定义了在嵌套事务场景下事务如何传播和交互。
- REQUIRED（默认）：如果当前没有事务，就创建一个新事务；如果当前已经存在事务，就加入到这个事务中。例如，外层方法有事务，内层方法调用时会加入外层事务；外层方法无事务，内层方法调用时会创建新事务。
- REQUIRES_NEW：无论当前是否存在事务，都会创建一个新的独立事务。内层事务和外层事务相互独立，内层事务的提交或回滚不会影响外层事务，外层事务的提交或回滚也不会影响内层事务，除非它们之间存在数据依赖等关系。
- SUPPORTS：如果当前存在事务，就加入到该事务中；如果当前没有事务，就以非事务方式执行。
- NOT_SUPPORTED：以非事务方式执行，如果当前存在事务，就把当前事务挂起。
- MANDATORY：如果当前存在事务，就加入到该事务中；如果当前没有事务，就抛出异常。
- NEVER：以非事务方式执行，如果当前存在事务，就抛出异常。
- NESTED：如果当前存在事务，就在嵌套事务中执行。嵌套事务是外层事务的一个子事务，外层事务回滚时，嵌套事务也会回滚；而嵌套事务回滚时，外层事务可以选择不回滚，具体取决于事务管理器和数据库的支持情况。
-
示例代码演示事务嵌套和传播行为
- 首先，假设我们有一个简单的用户服务和订单服务，涉及用户账户余额操作和订单创建操作。
- 实体类和数据访问层（省略部分代码）
- 用户实体类
User.java：import javax.persistence.Entity; import javax.persistence.GeneratedValue; import javax.persistence.GenerationType; import javax.persistence.Id;@Entity public class User {@Id@GeneratedValue(strategy = GenerationType.IDENTITY)private Long id;private String name;private double balance;// 构造函数、Getter和Setter方法等省略 } - 用户数据访问层接口
UserRepository.java：import org.springframework.data.jpa.repository.JpaRepository;public interface UserRepository extends JpaRepository<User, Long> { } - 订单实体类
Order.java：import javax.persistence.Entity; import javax.persistence.GeneratedValue; import javax.persistence.GenerationType; import javax.persistence.Id;@Entity public class Order {@Id@GeneratedValue(strategy = GenerationType.IDENTITY)private Long id;private Long userId;private double amount;// 构造函数、Getter和Setter方法等省略 } - 订单数据访问层接口
OrderRepository.java：import org.springframework.data.jpa.repository.JpaRepository;public interface OrderRepository extends JpaRepository<Order, Long> { }
- 用户实体类
- 服务层接口和实现类（重点展示事务嵌套）
- 用户服务接口
UserService.java：import org.springframework.transaction.annotation.Transactional;public interface UserService {@Transactionalvoid updateUserBalance(Long userId, double amount); } - 用户服务实现类
UserServiceImpl.java：import org.springframework.stereotype.Service; import javax.persistence.EntityManager; import javax.persistence.PersistenceContext; import org.springframework.transaction.annotation.Transactional; import java.util.Optional;@Service public class UserServiceImpl implements UserService {@PersistenceContextprivate EntityManager entityManager;@Override@Transactionalpublic void updateUserBalance(Long userId, double amount) {Optional<User> userOptional = Optional.ofNullable(entityManager.find(User.class, userId));if (userOptional.isPresent()) {User user = userOptional.get();user.setBalance(user.getBalance() + amount);entityManager.merge(user);}} } - 订单服务接口
OrderService.java：import org.springframework.transaction.annotation.Transactional; import org.springframework.transaction.annotation.Propagation;public interface OrderService {@Transactional(propagation = Propagation.REQUIRED)void createOrder(Long userId, double amount);@Transactional(propagation = Propagation.REQUIRES_NEW)void createOrderNewTransaction(Long userId, double amount); } - 订单服务实现类
OrderServiceImpl.java：import org.springframework.stereotype.Service; import javax.persistence.EntityManager; import javax.persistence.PersistenceContext; import org.springframework.transaction.annotation.Transactional; import java.util.Optional;@Service public class OrderServiceImpl implements OrderService {@PersistenceContextprivate EntityManager entityManager;@Override@Transactional(propagation = Propagation.REQUIRED)public void createOrder(Long userId, double amount) {Optional<User> userOptional = Optional.ofNullable(entityManager.find(User.class, userId));if (userOptional.isPresent()) {User user = userOptional.get();if (user.getBalance() >= amount) {Order order = new Order();order.setUserId(userId);order.setAmount(amount);entityManager.persist(order);user.setBalance(user.getBalance() - amount);entityManager.merge(user);} else {throw new RuntimeException("余额不足");}}}@Override@Transactional(propagation = Propagation.REQUIRES_NEW)public void createOrderNewTransaction(Long userId, double amount) {Optional<User> userOptional = Optional.ofNullable(entityManager.find(User.class, userId));if (userOptional.isPresent()) {User user = userOptional.get();if (user.getBalance() >= amount) {Order order = new Order();order.setUserId(userId);order.setAmount(amount);entityManager.persist(order);user.setBalance(user.getBalance() - amount);entityManager.merge(user);} else {throw new RuntimeException("余额不足");}}} }
- 用户服务接口
- 控制器类（用于调用服务方法）
OrderController.java：import org.springframework.beans.factory.annotation.Autowired; import org.springframework.web.bind.annotation.PathVariable; import org.springframework.web.bind.annotation.PostMapping; import org.springframework.web.bind.annotation.RestController;@RestController public class OrderController {@Autowiredprivate OrderService orderService;@Autowiredprivate UserService userService;@PostMapping("/orders/{userId}/{amount}")public void createOrder(@PathVariable Long userId, @PathVariable double amount) {try {// 演示REQUIRED传播行为orderService.createOrder(userId, amount);} catch (RuntimeException e) {e.printStackTrace();}}@PostMapping("/orders/new/{userId}/{amount}")public void createOrderNew(@PathVariable Long userId, @PathVariable double amount) {try {// 演示REQUIRES_NEW传播行为orderService.createOrderNewTransaction(userId, amount);} catch (RuntimeException e) {e.printStackTrace();}}@PostMapping("/orders/update-balance/{userId}/{amount}")public void updateUserBalance(@PathVariable Long userId, @PathVariable double amount) {try {userService.updateUserBalance(userId, amount);} catch (RuntimeException e) {e.printStackTrace();}} }
- 在上述代码中：
createOrder方法中的事务传播行为是REQUIRED。当调用这个方法时，如果当前没有事务，会创建一个新事务；如果已经有事务（比如在一个包含用户余额更新和订单创建的更大事务流程中），则会加入这个现有事务。createOrderNewTransaction方法中的事务传播行为是REQUIRES_NEW。每次调用这个方法，都会创建一个新的独立事务，与外层事务相互独立。例如，如果外层在更新用户余额的过程中调用这个方法创建订单，订单创建的事务（内层）和用户余额更新的事务（外层）是相互独立的，内层事务的回滚或提交不会影响外层事务的状态，反之亦然。
通过这些示例，可以更好地理解Spring Boot事务的嵌套以及不同事务传播行为的作用，从而在实际应用中根据业务需求合理地配置和使用事务。
五、SpringBoot 事务同步
-
事务同步的概念
- 在Spring Boot事务管理中，事务同步是指在事务的生命周期内（从开始到提交或回滚），能够让一些操作与事务的执行阶段进行同步。例如，在事务提交后执行某些资源清理操作，或者在事务开始时记录一些事务相关的日志。
-
使用
TransactionSynchronization接口实现事务同步- Spring提供了
TransactionSynchronization接口，该接口定义了在事务不同阶段可以执行的方法。 - 以下是
TransactionSynchronization接口中的主要方法：suspend()：在事务挂起时调用，用于暂停当前事务相关的资源（如数据库连接等），在使用TransactionSynchronizationManager挂起事务时会触发此方法。resume()：在事务恢复时调用，用于恢复之前挂起的事务相关资源，与suspend()方法相对应。beforeCommit(boolean readOnly)：在事务提交之前调用。如果readOnly参数为true，表示事务是只读的；如果为false，表示事务是读写事务。beforeCompletion()：在事务完成（提交或回滚）之前调用，这个方法可以用于在事务最终完成前执行一些通用的清理或准备工作。afterCommit()：在事务提交之后调用，可用于执行一些需要在事务成功提交后进行的操作，如发送通知、更新缓存等。afterCompletion(int status)：在事务完成（提交或回滚）之后调用，status参数表示事务的最终状态，STATUS_COMMITTED表示事务已提交，STATUS_ROLLED_BACK表示事务已回滚。
- 示例代码：
- 假设我们有一个服务类，用于处理订单相关的操作，并且希望在订单创建事务完成后记录日志。
- 首先是订单实体类
Order.java：import javax.persistence.Entity; import javax.persistence.GeneratedValue; import javax.persistence.GenerationType; import javax.persistence.Id;@Entity public class Order {@Id@GeneratedValue(strategy = GenerationType.IDENTITY)private Long id;private String productName;private double price;// 构造函数、Getter和Setter方法省略 } - 订单数据访问层接口
OrderRepository.java（假设使用JPA）：import org.springframework.data.jpa.repository.JpaRepository;public interface OrderRepository extends JpaRepository<Order, Long> { } - 服务类
OrderService.java：import org.springframework.stereotype.Service; import org.springframework.transaction.annotation.Transactional; import org.springframework.transaction.support.TransactionSynchronization; import org.springframework.transaction.support.TransactionSynchronizationManager;import javax.persistence.EntityManager; import javax.persistence.PersistenceContext; import java.util.List; import java.util.concurrent.CopyOnWriteArrayList;@Service public class OrderService {@PersistenceContextprivate EntityManager entityManager;private final List<String> logMessages = new CopyOnWriteArrayList<>();@Transactionalpublic void createOrder(String productName, double price) {Order order = new Order();order.setProductName(productName);order.setPrice(price);entityManager.persist(order);// 注册事务同步器TransactionSynchronizationManager.registerSynchronization(new TransactionSynchronization() {@Overridepublic void afterCompletion(int status) {if (status == TransactionSynchronization.STATUS_COMMITTED) {logMessages.add("订单创建成功，产品：" + productName + "，价格：" + price);System.out.println("订单创建成功，产品：" + productName + "，价格：" + price);} else if (status == TransactionSynchronization.STATUS_ROLLED_BACK) {logMessages.add("订单创建失败，产品：" + productName + "，价格：" + price);System.out.println("订单创建失败，产品：" + productName + "，价格：" + price);}}});}public List<String> getLogMessages() {return logMessages;} } - 控制器类
OrderController.java用于调用服务方法：import org.springframework.beans.factory.annotation.Autowired; import org.springframework.web.bind.annotation.*;import java.util.List;@RestController @RequestMapping("/orders") public class OrderController {@Autowiredprivate OrderService orderService;@PostMappingpublic void createOrder(@RequestParam String productName, @RequestParam double price) {orderService.createOrder(productName, price);}@GetMapping("/logs")public List<String> getLogMessages() {return orderService.getLogMessages();} }
- 在上述代码中：
- 在
OrderService的createOrder方法中，首先创建了一个订单并保存到数据库。然后，通过TransactionSynchronizationManager.registerSynchronization方法注册了一个TransactionSynchronization实例。 - 在
afterCompletion方法中，根据事务的最终状态（提交或回滚）记录相应的日志信息。这样就实现了事务同步，确保日志记录与订单创建事务的完成状态相匹配。
- 在
- Spring提供了
-
注意事项
- 事务同步操作应该尽量简洁，避免在事务同步方法中执行复杂或耗时过长的操作，以免影响事务的整体性能和响应时间。
- 要注意资源的正确释放和清理，特别是在
suspend和resume等涉及事务资源操作的方法中，确保数据库连接等资源不会出现泄漏或错误使用的情况。
五、SpringBoot 事务日志记录
以下是关于Spring Boot事务日志记录的详细解析以及相关案例代码示例，涵盖了为什么要记录事务日志、如何配置以及实际使用场景等方面内容。
一、事务日志记录的意义
在企业级应用开发中，事务管理至关重要，而记录事务日志可以帮助我们更好地进行问题排查、审计以及了解系统的运行状态。
- 问题排查：当事务出现异常（例如提交失败、回滚等情况）时，通过查看详细的事务日志，能够快速定位是业务逻辑问题、数据库连接问题还是其他配置相关的问题，便于及时修复。
- 审计需求：对于一些对数据操作严谨的系统（如金融系统），需要记录每个事务的详细情况，包括事务的开始、提交、回滚时间，涉及的操作内容等，以满足合规性审计要求。
二、Spring Boot中事务日志记录的配置与实现方式
（一）使用Spring的内置日志框架（如Logback结合SLF4J）
Spring Boot默认使用Logback作为日志框架（搭配SLF4J抽象层），可以方便地配置来记录事务相关信息。
- 添加依赖（一般Spring Boot项目默认已包含）：
如果是Maven项目，相关依赖如下（在pom.xml中）：
<dependency><groupId>org.springframework.boot</groupId><artifactId>spring-boot-starter-web</artifactId>
</dependency>
<dependency><groupId>org.springframework.boot</groupId><artifactId>spring-boot-starter-data-jpa</artifactId>
</dependency>
<dependency><groupId>org.slf4j</groupId><artifactId>slf4j-api</artifactId>
</dependency>
<dependency><groupId>ch.qos.logback</groupId><artifactId>logback-classic</artifactId>
</dependency>
- 配置日志级别与输出格式（在
application.properties或application.yml中）：
在application.properties中示例配置：
logging.level.org.springframework.transaction=DEBUG
logging.pattern.console=%d{yyyy-MM-dd HH:mm:ss.SSS} [%thread] %-5level %logger{36} - %msg%n
上述配置将Spring的事务相关日志级别设置为DEBUG，这样就能输出详细的事务执行过程信息到控制台，同时定义了日志输出的格式，包括日期时间、线程、日志级别、日志记录器名称以及消息内容等。
在application.yml中的等效配置示例：
logging:level:org.springframework.transaction: DEBUGpattern:console: '%d{yyyy-MM-dd HH:mm:ss.SSS} [%thread] %-5level %logger{36} - %msg%n'
（二）自定义事务监听器实现更精细的日志记录
可以通过实现TransactionListener接口，监听事务的各个阶段（开始、提交、回滚等）并记录自定义的日志信息。
- 创建自定义事务监听器类：
import org.springframework.transaction.event.TransactionPhase;
import org.springframework.transaction.event.TransactionalEventListener;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.stereotype.Component;@Component
public class CustomTransactionListener {private static final Logger logger = LoggerFactory.getLogger(CustomTransactionListener.class);// 监听事务开始事件@TransactionalEventListener(phase = TransactionPhase.BEFORE_COMMIT)public void beforeCommit(Object transaction) {logger.info("事务即将提交，相关事务信息: {}", transaction);}// 监听事务提交成功事件@TransactionalEventListener(phase = TransactionPhase.AFTER_COMMIT)public void afterCommit(Object transaction) {logger.info("事务已成功提交，相关事务信息: {}", transaction);}// 监听事务回滚事件@TransactionalEventListener(phase = TransactionPhase.AFTER_ROLLBACK)public void afterRollback(Object transaction) {logger.info("事务已回滚，相关事务信息: {}", transaction);}
}
在上述代码中：
- 通过@Component注解将该类注册为Spring容器中的组件。
- 定义了三个方法分别监听事务提交前、提交后以及回滚后的事件，并在每个方法中使用Logger记录相应阶段的日志信息，这里只是简单地打印了事务相关对象，实际中可以根据需求更深入地解析和记录事务详情，比如涉及的数据库操作语句等。
- 确保事务管理已正确配置（一般Spring Boot的
@EnableTransactionManagement已默认启用）：
如果是基于Java配置方式，确保配置类上有@EnableTransactionManagement注解，示例如下：
import org.springframework.context.annotation.Configuration;
import org.springframework.transaction.annotation.EnableTransactionManagement;@Configuration
@EnableTransactionManagement
public class AppConfig {// 可以在这里配置其他相关Bean等
}
三、案例代码演示事务日志记录
（一）准备数据库相关实体类与数据访问层（DAO）
假设我们有一个简单的用户实体类和对应的数据访问接口（使用Spring Data JPA）。
- 用户实体类（
User.java）：
import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;@Entity
public class User {@Id@GeneratedValue(strategy = GenerationType.IDENTITY)private Long id;private String username;private String password;// 构造函数、Getter和Setter方法等省略public User() {}public User(String username, String password) {this.username = username;this.password = password;}
}
- 用户数据访问接口（
UserRepository.java）：
import org.springframework.data.jpa.repository.JpaRepository;
import org.springframework.stereotype.Repository;@Repository
public interface UserRepository extends JpaRepository<User, Long> {
}
（二）创建服务层类并在方法中使用事务
创建一个服务层类，在其中定义一个涉及事务操作的方法，例如保存用户信息。
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import javax.annotation.Resource;
import java.util.Optional;@Service
public class UserService {@Resourceprivate UserRepository userRepository;@Transactionalpublic User saveUser(User user) {User savedUser = userRepository.save(user);// 模拟一个可能导致回滚的异常情况（这里只是简单示例，实际可根据业务场景调整）if (savedUser.getUsername().equals("test_exception")) {throw new RuntimeException("模拟事务回滚情况");}return savedUser;}
}
在上述UserService类的saveUser方法中：
- 使用了@Transactional注解来声明该方法运行在事务环境中，即所有对数据库的操作（这里就是保存用户信息到数据库）要么全部成功提交，要么全部回滚。
- 保存用户信息后，通过简单的条件判断模拟了一个会导致事务回滚的异常情况，用于测试事务回滚时的日志记录。
（三）创建控制器类来调用服务层方法并触发事务
创建一个简单的Spring MVC RESTful风格的控制器类，用于接收外部请求并调用服务层方法来触发事务操作。
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RestController;
import javax.annotation.Resource;@RestController
public class UserController {@Resourceprivate UserService userService;@PostMapping("/users")public String createUser(@RequestBody User user) {try {userService.saveUser(user);return "用户信息保存成功";} catch (Exception e) {return "保存用户信息出现异常，事务已回滚: " + e.getMessage();}}
}
这个控制器类提供了一个/users的POST接口，接收传入的用户信息（以JSON格式等传递，Spring会自动进行对象绑定），然后调用服务层的saveUser方法。根据方法执行情况返回相应的提示信息给客户端。
（四）测试事务日志记录
启动Spring Boot应用程序后，可以通过发送HTTP请求（例如使用Postman等工具向/users接口发送POST请求，带上合法或模拟异常的用户数据）来触发事务操作。
结合之前配置的日志级别和自定义的事务监听器等，在控制台（或者配置的日志输出文件中，如果有配置的话）就可以看到类似以下的事务日志信息示例（以出现模拟的事务回滚情况为例）：
2024-12-27 10:35:12.345 [http-nio-8080-exec-1] INFO com.example.demo.CustomTransactionListener - 事务即将提交，相关事务信息: org.springframework.data.jpa.repository.support.SimpleJpaRepository$SaveToPersistentContext@456789ab
2024-12-27 10:35:12.348 [http-nio-8080-exec-1] INFO com.example.demo.CustomTransactionListener - 事务已回滚，相关事务信息: org.springframework.data.jpa.repository.support.SimpleJpaRepository$SaveToPersistentContext@456789ab
同时，由于配置了Spring事务相关日志级别为DEBUG，还会看到Spring框架本身输出的关于事务管理过程的详细DEBUG级别日志，比如开启事务、设置事务隔离级别、执行数据库操作语句等相关的详细记录，帮助我们全面了解事务的整个执行过程和出现问题时能精准定位原因。
总之，通过合理配置和使用上述方式，可以有效地在Spring Boot应用中实现事务日志记录，提升系统的可维护性和可审计性。
请注意，上述代码中的包名（如com.example.demo）等需要根据实际项目结构进行相应调整，并且示例中的数据库操作是基于JPA和MySQL（默认配置情况下Spring Boot会自动配置的常见数据库）的简单演示，可根据实际使用的数据库和业务场景进一步优化完善。
