在同一个类中调用带有@Transactional注解的方法

痛定思痛。 2024-03-22 09:46 56阅读 0赞

1.  将调用方法和被调用方法分开，分别使用 @Transactional 注解来管理事务。

推荐这个方法\\color\{red\}\{推荐这个方法\}推荐这个方法

@Service
    @Transactional
    public class MyService {
    
        @Autowired
        private MyRepository myRepository;
    
        public void foo() {
            // 在此调用 bar 方法，事务将自动传播
            bar();
        }
    
        public void bar() {
            // 这里是被调用的方法，也添加 @Transactional 注解来管理事务
            myRepository.save(new MyEntity());
        }
    }
    复制代码

1.  使用 AspectJ 的方式，在同一个类中通过调用代理对象的方式来保证事务生效。

需要注意的是，使用 AopContext.currentProxy() 需要开启 Spring 的 AspectJ 支持，

@Service
    @Transactional
    public class MyService {
    
        @Autowired
        private MyRepository myRepository;
    
        public void foo() {
            // 在此调用 bar 方法，事务将生效
            ((MyService) AopContext.currentProxy()).bar();
        }
    
        @Transactional(propagation = Propagation.REQUIRES_NEW)
        private void bar() {
            // 这里是被调用的方法，使用 REQUIRES_NEW 传播行为开启一个新的事务
            myRepository.save(new MyEntity());
        }
    }
    复制代码

1.  在同一个类中注入自身实例，并通过这个实例调用被调用方法，保证事务生效。

需要注意的是，这种方式虽然可以保证事务生效，但是需要在同一个类中注入自己，不太符合面向对象的设计原则

@Service
    @Transactional
    public class MyService {
    
        @Autowired
        private MyRepository myRepository;
    
        @Autowired
        private MyService self;
    
        public void foo() {
            // 在此调用 bar 方法，事务将自动传播
            self.bar();
        }
    
        public void bar() {
            // 这里是被调用的方法，也添加 @Transactional 注解来管理事务
            myRepository.save(new MyEntity());
        }
    }
    复制代码

1.  使用 Spring 提供的 [TransactionTemplate][]，在同一个类中通过编程式事务处理的方式来保证事务生效。

@Service
    @Transactional
    public class MyService {
    
        @Autowired
        private MyRepository myRepository;
    
        @Autowired
        private TransactionTemplate transactionTemplate;
    
        public void foo() {
            // 在此调用 bar 方法，事务将生效
            transactionTemplate.execute(new TransactionCallback<Void>() {
                @Override
                public Void doInTransaction(TransactionStatus status) {
                    // 在此执行需要在事务中完成的逻辑
                    myRepository.save(new MyEntity());
                    return null;
                }
            });
        }
    }
    复制代码

其中，MyRepository 是一个 [JPA Repository][TransactionTemplate] 接口，用于操作数据库；MyEntity 是一个实体类，代表一个数据库表。

5 使用Spring的AOP功能来保证事务生效。

在同一个类中调用方法时，因为没有经过Spring代理，所以无法使用 @Transactional 注解来管理事务。但是，可以使用AspectJ的注解方式来实现事务的控制。

下面是一个示例代码，用于在同一个类中调用方法时，保证事务生效：

@Component
    @Aspect
    public class TransactionalAspect {
     
        @Autowired
        private PlatformTransactionManager transactionManager;
     
        @Pointcut("@annotation(org.springframework.transaction.annotation.Transactional)")
        public void transactionalMethod() {}
     
        @Around("transactionalMethod()")
        public Object manageTransaction(ProceedingJoinPoint pjp) throws Throwable {
            DefaultTransactionDefinition definition = new DefaultTransactionDefinition();
            definition.setName(pjp.getSignature().getName());
            definition.setPropagationBehavior(TransactionDefinition.PROPAGATION_REQUIRES_NEW);
            TransactionStatus status = transactionManager.getTransaction(definition);
            try {
                Object result = pjp.proceed();
                transactionManager.commit(status);
                return result;
            } catch (Throwable t) {
                transactionManager.rollback(status);
                throw t;
            }
        }
    }
    复制代码

上述示例代码中，定义了一个名为TransactionalAspect的切面类，使用@Aspect注解进行标注。在切面类中，定义了一个名为transactionalMethod的切点，用于匹配所有使用@Transactional注解标记的方法。

在manageTransaction方法中，使用TransactionTemplate手动开启一个新的事务，并在事务中执行被调用的方法。如果被调用的方法执行成功，则提交事务；如果被调用的方法发生异常，则回滚事务。

需要注意的是，这种方式虽然可以实现事务的控制，但是需要手动管理事务，增加了代码的复杂度和维护成本。因此，建议将调用方法和被调用方法分开，使用 @Transactional 注解来管理事务，以便更好地维护和管理代码。

[TransactionTemplate]: https://link.juejin.cn?target=