Detailed explanation of SpringBoot nested transactions and failure solutions

What is a nested transaction?

Nested transactions are transaction propagation behaviors that allow nesting another transaction in one transaction. Spring provides the PROPAGATION_NESTED transaction propagation property for implementing nested transactions. The characteristics of nested transactions are:

• Depend on outer transactions: The commit of nested transactions depends on outer transactions.
• Can be rolled back independently: When a nested transaction fails, it can be rolled back partially without affecting the outer transaction.

Causes of nested transaction failure

Spring's transaction management is based on AOP dynamic proxy. When a transaction method is called directly (for example through ()), the transaction function will be invalid without passing through Spring's proxy.

Core questions:

• Internal method calls do not trigger Spring's proxy logic.
• Therefore, transaction annotations such as @Transactional cannot take effect.

The sample code is as follows:

@Service
public class ExampleService {
    @Autowired
    private DemoRepository demoRepository;
 
    @Transactional
    public void outerMethod() {
        saveOuter();
        (); // Internal call, the transaction will not take effect    }
 
    private void saveOuter() {
        DemoEntity entity = new DemoEntity();
        ("Outer");
        (entity);
    }
 
    @Transactional(propagation = )
    public void innerMethod() {
        DemoEntity entity = new DemoEntity();
        ("Inner");
        (entity);
 
        // Simulate exceptions        throw new RuntimeException("Inner transaction failed");
    }
}

In the above code,outerMethodCalledinnerMethod, but because it is throughthisReference call, transaction annotation@TransactionalWill not take effect.

Solutions for nested transactions

In order to solve the problem of nested transaction failure, we can ensure that the method call goes through Spring's proxy mechanism through the following methods.

Solution 1: Extract nested transaction methods to independent classes

WillinnerMethodThe method is extracted into a new service class, ensuring that it is called through the proxy class managed by the Spring container.

Sample code：

• Create a new service class to handle nested transactions:

@Service
public class InnerService {
    @Autowired
    private DemoRepository demoRepository;
 
    @Transactional(propagation = )
    public void innerMethod() {
        DemoEntity entity = new DemoEntity();
        ("Inner");
        (entity);
 
        // Simulate exceptions        throw new RuntimeException("Inner transaction failed");
    }
}

• Modify outer service class:

@Service
public class ExampleService {
    @Autowired
    private InnerService innerService;
 
    @Autowired
    private DemoRepository demoRepository;
 
    @Transactional
    public void outerMethod() {
        saveOuter();
        (); // Through proxy calls, the transaction takes effect    }
 
    private void saveOuter() {
        DemoEntity entity = new DemoEntity();
        ("Outer");
        (entity);
    }
}

This method is the most common and can effectively solve the problem of nested transaction failure.

Solution 2: Use ApplicationContext to get proxy object

By Spring'sApplicationContextGet the proxy object of the current class to ensure that the transaction method call is made through the proxy.

Sample code：

@Service
public class ExampleService {
    @Autowired
    private DemoRepository demoRepository;
 
    @Autowired
    private ApplicationContext applicationContext;
 
    @Transactional
    public void outerMethod() {
        saveOuter();
 
        // Get your own agent        ExampleService proxy = ();
        (); // Through proxy calls, the transaction takes effect    }
 
    private void saveOuter() {
        DemoEntity entity = new DemoEntity();
        ("Outer");
        (entity);
    }
 
    @Transactional(propagation = )
    public void innerMethod() {
        DemoEntity entity = new DemoEntity();
        ("Inner");
        (entity);
 
        // Simulate exceptions        throw new RuntimeException("Inner transaction failed");
    }
}

Solution 3: Use AopContext to obtain proxy objects

Spring provides()Method, you can get the proxy object of the current class in the same class.

Sample code：

@Service
public class ExampleService {
    @Autowired
    private DemoRepository demoRepository;
 
    @Transactional
    public void outerMethod() {
        saveOuter();
 
        // Get the proxy object        ExampleService proxy = (ExampleService) ();
        (); // Through proxy calls, the transaction takes effect    }
 
    private void saveOuter() {
        DemoEntity entity = new DemoEntity();
        ("Outer");
        (entity);
    }
 
    @Transactional(propagation = )
    public void innerMethod() {
        DemoEntity entity = new DemoEntity();
        ("Inner");
        (entity);
 
        // Simulate exceptions        throw new RuntimeException("Inner transaction failed");
    }
}

Use this solution needs to be enabled in the configuration.exposeProxy：

@Configuration
@EnableTransactionManagement(proxyTargetClass = true)
public class TransactionConfig {
}

Summarize

The main reason why nested transactions fail in Spring Boot is that method calls fail to pass Spring's proxy mechanism. We can solve it in the following ways:

1. Extract nested transaction methods to independent classes(Recommended method).
2. Use ApplicationContext to get proxy objects。
3. Use AopContext to get proxy objects。

Choosing the right solution ensures that nested transactions work properly in complex business scenarios and avoid data consistency issues.

This is the end of this article about the detailed explanation of SpringBoot nested transactions and failure solutions. For more related SpringBoot nested transaction content, please search for my previous articles or continue browsing the related articles below. I hope everyone will support me in the future!