同一个类内，某函数引用带有事务管理的函数，如何处理

小民有话说

已于 2024-02-05 14:36:57 修改

阅读量472

点赞数 6

分类专栏： Java 文章标签： java

于 2024-02-05 14:15:24 首次发布

本文链接：https://blog.csdn.net/u013367040/article/details/136040649

版权

Java 专栏收录该内容

30 篇文章 0 订阅

订阅专栏

在Spring框架中，当一个类的方法内部调用同一类中另一个有@Transactional注解的方法时，可能会遇到事务管理不符合预期的情况。这是因为Spring使用代理来管理事务，而当通过this关键字调用另一个方法时，实际上是绕过了Spring的代理，导致被调用方法的事务注解不会被正确处理。

输出案例

假设我们有以下简化的Spring服务类示例：

@Service
public class MyService {

    @Transactional
    public void methodB() {
        // 这里是一些需要事务管理的数据库操作
    }

    public void methodA() {
        // 在同一类中调用methodB
        this.methodB();
    }
}

在这个例子中，methodA调用了同一类中的methodB。methodB有@Transactional注解，意味着它的执行应当在一个事务的上下文中进行。然而，由于methodA通过this.methodB()直接调用methodB，这种调用方式实际上绕过了Spring的代理机制，导致methodB中的事务注解可能不会被正确处理。

如何解决

要确保即使在同一类中方法相互调用时也能正确处理事务，可以采取以下几种策略之一：

1.自我注入

将当前类注入到自己的一个引用中，然后通过这个引用调用方法，以确保使用的是Spring的代理对象。
这种方法简洁，但可能会导致循环依赖问题，需要谨慎使用。

@Service
public class MyService {

    @Autowired
    private MyService self;

    @Transactional
    public void methodB() {
        // 需要事务管理的操作
    }

    public void methodA() {
        self.methodB();
    }
}

2.拆分服务

将需要被不同方法调用的@Transactional方法移到另一个服务类中。这样，当从一个服务类调用另一个服务类的方法时，Spring的代理机制能够正常工作。
这种方式符合单一职责原则，同时确保事务管理的正确应用。

@Service
public class TransactionalService {

    @Transactional
    public void methodB() {
        // 需要事务管理的操作
    }
}

@Service
public class MyService {

    @Autowired
    private TransactionalService transactionalService;

    public void methodA() {
        transactionalService.methodB();
    }
}

3.使用编程式事务管理

TransactionTemplate是一种更高级的、便利的方式来控制事务，它提供了一个回调方法来执行带有事务的代码。
这种方式提供了更大的灵活性，但牺牲了一定的便利性和声明式事务的简洁性。

@Service
public class MyService {

    private final TransactionTemplate transactionTemplate;

    // 通过构造器注入TransactionTemplate
    @Autowired
    public MyService(PlatformTransactionManager transactionManager) {
        this.transactionTemplate = new TransactionTemplate(transactionManager);
    }

    public void methodB() {
        // 这里是需要事务管理的数据库操作
    }

    public void methodA() {
        transactionTemplate.execute(new TransactionCallbackWithoutResult() {
            @Override
            protected void doInTransactionWithoutResult(TransactionStatus status) {
                methodB(); // 在事务中调用methodB
            }
        });
    }
}

在这个例子中，methodA通过transactionTemplate.execute方法执行methodB，确保methodB的执行在事务的上下文中进行。这样，即使methodB在同一个类中被调用，也能保证事务的正确处理。