Spring框架系列(10) - Spring AOP实现原理详解之AOP代理的创建

Posted 2022-07-02 realpdai

tags:

篇首语：本文由小常识网(cha138.com)小编为大家整理，主要介绍了Spring框架系列(10) - Spring AOP实现原理详解之AOP代理的创建相关的知识，希望对你有一定的参考价值。

上文我们介绍了Spring AOP原理解析的切面实现过程(将切面类的所有切面方法根据使用的注解生成对应Advice，并将Advice连同切入点匹配器和切面类等信息一并封装到Advisor)。本文在此基础上继续介绍，代理（cglib代理和JDK代理）的创建过程。@pdai

引入

前文主要Spring AOP原理解析的切面实现过程(加载配置，将切面类的所有切面方法根据使用的注解生成对应Advice，并将Advice连同切入点匹配器和切面类等信息一并封装到Advisor)。

同时我们也总结了Spring AOP初始化的过程，具体如下：

由IOC Bean加载方法栈中找到parseCustomElement方法，找到parse aop:aspectj-autoproxy的handler(org.springframework.aop.config.AopNamespaceHandler)
AopNamespaceHandler注册了<aop:aspectj-autoproxy/>的解析类是AspectJAutoProxyBeanDefinitionParser
AspectJAutoProxyBeanDefinitionParser的parse 方法通过AspectJAwareAdvisorAutoProxyCreator类去创建
AspectJAwareAdvisorAutoProxyCreator实现了两类接口，BeanFactoryAware和BeanPostProcessor；根据Bean生命周期方法找到两个核心方法：postProcessBeforeInstantiation和postProcessAfterInitialization

postProcessBeforeInstantiation：主要是处理使用了@Aspect注解的切面类，然后将切面类的所有切面方法根据使用的注解生成对应Advice，并将Advice连同切入点匹配器和切面类等信息一并封装到Advisor
postProcessAfterInitialization：主要负责将Advisor注入到合适的位置，创建代理（cglib或jdk)，为后面给代理进行增强实现做准备。

本文接着介绍postProcessAfterInitialization的方法，即Spring AOP的代理（cglib或jdk)的创建过程。

代理的创建

创建代理的方法是postProcessAfterInitialization：如果bean被子类标识为代理，则使用配置的拦截器创建一个代理

/**
  * Create a proxy with the configured interceptors if the bean is
  * identified as one to proxy by the subclass.
  * @see #getAdvicesAndAdvisorsForBean
  */
@Override
 Object (@Nullable Object bean, String beanName) 
   (bean != ) 
    Object cacheKey = getCacheKey(bean.getClass(), beanName);
    // 如果不是提前暴露的代理
     (.earlyProxyReferences.remove(cacheKey) != bean) 
       wrapIfNecessary(bean, beanName, cacheKey);
    
  
   bean;

wrapIfNecessary方法主要用于判断是否需要创建代理，如果Bean能够获取到advisor才需要创建代理

/**
  * Wrap the given bean if necessary, i.e. if it is eligible for being proxied.
  * @param bean the raw bean instance
  * @param beanName the name of the bean
  * @param cacheKey the cache key for metadata access
  * @return a proxy wrapping the bean, or the raw bean instance as-is
  */
 Object (Object bean, String beanName, Object cacheKey) 
   // 如果bean是通过TargetSource接口获取
    (beanName !=  && .targetSourcedBeans.contains(beanName)) 
       bean;
   
   // 如果bean是切面类
    (Boolean.FALSE.equals(.advisedBeans.get(cacheKey))) 
       bean;
   
   // 如果是aop基础类？是否跳过？
    (isInfrastructureClass(bean.getClass()) || shouldSkip(bean.getClass(), beanName)) 
      .advisedBeans.put(cacheKey, Boolean.FALSE);
       bean;
   

  // 重点：获取所有advisor，如果没有获取到，那说明不要进行增强，也就不需要代理了。
  Object[] specificInterceptors = getAdvicesAndAdvisorsForBean(bean.getClass(), beanName, );
   (specificInterceptors != DO_NOT_PROXY) 
    .advisedBeans.put(cacheKey, Boolean.TRUE);
    // 重点：创建代理
    Object proxy = createProxy(
        bean.getClass(), beanName, specificInterceptors,  SingletonTargetSource(bean));
    .proxyTypes.put(cacheKey, proxy.getClass());
     proxy;
  

  .advisedBeans.put(cacheKey, Boolean.FALSE);
   bean;

获取所有的Advisor

我们看下获取所有advisor的方法getAdvicesAndAdvisorsForBean

@Override
@Nullable
 Object[] getAdvicesAndAdvisorsForBean(
    Class<?> beanClass, String beanName, @Nullable TargetSource targetSource) 

  List<Advisor> advisors = findEligibleAdvisors(beanClass, beanName);
   (advisors.isEmpty()) 
     DO_NOT_PROXY;
  
   advisors.toArray();

通过findEligibleAdvisors方法获取advisor，如果获取不到返回DO_NOT_PROXY（不需要创建代理），findEligibleAdvisors方法如下

/**
  * Find all eligible Advisors for auto-proxying this class.
  * @param beanClass the clazz to find advisors for
  * @param beanName the name of the currently proxied bean
  * @return the empty List, not @code null,
  * if there are no pointcuts or interceptors
  * @see #findCandidateAdvisors
  * @see #sortAdvisors
  * @see #extendAdvisors
  */
 List<Advisor> (Class<?> beanClass, String beanName) 
  // 和上文一样，获取所有切面类的切面方法生成Advisor
  List<Advisor> candidateAdvisors = findCandidateAdvisors();
  // 找到这些Advisor中能够应用于beanClass的Advisor
  List<Advisor> eligibleAdvisors = findAdvisorsThatCanApply(candidateAdvisors, beanClass, beanName);
  // 如果需要，交给子类拓展
  extendAdvisors(eligibleAdvisors);
  // 对Advisor排序
   (!eligibleAdvisors.isEmpty()) 
    eligibleAdvisors = sortAdvisors(eligibleAdvisors);
  
   eligibleAdvisors;

获取所有切面类的切面方法生成Advisor

/**
  * Find all candidate Advisors to use in auto-proxying.
  * @return the List of candidate Advisors
  */
 List<Advisor> () 
  Assert.state(.advisorRetrievalHelper != , "No BeanFactoryAdvisorRetrievalHelper available");
   .advisorRetrievalHelper.findAdvisorBeans();

找到这些Advisor中能够应用于beanClass的Advisor

/**
  * Determine the sublist of the @code candidateAdvisors list
  * that is applicable to the given class.
  * @param candidateAdvisors the Advisors to evaluate
  * @param clazz the target class
  * @return sublist of Advisors that can apply to an object of the given class
  * (may be the incoming List as-is)
  */
  List<Advisor> (List<Advisor> candidateAdvisors, Class<?> clazz) 
   (candidateAdvisors.isEmpty()) 
     candidateAdvisors;
  
  List<Advisor> eligibleAdvisors =  ArrayList<>();
   (Advisor candidate : candidateAdvisors) 
    // 通过Introduction实现的advice
     (candidate  IntroductionAdvisor && canApply(candidate, clazz)) 
      eligibleAdvisors.add(candidate);
    
  
   hasIntroductions = !eligibleAdvisors.isEmpty();
   (Advisor candidate : candidateAdvisors) 
     (candidate  IntroductionAdvisor) 
      // already processed
      ;
    
    // 是否能够应用于clazz的Advice
     (canApply(candidate, clazz, hasIntroductions)) 
      eligibleAdvisors.add(candidate);
    
  
   eligibleAdvisors;

创建代理的入口方法

获取所有advisor后，如果有advisor，则说明需要增强，即需要创建代理，创建代理的方法如下：

/**
  * Create an AOP proxy for the given bean.
  * @param beanClass the class of the bean
  * @param beanName the name of the bean
  * @param specificInterceptors the set of interceptors that is
  * specific to this bean (may be empty, but not null)
  * @param targetSource the TargetSource for the proxy,
  * already pre-configured to access the bean
  * @return the AOP proxy for the bean
  * @see #buildAdvisors
  */
 Object (Class<?> beanClass, @Nullable String beanName,
    @Nullable Object[] specificInterceptors, TargetSource targetSource) 

   (.beanFactory  ConfigurableListableBeanFactory) 
    AutoProxyUtils.exposeTargetClass((ConfigurableListableBeanFactory) .beanFactory, beanName, beanClass);
  

  ProxyFactory proxyFactory =  ProxyFactory();
  proxyFactory.copyFrom();

   (proxyFactory.isProxyTargetClass()) 
    // Explicit handling of JDK proxy targets (for introduction advice scenarios)
     (Proxy.isProxyClass(beanClass)) 
      // Must allow for introductions; cant just set interfaces to the proxys interfaces only.
       (Class<?> ifc : beanClass.getInterfaces()) 
        proxyFactory.addInterface(ifc);
      
    
  
   
    // No proxyTargetClass flag enforced, lets apply our default checks...
     (shouldProxyTargetClass(beanClass, beanName)) 
      proxyFactory.setProxyTargetClass();
    
     
      evaluateProxyInterfaces(beanClass, proxyFactory);
    
  

  Advisor[] advisors = buildAdvisors(beanName, specificInterceptors);
  proxyFactory.addAdvisors(advisors);
  proxyFactory.setTargetSource(targetSource);
  customizeProxyFactory(proxyFactory);

  proxyFactory.setFrozen(.freezeProxy);
   (advisorsPreFiltered()) 
    proxyFactory.setPreFiltered();
  

  // Use original ClassLoader if bean class not locally loaded in overriding class loader
  ClassLoader classLoader = getProxyClassLoader();
   (classLoader  SmartClassLoader && classLoader != beanClass.getClassLoader()) 
    classLoader = ((SmartClassLoader) classLoader).getOriginalClassLoader();
  
   proxyFactory.getProxy(classLoader);

proxyFactory.getProxy(classLoader)

Spring框架系列(10)

/**
  * Create a new proxy according to the settings in this factory.
  * <p>Can be called repeatedly. Effect will vary if weve added
  * or removed interfaces. Can add and remove interceptors.
  * <p>Uses the given class loader (if necessary for proxy creation).
  * @param classLoader the class loader to create the proxy with
  * (or @code null for the low-level proxy facilitys default)
  * @return the proxy object
  */
 Object (@Nullable ClassLoader classLoader) 
   createAopProxy().getProxy(classLoader);

依据条件创建代理(jdk或cglib)

DefaultAopProxyFactory.createAopProxy

@Override
 AopProxy (AdvisedSupport config)  AopConfigException 
   (!NativeDetector.inNativeImage() &&
      (config.isOptimize() || config.isProxyTargetClass() || hasNoUserSuppliedProxyInterfaces(config))) 
    Class<?> targetClass = config.getTargetClass();
     (targetClass == ) 
        AopConfigException("TargetSource cannot determine target class: " +
          "Either an interface or a target is required for proxy creation.");
    
     (targetClass.isInterface() || Proxy.isProxyClass(targetClass)) 
        JdkDynamicAopProxy(config);
    
      ObjenesisCglibAopProxy(config);
  
   
      JdkDynamicAopProxy(config);

几个要点

config.isOptimize() 是通过optimize设置，表示配置是自定义的，默认是false；
config.isProxyTargetClass()是通过<aop:config proxy-target-class="true" /> 来配置的，表示优先使用cglib代理，默认是false；
hasNoUserSuppliedProxyInterfaces(config) 表示是否目标类实现了接口

由此我们可以知道：

Spring默认在目标类实现接口时是通过JDK代理实现的，只有非接口的是通过Cglib代理实现的。当设置proxy-target-class为true时在目标类不是接口或者代理类时优先使用cglib代理实现。

Spring框架系列(10) - Spring AOP实现原理详解之AOP代理的创建

引入

代理的创建

获取所有的Advisor

创建代理的入口方法

依据条件创建代理(jdk或cglib)

更多文章