關于 Spring AOP 的原理分析！
Spring AOP是 Spring框架中的一個重要模塊，它通過分離關注點來提高代碼的模塊化程度，AOP允許開發者在不改變業務邏輯的情況下，通過切面來增強或修改代碼的行為。本文我們將深入分析 Spring AOP的原理。
一、Spring AOP概述
什么是AOP？
AOP，全程 Aspect-Oriented Programming，中文翻譯為面向切面編程，它是一種編程范式，旨在通過將橫切關注點（如日志記錄、事務管理、權限控制等）分離出來，使得這些關注點可以獨立于業務邏輯進行處理。AOP的核心概念包括：
- 切面（Aspect）：模塊化的關注點，通常橫切多個對象。
- 連接點（Join Point）：程序執行過程中的某個點，比如方法調用或異常拋出。
- 通知（Advice）：在切面的某個特定的連接點上執行的動作。
- 切入點（Pointcut）：匹配連接點的斷言。
- 目標對象（Target Object）：被通知的對象。
- 代理（Proxy）：通知目標對象后，創建的對象。
- 織入（Weaving）：將切面連接到其它應用程序類型或對象上，并創建一個通知對象。
二、Spring AOP的核心原理
1.AOP的實現機制
Spring AOP基于代理模式實現，主要通過Proxy對象來替代目標對象，并在Proxy對象的方法調用中插入切面邏輯。Spring AOP使用ProxyFactory和AdvisedSupport等類來管理和創建代理對象。代理又可以細分為：
- JDK動態代理：基于接口的代理，目標對象必須實現一個或多個接口。
- CGLIB代理：基于子類的代理，適用于目標對象沒有實現接口的情況。
2.AOP的核心組件
- Advisor：包含切入點和通知的元數據。
- Advice：定義切面在連接點上執行的操作。
- Pointcut：定義匹配連接點的規則。
- AopProxy：負責創建代理實例，具體實現有JdkDynamicAopProxy和CglibAopProxy。
3.AOP的執行流程
Spring AOP的執行流程是理解其工作原理的關鍵，它通過在程序運行時動態地將切面邏輯織入到目標對象中，從而實現橫切關注點的分離。下面我們來詳細地分析 Spring AOP的執行流程。
(1) 配置切面
AOP的執行流程從配置切面開始，切面可以通過 XML配置文件或基于注解的方式進行定義。配置切面時，主要涉及以下幾個元素：
- 切面類（Aspect）：包含橫切邏輯的類，通常用@Aspect注解標識。
- 通知方法（Advice）：定義在特定連接點上執行的橫切邏輯。通知類型包括@Before、@After、@Around、@AfterReturning、@AfterThrowing等。
- 切入點表達式（Pointcut Expression）：用于匹配連接點的方法執行點，通常使用AspectJ的切入點表達式語法。
(2) 創建代理對象
在Spring容器啟動時，Spring會掃描配置的切面類，并為每個目標對象創建代理對象。代理對象負責在目標方法執行前后插入切面邏輯。Spring AOP使用兩種主要的代理方式：
- JDK動態代理：適用于目標對象實現了接口的情況，通過Java的反射機制創建代理對象。
- CGLIB代理：適用于目標對象沒有實現接口的情況，通過生成目標類的子類來創建代理。
(3) 方法調用攔截
當客戶端代碼調用目標對象的方法時，實際上是通過代理對象來進行調用的。代理對象實現了與目標對象相同的接口，因此客戶端代碼無需感知代理的存在。
- 攔截方法調用：代理對象攔截對目標方法的調用。對于JDK動態代理，這是通過實現InvocationHandler接口的invoke方法來實現的；對于CGLIB代理，這是通過生成子類并重寫方法來實現的。
(4) 執行通知
在方法調用被攔截后，代理對象會根據切面配置執行相應的通知邏輯：
- Before通知：在目標方法執行之前執行。
- After通知：在目標方法執行之后執行，無論方法是否拋出異常。
- Around通知：包圍目標方法的執行，可以在方法執行前后進行自定義邏輯，甚至可以決定是否執行目標方法。
- AfterReturning通知：在目標方法成功返回后執行。
- AfterThrowing通知：在目標方法拋出異常后執行。
(5) 執行目標方法
在執行完Before或Around通知的前置邏輯后，代理對象會調用目標對象的實際方法。目標方法執行完成后，代理對象會繼續執行After、Around的后置邏輯、AfterReturning或AfterThrowing通知。
(6) 返回結果或拋出異常
代理對象在完成所有通知邏輯后，將目標方法的返回結果返回給調用方。如果目標方法拋出異常，代理對象也會處理異常并根據配置決定是否重新拋出或轉換異常。
(7) 結束
AOP的執行流程在代理對象返回結果或拋出異常后結束，整個過程是透明的，調用方無需關心代理的存在，目標對象的行為在運行時被增強。
三、Spring AOP核心源碼分析
Spring AOP的源碼涉及到多個核心類和接口，包括ProxyFactory、AdvisedSupport、AopProxy、JdkDynamicAopProxy、CglibAopProxy等。下面，我們將對這些核心組件進行詳細分析。
1.ProxyFactory
ProxyFactory是Spring AOP創建代理的核心工廠類。它負責根據配置創建合適的代理對象（JDK動態代理或CGLIB代理）。
public class ProxyFactory extends ProxyCreatorSupport {
// 獲取代理對象
public Object getProxy() {
return createAopProxy().getProxy();
}
// 創建AopProxy對象
protected AopProxy createAopProxy() {
if (!this.isProxyTargetClass()) { // 是否強制使用CGLIB代理
return new JdkDynamicAopProxy(this);
}
return new CglibAopProxy(this);
}
}- getProxy()：對外提供獲取代理對象的方法。
- createAopProxy()：根據ProxyTargetClass屬性判斷使用JDK動態代理還是CGLIB代理。
2.AdvisedSupport
AdvisedSupport是Spring AOP的配置類，持有AOP代理需要的各種配置，包括目標對象、切面、通知等。
public class AdvisedSupport extends ProxyConfig implements Advised {
private TargetSource targetSource;
private List<Advisor> advisors = new ArrayList<>();
private List<Class<?>> interfaces = new ArrayList<>();
// 其他配置和方法
}- TargetSource：封裝了目標對象。
- advisors：存儲應用于目標對象的通知（Advice）和切入點（Pointcut）。
- interfaces：代理對象需要實現的接口列表。
3.AopProxy接口
AopProxy是一個接口，定義了AOP代理對象的創建方法。
public interface AopProxy {
Object getProxy();
Object getProxy(ClassLoader classLoader);
}- getProxy()：用于創建代理對象。
- getProxy(ClassLoader classLoader)：允許指定類加載器創建代理對象。
4.JdkDynamicAopProxy
JdkDynamicAopProxy實現了AopProxy接口，使用JDK動態代理為目標對象創建代理。
public class JdkDynamicAopProxy implements AopProxy, InvocationHandler {
private final AdvisedSupport advised;
public JdkDynamicAopProxy(AdvisedSupport config) {
this.advised = config;
}
@Override
public Object getProxy() {
return getProxy(Thread.currentThread().getContextClassLoader());
}
@Override
public Object getProxy(ClassLoader classLoader) {
return Proxy.newProxyInstance(classLoader, this.advised.getProxiedInterfaces(), this);
}
@Override
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
List<Object> chain = this.advised.getInterceptorsAndDynamicInterceptionAdvice(method, this.advised.getTargetClass());
if (chain.isEmpty()) {
return method.invoke(this.advised.getTargetSource().getTarget(), args);
}
MethodInvocation invocation = new ReflectiveMethodInvocation(proxy, this.advised.getTargetSource().getTarget(), method, args, chain);
return invocation.proceed();
}
}- getProxy()：通過Proxy.newProxyInstance創建代理對象。
- invoke()：實現InvocationHandler接口的方法，負責方法調用的攔截和通知鏈的執行。
5.CglibAopProxy
CglibAopProxy同樣實現了AopProxy接口，使用CGLIB庫為目標對象創建代理。
public class CglibAopProxy implements AopProxy {
private final AdvisedSupport advised;
public CglibAopProxy(AdvisedSupport config) {
this.advised = config;
}
@Override
public Object getProxy() {
return getProxy(Thread.currentThread().getContextClassLoader());
}
@Override
public Object getProxy(ClassLoader classLoader) {
Enhancer enhancer = new Enhancer();
enhancer.setSuperclass(this.advised.getTargetClass());
enhancer.setInterfaces(this.advised.getProxiedInterfaces());
enhancer.setCallback(new DynamicAdvisedInterceptor(this.advised));
return enhancer.create();
}
private static class DynamicAdvisedInterceptor implements MethodInterceptor {
private final AdvisedSupport advised;
public DynamicAdvisedInterceptor(AdvisedSupport advised) {
this.advised = advised;
}
@Override
public Object intercept(Object obj, Method method, Object[] args, MethodProxy proxy) throws Throwable {
List<Object> chain = this.advised.getInterceptorsAndDynamicInterceptionAdvice(method, this.advised.getTargetClass());
if (chain.isEmpty()) {
return proxy.invokeSuper(obj, args);
}
MethodInvocation invocation = new CglibMethodInvocation(obj, this.advised.getTargetSource().getTarget(), method, args, proxy, chain);
return invocation.proceed();
}
}
}- getProxy()：使用CGLIB的Enhancer創建代理對象。
- DynamicAdvisedInterceptor：CGLIB的攔截器實現，負責方法調用的攔截和通知鏈的執行。
6.MethodInvocation
MethodInvocation接口及其實現類（如ReflectiveMethodInvocation）負責封裝方法調用的上下文信息，并管理通知鏈的執行。
public interface MethodInvocation extends Joinpoint {
Method getMethod();
Object[] getArguments();
}
public class ReflectiveMethodInvocation implements MethodInvocation {
private final Object proxy;
private final Object target;
private final Method method;
private final Object[] arguments;
private final List<?> interceptorsAndDynamicMethodMatchers;
private int currentInterceptorIndex = -1;
@Override
public Object proceed() throws Throwable {
if (this.currentInterceptorIndex == this.interceptorsAndDynamicMethodMatchers.size() - 1) {
return this.method.invoke(this.target, this.arguments);
}
Object interceptorOrInterceptionAdvice = this.interceptorsAndDynamicMethodMatchers.get(++this.currentInterceptorIndex);
if (interceptorOrInterceptionAdvice instanceof MethodInterceptor) {
MethodInterceptor interceptor = (MethodInterceptor) interceptorOrInterceptionAdvice;
return interceptor.invoke(this);
} else {
return proceed();
}
}
}- proceed()：遞歸調用通知鏈中的下一個攔截器，最終執行目標方法。
通過對 Spring AOP源碼的詳細分析，我們可以看到Spring AOP是如何通過代理模式實現面向切面編程的。
四、Spring AOP應用示例
下面我們通過一個簡單的 Spring AOP示例，展示如何通過AOP實現日志記錄。
1.定義業務類
public class UserService {
public void createUser(String username) {
System.out.println("Creating user: " + username);
}
}2.定義切面
@Aspect
public class LoggingAspect {
@Before("execution(* UserService.createUser(..))")
public void logBefore(JoinPoint joinPoint) {
System.out.println("Before method: " + joinPoint.getSignature().getName());
}
}3.Spring配置
使用Java配置：
@Configuration
@EnableAspectJAutoProxy
public class AppConfig {
@Bean
public UserService userService() {
return new UserService();
}
@Bean
public LoggingAspect loggingAspect() {
return new LoggingAspect();
}
}4.測試AOP功能
public class AopTest {
public static void main(String[] args) {
ApplicationContext context = new AnnotationConfigApplicationContext(AppConfig.class);
UserService userService = context.getBean(UserService.class);
userService.createUser("Alice");
}
}輸出結果：
Before method: createUser
Creating user: Alice五、總結
Spring AOP通過代理模式實現了面向切面編程，能夠在不改變業務邏輯的情況下增強代碼功能。通過本文的分析，我們了解了 Spring AOP的基本概念、實現機制、核心組件以及如何在實際項目中應用 AOP。Spring AOP的強大之處在于其靈活性和可擴展性，使得開發者可以輕松地實現橫切關注點的分離和復用。
