SpringFramework Aop: Common techniques and practical cases to implement surface programming in the Java class library
Spring Framework Aop
introduction:
Facial -oriented programming (AOP) is a software design mode to separate the business logic of the application from cross -sectional attention (such as log records, transaction management, etc.).AOP in Spring Framework is a powerful tool to achieve cut -oriented programming.This article will introduce some common techniques and practical cases to help you better use AOP in Spring Framework.
1. Cut point expression:
Where to specify the expression of the cut expression (class, method) to apply the cut surface.Spring Framework Aop uses a cut point -based expression to select the cut point.Below is an example, and only the surface is applied in all methods of all classes under the specified package.
@Pointcut("execution(* com.example.myapp.service.*.*(..))")
public void pointcutExpression(){}
2. Cutting surface definition:
The cut surface defines the logic to be executed at the cut point.It contains the types of notifications (front, rear, surround, etc.) required for the cut surface.The following is an example, defining a simple front notice.
@Before("pointcutExpression()")
public void beforeAdvice(){
// Execute the front logic
}
3. Join Point:
The connection point is a specific point that can insert the cut surface during execution.It can be the execution of the method, abnormal throwing, field access, etc.The following is an example that obtains the parameters of the method through the connection point.
@Around("execution(* com.example.myapp.service.*.*(..))")
public Object aroundAdvice(ProceedingJoinPoint joinPoint) throws Throwable{
Object[] args = joinPoint.getArgs();
// Execute the surround logic
Object result = joinPoint.proceed();
// process result
return result;
}
4. Notification type:
The notification type specifies the timing of the cut surface at the connection point.Spring Framework supports the following types of notifications:
-For notice (@Before): execute before the connection point, suitable for transaction management, permission inspection, etc.
-The rear notification (@Aterreturning): execute after the connection point, suitable for recording logs, resource cleaning, etc.
-This notification (@AFTERTHROWING): After throwing abnormalities at the connection point, it is suitable for handling abnormal conditions.
-Stop notification (@Around): execute before and after the connection point, and can freely control the execution of the connection point.
5. Introduction:
Introduction is a special type of notification that is used to dynamically add new methods and fields to exist.The following is an example that adds a new method by introducing the existing class.
public interface NewFeatureInterface{
void newMethod();
}
public class ExistingClass implements NewFeatureInterface{
// ...
}
@Aspect
public class FeatureIntroduction{
@DeclareParents(value="com.example.myapp.service.ExistingClass+", defaultImpl=NewFeatureImpl.class)
public static NewFeatureInterface mixin;
}
public class NewFeatureImpl implements NewFeatureInterface{
public void newMethod(){
// The implementation of the new method
}
}
6. Automatic proxy of the cut surface:
Spring Framework provides a mechanism for automatic proxy, which can generate an agent object based on the configuration as a category of category, and apply the cut surface to the target class.The following is an example that uses @EnableAspectjautoProxy to enable automatic proxy.
@Configuration
@EnableAspectJAutoProxy
public class AppConfig{
// Configure other beans
}
7. The order of cutting surface:
When multiple cutting planes are suitable for the same connection point, Spring Framework uses the order of specified the specified cut surface with @order annotation.Cutting surfaces with smaller values are prioritized.The following is an example, specifying the order of the cut surface execution.
@Aspect
@Order(1)
public class FirstAspect{
// ...
}
@Aspect
@Order(2)
public class SecondAspect{
// ...
}
in conclusion:
Spring Framework Aop provides powerful tools and skills to achieve cutting programming.This article introduces some commonly used techniques and practical cases, including cutting point expression, cutting surface definition, connection point, notification type, introduction, automatic proxy, and sequential sequence of sections.I hope these techniques can help you better use AOP in Spring Framework to achieve modular and maintained applications.
