Are reactive code with synchronous transactions compatible?

Reactive code and synchronous transactions are poorly compatible for several reasons:

• Asynchronous vs synchronous: Reactive code is built on asynchronous data processing, where operations can be executed at different times and on different threads. Synchronous transactions, on the other hand, assume sequential execution on a single thread.

• Transaction context issues: Transactions in traditional (synchronous) approaches are often tied to a thread. In reactive programming, the thread can change during execution, leading to loss of transaction context.

• Locks and performance: Using synchronous transactions in reactive code can lead to thread blocking, reducing the benefits of the reactive model and potentially causing performance degradation.

For proper transaction handling in reactive code, it is recommended to use reactive transaction managers that support reactive contexts, such as R2DBC with TransactionalOperator in Spring WebFlux.

Example of using a reactive transaction in Spring WebFlux:

@Transactional
public Mono<Void> reactiveMethod() {
    return transactionalOperator.execute(status -> {
        return repository.save(entity)
            .then(otherRepository.save(otherEntity));
    }).then();
}

Thus, synchronous transactions are not suitable for reactive code; it is better to use reactive transaction mechanisms to preserve the advantages of asynchrony and avoid context-related issues.