(Spring）AOP是怎么實現的

AOP

AOP聯盟標准

AOP聯盟將AOP體系分為三層，從三層結構可以看出，AOP實現方式有很多種，包括反射、元數據處理、程序處理、攔截器處理等，通過本節學習，你就會看到Spring AOP的實現使用的是Java語言本身的特性，即Java Proxy代理類、攔截器技術實現。

AOP簡介

概念

切面（Aspect） ：官方的抽象定義為“一個關注點的模塊化，這個關注點可能會橫切多個對象”。
連接點（Joinpoint） ：程序執行過程中的某一行為。
通知（Advice） ：“切面”對於某個“連接點”所產生的動作。
切入點（Pointcut） ：匹配連接點的斷言，在AOP中通知和一個切入點表達式關聯。
目標對象（Target Object） ：被一個或者多個切面所通知的對象。
AOP代理（AOP Proxy） 在Spring AOP中有兩種代理方式，JDK動態代理和CGLIB代理。

通知（Advice）類型
前置通知（Before advice） ：在某連接點（JoinPoint）之前執行的通知，但這個通知不能阻止連接點前的執行。ApplicationContext中在<aop:aspect>里面使用<aop:before>元素進行聲明。
后通知（After advice） ：當某連接點退出的時候執行的通知（不論是正常返回還是異常退出）。ApplicationContext中在<aop:aspect>里面使用<aop:after>元素進行聲明。
返回后通知（After return advice） ：在某連接點正常完成后執行的通知，不包括拋出異常的情況。ApplicationContext中在<aop:aspect>里面使用<after-returning>元素進行聲明。
環繞通知（Around advice） ：包圍一個連接點的通知，類似Web中Servlet規范中的Filter的doFilter方法。可以在方法的調用前后完成自定義的行為，也可以選擇不執行。ApplicationContext中在<aop:aspect>里面使用<aop:around>元素進行聲明。
拋出異常后通知（After throwing advice） ： 在方法拋出異常退出時執行的通知。 ApplicationContext中在<aop:aspect>里面使用<aop:after-throwing>元素進行聲明。

切入點表達式 ：如execution(* com.spring.service.*.*(..))

特點

1、降低模塊之間的耦合度

2、使系統容易擴展

3、更好的代碼復用。

 

時序圖

 

流程說明

1）AOP標簽的定義解析劉徹骨肯定是從NamespaceHandlerSupport的實現類開始解析的，這個實現類就是AopNamespaceHandler。至於為什么會是從NamespaceHandlerSupport的實現類開始解析的，這個的話我想讀者可以去在回去看看Spring自定義標簽的解析流程，里面說的比較詳細。

2）要啟用AOP，我們一般會在Spring里面配置<aop:aspectj-autoproxy/>  ，所以在配置文件中在遇到aspectj-autoproxy標簽的時候我們會采用AspectJAutoProxyBeanDefinitionParser解析器

3）進入AspectJAutoProxyBeanDefinitionParser解析器后，調用AspectJAutoProxyBeanDefinitionParser已覆蓋BeanDefinitionParser的parser方法，然后parser方法把請求轉交給了AopNamespaceUtils的registerAspectJAnnotationAutoProxyCreatorIfNecessary去處理

4）進入AopNamespaceUtils的registerAspectJAnnotationAutoProxyCreatorIfNecessary方法后，先調用AopConfigUtils的registerAspectJAnnotationAutoProxyCreatorIfNecessary方法，里面在轉發調用給registerOrEscalateApcAsRequired，注冊或者升級AnnotationAwareAspectJAutoProxyCreator類。對於AOP的實現，基本是靠AnnotationAwareAspectJAutoProxyCreator去完成的，它可以根據@point注解定義的切點來代理相匹配的bean。

5）AopConfigUtils的registerAspectJAnnotationAutoProxyCreatorIfNecessary方法處理完成之后，接下來會調用useClassProxyingIfNecessary() 處理proxy-target-class以及expose-proxy屬性。如果將proxy-target-class設置為true的話，那么會強制使用CGLIB代理，否則使用jdk動態代理，expose-proxy屬性是為了解決有時候目標對象內部的自我調用無法實現切面增強。

6）最后的調用registerComponentIfNecessary 方法，注冊組建並且通知便於監聽器做進一步處理。

創建AOP代理

上面說到AOP的核心邏輯是在AnnotationAwareAspectJAutoProxyCreator類里面實現，那么我們先來看看這個類的層次關系

這個類實現了BeanPostProcessor接口，那就意味着這個類在spring加載實例化前會調用postProcessAfterInitialization方法，對於AOP的邏輯也是由此開始的。

 

時序圖

 

流程說明

1）spring 容器啟動，每個bean的實例化之前都會先經過AbstractAutoProxyCreator類的postProcessAfterInitialization（）這個方法，然后接下來是調用wrapIfNecessary方法。

1.  
   /**
2.  
   * Create a proxy with the configured interceptors if the bean is
3.  
   * identified as one to proxy by the subclass.
4.  
   * @see #getAdvicesAndAdvisorsForBean
5.  
   */
6.  
   public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
7.  
   if (bean != null) {
8.  
   Object cacheKey = getCacheKey(bean.getClass(), beanName);
9.  
   if (!this.earlyProxyReferences.containsKey(cacheKey)) {
10.  
    return wrapIfNecessary(bean, beanName, cacheKey);
11.  
    }
12.  
    }
13.  
    return bean;
14.  
    }

2）進入wrapIfNecessary方法后，我們直接看重點實現邏輯的方法getAdvicesAndAdvisorsForBean，這個方法會提取當前bean 的所有增強方法，然后獲取到適合的當前bean 的增強方法，然后對增強方法進行排序，最后返回

1.  
   /**
2.  
   * Wrap the given bean if necessary, i.e. if it is eligible for being proxied.
3.  
   * @param bean the raw bean instance
4.  
   * @param beanName the name of the bean
5.  
   * @param cacheKey the cache key for metadata access
6.  
   * @return a proxy wrapping the bean, or the raw bean instance as-is
7.  
   */
8.  
   protected Object wrapIfNecessary(Object bean, String beanName, Object cacheKey) {
9.  
   if (beanName != null && this.targetSourcedBeans.containsKey(beanName)) {
10.  
    return bean;
11.  
    }
12.  
    if (Boolean.FALSE.equals(this.advisedBeans.get(cacheKey))) {
13.  
    return bean;
14.  
    }
15.  
    if (isInfrastructureClass(bean.getClass()) || shouldSkip(bean.getClass(), beanName)) {
16.  
    this.advisedBeans.put(cacheKey, Boolean.FALSE);
17.  
    return bean;
18.  
    }
19.  
     
20.  
    // Create proxy if we have advice.
21.  
    Object[] specificInterceptors = getAdvicesAndAdvisorsForBean(bean.getClass(), beanName, null);
22.  
    if (specificInterceptors != DO_NOT_PROXY) {
23.  
    this.advisedBeans.put(cacheKey, Boolean.TRUE);
24.  
    Object proxy = createProxy(bean.getClass(), beanName, specificInterceptors, new SingletonTargetSource(bean));
25.  
    this.proxyTypes.put(cacheKey, proxy.getClass());
26.  
    return proxy;
27.  
    }
28.  
     
29.  
    this.advisedBeans.put(cacheKey, Boolean.FALSE);
30.  
    return bean;
31.  
    }

3）獲取到當前bean的增強方法后，便調用createProxy方法，創建代理。先創建代理工廠proxyFactory，然后獲取當前bean 的增強器advisors，把當前獲取到的增強器添加到代理工廠proxyFactory，然后設置當前的代理工的代理目標對象為當前bean，最后根據配置創建JDK的動態代理工廠，或者CGLIB的動態代理工廠，然后返回proxyFactory

1.  
   /**
2.  
   * Create an AOP proxy for the given bean.
3.  
   * @param beanClass the class of the bean
4.  
   * @param beanName the name of the bean
5.  
   * @param specificInterceptors the set of interceptors that is
6.  
   * specific to this bean (may be empty, but not null)
7.  
   * @param targetSource the TargetSource for the proxy,
8.  
   * already pre-configured to access the bean
9.  
   * @return the AOP proxy for the bean
10.  
    * @see #buildAdvisors
11.  
    */
12.  
    protected Object createProxy(
13.  
    Class<?> beanClass, String beanName, Object[] specificInterceptors, TargetSource targetSource) {
14.  
     
15.  
    ProxyFactory proxyFactory = new ProxyFactory();
16.  
    // Copy our properties (proxyTargetClass etc) inherited from ProxyConfig.
17.  
    proxyFactory.copyFrom( this);
18.  
     
19.  
    if (!shouldProxyTargetClass(beanClass, beanName)) {
20.  
    // Must allow for introductions; can't just set interfaces to
21.  
    // the target's interfaces only.
22.  
    Class<?>[] targetInterfaces = ClassUtils.getAllInterfacesForClass(beanClass, this.proxyClassLoader);
23.  
    for (Class<?> targetInterface : targetInterfaces) {
24.  
    proxyFactory.addInterface(targetInterface);
25.  
    }
26.  
    }
27.  
     
28.  
    Advisor[] advisors = buildAdvisors(beanName, specificInterceptors);
29.  
    for (Advisor advisor : advisors) {
30.  
    proxyFactory.addAdvisor(advisor);
31.  
    }
32.  
     
33.  
    proxyFactory.<strong>setTargetSource</strong>(targetSource);
34.  
    customizeProxyFactory(proxyFactory);
35.  
     
36.  
    proxyFactory.setFrozen( this.freezeProxy);
37.  
    if (advisorsPreFiltered()) {
38.  
    proxyFactory.setPreFiltered( true);
39.  
    }
40.  
     
41.  
    return proxyFactory.getProxy(this.proxyClassLoader);
42.  
    }

AOP動態代理執行

 

關於AOP的動態代理執行，有兩種主要的方式JDK的動態代理和CGLIB的動態代理，接下來，我們先來看看AOP動態代理的實現選擇方式，先上核心實現代碼：

 

1.  
   public AopProxy createAopProxy(AdvisedSupport config) throws AopConfigException {
2.  
   if (config.isOptimize() || config.isProxyTargetClass() || hasNoUserSuppliedProxyInterfaces(config)) {
3.  
   Class targetClass = config.getTargetClass();
4.  
   if (targetClass == null) {
5.  
   throw new AopConfigException("TargetSource cannot determine target class: " +
6.  
   "Either an interface or a target is required for proxy creation.");
7.  
   }
8.  
   if (targetClass.isInterface()) {
9.  
   return new JdkDynamicAopProxy(config);
10.  
    }
11.  
    return CglibProxyFactory.createCglibProxy(config);
12.  
    }
13.  
    else {
14.  
    return new JdkDynamicAopProxy(config);
15.  
    }
16.  
    }

Spring JDK動態代理實現

 

在上面的第三步驟說道或根據用戶的配置（例如是否配置了 proxyTargetClass屬性為true），選擇創建的代理類型，這個的代理類型分兩種實現，都是比較高效的，下面根據JDK的動態代理來說明AOP的執行，也是先上JdkDynamicAopProxy的核心代碼invoke方法：

 

1.  
   public Object invoke(Object proxy, Method method, Object[] args) throwsThrowable {
2.  
   MethodInvocation invocation = null;
3.  
   Object oldProxy = null;
4.  
   boolean setProxyContext = false;
5.  
    
6.  
   TargetSource targetSource = this.advised.targetSource;
7.  
   Class targetClass = null;
8.  
   Object target = null;
9.  
    
10.  
    try {
11.  
    //eqauls()方法，具目標對象未實現此方法
12.  
    if (!this.equalsDefined && AopUtils.isEqualsMethod(method)){
13.  
    return (equals(args[0])? Boolean.TRUE : Boolean.FALSE);
14.  
    }
15.  
     
16.  
    //hashCode()方法，具目標對象未實現此方法
17.  
    if (!this.hashCodeDefined && AopUtils.isHashCodeMethod(method)){
18.  
    return newInteger(hashCode());
19.  
    }
20.  
     
21.  
    //Advised接口或者其父接口中定義的方法,直接反射調用,不應用通知
22.  
    if (!this.advised.opaque &&method.getDeclaringClass().isInterface()
23.  
    &&method.getDeclaringClass().isAssignableFrom(Advised.class)) {
24.  
    // Service invocations onProxyConfig with the proxy config...
25.  
    return AopUtils.invokeJoinpointUsingReflection(this.advised,method, args);
26.  
    }
27.  
     
28.  
    Object retVal = null;
29.  
     
30.  
    if (this.advised.exposeProxy) {
31.  
    // Make invocation available ifnecessary.
32.  
    oldProxy = AopContext.setCurrentProxy(proxy);
33.  
    setProxyContext = true;
34.  
    }
35.  
     
36.  
    //獲得目標對象的類
37.  
    target = targetSource.getTarget();
38.  
    if (target != null) {
39.  
    targetClass = target.getClass();
40.  
    }
41.  
     
42.  
    //獲取可以應用到此方法上的Interceptor列表
43.  
    List chain = this.advised.getInterceptorsAndDynamicInterceptionAdvice(method,targetClass);
44.  
     
45.  
    //如果沒有可以應用到此方法的通知(Interceptor)，此直接反射調用 method.invoke(target, args)
46.  
    if (chain.isEmpty()) {
47.  
    retVal = AopUtils.invokeJoinpointUsingReflection(target,method, args);
48.  
    } else {
49.  
    //創建MethodInvocation
50.  
    invocation = newReflectiveMethodInvocation(proxy, target, method, args, targetClass, chain);
51.  
    retVal = invocation.proceed();
52.  
    }
53.  
     
54.  
    // Massage return value if necessary.
55.  
    if (retVal != null && retVal == target &&method.getReturnType().isInstance(proxy)
56.  
    &&!RawTargetAccess.class.isAssignableFrom(method.getDeclaringClass())) {
57.  
    // Special case: it returned"this" and the return type of the method
58.  
    // is type-compatible. Notethat we can't help if the target sets
59.  
    // a reference to itself inanother returned object.
60.  
    retVal = proxy;
61.  
    }
62.  
    return retVal;
63.  
    } finally {
64.  
    if (target != null && !targetSource.isStatic()) {
65.  
    // Must have come fromTargetSource.
66.  
    targetSource.releaseTarget(target);
67.  
    }
68.  
    if (setProxyContext) {
69.  
    // Restore old proxy.
70.  
    AopContext.setCurrentProxy(oldProxy);
71.  
    }
72.  
    }
73.  
    }

其實上面的注釋也說的比較清楚，各個步驟執行的說明：

1）獲取攔截器

2）判斷攔截器鏈是否為空，如果是空的話直接調用切點方法

3）如果攔截器不為空的話那么便創建ReflectiveMethodInvocation類，把攔截器方法都封裝在里面，也就是執行 getInterceptorsAndDynamicInterceptionAdvice方法

 

1.  
   public List<Object> getInterceptorsAndDynamicInterceptionAdvice(Method method, Class targetClass) {
2.  
   MethodCacheKeycacheKey = new MethodCacheKey(method);
3.  
   List<Object>cached = this.methodCache.get(cacheKey);
4.  
   if(cached == null) {
5.  
   cached= this.advisorChainFactory.getInterceptorsAndDynamicInterceptionAdvice(
6.  
   this,method, targetClass);
7.  
   this.methodCache.put(cacheKey,cached);
8.  
   }
9.  
   returncached;
10.  
    }

4)其實實際的獲取工作其實是由AdvisorChainFactory. getInterceptorsAndDynamicInterceptionAdvice()這個方法來完成的，獲取到的結果會被緩存，下面來分析下這個方法的實現：

1.  
   /**
2.  
   * 從提供的配置實例config中獲取advisor列表,遍歷處理這些advisor.如果是IntroductionAdvisor,
3.  
   * 則判斷此Advisor能否應用到目標類targetClass上.如果是PointcutAdvisor,則判斷
4.  
   * 此Advisor能否應用到目標方法method上.將滿足條件的Advisor通過AdvisorAdaptor轉化成Interceptor列表返回.
5.  
   */
6.  
   publicList getInterceptorsAndDynamicInterceptionAdvice(Advised config, Methodmethod, Class targetClass) {
7.  
   // This is somewhat tricky... we have to process introductions first,
8.  
   // but we need to preserve order in the ultimate list.
9.  
   List interceptorList = new ArrayList(config.getAdvisors().length);
10.  
     
11.  
    //查看是否包含IntroductionAdvisor
12.  
    boolean hasIntroductions = hasMatchingIntroductions(config,targetClass);
13.  
     
14.  
    //這里實際上注冊一系列AdvisorAdapter,用於將Advisor轉化成MethodInterceptor
15.  
    AdvisorAdapterRegistry registry = GlobalAdvisorAdapterRegistry.getInstance();
16.  
     
17.  
    Advisor[] advisors = config.getAdvisors();
18.  
    for (int i = 0; i <advisors.length; i++) {
19.  
    Advisor advisor = advisors[i];
20.  
    if (advisor instanceof PointcutAdvisor) {
21.  
    // Add it conditionally.
22.  
    PointcutAdvisor pointcutAdvisor= (PointcutAdvisor) advisor;
23.  
    if(config.isPreFiltered() ||pointcutAdvisor.getPointcut().getClassFilter().matches(targetClass)) {
24.  
    //TODO: 這個地方這兩個方法的位置可以互換下
25.  
    //將Advisor轉化成Interceptor
26.  
    MethodInterceptor[]interceptors = registry.getInterceptors(advisor);
27.  
     
28.  
    //檢查當前advisor的pointcut是否可以匹配當前方法
29.  
    MethodMatcher mm =pointcutAdvisor.getPointcut().getMethodMatcher();
30.  
     
31.  
    if (MethodMatchers.matches(mm,method, targetClass, hasIntroductions)) {
32.  
    if(mm.isRuntime()) {
33.  
    // Creating a newobject instance in the getInterceptors() method
34.  
    // isn't a problemas we normally cache created chains.
35.  
    for (intj = 0; j < interceptors.length; j++) {
36.  
    interceptorList.add( new InterceptorAndDynamicMethodMatcher(interceptors[j],mm));
37.  
    }
38.  
    } else {
39.  
    interceptorList.addAll(Arrays.asList(interceptors));
40.  
    }
41.  
    }
42.  
    }
43.  
    } else if (advisor instanceof IntroductionAdvisor){
44.  
    IntroductionAdvisor ia =(IntroductionAdvisor) advisor;
45.  
    if(config.isPreFiltered() || ia.getClassFilter().matches(targetClass)) {
46.  
    Interceptor[] interceptors= registry.getInterceptors(advisor);
47.  
    interceptorList.addAll(Arrays.asList(interceptors));
48.  
    }
49.  
    } else {
50.  
    Interceptor[] interceptors =registry.getInterceptors(advisor);
51.  
    interceptorList.addAll(Arrays.asList(interceptors));
52.  
    }
53.  
    }
54.  
    return interceptorList;
55.  
    }

5）這個方法執行完成后，Advised中配置能夠應用到連接點或者目標類的Advisor全部被轉化成了MethodInterceptor.

6）接下來貨到invoke方法中的proceed方法 ，我們再看下得到的攔截器鏈是怎么起作用的，也就是proceed方法的執行過程

1.  
   public Object proceed() throws Throwable {
2.  
   // We start with an index of -1and increment early.
3.  
   if (this.currentInterceptorIndex == this.interceptorsAndDynamicMethodMatchers.size()- 1) {
4.  
   //如果Interceptor執行完了，則執行joinPoint
5.  
   return invokeJoinpoint();
6.  
   }
7.  
    
8.  
   Object interceptorOrInterceptionAdvice =
9.  
   this.interceptorsAndDynamicMethodMatchers.get(++this.currentInterceptorIndex);
10.  
     
11.  
    //如果要動態匹配joinPoint
12.  
    if (interceptorOrInterceptionAdvice instanceof InterceptorAndDynamicMethodMatcher){
13.  
    // Evaluate dynamic method matcher here: static part will already have
14.  
    // been evaluated and found to match.
15.  
    InterceptorAndDynamicMethodMatcher dm =
16.  
    (InterceptorAndDynamicMethodMatcher)interceptorOrInterceptionAdvice;
17.  
    //動態匹配：運行時參數是否滿足匹配條件
18.  
    if (dm.methodMatcher.matches(this.method, this.targetClass,this.arguments)) {
19.  
    //執行當前Intercetpor
20.  
    returndm.interceptor.invoke( this);
21.  
    }
22.  
    else {
23.  
    //動態匹配失敗時,略過當前Intercetpor,調用下一個Interceptor
24.  
    return proceed();
25.  
    }
26.  
    }
27.  
    else {
28.  
    // It's an interceptor, so we just invoke it: The pointcutwill have
29.  
    // been evaluated statically before this object was constructed.
30.  
    //執行當前Intercetpor
31.  
    return ((MethodInterceptor) interceptorOrInterceptionAdvice).invoke(this);
32.  
    }
33.  
    }

7）好了攔截器到這邊就可以執行了，復雜的代理終於可以起到他的作用了

 

Spring CGLIB動態代理實現

由於CGLIB的動態代理代碼量比較長，在這就不貼出來代碼了，其實這兩個代理的實現方式都差不多，都是創建方法調用鏈，不同的是jdk的動態代理創建的是

ReflectiveMethodInvocation調用鏈，而cglib創建的是Cglib MethodInvocation。