What is AOP
AOP stands for Aspect Oriented Programming. It is mainly used to implement the Cross-Cutting concerns in applications. These are used to reduce the mix of the business logic from the NFR (Non Functional Requirements) like logging, performance monitoring, validations etc.
Also, these "Aspects" can be [should be] generalized and be located in a common library or package so that it can be easily upgraded / patched.
Further, these Aspects are to be implemented without bringing-in these Aspects into every service or business logic layer so that they can be less invasive and like autowired to get the job done without being omni-present.
Spring AOP helps us achieve this model by bringing in the support for the Aspects and help us wire these aspects at places where required.
Core Terms / Concepts
Aspect
This is the cross cutting concern like logging / time measurement / validation etc.
Join Point
The method execution. (Example: Executing a service method like CustomerService::addNewCustomer)
Advice
The hook where we want the logic to be placed like before execution of the method, after execution or before and after method execution. (An Advice can be thought to be similar to a pre-processor / post processor or a combination of both)
Point Cut
This indicates the expression or an indication of at which join point the advice to be executed. This is more like an identifier that helps AOP to find and run the Advice at the points defined. These can be identical to that of labels or markers which can be used to locate the code where the advice is to be executed.
Introduction
The process of adding a new field or an interface to a type (like C# static methods being used to add behavior to the existing classes)
Target Object
The object on which the Advice is being executed or planned to execute. Since spring uses proxies, this will normally be a proxy object
AOP Proxy
This is created by Spring AOP to execute the AOP contracts like advices / introductions to the target objects.
Weaving
This is a beautiful term IMHO. This is where the aspects are linked with the objects to create adviced objects. This can be done at compile time, load time or at Runtime by the Spring AOP framework
What are the types of Advices
1. Before
This is used to execute logic before the method is being executed
2. After returning
To execute the advice once the method has completed the execution
3. Around
To have our code run before and after the method execution. This can be thought of like having a workflow inside an Abstract class that invokes the concrete implementations
4. After throwing
To execute the logic after a method execution results in an exception
5. After finally
To execute the logic regardless of the state in which the method execution exits (be it erroring out with an exception [or] successfully complete execution)
Which one do I choose?
As the saying goes "The right choices you make, make your life", so it is applicable to the aspects as well.
Choose the right advice type that is least powerful so that the impact is less. For example, if the requirement is to operate on the result, we need to use either After finally or After returning so that we can focus on getting the data captured rather than focusing on the Around where we have logic to be executed before and after execution and the method execution needs to be triggered without fail
For more detailed point cut expressions, please refer to the official Spring documentation because some of the AspectJ expressions are not yet supported by Spring framework.
Comments
Post a Comment