Purpose of AOP

• WHY: Separating cross-cutting concerns(=repeatative tasks) from the core logic(=non repeatative tasks)

Examples of Cross-Cutting Concerns

• eg -1. separating global exception handling code from request handling logic(RestControllers)
• 1. separating Tx management code from B.L (service) | DAL (DAO)
  • (Spring supplied Tx mgr bean - supplies common advice to all Service | DAO layer , regarding Tx management)
• 1. separating security requirements(authentication , authorization ,protection against common security attacks) - RESTful web service
• All 3 of above - examples of ready made aspects (spring supplied)
• In case of specific recurring task - programmer has to create custom aspect.
  • eg - logging aspect , perfomance measurement

Example Requirement

• Requirement - Log every incoming request.

Development Steps for Implementing AOP

1. Add Dependencies
   • Add spring-aop-starter
     • Its implicitly added along with spring-web-starter
2. Identify Cross-Cutting Concern
   • Identify cross cutting concern(=recurring task , eg - logging)
     • add it in the custom aspect class
     • Mandatory annotations
       • @Aspect : to specify - recurring task
       • @Component - to declare spring bean
3. Aspect Class Structure
   • represents an advisor.
   • contains
     • 1. Advice
       • WHAT(=recurring task) n WHEN
         • @Before - advice is called before core logic
         • @After - advice is called after core logic rets (in case success as well as failure)
         • @AfterReturning - advice is called after core logic rets (in case success)
         • @AfterThrowing - advice is called after core logic rets (in case failure - exception)
         • @Around - most powerful advice , since its fired before n after method execution. Allows | Forbids the control to proceed to actual method invocation
     • 2. JoinPoint

       • To specify which the core logic method/s , need to be advised.

       • Represents WHERE to apply advice

       • PointCut - collection of join points.

         • using point cut expression
         • @PointCut
         • OR
         • You can define this point cut expression along with @Before |@After .... annotations.

       • Example in Aspect Class:

         @Before ("execution (* com.sunbeam.service.UserService.*(String,String))")
         public void logIt()
         {
           log.info(.....);
         }
         
         

Additional Details

Importance of AOP

• IMPORTANT
  • The key unit of modularity in OOP is the class, whereas in AOP the unit of modularity is the aspect. Dependency Injection helps you decouple your application objects from each other(eg : Controller separate from Service or DAO layers) and AOP helps you decouple cross-cutting concerns from the objects that they affect.(eg : transactional code or security related code can be kept separate from B.L or exception handling code from request handling method)
  • eg of ready made aspects provided by SC : tx management,security , exc handling