Does spring self injection lead to memory leakage?-CodePudding

In Spring, beans are encapsulated by a proxy object and when called from outer object the proxy object's method is also called. By using this trick transaction management is performed in proxy object's methods. But when you are calling a method in the same bean and if you want the called method to be run in another transaction with the caller method it is not possible. Since the method calls in the same bean does not pass through the proxy object which performs transaction operations. In order to solve this, self-injection of the bean inside itself is proposed.

like this

@Service
public class MyService{
    @Autowired
    public MyService myService;

    @Transactional(propagation = Propagation.REQUIRES_NEW)
    public void method1(){
      method2();// runs in the same transaction with method1
      myService.method2();// runs in separate transaction from method1
    }
    @Transactional(propagation = Propagation.REQUIRES_NEW)
    public void method2(){

    }
}

I want to ask whether self-injection leads to memory leakage. Outer bean MyService includes injected myService and myService should include attribute of type MyService, which should include attribute of type MyService ....

CodePudding user response：

The service is not copied, it is only a reference. But I'd be wary of such a design: it creates a circular reference and the object graph is impossible to create at once. You first need to create the incomplete service, then set its field. Furthermore, it is kind of confusing and surprising to find such a dependency to self

I'd propose a different solution:

@Component
public class WithTransaction {
    @Transactional(propagation = Propagation.REQUIRES_NEW)
    public void requiresNew(final Runnable runnable) {
        runnable.run();
    }
}

@Service
public class MyService{
    private final WithTransaction withTransaction;

    @Autowired
    public MyService(final WithTransaction withTransaction) {
      this.withTransaction = withTransaction;
    }

    @Transactional(propagation = Propagation.REQUIRES_NEW)
    public void method1(){
      method2();// runs in the same transaction with method1
      withTransaction.requiresNew(this::method2); // runs in separate transaction from method1
    }
    @Transactional(propagation = Propagation.REQUIRES_NEW)
    public void method2(){

    }
}

And if you can avoid it: don't call any public methods from your service on the service itself. Split the service into smaller components so that each "public" call must go through the proxy.