- Adds global behavior to the application
- Re-usable block of code that can be injected into the application during runtime
- Leverages AspectJ
- Byte code modification (Runtime interweaving)
- Dynamic proxy-based
- Common applications
- logging and tracing
- Transaction management
- Caching
- Security
- Parts of Spring Aspect
- Join Point :
- Represents these specific points in the execution of a program where advice can be applied.
- Business logic where aspect can be applied
- You apply the aspect here
- Pointcut :
- Specifies certain conditions or criteria that define when certain pieces of code (advice) should be executed.
- Select the joinpoint for the cross-cutting concern
- This is the trigger of aspect
- signature: `designator("returntype packageName.className.methodName(argument)" )`
- common designators :
- `execution` (expression for matching method execution),
- `within` (expression for matching within certain type),
- `target` (expression for matching specific type),
- `@annotation` (expression for matching specific annotation)
- Advice :
- Represents the actual code or instructions that need to be executed when the conditions specified by the pointcut are met.
- The code that is applied to the join point when it is selected by the pointcut (cross-cutting concern )
- This is the aspected behavior itself
package com.xyz.someapp;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Pointcut;
@Aspect
public class SystemArchitecture {
/**
* A join point is in the web layer if the method is defined
* in a type in the com.xyz.someapp.web package or any sub-package
* under that.
*/
@Pointcut("within(com.xyz.someapp.web..*)")
public void inWebLayer() {}
/**
* A join point is in the service layer if the method is defined
* in a type in the com.xyz.someapp.service package or any sub-package
* under that.
*/
@Pointcut("within(com.xyz.someapp.service..*)")
public void inServiceLayer() {}
/**
* A join point is in the data access layer if the method is defined
* in a type in the com.xyz.someapp.dao package or any sub-package
* under that.
*/
@Pointcut("within(com.xyz.someapp.dao..*)")
public void inDataAccessLayer() {}
/**
* A business service is the execution of any method defined on a service
* interface. This definition assumes that interfaces are placed in the
* "service" package, and that implementation types are in sub-packages.
*
* If you group service interfaces by functional area (for example,
* in packages com.xyz.someapp.abc.service and com.xyz.def.service) then
* the pointcut expression "execution(* com.xyz.someapp..service.*.*(..))"
* could be used instead.
*
* Alternatively, you can write the expression using the 'bean'
* PCD, like so "bean(*Service)". (This assumes that you have
* named your Spring service beans in a consistent fashion.)
*/
@Pointcut("execution(* com.xyz.someapp.service.*.*(..))")
public void businessService() {}
/**
* A data access operation is the execution of any method defined on a
* dao interface. This definition assumes that interfaces are placed in the
* "dao" package, and that implementation types are in sub-packages.
*/
@Pointcut("execution(* com.xyz.someapp.dao.*.*(..))")
public void dataAccessOperation() {}
}