在 Spring Boot 中，@Transactional 注解仍然是 Spring 框架提供的一个核心注解，用于声明式事务管理。Spring Boot 通过自动配置和简化配置，使得在 Spring Boot 应用程序中使用 @Transactional 注解变得更加方便。本文将深入探讨 @Transactional 注解在 Spring Boot 中的使用方法、配置和最佳实践。
基本概念
@Transactional 注解用于确保一组数据库操作要么全部成功提交，要么全部回滚，以保持数据的一致性和完整性。它可以通过注解的方式在方法或类级别声明事务管理规则。
Spring Boot 中的自动配置
Spring Boot 提供了自动配置功能，可以自动检测并配置事务管理器。这意味着你通常不需要手动配置事务管理器，只需添加必要的依赖，Spring Boot 会为你自动配置。
常用属性
@Transactional 注解有许多属性，可以通过这些属性来细粒度地控制事务行为。
1. value 或 transactionManager
- 描述：指定使用的事务管理器的名称。
- 类型：String
- 默认值：默认使用名为
transactionManager的事务管理器。
@Transactional("txManager")
public void performTransaction() {
// 事务操作
}2. propagation
- 描述：指定事务的传播行为。
- 类型：Propagation
- 默认值：Propagation.REQUIRED
常见的传播行为包括：
- REQUIRED：如果当前存在事务，则加入该事务；否则创建一个新的事务。
- REQUIRES_NEW：创建一个新的事务，如果当前存在事务，则暂停当前事务。
- SUPPORTS：如果当前存在事务，则加入该事务；否则以非事务方式执行。
- NOT_SUPPORTED：以非事务方式执行，如果当前存在事务，则暂停当前事务。
- MANDATORY：如果当前存在事务，则加入该事务；否则抛出异常。
- NEVER：以非事务方式执行，如果当前存在事务，则抛出异常。
- NESTED：如果当前存在事务，则在嵌套事务内执行；否则创建一个新的事务。
@Transactional(propagation = Propagation.REQUIRES_NEW)
public void createNewTransaction() {
// 新的事务操作
}3. isolation
- 描述：指定事务的隔离级别。
- 类型：Isolation
- 默认值：Isolation.DEFAULT
常见的隔离级别包括：
- DEFAULT：使用数据库的默认隔离级别。
- READ_UNCOMMITTED：允许读取尚未提交的数据变更。
- READ_COMMITTED：允许读取已经提交的数据变更。
- REPEATABLE_READ：对同一字段的多次读取结果一致，除非数据被其他事务更新。
- SERIALIZABLE：完全隔离，防止其他事务的干扰。
@Transactional(isolation = Isolation.READ_COMMITTED)
public void readCommittedTransaction() {
// 事务操作
}4. readOnly
- 描述：指定事务是否只读。
- 类型：boolean
- 默认值：false
@Transactional(readOnly = true)
public List<User> findAllUsers() {
// 查询操作
}5. timeout
- 描述：指定事务的超时时间（秒）。
- 类型：int
- 默认值：-1（永不超时）
@Transactional(timeout = 30)
public void longRunningTransaction() {
// 长时间运行的事务操作
}6. rollbackFor
- 描述：指定哪些异常会导致事务回滚。
- 类型：Class[]
- 默认值：无
@Transactional(rollbackFor = {IllegalArgumentException.class, IOException.class})
public void transactionWithRollback() {
// 事务操作
}7. noRollbackFor
- 描述：指定哪些异常不会导致事务回滚。
- 类型：Class[]
- 默认值：无
@Transactional(noRollbackFor = {IllegalArgumentException.class})
public void transactionWithoutRollback() {
// 事务操作
}示例
下面是一个综合示例，展示了如何在 Spring Boot 应用程序中使用 @Transactional 注解：
- 添加依赖：在
pom.xml文件中添加 Spring Boot 和 JPA 的依赖。
<dependencies>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-data-jpa</artifactId>
</dependency>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-web</artifactId>
</dependency>
<dependency>
<groupId>com.h2database</groupId>
<artifactId>h2</artifactId>
<scope>runtime</scope>
</dependency>
</dependencies>- 配置数据源：在
application.properties文件中配置数据源。
spring.datasource.url=jdbc:h2:mem:testdb
spring.datasource.driverClassName=org.h2.Driver
spring.datasource.username=sa
spring.datasource.password=password
spring.jpa.database-platform=org.hibernate.dialect.H2Dialect- 创建实体类：定义一个简单的实体类。
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 String email;
// Getters and Setters
}- 创建仓库接口：定义一个 JPA 仓库接口。
import org.springframework.data.jpa.repository.JpaRepository;
public interface UserRepository extends JpaRepository<User, Long> {
}- 创建服务类：在服务类中使用
@Transactional注解。
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
@Service
public class UserService {
@Autowired
private UserRepository userRepository;
@Transactional
public void createUser(User user) {
// 创建用户
userRepository.save(user);
}
@Transactional(propagation = Propagation.REQUIRES_NEW)
public void createNewTransaction(User user) {
// 创建新的事务
userRepository.save(user);
}
@Transactional(isolation = Isolation.READ_COMMITTED)
public User findUserById(Long id) {
// 查询用户
return userRepository.findById(id).orElse(null);
}
@Transactional(readOnly = true)
public List<User> findAllUsers() {
// 查询所有用户
return userRepository.findAll();
}
@Transactional(timeout = 30)
public void longRunningTransaction() {
// 长时间运行的事务操作
for (int i = 0; i < 1000000; i++) {
// 模拟长时间操作
}
}
@Transactional(rollbackFor = {IllegalArgumentException.class, IOException.class})
public void transactionWithRollback() {
// 事务操作
if (true) {
throw new IllegalArgumentException("Test exception");
}
}
@Transactional(noRollbackFor = {IllegalArgumentException.class})
public void transactionWithoutRollback() {
// 事务操作
if (true) {
throw new IllegalArgumentException("Test exception");
}
}
}- 创建控制器类：定义一个简单的控制器类。
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*;
@RestController
@RequestMapping("/users")
public class UserController {
@Autowired
private UserService userService;
@PostMapping
public String createUser(@RequestBody User user) {
userService.createUser(user);
return "User created successfully";
}
@GetMapping("/{id}")
public User getUserById(@PathVariable Long id) {
return userService.findUserById(id);
}
@GetMapping
public List<User> getAllUsers() {
return userService.findAllUsers();
}
}最佳实践
- 细粒度控制：尽量在最细粒度的方法上使用
@Transactional注解，避免在类级别滥用事务。 - 事务传播：合理选择事务传播行为，避免不必要的事务嵌套。
- 只读事务：对于只读操作，使用
readOnly = true可以提高性能。 - 异常处理：明确指定哪些异常会导致事务回滚，避免意外的事务回滚。
- 事务超时：为长时间运行的事务设置合理的超时时间，防止长时间占用资源。
- 事务管理器配置：确保正确配置事务管理器，特别是多数据源场景下。
总结
@Transactional注解：是 Spring 框架提供的一个注解，用于声明式事务管理。- Spring Boot：通过自动配置和简化配置，使得在 Spring Boot 应用程序中使用
@Transactional注解更加方便。 - 使用场景：无论是纯 Spring 应用程序还是 Spring Boot 应用程序，都可以使用
@Transactional注解来管理事务。
理解 @Transactional 注解的工作原理和使用方法，可以更高效地管理事务，确保数据的一致性和完整性。在 Spring Boot 中，通过自动配置和简化配置，开发者可以更轻松地使用 @Transactional 注解，提高开发效率。