Aspect-Oriented Programming (AOP) is a programming paradigm that aims to enhance the maintainability, and reusability of software systems.

The idea behind AOP is to identify the cross-cutting concerns, such as

  • Logging
  • Error handling
  • Security

and encapsulate them in separate modules, called aspects, that can be applied to the different modules of the system without modifying their code.

AOP Limitation

However, AOP has some limitations, one of which is that it cannot be applied to self-invoking methods.

AOP limitations

Self-invocation refers to a situation in which a method calls itself recursively, without any external intervention. In this case, the method is responsible for executing its own behavior and cannot be modified by an external aspect.

Consider the following example of a self-invoking method in Java:

@Service
public class MyClass {

    public void executeTransaction(Transaction trx) {
       if(this.isValidTransaction(trx)) {
        // CODE GOES HERE...
       }
    }

    public Boolean isValidTransaction(Transaction trx) {
       // CODE GOES HERE...
    }
}

Self-injection

To overcome this limitation of AOP, a technique known as self-injection can be used here which involve injecting the Service(Bean) inside itself

The code shown previously will be transformed as follows:

@Service
public class MyClass {

    @Autowired
    private MyClass myClass;

    public void executeTransaction(Transaction trx) {
       if(myClass.isValidTransaction(trx)) {
        // CODE GOES HERE...
       }
    }

    public Boolean isValidTransaction(Transaction trx) {
       // CODE GOES HERE...
    }
}

By injecting the bean in itself, we overcome the AOP limitation where no longer the same object calling itself, it is another instance (different reference) calling it.

Self-Injection Risk

Although self-injection can be used to overcome the AOP limitation of not being able to apply aspects to self-invoking methods, it can also introduce new risks to the software system.

Self-Injection Pros VS Cons
  1. Self-injection can make the debugging harder when trying to understanding how the code is behaving, as it creates additional complexity and makes it harder to track the flow of data between different parts of the system which can make the code difficult to maintain and test.
  2. self-injection can lead to memory leaks and performance issues, as it creates additional instances of the same class. This can lead to increased memory usage and slower performance, especially in systems that process large amounts of data or have high concurrency.

Conclusion

While self-injection can be a useful technique in some cases, it should be used with caution and only when necessary to overcome specific limitations of AOP.

It is important to carefully consider the potential risks and trade-offs before using self-injection in a software system.

Want to learn more?

👉 Read Next: What Is Dependency Injection In Spring

👉 Read Next: What are Beans in Spring?

👉 Read Next: What Is Bean Lifecycle In Spring