理解@Transactional

最新推荐文章于 2026-04-30 11:09:41 发布

原创最新推荐文章于 2026-04-30 11:09:41 发布 · 1.1k 阅读

12 ·

本内容遵循CC 4.0 BY-SA版权协议

GEO检测

收录于

Spring Boot 常用注解

在 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();
    }
}