在一个事务中从调度程序调用 2 个服务方法的最佳方法

Question

我有调度器：

@Component
public class MyScheduler {

    private static final long INIT_DELAY = 1L;
    private static final long DELAY = 10L;

    private final UserService userService;

    public MyScheduler(UserService userService) {
        this.userService = userService;
    }

    @EventListener(ApplicationReadyEvent.class)
    public void schedule() {
        ScheduledExecutorService scheduledExecutorService = Executors.newSingleThreadScheduledExecutor();
        scheduledExecutorService.scheduleWithFixedDelay(this::process, INIT_DELAY, DELAY, TimeUnit.SECONDS);
    }

    private void process() {
        userService.process(new User("Bill", 20));
    }
}

在 UserService 中我保存新用户并抛出异常：

@Slf4j
@Service
public class UserServiceImpl implements UserService {

    private final UserRepository userRepository;

    public UserServiceImpl(UserRepository userRepository) {
        this.userRepository = userRepository;
    }

    @Override
    public void process(User user) {
        log.info("Start process...");
        userRepository.save(user);
        methodWithException();
        log.info("End process...");
    }

    private void methodWithException() {
        throw new RuntimeException();
    }
}

因此，尽管出现异常，用户仍被保存。为了解决这个问题，我可以应用几种方法：

1) 在private void process()上方添加@Transactional，并将此方法改为public

2) 在UserServicepublic void process(User user)方法上方添加@Transactional

在第一种情况下它没有帮助，因为 process() witn @Transactional 从同一个类调用。

在第二种情况下它会有所帮助。

但是如果我添加新的Service，例如LogService：

@Service
public class LogServiceImpl implements LogService {

    private final LogRepository logRepository;

    public LogServiceImpl(LogRepository logRepository) {
        this.logRepository = logRepository;
    }

    @Transactional
    @Override
    public Log save(Log log) {
        return logRepository.save(log);
    }
}

并将调度程序更改为：

@Component
public class MyScheduler {

    private static final long INIT_DELAY = 1L;
    private static final long DELAY = 10L;

    private final UserService userService;
    private final LogService logService;

    public MyScheduler(UserService userService, LogService logService) {
        this.userService = userService;
        this.logService = logService;
    }

    @EventListener(ApplicationReadyEvent.class)
    public void schedule() {
        ScheduledExecutorService scheduledExecutorService = Executors.newSingleThreadScheduledExecutor();
        scheduledExecutorService.scheduleWithFixedDelay(this::process, INIT_DELAY, DELAY, TimeUnit.SECONDS);
    }

    private void process() {
        User user = userService.process(new User("Bill", 20));
        logService.save(new Log(user.getId(), new Date()));
    }
}

问题：

userService.process 调用一个事务，logService.save 调用另一个事务。我需要在一笔交易中调用双方服务。

我看到了两种方式：

1) 将logService 注入userService 并在userService.process 方法中调用logService.save

2) 使用process 方法创建新服务，例如SchedulerService，并在该服务中注入userService 和logService。并在一个事务中调用两个服务。

在第一种情况下，我在userService 中获得了新的依赖项，这可能违反了此服务的责任范围。为什么服务应该知道拉另一个服务

在第二种情况下，我需要创建额外的服务（一个类）

最好能够注释内部调度程序方法@Transactional 注释。我知道这可以使用 cglib 而不是 proxy 来完成，但我使用代理。

哪种方法更好？

Answer 1

恕我直言，这是 PlatformTransactionManager 的一个很好的用例，有或没有 TransactionTemplate。
为此，我将使用纯 PlatformTransactionManager 解决方案。

如果您使用的是Spring Boot，默认情况下您会将其作为 Bean。

@Component
class MyScheduler {
    private static final long INIT_DELAY = 1L;
    private static final long DELAY = 10L;

    private final PlatformTransactionManager txManager;
    private final ConcurrencyService userService;
    private final LogService logService;

    MyScheduler(
            final PlatformTransactionManager txManager,
            final ConcurrencyService userService,
            final LogService logService) {
        this.txManager = txManager;
        this.userService = userService;
        this.logService = logService;
    }

    @EventListener(ApplicationReadyEvent.class)
    public void schedule() {
        final ScheduledExecutorService scheduledExecutorService = Executors.newSingleThreadScheduledExecutor();
        scheduledExecutorService.scheduleWithFixedDelay(this::process, INIT_DELAY, DELAY, TimeUnit.SECONDS);
    }

    private void process() {
       final DefaultTransactionDefinition definition = new DefaultTransactionDefinition(PROPAGATION_REQUIRES_NEW);
       final TransactionStatus tx = txManager.getTransaction(definition);

       try {
          final User user = userService.process(new User("Bill", 20));
          logService.save(new Log(user.getId(), new Date()));
          txManager.commit(tx);
       } catch (final YourException e) {
          txManager.rollback(tx);
       }
    }
}

---

使用TransactionTemplate 将“消除”显式调用commit 和rollback 的需要。

您可以将TransactionTemplate 作为一个Bean，或者您可以从PlatformTransactionManager 手动构造它，就像我在这里所做的那样。

final TransactionTemplate transactionTemplate = new TransactionTemplate(txManager);
transactionTemplate.execute(new TransactionCallbackWithoutResult() {
    @Override
    protected void doInTransactionWithoutResult(final TransactionStatus status) {
       final User user = userService.process(new User("Bill", 20));
       logService.save(new Log(user.getId(), new Date()));
    }
});