Spring Aop基本流程原理

一、代理对象的创建过程：

AbstractAutowireCapableBeanFactory#initializeBean

  

   

    

     

    
    

     

      protectedObjectinitializeBean(StringbeanName,Objectbean,
      @NullableRootBeanDefinitionmbd){
     
    
   

    

     

    
    

     
    
      if(System.getSecurityManager()!=
      null){
     
    
   

    

     

    
    

     

              AccessController.doPrivileged((PrivilegedAction<Object>)()->{
     
    
   

    

     

    
    

     

                  invokeAwareMethods(beanName,bean);
     
    
   

    

     

    
    

     
            
      return 
      null;
     
    
   

    

     

    
    

     

              },getAccessControlContext());
     
    
   

    

     

    
    

     

          }
     
    
   

    

     

    
    

     
    
      else{
     
    
   

    

     

    
    

     

              invokeAwareMethods(beanName,bean);
     
    
   

    

     

    
    

     

          }
     
    
   

    

     

    
    

     
 
     
    
   

    

     

    
    

     

          ObjectwrappedBean=bean;
     
    
   

    

     

    
    

     
    
      if(mbd==
      null||!mbd.isSynthetic()){
     
    
   

    

     

    
    

     
        
      // 执⾏所有的BeanPostProcessor#postProcessBeforeInitialization 初始化之前
     
    
   

    

     

    
    

     

      的处理器⽅法
     
    
   

    

     

    
    

     

              wrappedBean=applyBeanPostProcessorsBeforeInitialization(wrappedBean,beanName);
     
    
   

    

     

    
    

     

          }
     
    
   

    

     

    
    

     
 
     
    
   

    

     

    
    

     
    
      try{
     
    
   

    

     

    
    

     
        
      // 这⾥就开始执⾏afterPropertiesSet（实现了InitializingBean接⼝）⽅法和
     
    
   

    

     

    
    

     
        
      initMethod
     
    
   

    

     

    
    

     
        
      invokeInitMethods
      (beanName,wrappedBean,mbd);
     
    
   

    

     

    
    

     

          }
     
    
   

    

     

    
    

     
    
      catch(Throwableex){
     
    
   

    

     

    
    

     

              thrownewBeanCreationException((mbd!=
      null?            mbd.getResourceDescription():
      null),beanName,
      "Invocationofinitmethodfailed",ex);
     
    
   

    

     

    
    

     

          }
     
    
   

    

     

    
    

     
    
      if(mbd==
      null||!mbd.isSynthetic()){
     
    
   

    

     

    
    

     
        
      // 整个Bean初始化完成，执⾏后置处理器⽅法
     
    
   

    

     

    
    

     

              wrappedBean=applyBeanPostProcessorsAfterInitialization(wrappedBean,beanName);
     
    
   

    

     

    
    

     

          }
     
    
   

    

     

    
    

     
 
     
    
   

    

     

    
    

     
    
      return wrappedBean;
     
    
   

    

     

    
    

     

      }
     
    
  

可以看到有初始化前执行的方法、初始化时执行的方法、初始化之后执行的方法，我们从初始化之后执行的方法入手。

二、applyBeanPostProcessorsAfterInitialization

applyBeanPostProcessorsAfterInitialization（）方法的流程如下:

  

   

    

     

    
    

     

      AbstractAutowireCapableBeanFactory#applyBeanPostProcessorsAfterInitialization
     
    
   

    

     

    
    

     

      ->AbstractAutoProxyCreator#postProcessAfterInitialization
     
    
  

applyBeanPostProcessorsAfterInitialization中会检查下该类是否已经暴露过了（可能已经创建了，⽐如A依赖B时，创建A时候，就会先去创建B。当真正需要创建B时，就没必要再代理⼀次已经代理过的对象）,避免重复创建。

->AbstractAutoProxyCreator#wrapIfNecessary

得到所有候选Advisor，对Advisors和bean的⽅法双层遍历匹配，最终得到⼀个List<Advisor>，即specificInterceptors

->AbstractAutoProxyCreator#createProxy

(1)创建代理的⼯作交给ProxyFactory

(2)把指定和通⽤拦截对象合并, 并都适配成Advisor

(3)上⾯准备做完就开始创建代理

->proxyFactory.getProxy()

⽤ProxyFactory创建AopProxy, 然后⽤AopProxy创建Proxy, 所以这⾥重要的是看获取的AopProxy对象是什么，然后进去看怎么创建动态代理, 提供了两种：jdk proxy, cglib

总结：简要流程