批处理异常UnexpectedRollbackException-事务回滚

Question

I am getting the below exception when doing a batch processing

encountered an error.org.springframework.transaction.UnexpectedRollbackException: Transaction rolled back because it has been marked as rollback-only
    at java.util.concurrent.FutureTask$Sync.innerGet(FutureTask.java:252)
    at java.util.concurrent.FutureTask.get(FutureTask.java:111)

Could someone help me with what might be the issue?

Thanks.

Answer 1

Probably you have a checked exception somewhere in one of your beans that you catch in another one, but the transaction advice of spring notices it and will mark the transaction for rollback.

You can play with the noRollBackFor property of the Transactional annotation.

Answer 2

The possibility of getting this exception in Spring-managed environments is when the transaction propagation is set to REQUIRED :

<tx:method name="do*" propagation="REQUIRED" />

Consider a scenario as this:

Caller -------> [Transactional Method1(m1)] ----------> [Transactional Method2(m2)]

In Spring-managed environments, there is a difference between logical and physical transactions. A logical transaction scope is created for each method upon which this setting is applied. The logical transaction scope for method m1 is different from m2 . Each logical transaction can determine its own rollback-only status individually. And with this setting, an outer transaction scope (m1's scope) is logically independent from the inner transaction scope (m2's scope).

But all these scopes are mapped to the same physical transaction. So, if the inner transaction is marked for rollback, it effects the outer transaction's chance to commit (even if there is no exception thrown from the the outer transaction).

Now if there is an exception thrown from inner transaction and it is marked for rollback. But there is no exception thrown from outer transaction, so it has not decided on the rollback itself, and so the rollback (silently triggered by the inner transaction scope) is unexpected. And a corresponding UnexpectedRollbackException is thrown at that point.

So if an inner transaction (of which the outer caller is not aware) silently marks a transaction as rollback-only, the outer caller receives an UnexpectedRollbackException if it still calls commit. This is an indication to the outer caller that a rollback was performed instead of a commit. And this an expected behavior to let the caller of a transaction know that there was an exception and the the transaction was rolled back.