Spring @Transactional 在服务和非服务方法上的不同行为？

Question

I have a Spring Boot 2.3 REST application with a standard architecture (controller -> service -> repository). For auditing purposes, I inserted a thin layer (some kind of a Mediator ), so that I persist all the requests to some specific service method regardless they are successfully persisted or an exception is thrown and the transaction is rollbacked. Example:

@Component
public class Mediator {

    private final Service service;
    private final AuditService auditService;

    public Mediator(Service service, AuditService auditService) {
        this.service = service;
        this.auditService = auditService;
    }

    @Transactional
    public void saveReport(Report report) {
        try {
            service.saveReport(report);
            auditService.saveReport(report); 
        } catch (Exception exception) {
            auditService.saveReport(report, exception);
            throw exception;
        }
    }
}

Thus I encountered a weird situation: if I place the @Transactional on the Mediator's method (example above), all the operations in the JPA Repositories are successfully persisted. If I place the @Transactional on the ServiceImpl method instead (example below) and no longer on the Mediator, one of the delete queries is not ran, although the rest of the queries are executed just fine. Suppose my ServiceImpl looks something like:

@Service
public class ServiceImpl implements Service {

    private final RepositoryA repositoryA;
    private final RepositoryB repositoryB;

    public ServiceImpl(RepositoryA repositoryA, RepositoryB repositoryB) {
        this.repositoryA = repositoryA;
        this.repositoryB = repositoryB;
    }

    @Transactional
    public void saveReport(Report report) {
        repositoryA.save(report.getA());
        repositoryB.save(report.getB());
        repositoryB.delete(report.getSomethingElse());
    }
}

The only visible difference between the two approaches with respect to the Transactions is that in the first scenario, I have this for each Mediator call:

o.s.orm.jpa.JpaTransactionManager        : Opened new EntityManager [SessionImpl(909894553<open>)] for JPA transaction

while in the second scenario, I have this:

tor$SharedEntityManagerInvocationHandler : Creating new EntityManager for shared EntityManager invocation

I guess there is a difference between annotating directly a bean's method with @Transactional (what I do in the Mediator) and annotating a bean's ( that is the implementation of the interface injected ) method with the same thing (what we usually do by annotating a ServiceImpl method), but I am not sure and cannot spot the reason for this weird behaviour. Does anyone have an idea why this happens?

Answer 1

I guess that this difference in behavior is due to Spring OpenSessionInView which is enabled by default. You must set in application.yml

spring:
  jpa:
    open-in-view: false

Please see OSIV