spring boot aop

spring boot 开启aop

动态代理相关分析见之前的博文动态代理

引入starter

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-aop</artifactId>
</dependency>

配置

spring.aop.auto=true # Add @EnableAspectJAutoProxy.
spring.aop.proxy-target-class=true # true 使用CGLIB false使用JDK
默认开启，使用CGLib

AopAutoConfiguration

自动配置时注入。

@Configuration(proxyBeanMethods = false)
@ConditionalOnProperty(prefix = "spring.aop", name = "auto", havingValue = "true", matchIfMissing = true)
public class AopAutoConfiguration {
   

   @Configuration(proxyBeanMethods = false)
   @ConditionalOnClass(Advice.class)
   static class AspectJAutoProxyingConfiguration {
   

      @Configuration(proxyBeanMethods = false)
      @EnableAspectJAutoProxy(proxyTargetClass = false)
      @ConditionalOnProperty(prefix = "spring.aop", name = "proxy-target-class", havingValue = "false",
            matchIfMissing = false)
      static class JdkDynamicAutoProxyConfiguration {
   
      }

      @Configuration(proxyBeanMethods = false)
      @EnableAspectJAutoProxy(proxyTargetClass = true)
      @ConditionalOnProperty(prefix = "spring.aop", name = "proxy-target-class", havingValue = "true",
            matchIfMissing = true)
      static class CglibAutoProxyConfiguration {
   
      }
   }

   @Configuration(proxyBeanMethods = false)
   @ConditionalOnMissingClass("org.aspectj.weaver.Advice")
   @ConditionalOnProperty(prefix = "spring.aop", name = "proxy-target-class", havingValue = "true",
         matchIfMissing = true)
   static class ClassProxyingConfiguration {
   

      ClassProxyingConfiguration(BeanFactory beanFactory) {
   
         if (beanFactory instanceof BeanDefinitionRegistry) {
   
            BeanDefinitionRegistry registry = (BeanDefinitionRegistry) beanFactory;
            AopConfigUtils.registerAutoProxyCreatorIfNecessary(registry);
            AopConfigUtils.forceAutoProxyCreatorToUseClassProxying(registry);
         }
      }
   }
}

@EnableAspectJAutoProxy注解：

@Import(AspectJAutoProxyRegistrar.class)
public @interface EnableAspectJAutoProxy {
   

   /**
    * Indicate whether subclass-based (CGLIB) proxies are to be created as opposed
    * to standard Java interface-based proxies. The default is {@code false}.
    */
   boolean proxyTargetClass() default false;

   /**
    * Indicate that the proxy should be exposed by the AOP framework as a {@code ThreadLocal}
    * for retrieval via the {@link org.springframework.aop.framework.AopContext} class.
    * Off by default, i.e. no guarantees that {@code AopContext} access will work.
    * @since 4.3.1
    */
   boolean exposeProxy() default false;

}

AspectJAutoProxyRegistrar#registerBeanDefinitions：注册beanDefinition（internalAutoProxyCreator）到容器中

class AspectJAutoProxyRegistrar implements ImportBeanDefinitionRegistrar {
   

   /**
    * Register, escalate, and configure the AspectJ auto proxy creator based on the value
    * of the @{@link EnableAspectJAutoProxy#proxyTargetClass()} attribute on the importing
    * {@code @Configuration} class.
    */
   @Override
   public void registerBeanDefinitions(
         AnnotationMetadata importingClassMetadata, BeanDefinitionRegistry registry) {
   

      //注册beanDefinition（internalAutoProxyCreator，AnnotationAwareAspectJAutoProxyCreator.class）到容器中
      AopConfigUtils.registerAspectJAnnotationAutoProxyCreatorIfNecessary(registry);

      //获取注解属性
      AnnotationAttributes enableAspectJAutoProxy =
            AnnotationConfigUtils.attributesFor(importingClassMetadata, EnableAspectJAutoProxy.class);
      if (enableAspectJAutoProxy != null) {
   
         if (enableAspectJAutoProxy.getBoolean("proxyTargetClass")) {
   
            //如果proxyTargetClass为true，为beanDefinition添加属性proxyTargetClass->true
            AopConfigUtils.forceAutoProxyCreatorToUseClassProxying(registry);
         }
         if (enableAspectJAutoProxy.getBoolean("exposeProxy")) {
   
            AopConfigUtils.forceAutoProxyCreatorToExposeProxy(registry);
         }
      }
   }
}

AnnotationAwareAspectJAutoProxyCreator#postProcessBeforeInstantiation

public Object postProcessBeforeInstantiation(Class<?> beanClass, String beanName) {
   
   Object cacheKey = getCacheKey(beanClass, beanName);

   //advisedBeans用于存储不可代理的bean
   if (!StringUtils.hasLength(beanName) || !this.targetSourcedBeans.contains(beanName)) {
   
      if (this.advisedBeans.containsKey(cacheKey)) {
   
         return null;
      }
      if (isInfrastructureClass(beanClass) || shouldSkip(beanClass, beanName)) {
   
         this.advisedBeans.put(cacheKey, Boolean.FALSE);
         return null;
      }
   }

   // Create proxy here if we have a custom TargetSource.
   // Suppresses unnecessary default instantiation of the target bean:
   // The TargetSource will handle target instances in a custom fashion.
   //如果自定义了目标类，此时代理类，然后执行postProcessAfterInitialization
   TargetSource targetSource = getCustomTargetSource(beanClass, beanName)