Analysis and Solutions for 'Transaction Marked as Rollback Only' in Spring

Problem Background and Symptoms

In Spring framework transaction management, developers often encounter the "Transaction marked as rollback only" error. This typically occurs in methods annotated with @Transactional, where the method appears to execute successfully but encounters rollback during transaction commit.

Core Problem Analysis

The root cause lies in Spring's transaction propagation mechanism and exception handling logic. When we call one transactional method from within another transactional method, if the inner method throws an exception, even if the outer method catches it, the transaction will still be marked as rollback-only.

Consider this typical scenario:

public void methodA() {
    methodB();
}

@Transactional(noRollbackFor = Exception.class)
public void methodB() {
    try {
        methodC();
    } catch (Exception e) {
        // Handle exception
    }
    System.out.println("OK");
}

@Transactional
public void methodC() {
    throw new RuntimeException("Inner method exception");
}

In this example, although methodB is configured with noRollbackFor = Exception.class, methodC's @Transactional annotation lacks corresponding configuration. When methodC throws an exception, the second transaction marks the first transaction as rollback-only, even though the exception is caught in methodB.

Solutions

Solution 1: Unified Transaction Propagation Configuration

Ensure all transactional methods have consistent transaction configuration:

@Transactional(noRollbackFor = RuntimeException.class)
public void methodB() {
    try {
        methodC();
    } catch (RuntimeException e) {
        // Handle exception
    }
}

@Transactional(noRollbackFor = RuntimeException.class)
public void methodC() {
    // Business logic
}

Solution 2: Using PROPAGATION_REQUIRES_NEW

Set propagation behavior to PROPAGATION_REQUIRES_NEW to execute inner methods in separate transactions:

@Transactional
public void methodB() {
    try {
        methodC();
    } catch (Exception e) {
        // Handle exception without affecting outer transaction
    }
}

@Transactional(propagation = Propagation.REQUIRES_NEW)
public void methodC() {
    throw new RuntimeException("Inner exception");
}

Solution 3: Debugging and Diagnostic Techniques

In Hibernate environments, diagnose transaction rollback causes by setting breakpoints:

// Before Hibernate 4.3
org.hibernate.ejb.TransactionImpl.setRollbackOnly()

// Hibernate 4.3 and later
org.hibernate.jpa.internal.TransactionImpl()

By examining the call stack, you can identify the specific exception that caused the transaction to be marked for rollback.

Best Practice Recommendations

1. Clear Transaction Boundaries: Ensure clear call hierarchy in transactional methods, avoiding unnecessary transaction nesting.

2. Consistent Exception Handling: Maintain consistent exception handling strategies across all methods in the transaction chain.

3. Reasonable Propagation Behavior: Choose appropriate propagation behavior based on business requirements, avoiding unnecessary transaction propagation.

4. Monitoring and Logging: Add detailed logging in critical transactional methods for easier troubleshooting.

Conclusion

The "rollback only" issue in Spring transactions typically stems from inconsistent configuration of transaction propagation and exception handling. By understanding transaction propagation mechanisms, unifying exception handling strategies, and properly using transaction attributes, developers can effectively prevent and resolve such issues. In practical development, thorough transaction testing is recommended to ensure transaction behavior meets expectations.