为什么事务没有在Spring JPA中得到所需传播级别的回滚？

Question

@Transactional(propagation = Propagation.REQUIRED)
public void persistEmployee() {
    Employee employee = new Employee("Peter", "Washington DC");
    entityManager.persist(employee);
    try {
        persistLineManager();
    }
    catch( Exception e ) {
         // some task
    }
}

@Transactional(propagation = Propagation.REQUIRED, rollbackFor = RuntimeException.class)
public void persistLineManager() {
    Employee lineManager = new Employee("John", "NYC");
    entityManager.persist(lineManager);
    if(lineManager != null) // intentionally! To trigger rollback
        throw new RuntimeException("Rollback!");
}

根据Spring文档，当传播级别为required时，两个方法将在同一事务中运行。在我的代码中，我有意抛出异常来触发回滚，但仍然保持了两个实体。但我认为这两项行动都应该取消。如果我的理解不正确，请更正，并让我知道回滚两个操作的正确方法。

PROPAGATION_REQUIRES_NEW:[来自spring Docs]

PROPAGATION_REQUIRES_NEW与PROPAGATION_REQUIRED不同，它为每个受影响的事务范围使用一个完全独立的事务。在这种情况下，基础物理事务是不同的，因此可以独立提交或回滚，外部事务不受内部事务回滚状态的影响。

Answer 1

现在，这个“任何来自外界的来电者都不会直接与你对话”是非常重要的。如果进行内部调用，就像在PersistEmployee中调用PersistLineManager一样，则不通过代理。您直接调用您的方法，而不是代理。因此，您的PersistLineManager方法顶部的注释不会被读取。

因此，当PersistLineManager抛出RuntimeException时，调用方PersistEmployee直接捕获异常，您可以直接进行捕获。由于没有代理，因此没有回滚，因为事务性代理没有捕获异常。

如果只执行此操作,将发生回滚：

@Transactional(propagation = Propagation.REQUIRED)
public void persistEmployee() {
    Employee employee = new Employee("Peter", "Washington DC");
    entityManager.persist(employee);
    persistLineManager();
    // Don't catch and the exception will be catched by the transaction proxy, which will rollback
}

public void persistLineManager() {
    Employee lineManager = new Employee("John", "NYC");
    entityManager.persist(lineManager);
    if(lineManager != null) // intentionally! To trigger rollback
        throw new RuntimeException("Rollback!");
}

class MyService {
    // Have a field of type TransactionTemplate
    private TransactionTemplate template;

    // In the constructor, Spring will inject the correct bean
    public MyService(PlatformTransactionManager transactionManager) {
        template = new TransactionTemplate(transactionManager);
        // Set this here if you always want this behaviour for your programmatic transaction
        template.setPropagationBehavior(TransactionDefinition.PROPAGATION_REQUIRES_NEW);
    }

    // Here you start your first transaction when arriving from the outside
    @Transactional(propagation = Propagation.REQUIRED)
    public void persistEmployee() {
        Employee employee = new Employee("Peter", "Washington DC");
        entityManager.persist(employee);
        // Inner call
        try {
            persistLineManager();
        } catch (RuntimeException e) {
            // Do what you want
        }
    }

    public void persistLineManager() {
        // Here, ask to your transactionTemplate to execute your code.
        template.execute(status -> {
            Employee lineManager = new Employee("John", "NYC");
            entityManager.persist(lineManager);
            if(lineManager != null) // intentionally! To trigger rollback
                throw new RuntimeException("Rollback!");
            return null;
        });
    }
}

让我添加关于PROPAGATION_REQUIRED和propagation_requires_new之间区别的最后一部分：

• 要么我没有事务，然后创建一个事务
• 或者有一个正在运行的事务，而我加入了它。

• 在任何情况下，无论事务是否正在运行，我都将创建一个新的事务。

null