为什么声明的异常被视为意外？

Question

使用Spring框架实现以下场景

@Transactional
processRequest() {
    createOrder();
}

@Transactional
createOrder() {
    ...
    try {
        saveRow();
    } catch (SaveNotAllowedException e) {
        // Handle the expected problem
        ...
        log.info("Save was not allowed...");

        // We have to do this otherwise we get UnexpectedRollbackException
        TransactionAspectSupport.currentTransactionStatus().setRollbackOnly();
    }
}

@Transactional(rollbackFor = SaveNotAllowedException.class)
saveRow() throws SaveNotAllowedException {
    // Updating row in database is not allowed because of some business condition
    throw new SaveNotAllowedException();
}

请注意：方法是公共的，在不同的类中。省略了参数和不相关的东西。SaveNotAllowedException被选中异常。

在saveRow方法上，我声明我希望对检查的异常进行回滚。在createOrder方法中，我捕获该异常并执行相关工作来处理该情况。但由于这是一个预期的回滚，我希望Spring也将其视为预期的回滚，并让我尝试一下。

有些人认为这是一个特例。据我理解，这是完全相反的，这实际上是通常的情况。拥有业务代码，调用某个方法，抛出业务异常，并检查它，以预期的方式改变行为，这在我看来是相当标准的。那么，为什么我必须执行一个特殊步骤，调用晦涩的API setRollbackOnly（）来避免崩溃呢？

Answer 1

预期的异常被视为意外，因为AOP代理只有在从最后一个@transactional方法返回时才会做出决定，该方法创建了事务。代理必须看到正在传播的异常并为其声明了回滚。

为了防止ExpectiontedrollbackException，检查的异常必须在事务之外的代码中捕获，即在代理关闭事务后调用的代码中捕获。

在最初的问题示例中，事务在processRequest（）上启动，它是从框架调用的，显然不能抛出任何检查过的异常。因此，在这种情况下，必须在之前捕获异常。

@Transactional
processRequest() {
    ...
    try {
      createOrder();
    } catch (SaveNotAllowedException e) {
        // Handle the expected problem
        ...
        log.info("Save was not allowed...");
    }

    try {
      backupOrder();
    } catch (AnotherException e) {
        ...
    }       
}

@Transactional(propagation = Propagation.REQUIRES_NEW, 
rollbackFor = SaveNotAllowedException.class)
createOrder() throws SaveNotAllowedException {
    ...
    saveRow();
}

@Transactional(propagation = Propagation.REQUIRES_NEW, 
rollbackFor = AnotherException.class)
backupOrder() throws AnotherException {
    ...
}

@Transactional
saveRow() throws SaveNotAllowedException {
    // Updating row in database is not allowed because of some business condition
    throw new SaveNotAllowedException();
}

从processRequest（）中删除@transaction。使用@transactional(rollbackFor=savenotallowedexception.class)在createorder（）上声明回滚。在processRequest（）中捕获异常。

processRequest() {
    ...
    try {
      createOrder();
    } catch (SaveNotAllowedException e) {
        // Handle the expected problem
        ...
        log.info("Save was not allowed...");
    }

    try {
      backupOrder();
    } catch (AnotherException e) {
        ...
    }       
}

@Transactional(rollbackFor = SaveNotAllowedException.class)
createOrder() throws SaveNotAllowedException {
    ...
    saveRow();
}

@Transactional(rollbackFor = AnotherException.class)
backupOrder() throws AnotherException {
    ...
}

@Transactional
saveRow() throws SaveNotAllowedException {
    // Updating row in database is not allowed because of some business condition
    throw new SaveNotAllowedException();
}

但是解决方案1和2可能不是你想要的。您可能希望将整个流程（createOrder（）和backupOrder（））放在一个事务中，而不是创建新的流程。另一种方法是创建另一个从processRequest（）调用的事务性助手服务方法，该方法将在一个事务中调用createOrder和backupOrder。我们需要创建的helper方法与我们拥有的事务组合一样多。

令人遗憾的是，Spring文档中没有提到这些复杂的细节。最接近的信息是http://docs.spring.io/spring-framework/docs/current/spring-framework-reference/html/transaction.html#tx-propagation--这是必需的，但需要更详细的说明或至少需要重新措辞。