使用Spring boot的@Transactional进行事务管理

已于 2025-03-20 12:10:11 修改
阅读量2.3k 收藏 14
点赞数 21
分类专栏： smart Spring 文章标签： spring boot 后端 java
于 2025-02-08 15:37:12 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Tracycoder/article/details/145516934
版权

文章目录

在 Spring Boot 中，@Transactional 是用于声明式事务管理的关键注解。它基于 Spring 的 AOP（面向切面编程）实现，可以简化数据库事务的管理。

一、前置条件

  1. 依赖引入：确保项目中包含 spring-boot-starter-data-jpa 或 spring-boot-starter-jdbc
  2. 启用事务管理：Spring Boot 默认自动配置事务管理器（如 DataSourceTransactionManager），无需手动启用。

二、基本用法

1. 在方法上添加注解

@Service
public class UserService {

    @Autowired
    private UserRepository userRepository;

    @Transactional
    public void createUser(User user) {
        userRepository.save(user);
        // 其他数据库操作
    }
}

2. 在类上添加注解

@Service
@Transactional
public class UserService {
    // 类中所有 public 方法都会应用事务
}

三、核心配置参数

1. 传播行为（Propagation）

控制事务的边界，默认为 Propagation.REQUIRED。

@Transactional(propagation = Propagation.REQUIRES_NEW)
public void updateUser(User user) {
    // 始终开启新事务
}

常见选项：

  • REQUIRED（默认）：如果当前存在事务，则加入；否则新建
  • REQUIRES_NEW：始终新建事务，挂起当前事务（如有）
  • SUPPORTS：如果当前存在事务，则加入；否则非事务运行
  • NOT_SUPPORTED：非事务运行，挂起当前事务（如有）
  • MANDATORY：必须在事务中调用，否则抛出异常
  • NEVER：必须在非事务中调用，否则抛出异常

2. 隔离级别（Isolation）

控制事务的隔离性，默认为 Isolation.DEFAULT（使用数据库默认）。

@Transactional(isolation = Isolation.SERIALIZABLE)
public void sensitiveOperation() {
    // 最高隔离级别
}

3. 超时时间（Timeout）

事务超时时间（秒），默认-1（使用数据库默认）。

@Transactional(timeout = 30)
public void longRunningProcess() {
    // 超过30秒将回滚
}

4. 只读模式（readOnly）

优化只读操作，默认为 false。

@Transactional(readOnly = true)
public List<User> findAllUsers() {
    return userRepository.findAll();
}

5. 回滚规则（rollbackFor/noRollbackFor）

指定触发回滚的异常类型：

@Transactional(rollbackFor = CustomException.class)
public void process() throws CustomException {
    // 抛出 CustomException 时回滚
}

四、关键注意事项

1. 方法可见性

  • 必须为 public：由于 Spring AOP 的实现机制，非 public 方法上的 @Transactional 无效

2. 自调用问题

  • 同类中的方法互相调用时，事务不会生效（绕过代理对象）
// 错误示例
public void methodA() {
    methodB(); // 事务不生效
}

@Transactional
public void methodB() { ... }

3. 异常处理

  • 默认回滚条件：抛出 RuntimeException 或 Error
  • 检查型异常（Checked Exception）默认不会触发回滚
// 处理检查型异常
@Transactional(rollbackFor = IOException.class)
public void fileOperation() throws IOException {
    // ...
}

4. 多数据源事务

需配置多个事务管理器，并通过 @Transactional(value = "specificTransactionManager") 指定

五、调试技巧

  1. 启用调试日志：
logging.level.org.springframework.transaction.interceptor=TRACE
logging.level.org.springframework.jdbc.datasource.DataSourceTransactionManager=DEBUG
  1. 检查代理对象：
System.out.println(userService.getClass().getName());
// 输出应为代理类：com.sun.proxy.$ProxyXX 或 ...$$EnhancerBySpringCGLIB$$...

六、最佳实践

  1. 服务层使用：在 Service 层而非 Controller 层使用事务
  2. 保持短事务：避免在事务中包含远程调用、文件IO等耗时操作
  3. 精确回滚规则：明确指定 rollbackFor 而非依赖默认行为
  4. 结合 JPA 使用：
@Transactional
public void updateUserEmail(Long userId, String email) {
    User user = userRepository.findById(userId).orElseThrow();
    user.setEmail(email); // 自动脏检查，事务提交时更新
}

七、完整示例

@Service
public class OrderService {

    @Autowired
    private OrderRepository orderRepository;
    
    @Autowired
    private InventoryService inventoryService;

    @Transactional(
        propagation = Propagation.REQUIRED,
        isolation = Isolation.READ_COMMITTED,
        timeout = 30,
        rollbackFor = {InsufficientStockException.class, PaymentFailedException.class}
    )
    public void placeOrder(Order order) {
        inventoryService.reduceStock(order.getItems()); // 可能抛出 InsufficientStockException
        orderRepository.save(order);
        processPayment(order); // 可能抛出 PaymentFailedException
    }

    private void processPayment(Order order) {
        // 支付逻辑
    }
}

八、适用于关系型数据库

@Transactional 的使用与数据库层有直接关系，但它的事务管理机制是基于数据库事务的。如果 Service 层方法使用了 Elasticsearch 客户端读写 Elasticsearch，那么 @Transactional 的行为会受到影响。

1.@Transactional 的适用范围

@Transactional 是 Spring 提供的事务管理机制，主要用于管理数据库事务。它依赖于底层的事务管理器（如 DataSourceTransactionManager），而这些事务管理器通常是与关系型数据库（如 MySQL、PostgreSQL）交互的。

  • 数据库事务：@Transactional 可以确保数据库操作的原子性、一致性、隔离性和持久性（ACID）。
  • 非数据库操作：对于非数据库操作（如 Elasticsearch、Redis、文件系统等），@Transactional 无法直接管理其事务。

2.Elasticsearch 与 @Transactional 的关系

Elasticsearch 是一个分布式搜索引擎，它本身不支持传统意义上的事务（ACID）。因此，@Transactional 对 Elasticsearch 的操作没有直接的事务管理能力。

（1）场景分析

假设我们的 Service 方法同时操作了数据库和 Elasticsearch：

@Service
public class UserService {

    @Autowired
    private UserRepository userRepository; // 数据库操作

    @Autowired
    private ElasticsearchClient elasticsearchClient; // Elasticsearch 操作

    @Transactional
    public void createUser(User user) {
        // 操作数据库
        userRepository.save(user);

        // 操作 Elasticsearch
        IndexRequest request = new IndexRequest("users")
            .id(user.getId().toString())
            .source("name", user.getName(), "email", user.getEmail());
        elasticsearchClient.index(request, RequestOptions.DEFAULT);
    }
}

（2）可能出现的问题

  • 数据库事务回滚，Elasticsearch 操作不回滚：
    • 如果 userRepository.save(user) 成功，但后续 Elasticsearch 操作失败，数据库事务会回滚（因为 @Transactional 生效），但 Elasticsearch 的数据已经写入，无法回滚。
  • 数据库事务提交，Elasticsearch 操作失败：
    • 如果数据库操作成功，但 Elasticsearch 操作失败，数据库事务已经提交，而 Elasticsearch 数据未更新，导致数据不一致。

3.如何解决 Elasticsearch 与数据库的事务一致性问题

由于 Elasticsearch 不支持事务，因此需要采用其他机制来保证数据一致性。

（1）手动补偿机制

  • 在 Elasticsearch 操作失败时，手动回滚数据库操作。
  • 示例：
    @Transactional
public void createUser(User user) {
    try {
        userRepository.save(user); // 数据库操作
        IndexRequest request = new IndexRequest("users")
            .id(user.getId().toString())
            .source("name", user.getName(), "email", user.getEmail());
        elasticsearchClient.index(request, RequestOptions.DEFAULT); // Elasticsearch 操作
    } catch (Exception e) {
        // Elasticsearch 操作失败，手动回滚数据库
        TransactionAspectSupport.currentTransactionStatus().setRollbackOnly();
        throw e;
    }
}

（2）消息队列（最终一致性）

  • 将 Elasticsearch 操作异步化，通过消息队列（如 Kafka、RabbitMQ）实现最终一致性。
  • 示例：
    1. 数据库操作完成后，发送消息到队列。
    2. 消费者从队列中读取消息并更新 Elasticsearch。

（3）两阶段提交（2PC）

  • 使用分布式事务管理器（如 Seata）实现数据库和 Elasticsearch 的分布式事务。
  • 这种方法复杂度较高，通常不推荐用于 Elasticsearch。

（4）本地消息表

  • 在数据库中创建一张消息表，记录需要同步到 Elasticsearch 的数据。
  • 通过定时任务或事件监听器将数据同步到 Elasticsearch。

总结

  • @Transactional 只对数据库事务有效：它无法管理 Elasticsearch 等非关系型数据存储的事务。
  • Elasticsearch 操作与数据库事务的一致性：需要通过补偿机制、消息队列等方式实现。
  • 设计建议：
    • 尽量避免在同一个事务中混合数据库和 Elasticsearch 操作。
    • 采用异步化或最终一致性方案来保证数据一致性。

九、失效场景

在Spring Boot中，@Transactional 注解是用于管理事务的强大工具，但在以下几种场景下可能会失效：

1. 方法不是public的

@Transactional 注解只能应用在 public 方法上。如果将其放在非 public 方法上，事务不会生效。这是因为Spring通过AOP代理来实现事务管理，而AOP默认只能对 public 方法进行代理增强。

@Service
public class UserService {

    // 事务不会生效
    @Transactional
    void nonPublicMethod() {
        // 业务逻辑
    }

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

2. 自调用问题

当一个 @Transactional 修饰的方法内部调用本类的另一个方法，而被调用方法也有 @Transactional 注解时，被调用方法的事务会失效。这是因为Spring的事务管理是基于代理机制的，自调用时并没有通过代理对象调用，所以事务配置不会生效。

@Service
public class OrderService {

    @Transactional
    public void placeOrder() {
        // 一些业务逻辑
        updateOrderStatus(); // 自调用
    }

    @Transactional
    public void updateOrderStatus() {
        // 更新订单状态的逻辑
    }
}

要解决这个问题，可以通过注入自身的代理对象来调用方法，如使用 AopContext.currentProxy() 或将自身注入到自身中（需要一些额外配置）。

3. 异常被捕获处理

如果 @Transactional 修饰的方法内部捕获了异常，并且没有重新抛出，事务将不会回滚，即事务失效。Spring默认只在抛出未检查异常（继承自 RuntimeException）或 Error 时才会回滚事务。

@Service
public class ProductService {

    @Transactional
    public void updateProductStock(String productId, int quantity) {
        try {
            // 减库存逻辑
            int result = productDao.reduceStock(productId, quantity);
            if (result <= 0) {
                throw new RuntimeException("库存不足");
            }
        } catch (Exception e) {
            // 捕获异常但未重新抛出，事务不会回滚
            System.out.println("处理异常: " + e.getMessage());
        }
    }
}

要确保事务回滚，需要在捕获异常后重新抛出未检查异常，或者在 @Transactional 注解中指定需要回滚的异常类型，如 @Transactional(rollbackFor = Exception.class)。

4. 事务传播行为设置不当

@Transactional 注解的 propagation 属性定义了事务的传播行为。如果设置不当，可能导致事务失效。例如，当使用 Propagation.NOT_SUPPORTED 传播行为时，当前方法不会在事务中运行，即使调用它的方法有事务。

@Service
public class PaymentService {

    @Transactional(propagation = Propagation.NOT_SUPPORTED)
    public void processPayment() {
        // 支付处理逻辑，不会在事务中
    }
}

如果期望方法在事务中执行，应确保使用合适的传播行为，如 Propagation.REQUIRED（默认值）。

5. 数据源未配置事务管理器

如果没有正确配置事务管理器，@Transactional 注解将无法正常工作。在Spring Boot中，对于不同的数据源（如MySQL、Oracle等），需要配置相应的事务管理器。例如，对于基于JDBC的数据源，通常需要配置 DataSourceTransactionManager。

@Configuration
@EnableTransactionManagement
public class TransactionConfig {

    @Autowired
    private DataSource dataSource;

    @Bean
    public PlatformTransactionManager transactionManager() {
        return new DataSourceTransactionManager(dataSource);
    }
}

如果没有这样的配置，@Transactional 注解可能会失效。

6. 类没有被Spring管理

只有被Spring容器管理的Bean中的 @Transactional 注解才会生效。如果一个类没有被 @Component、@Service 等注解标记，或者没有通过其他方式注册到Spring容器中，那么 @Transactional 注解将不会起作用。

// 这个类没有被Spring管理，@Transactional 无效
public class UnmanagedClass {

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

十、生效场景

在Spring Boot中，@Transactional注解在以下常见场景下能够生效：

1. 常规业务方法

当一个@Service注解标注的服务类中的public方法被@Transactional注解标注时，事务通常会生效。这是最常见的使用场景，Spring通过AOP代理机制来管理事务的开启、提交和回滚。

@Service
public class UserService {

    @Autowired
    private UserRepository userRepository;

    @Transactional
    public User saveUser(User user) {
        return userRepository.save(user);
    }
}

在上述示例中，saveUser方法被@Transactional注解修饰，当该方法执行时，Spring会在方法调用前后进行事务相关的操作。如果方法执行过程中没有抛出异常，事务将正常提交；如果抛出未捕获的运行时异常（或Error），事务将回滚。

2. 多个方法调用的事务管理

当一个@Transactional方法调用其他@Transactional方法时，只要这些方法在同一个事务上下文中，事务也能生效。例如：

@Service
public class OrderService {

    @Autowired
    private OrderRepository orderRepository;
    @Autowired
    private ProductRepository productRepository;

    @Transactional
    public void placeOrder(Order order) {
        orderRepository.save(order);
        updateProductStock(order.getProductId(), order.getQuantity());
    }

    @Transactional
    public void updateProductStock(String productId, int quantity) {
        Product product = productRepository.findById(productId).orElseThrow();
        product.setStock(product.getStock() - quantity);
        productRepository.save(product);
    }
}

在placeOrder方法中调用了updateProductStock方法，由于它们都在同一个事务上下文中（默认传播行为Propagation.REQUIRED），整个操作要么全部成功，要么全部失败并回滚。

3. 配置了合适的事务管理器

当应用程序配置了与数据源匹配的事务管理器时，@Transactional注解才能正常生效。对于关系型数据库，如MySQL，通常配置DataSourceTransactionManager。例如：

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.jdbc.datasource.DataSourceTransactionManager;
import org.springframework.transaction.PlatformTransactionManager;
import org.springframework.transaction.annotation.EnableTransactionManagement;

import javax.sql.DataSource;

@Configuration
@EnableTransactionManagement
public class TransactionConfig {

    @Autowired
    private DataSource dataSource;

    @Bean
    public PlatformTransactionManager transactionManager() {
        return new DataSourceTransactionManager(dataSource);
    }
}

上述配置中，DataSourceTransactionManager与应用的数据源关联，确保@Transactional注解能够正确管理事务。

4. 处理特定异常回滚

可以通过@Transactional注解的rollbackFor属性指定需要回滚的异常类型，这样即使抛出的不是运行时异常，事务也能回滚。例如：

@Service
public class AccountService {

    @Autowired
    private AccountRepository accountRepository;

    @Transactional(rollbackFor = InsufficientFundsException.class)
    public void transferFunds(String fromAccountId, String toAccountId, double amount) throws InsufficientFundsException {
        Account fromAccount = accountRepository.findById(fromAccountId).orElseThrow();
        Account toAccount = accountRepository.findById(toAccountId).orElseThrow();

        if (fromAccount.getBalance() < amount) {
            throw new InsufficientFundsException();
        }

        fromAccount.setBalance(fromAccount.getBalance() - amount);
        toAccount.setBalance(toAccount.getBalance() + amount);

        accountRepository.save(fromAccount);
        accountRepository.save(toAccount);
    }
}

class InsufficientFundsException extends Exception {
    // 自定义异常类
}

在这个例子中，transferFunds方法声明了rollbackFor = InsufficientFundsException.class，当抛出InsufficientFundsException异常时，事务会回滚。

5. 正确处理嵌套事务

当方法之间存在嵌套调用且事务传播行为设置正确时，@Transactional注解能有效管理嵌套事务。例如，使用Propagation.REQUIRES_NEW传播行为可以开启一个新的事务。

@Service
public class ParentService {

    @Autowired
    private ChildService childService;

    @Transactional
    public void parentMethod() {
        // 一些业务逻辑
        childService.childMethod();
        // 更多业务逻辑
    }
}

@Service
public class ChildService {

    @Transactional(propagation = Propagation.REQUIRES_NEW)
    public void childMethod() {
        // 子方法业务逻辑
    }
}

在上述代码中，childMethod使用Propagation.REQUIRES_NEW传播行为，会开启一个新的事务，独立于parentMethod的事务，这样可以实现更细粒度的事务控制。

【SpringBoot】89、SpringBoot中使用@Transactional进行事务管理
Asurplus
08-15 3万+
事务是一组组合成逻辑工作单元的操作，虽然系统中可能会出错，但事务将控制和维护事务中每个操作的一致性和完整性。
深入解析Spring Boot中的`@Transactional`注解
fudaihb的博客
09-03 3322
在Spring Boot开发中，数据库事务管理是一个至关重要的环节。`@Transactional`注解是Spring框架提供的一个强大工具，能够帮助开发者方便地管理事务。本文将深入解析`@Transactional`注解的工作原理、使用方式以及注意事项，并结合实际应用场景，帮助开发者更好地掌握这一工具。
springboot 事务（@Transactional）
lizsy的博客
06-07 1535
外部类调用：如果一个有事务的方法被另一个类的方法调用，事务传播可能会受到影响。自调用方法：如果一个带有事务的方法在同一个类中通过普通的方法调用自己，事务传播可能会失效。外部调用：如果一个有事务的方法被另一个没有事务的方法直接调用，事务传播可能会受到影响。在这种情况下，被调用的方法会在自己的事务中执行，而不是加入到外部方法的事务中。在springboot中，在方法或类上添加@Transactional注解，将会把该方法或类中的数据库操作放到一个事务中，中途发生异常时，则事务会回滚，代码如下。
SpringBoot之Transactional事务
Davis
06-04 4039
如果方法没有关联到一个事务，容器不会为他开启事务，如果方法在一个事务中被调用，该事务会被挂起，调用结束后，原先的事务会恢复执行。每一条语句处于一个单独的事务中，在这条语句执行完毕时，如果执行成功则隐式的提交事务，如果执行失败则隐式的回滚事务。事务的传播行为是指，如果在开始当前事务之前，一个事务上下文已经存在，此时有若干选项可以指定一个事务性方法的执行行为。如果方法已经运行在一个事务中，则原有事务挂起，新的事务被创建。如果方法运行时，已经处在一个事务中，那么加入到这个事务，否则自己新建一个新的事务。
Springboot事务篇
最新发布
m0_37145844的博客
03-13 1384
通过。
SpringBoot系列：事务管理器Transactional
Simple_Yangger的博客
08-27 1310
一、事务 事务（Transaction），一般是指要做的或所做的事情。在计算机术语中是指访问并可能更新数据库中各种数据项的一个程序执行单元(unit)。事务通常由高级数据库操纵语言或编程语言（如SQL，C++或Java）书写的用户程序的执行所引起，并用形如begin transaction和end transaction语句（或函数调用）来界定。事务由事务开始(begin transaction)...
Spring Boot 中使用 @Transactional 注解配置事务管理
weixin_40497755的博客
11-15 3204
Spring Boot 中使用 @Transactional 注解配置事务管理
springboot之@Transactional详解
jiaxiaoyan321的博客
09-08 4093
springboot @Transactional注解是如何起作用？
SpringBoot 中 @Transactional 的使用细节
小左的博客
12-05 2333
1.spring boot 中事物的使用 （当前指代的不是多数据源，只有一个数据源的前提下） <1> 在springboot 启动类上加上允许使用事物注解 @EnableTransactionManagement <2> 就这么简单的一个操作，更主要的是了解@Transactional 的一些特性，到底该怎么使用，什么时候使用。 事物的四个特性想必大家应该都知道，...
深入学习Spring Boot排查 @Transactional 引起的 NullPointerException问题
08-28
当我们使用 @Transactional 注解时，Spring Boot 会生成一个代理对象来管理事务。在代理对象中，SqlSession sqlSession 将被注入到代理对象中。 然而，在 finalSelectStudentById 函数中，我们使用了 final 关键字...
【Java Web Spring Boot中的@Transactional注解】
xycxycooo的博客
07-26 1278
如果你希望对其他类型的异常也进行回滚，或者希望某些特定异常不触发回滚，可以使用注解的和属性进行自定义。假设我们希望对");} }");} }");} }");在这个例子中，当createUser方法抛出时，事务将会回滚。
Spring Boot之@Transactional
张育嘉的博客
09-11 684
事务管理是应用系统开发中必不可少的一部分。Spring 为事务管理提供了丰富的功能支持。Spring 事务管理分为编程式和声明式的两种方式。 编程式事务指的是通过编码方式实现事务； 声明式事务基于 AOP,将具体业务逻辑与事务处理解耦。 声明式事务有两种方式： 配置文件（xml） @Transactional 注解 本文将着重介绍基于 @Transactional 注解的事务管理。...
【Java 基础】SpringBoot 中 @Transactional 注解的使用与实践
热门推荐
yuxiangdeming的博客
06-12 2万+
事务管理是应用系统开发中必不可少的一部分。Spring 为事务管理提供了丰富的功能支持。Spring 事务管理分为编程式和声明式的两种方式。本篇只说明声明式注解。 事务：是数据库操作的最小工作单元，是作为单个逻辑工作单元执行的一系列操作；这些操作作为一个整体一起向系统提交，要么都执行、要么都不执行；事务是一组不可再分割的操作集合（工作逻辑单元）。 事务的四大特性：只需在方法加上 @Transactional 注解就可以了。如下有一个保存数据的方法，加入 @transactiona
SpringBoot 中 @Transactional 注解的使用
_江屿_
01-08 2417
SpringBoot 中 @Transactional 注解的使用
SpringBoot - @Transactional注解详解
记录并分享
06-19 3643
Spring中的@Transactional注解，基于动态代理的机制，提供了一种透明的事务管理机制，方便快捷的解决在开发中碰到的问题，@Transactional 的事务开启 ，或者是基于接口的或者是基于类的代理被创建。Spring为了更好的支撑数据库操作，在框架中支持了两种事务管理的方式：编程式事务和声明式事务，能够保证作单个逻辑工作单元执行的一系列操作，要么同时成功，要么同时失败。
spring(基础24) Spring注解@Transactional配置事务
babyZeng
06-17 380
1、详细介绍 事务管理是应用系统开发中必不可少的一部分。Spring 为事务管理提供了丰富的功能支持。Spring 事务管理分为编程式和声明式的两种方式。 编程式事务指的是通过编码方式实现事务；声明式事务基于 AOP,将具体业务逻辑与事务处理解耦。声明式事务管理使业务代码逻辑不受污染, 因此在实际使用中声明式事务用的比较多。声明式事务有两种方式，一种是在配置文件（xml）中做相关的事务规则声明，另...
spring boot@Transactional
12-21
在Java Spring Boot中，@Transactional是一个注解，用于标记一个方法或类需要进行事务管理。事务是一组操作的逻辑单元，要么全部成功执行，要么全部回滚。使用@Transactional注解可以确保在方法执行期间，如果发生异常或错误，所有对数据库的操作都会回滚到事务开始之前的状态。 当我们在一个方法上添加@Transactional注解时，Spring会自动为该方法创建一个事务，并在方法执行之前开启事务，在方法执行之后根据方法的执行结果决定是提交事务还是回滚事务。如果方法执行成功，事务将会被提交，如果方法执行失败，事务将会被回滚。 除了在方法上使用@Transactional注解，我们还可以将它应用于类级别。当我们在类级别上添加@Transactional注解时，该类中的所有方法都将被包装在一个事务中。 需要注意的是，@Transactional注解默认只对未检查异常（RuntimeException及其子类）进行回滚，对于检查异常（Exception及其子类）不会回滚。如果需要对检查异常进行回滚，可以使用@Transactional(rollbackFor = Exception.class)来指定回滚的异常类型。 另外，@Transactional注解还可以接收一些参数，用于配置事务的传播行为、隔离级别、超时时间等。例如，@Transactional(propagation = Propagation.REQUIRED, isolation = Isolation.DEFAULT, timeout = 3600)。 总结一下，@Transactional注解是用于在Java Spring Boot中进行事务管理的注解，通过标记方法或类，可以确保一组操作要么全部成功执行，要么全部回滚。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

TracyCoder123

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值