Spring可以以注解的方式使用AOP的原因就是在XML中<aop:aspectj-autoproxy/>,分析注解式AOP就要从这句话入手

动态AOP自定义标签

一旦遇到<aop:aspectj-autoproxy/>在AopNamespaceHandler就会注册AspectJAutoProxyBeanDefinitionParser

注册AnnotationAwareAspectJAutoProxyCreator

在AspectJAutoProxyBeanDefinitionParser的parse中注册了AnnotationAwareAspectJAutoProxyCreator

  1.     public static void registerAspectJAnnotationAutoProxyCreatorIfNecessary(
  2.             ParserContext parserContext, Element sourceElement) {
  4.         BeanDefinition beanDefinition = AopConfigUtils.registerAspectJAnnotationAutoProxyCreatorIfNecessary(
  5.                 parserContext.getRegistry(), parserContext.extractSource(sourceElement));
  6.         useClassProxyingIfNecessary(parserContext.getRegistry(), sourceElement);
  7.         registerComponentIfNecessary(beanDefinition, parserContext);
  8.     }

  1. 注册或者升级AnnotationAwareAspectJAutoProxyCreator

    1.  @Nullable
    2.  private static BeanDefinition registerOrEscalateApcAsRequired(
    3.          Class<?> cls, BeanDefinitionRegistry registry, @Nullable Object source) {
    5.      Assert.notNull(registry, "BeanDefinitionRegistry must not be null");
    7.      if (registry.containsBeanDefinition(AUTO_PROXY_CREATOR_BEAN_NAME)) {
    8.          BeanDefinition apcDefinition = registry.getBeanDefinition(AUTO_PROXY_CREATOR_BEAN_NAME);
    9.          if (!cls.getName().equals(apcDefinition.getBeanClassName())) {
    10.              int currentPriority = findPriorityForClass(apcDefinition.getBeanClassName());
    11.              int requiredPriority = findPriorityForClass(cls);
    12.              if (currentPriority < requiredPriority) {
    13.                  apcDefinition.setBeanClassName(cls.getName());
    14.              }
    15.          }
    16.          return null;
    17.      }
    19.      RootBeanDefinition beanDefinition = new RootBeanDefinition(cls);
    20.      beanDefinition.setSource(source);
    21.      beanDefinition.getPropertyValues().add("order", Ordered.HIGHEST_PRECEDENCE);
    22.      beanDefinition.setRole(BeanDefinition.ROLE_INFRASTRUCTURE);
    23.      registry.registerBeanDefinition(AUTO_PROXY_CREATOR_BEAN_NAME, beanDefinition);
    24.      return beanDefinition;
    25.  }

    实现了自动注册AnnotationAwareAspectJAutoProxyCreator类的功能

  2. 处理proxy-target-class以及expose-proxy属性

    1.  private static void useClassProxyingIfNecessary(BeanDefinitionRegistry registry, @Nullable Element sourceElement) {
    2.      if (sourceElement != null) {
    3.          boolean proxyTargetClass = Boolean.parseBoolean(sourceElement.getAttribute(PROXY_TARGET_CLASS_ATTRIBUTE));
    4.          if (proxyTargetClass) {
    5.              AopConfigUtils.forceAutoProxyCreatorToUseClassProxying(registry);
    6.          }
    7.          boolean exposeProxy = Boolean.parseBoolean(sourceElement.getAttribute(EXPOSE_PROXY_ATTRIBUTE));
    8.          if (exposeProxy) {
    9.              AopConfigUtils.forceAutoProxyCreatorToExposeProxy(registry);
    10.          }
    11.      }
    12.  }
  • proxy-target-class：设置为true，强制使用CGLIB
    • 无法通知final
    • 需要引入cglib包
    • CGLIB底层依靠ASM
  • expose-proxy：暴露代理对象，解决同类调用问题
    • ((AService)AopContext.currentProxy()).b();

创建AOP代理

AnnotationAwareAspectJAutoProxyCreator是用来创建AOP代理对象的，类结构如下：
image.png

类是实现了BeanPostProcessor的，主要是其postProcessAfterInitialization中的逻辑

  1. @Override
  2.     public Object postProcessAfterInitialization(@Nullable Object bean, String beanName) {
  3.         if (bean != null) {
  4.             Object cacheKey = getCacheKey(bean.getClass(), beanName);
  5.             if (this.earlyProxyReferences.remove(cacheKey) != bean) {
  6.                 return wrapIfNecessary(bean, beanName, cacheKey);
  7.             }
  8.         }
  9.         return bean;
  10.     }
  12. protected Object wrapIfNecessary(Object bean, String beanName, Object cacheKey) {
  13.         if (StringUtils.hasLength(beanName) && this.targetSourcedBeans.contains(beanName)) {
  14.             return bean;
  15.         }
  16.         if (Boolean.FALSE.equals(this.advisedBeans.get(cacheKey))) {
  17.             return bean;
  18.         }
  19.         if (isInfrastructureClass(bean.getClass()) || shouldSkip(bean.getClass(), beanName)) {
  20.             this.advisedBeans.put(cacheKey, Boolean.FALSE);
  21.             return bean;
  22.         }
  24.         // Create proxy if we have advice.
  25.         Object[] specificInterceptors = getAdvicesAndAdvisorsForBean(bean.getClass(), beanName, null);
  26.         if (specificInterceptors != DO_NOT_PROXY) {
  27.             this.advisedBeans.put(cacheKey, Boolean.TRUE);
  28.             Object proxy = createProxy(
  29.                     bean.getClass(), beanName, specificInterceptors, new SingletonTargetSource(bean));
  30.             this.proxyTypes.put(cacheKey, proxy.getClass());
  31.             return proxy;
  32.         }
  34.         this.advisedBeans.put(cacheKey, Boolean.FALSE);
  35.         return bean;
  36.     }
  1. 获取增强方法或者增强器
  2. 根据获取的增强器惊醒代理

image.png

  1.     @Override
  2.     @Nullable
  3.     protected Object[] getAdvicesAndAdvisorsForBean(
  4.             Class<?> beanClass, String beanName, @Nullable TargetSource targetSource) {
  6.         List<Advisor> advisors = findEligibleAdvisors(beanClass, beanName);
  7.         if (advisors.isEmpty()) {
  8.             return DO_NOT_PROXY;
  9.         }
  10.         return advisors.toArray();
  11.     }
  14.     protected List<Advisor> findEligibleAdvisors(Class<?> beanClass, String beanName) {
  15.         List<Advisor> candidateAdvisors = findCandidateAdvisors();
  16.         List<Advisor> eligibleAdvisors = findAdvisorsThatCanApply(candidateAdvisors, beanClass, beanName);
  17.         extendAdvisors(eligibleAdvisors);
  18.         if (!eligibleAdvisors.isEmpty()) {
  19.             eligibleAdvisors = sortAdvisors(eligibleAdvisors);
  20.         }
  21.         return eligibleAdvisors;
  22.     }

主要做了两件事： findCandidateAdvisors findAdvisorsThatCanApply

获取增强器-findCandidateAdvisors

  1.     @Override
  2.     protected List<Advisor> findCandidateAdvisors() {
  3.         // Add all the Spring advisors found according to superclass rules.
  4.         List<Advisor> advisors = super.findCandidateAdvisors();
  5.         // Build Advisors for all AspectJ aspects in the bean factory.
  6.         if (this.aspectJAdvisorsBuilder != null) {
  7.             advisors.addAll(this.aspectJAdvisorsBuilder.buildAspectJAdvisors());
  8.         }
  9.         return advisors;
  10.     }
  12.     @Override
  13.     protected List<Advisor> findCandidateAdvisors() {
  14.         // Add all the Spring advisors found according to superclass rules.
  15.         List<Advisor> advisors = super.findCandidateAdvisors();
  16.         // Build Advisors for all AspectJ aspects in the bean factory.
  17.         if (this.aspectJAdvisorsBuilder != null) {
  18.             advisors.addAll(this.aspectJAdvisorsBuilder.buildAspectJAdvisors());
  19.         }
  20.         return advisors;
  21.     }

this.aspectJAdvisorsBuilder.buildAspectJAdvisors()才是获取注解增强功能的

  1.     public List<Advisor> buildAspectJAdvisors() {
  2.         List<String> aspectNames = this.aspectBeanNames;
  4.         if (aspectNames == null) {
  5.             synchronized (this) {
  6.                 aspectNames = this.aspectBeanNames;
  7.                 if (aspectNames == null) {
  8.                     List<Advisor> advisors = new ArrayList<>();
  9.                     aspectNames = new ArrayList<>();
  10.                     String[] beanNames = BeanFactoryUtils.beanNamesForTypeIncludingAncestors(
  11.                             this.beanFactory, Object.class, true, false);
  12.                     for (String beanName : beanNames) {
  13.                         if (!isEligibleBean(beanName)) {
  14.                             continue;
  15.                         }
  16.                         // We must be careful not to instantiate beans eagerly as in this case they
  17.                         // would be cached by the Spring container but would not have been weaved.
  18.                         Class<?> beanType = this.beanFactory.getType(beanName, false);
  19.                         if (beanType == null) {
  20.                             continue;
  21.                         }
  22.                         if (this.advisorFactory.isAspect(beanType)) {
  23.                             aspectNames.add(beanName);
  24.                             AspectMetadata amd = new AspectMetadata(beanType, beanName);
  25.                             if (amd.getAjType().getPerClause().getKind() == PerClauseKind.SINGLETON) {
  26.                                 MetadataAwareAspectInstanceFactory factory =
  27.                                         new BeanFactoryAspectInstanceFactory(this.beanFactory, beanName);
  28.                                 List<Advisor> classAdvisors = this.advisorFactory.getAdvisors(factory);
  29.                                 if (this.beanFactory.isSingleton(beanName)) {
  30.                                     this.advisorsCache.put(beanName, classAdvisors);
  31.                                 }
  32.                                 else {
  33.                                     this.aspectFactoryCache.put(beanName, factory);
  34.                                 }
  35.                                 advisors.addAll(classAdvisors);
  36.                             }
  37.                             else {
  38.                                 // Per target or per this.
  39.                                 if (this.beanFactory.isSingleton(beanName)) {
  40.                                     throw new IllegalArgumentException("Bean with name '" + beanName +
  41.                                             "' is a singleton, but aspect instantiation model is not singleton");
  42.                                 }
  43.                                 MetadataAwareAspectInstanceFactory factory =
  44.                                         new PrototypeAspectInstanceFactory(this.beanFactory, beanName);
  45.                                 this.aspectFactoryCache.put(beanName, factory);
  46.                                 advisors.addAll(this.advisorFactory.getAdvisors(factory));
  47.                             }
  48.                         }
  49.                     }
  50.                     this.aspectBeanNames = aspectNames;
  51.                     return advisors;
  52.                 }
  53.             }
  54.         }
  56.         if (aspectNames.isEmpty()) {
  57.             return Collections.emptyList();
  58.         }
  59.         List<Advisor> advisors = new ArrayList<>();
  60.         for (String aspectName : aspectNames) {
  61.             List<Advisor> cachedAdvisors = this.advisorsCache.get(aspectName);
  62.             if (cachedAdvisors != null) {
  63.                 advisors.addAll(cachedAdvisors);
  64.             }
  65.             else {
  66.                 MetadataAwareAspectInstanceFactory factory = this.aspectFactoryCache.get(aspectName);
  67.                 advisors.addAll(this.advisorFactory.getAdvisors(factory));
  68.             }
  69.         }
  70.         return advisors;
  71.     }
  74. //上面代码的关键
  75.     @Override
  76.     public List<Advisor> getAdvisors(MetadataAwareAspectInstanceFactory aspectInstanceFactory) {
  77.         Class<?> aspectClass = aspectInstanceFactory.getAspectMetadata().getAspectClass();
  78.         String aspectName = aspectInstanceFactory.getAspectMetadata().getAspectName();
  79.         validate(aspectClass);
  81.         // We need to wrap the MetadataAwareAspectInstanceFactory with a decorator
  82.         // so that it will only instantiate once.
  83.         MetadataAwareAspectInstanceFactory lazySingletonAspectInstanceFactory =
  84.                 new LazySingletonAspectInstanceFactoryDecorator(aspectInstanceFactory);
  86.         List<Advisor> advisors = new ArrayList<>();
  87.         for (Method method : getAdvisorMethods(aspectClass)) {
  88.             // Prior to Spring Framework 5.2.7, advisors.size() was supplied as the declarationOrderInAspect
  89.             // to getAdvisor(...) to represent the "current position" in the declared methods list.
  90.             // However, since Java 7 the "current position" is not valid since the JDK no longer
  91.             // returns declared methods in the order in which they are declared in the source code.
  92.             // Thus, we now hard code the declarationOrderInAspect to 0 for all advice methods
  93.             // discovered via reflection in order to support reliable advice ordering across JVM launches.
  94.             // Specifically, a value of 0 aligns with the default value used in
  95.             // AspectJPrecedenceComparator.getAspectDeclarationOrder(Advisor).
  96.             Advisor advisor = getAdvisor(method, lazySingletonAspectInstanceFactory, 0, aspectName);
  97.             if (advisor != null) {
  98.                 advisors.add(advisor);
  99.             }
  100.         }
  102.         // If it's a per target aspect, emit the dummy instantiating aspect.
  103.         if (!advisors.isEmpty() && lazySingletonAspectInstanceFactory.getAspectMetadata().isLazilyInstantiated()) {
  104.             Advisor instantiationAdvisor = new SyntheticInstantiationAdvisor(lazySingletonAspectInstanceFactory);
  105.             advisors.add(0, instantiationAdvisor);
  106.         }
  108.         // Find introduction fields.
  109.         for (Field field : aspectClass.getDeclaredFields()) {
  110.             Advisor advisor = getDeclareParentsAdvisor(field);
  111.             if (advisor != null) {
  112.                 advisors.add(advisor);
  113.             }
  114.         }
  116.         return advisors;
  117.     }

image.png

  1. 普通增强器的获取

    1.  @Override
    2.  @Nullable
    3.  public Advisor getAdvisor(Method candidateAdviceMethod, MetadataAwareAspectInstanceFactory aspectInstanceFactory,
    4.          int declarationOrderInAspect, String aspectName) {
    6.      validate(aspectInstanceFactory.getAspectMetadata().getAspectClass());
    7.      //切点获取
    8.      AspectJExpressionPointcut expressionPointcut = getPointcut(
    9.              candidateAdviceMethod, aspectInstanceFactory.getAspectMetadata().getAspectClass());
    10.      if (expressionPointcut == null) {
    11.          return null;
    12.      }
    13.      //根据切点信息生成增强
    14.      return new InstantiationModelAwarePointcutAdvisorImpl(expressionPointcut, candidateAdviceMethod,
    15.              this, aspectInstanceFactory, declarationOrderInAspect, aspectName);
    16.  }

  2. 增加同步实例化增强器

  3. 获取DeclareParents注解

    寻找匹配增强器-findAdvisorsThatCanApply

    从所有增强器中寻找这个Bean可以用的上的

    1.  protected List<Advisor> findAdvisorsThatCanApply(
    2.          List<Advisor> candidateAdvisors, Class<?> beanClass, String beanName) {
    4.      ProxyCreationContext.setCurrentProxiedBeanName(beanName);
    5.      try {
    6.          return AopUtils.findAdvisorsThatCanApply(candidateAdvisors, beanClass);
    7.      }
    8.      finally {
    9.          ProxyCreationContext.setCurrentProxiedBeanName(null);
    10.      }
    11.  }

  4. AopUtils#findAdvisorsThatCanApply

  5. AopUtils#canApply

    创建代理

    1. protected Object createProxy(Class<?> beanClass, @Nullable String beanName,
    2.          @Nullable Object[] specificInterceptors, TargetSource targetSource) {
    4.      if (this.beanFactory instanceof ConfigurableListableBeanFactory) {
    5.          AutoProxyUtils.exposeTargetClass((ConfigurableListableBeanFactory) this.beanFactory, beanName, beanClass);
    6.      }
    8.      ProxyFactory proxyFactory = new ProxyFactory();
    9.      proxyFactory.copyFrom(this);
    11.      if (!proxyFactory.isProxyTargetClass()) {
    12.          if (shouldProxyTargetClass(beanClass, beanName)) {
    13.              proxyFactory.setProxyTargetClass(true);
    14.          }
    15.          else {
    16.              evaluateProxyInterfaces(beanClass, proxyFactory);
    17.          }
    18.      }
    20.      Advisor[] advisors = buildAdvisors(beanName, specificInterceptors);
    21.      proxyFactory.addAdvisors(advisors);
    22.      proxyFactory.setTargetSource(targetSource);
    23.      customizeProxyFactory(proxyFactory);
    25.      proxyFactory.setFrozen(this.freezeProxy);
    26.      if (advisorsPreFiltered()) {
    27.          proxyFactory.setPreFiltered(true);
    28.      }
    30.      // Use original ClassLoader if bean class not locally loaded in overriding class loader
    31.      ClassLoader classLoader = getProxyClassLoader();
    32.      if (classLoader instanceof SmartClassLoader && classLoader != beanClass.getClassLoader()) {
    33.          classLoader = ((SmartClassLoader) classLoader).getOriginalClassLoader();
    34.      }
    35.      return proxyFactory.getProxy(classLoader);
    36.  }

    Spring委托给ProxyFactory去处理

  6. 获取当前类中的属性

  7. 添加代理接口
  8. 封装Advisor并加入ProxyFactory
  9. 设置要代理的类
  10. Spring提供子类可拓展的方法customizeProxyFactory
  11. 进行获取代理操作

    创建代理

    ```java protected final synchronized AopProxy createAopProxy() {
    1.  if (!this.active) {
    2.      activate();
    3.  }
    4.  return getAopProxyFactory().createAopProxy(this);
    }
  1. @Override
  2. public AopProxy createAopProxy(AdvisedSupport config) throws AopConfigException {
  3.     if (!NativeDetector.inNativeImage() &&
  4.             (config.isOptimize() || config.isProxyTargetClass() || hasNoUserSuppliedProxyInterfaces(config))) {
  5.         Class<?> targetClass = config.getTargetClass();
  6.         if (targetClass == null) {
  7.             throw new AopConfigException("TargetSource cannot determine target class: " +
  8.                     "Either an interface or a target is required for proxy creation.");
  9.         }
  10.         if (targetClass.isInterface() || Proxy.isProxyClass(targetClass)) {
  11.             return new JdkDynamicAopProxy(config);
  12.         }
  13.         return new ObjenesisCglibAopProxy(config);
  14.     }
  15.     else {
  16.         return new JdkDynamicAopProxy(config);
  17.     }
  18. }
  2. 1. `optimize`：用来控制通过CGLIB创建的代理是否使用激进优化，仅用于CGLIB
  3. 2. `proxyTargetClass`：为true时CGLIB被使用
  4. <a name="A7alH"></a>
  5. ### 获取代理
  7. 1. Spring中应用JDK动态代理
  9. `org.springframework.aop.framework.JdkDynamicAopProxy#getProxy(java.lang.ClassLoader)`
  10. ```java
  11.     @Override
  12.     public Object getProxy(@Nullable ClassLoader classLoader) {
  13.         if (logger.isTraceEnabled()) {
  14.             logger.trace("Creating JDK dynamic proxy: " + this.advised.getTargetSource());
  15.         }
  16.         return Proxy.newProxyInstance(classLoader, this.proxiedInterfaces, this);
  17.     }

JdkDynamicAopProxy的invoke函数

  1. @Override
  2.     @Nullable
  3.     public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
  4.         Object oldProxy = null;
  5.         boolean setProxyContext = false;
  7.         TargetSource targetSource = this.advised.targetSource;
  8.         Object target = null;
  10.         try {
  11.             if (!this.equalsDefined && AopUtils.isEqualsMethod(method)) {
  12.                 // The target does not implement the equals(Object) method itself.
  13.                 return equals(args[0]);
  14.             }
  15.             else if (!this.hashCodeDefined && AopUtils.isHashCodeMethod(method)) {
  16.                 // The target does not implement the hashCode() method itself.
  17.                 return hashCode();
  18.             }
  19.             else if (method.getDeclaringClass() == DecoratingProxy.class) {
  20.                 // There is only getDecoratedClass() declared -> dispatch to proxy config.
  21.                 return AopProxyUtils.ultimateTargetClass(this.advised);
  22.             }
  23.             else if (!this.advised.opaque && method.getDeclaringClass().isInterface() &&
  24.                     method.getDeclaringClass().isAssignableFrom(Advised.class)) {
  25.                 // Service invocations on ProxyConfig with the proxy config...
  26.                 return AopUtils.invokeJoinpointUsingReflection(this.advised, method, args);
  27.             }
  29.             Object retVal;
  31.             if (this.advised.exposeProxy) {
  32.                 // Make invocation available if necessary.
  33.                 oldProxy = AopContext.setCurrentProxy(proxy);
  34.                 setProxyContext = true;
  35.             }
  37.             // Get as late as possible to minimize the time we "own" the target,
  38.             // in case it comes from a pool.
  39.             target = targetSource.getTarget();
  40.             Class<?> targetClass = (target != null ? target.getClass() : null);
  42.             // Get the interception chain for this method.
  43.             List<Object> chain = this.advised.getInterceptorsAndDynamicInterceptionAdvice(method, targetClass);
  45.             // Check whether we have any advice. If we don't, we can fallback on direct
  46.             // reflective invocation of the target, and avoid creating a MethodInvocation.
  47.             if (chain.isEmpty()) {
  48.                 // We can skip creating a MethodInvocation: just invoke the target directly
  49.                 // Note that the final invoker must be an InvokerInterceptor so we know it does
  50.                 // nothing but a reflective operation on the target, and no hot swapping or fancy proxying.
  51.                 Object[] argsToUse = AopProxyUtils.adaptArgumentsIfNecessary(method, args);
  52.                 retVal = AopUtils.invokeJoinpointUsingReflection(target, method, argsToUse);
  53.             }
  54.             else {
  55.                 // We need to create a method invocation...
  56.                 MethodInvocation invocation =
  57.                         new ReflectiveMethodInvocation(proxy, target, method, args, targetClass, chain);
  58.                 // Proceed to the joinpoint through the interceptor chain.
  59.                 retVal = invocation.proceed();
  60.             }
  62.             // Massage return value if necessary.
  63.             Class<?> returnType = method.getReturnType();
  64.             if (retVal != null && retVal == target &&
  65.                     returnType != Object.class && returnType.isInstance(proxy) &&
  66.                     !RawTargetAccess.class.isAssignableFrom(method.getDeclaringClass())) {
  67.                 // Special case: it returned "this" and the return type of the method
  68.                 // is type-compatible. Note that we can't help if the target sets
  69.                 // a reference to itself in another returned object.
  70.                 retVal = proxy;
  71.             }
  72.             else if (retVal == null && returnType != Void.TYPE && returnType.isPrimitive()) {
  73.                 throw new AopInvocationException(
  74.                         "Null return value from advice does not match primitive return type for: " + method);
  75.             }
  76.             return retVal;
  77.         }
  78.         finally {
  79.             if (target != null && !targetSource.isStatic()) {
  80.                 // Must have come from TargetSource.
  81.                 targetSource.releaseTarget(target);
  82.             }
  83.             if (setProxyContext) {
  84.                 // Restore old proxy.
  85.                 AopContext.setCurrentProxy(oldProxy);
  86.             }
  87.         }
  88.     }

最主要的工作就是创建了一个拦截器链，并使用ReflectiveMethodInvocation类进行了链的封装，而在ReflectiveMethodInvocation类的proceed方法中实现了拦截器的逐一调用

  1. CGLIB方式