What nuances and features exist when using transactional proxy mechanisms for multiple methods within a single component in Spring?

In Spring, transactional proxy handling is based on creating a proxy object that intercepts method calls and manages transactions.

Features when using multiple methods within a single component:

• Method calls within the same class do not go through the proxy if they are called directly (this.method()), so the @Transactional annotation on such methods will not work.
• For a transaction to be applied, the call must come from outside through the proxy, for example, from another bean.
• You can use AopContext.currentProxy() to get the proxy inside the class and call the method through it, but this complicates the code.
• When declaring multiple methods with @Transactional in one class, it is important to remember that nested calls will not create new transactions unless the appropriate propagation is configured.

Example of a problem:

@Service
public class MyService {

    @Transactional
    public void methodA() {
        methodB(); // direct call, `@Transactional` on methodB will not work
    }

    @Transactional(propagation = Propagation.REQUIRES_NEW)
    public void methodB() {
        // a new transaction will not be created when called from methodA
    }
}

For proper operation, you can:

• Move methods to different beans.
• Call the method through the proxy, for example:

((MyService) AopContext.currentProxy()).methodB();