Spring源码解析之Aop：切面和代理对象的创建

最新推荐文章于 2023-11-01 13:59:02 发布

Java技术攻略

最新推荐文章于 2023-11-01 13:59:02 发布

阅读量290

点赞数 2

文章标签： spring java spring boot

本文链接：https://blog.csdn.net/ww2651071028/article/details/130146068

版权

本文深入解析Spring Boot集成Spring AOP的自动配置过程，包括AspectJAutoProxyRegistrar的注册和自动代理类创建，以及AnnotationAwareAspectJAutoProxyCreator如何在Bean实例化前后处理信息，涉及CGLIB和JDK动态代理的选择。

摘要由CSDN通过智能技术生成

SpringBoot集成Spring的Aop只需要导入aop依赖包就能自动实现AOP功能。

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-aop</artifactId>
</dependency>
复制代码

SpringBoot是通过自动配置来实现的，所以我们只需要看aop的自动配置AopAutoConfiguration类究竟做了什么

一、SpringBoot自动导入Aop

@Configuration(proxyBeanMethods = false)
//1.spring.aop.auto配置为true才生效
@ConditionalOnProperty(prefix = "spring.aop", name = "auto", havingValue = "true", matchIfMissing = true)
public class AopAutoConfiguration {

   @Configuration(proxyBeanMethods = false)
   //2.有Advice这个类
   @ConditionalOnClass(Advice.class)
   static class AspectJAutoProxyingConfiguration {

      @Configuration(proxyBeanMethods = false)
      //4.使AOP生效（如果是接口使用JDK代理）
      @EnableAspectJAutoProxy(proxyTargetClass = false)
      //3.spring.aop.proxy-target-class配置为false
      @ConditionalOnProperty(prefix = "spring.aop", name = "proxy-target-class", havingValue = "false",
            matchIfMissing = false)
      static class JdkDynamicAutoProxyConfiguration {

      }

      @Configuration(proxyBeanMethods = false)
      //4.使AOP生效（如果是接口使用Cjlib代理）
      @EnableAspectJAutoProxy(proxyTargetClass = true)
      //3.spring.aop.proxy-target-class配置为true
      @ConditionalOnProperty(prefix = "spring.aop", name = "proxy-target-class", havingValue = "true",
            matchIfMissing = true)
      static class CglibAutoProxyConfiguration {

      }

   }

   @Configuration(proxyBeanMethods = false)
   //如果没有Advice只为基础的advisor做动态代理，而忽略应用定义的Advisors，说明项目中我们自定义的切面是不会被AOP代理的。
   @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;
            //注册InfrastructureAdvisorAutoProxyCreator
            AopConfigUtils.registerAutoProxyCreatorIfNecessary(registry);
            //将InfrastructureAdvisorAutoProxyCreator设置为默认代理类
            AopConfigUtils.forceAutoProxyCreatorToUseClassProxying(registry);
         }
      }

   }

}
复制代码

流程如下图：

1.1 AspectJAutoProxyRegistrar

class AspectJAutoProxyRegistrar implements ImportBeanDefinitionRegistrar {

   @Override
   public void registerBeanDefinitions(
         AnnotationMetadata importingClassMetadata, BeanDefinitionRegistry registry) {

      // 1.1.1 注册自动代理类 
      AopConfigUtils.registerAspectJAnnotationAutoProxyCreatorIfNecessary(registry);
      // 1.1.2 解析注解
      AnnotationAttributes enableAspectJAutoProxy =
            AnnotationConfigUtils.attributesFor(importingClassMetadata, EnableAspectJAutoProxy.class);
      if (enableAspectJAutoProxy != null) {
         if (enableAspectJAutoProxy.getBoolean("proxyTargetClass")) {
            AopConfigUtils.forceAutoProxyCreatorToUseClassProxying(registry);
         }
         if (enableAspectJAutoProxy.getBoolean("exposeProxy")) {
            AopConfigUtils.forceAutoProxyCreatorToExposeProxy(registry);
         }
      }
   }

}
复制代码

1.1.1 注册自动代理类

public static BeanDefinition registerAspectJAnnotationAutoProxyCreatorIfNecessary(BeanDefinitionRegistry registry) {
   return registerAspectJAnnotationAutoProxyCreatorIfNecessary(registry, null);
}
复制代码

public static BeanDefinition registerAspectJAnnotationAutoProxyCreatorIfNecessary(
      BeanDefinitionRegistry registry, @Nullable Object source) {

   return registerOrEscalateApcAsRequired(AnnotationAwareAspectJAutoProxyCreator.class, registry, source);
}
复制代码

创建AnnotationAwareAspectJAutoProxyCreator的BeanDefinition并注册进容器，Bean名称：org.springframework.aop.config.internalAutoProxyCreator

private static BeanDefinition registerOrEscalateApcAsRequired(
      Class<?> cls, BeanDefinitionRegistry registry, @Nullable Object source) {

   Assert.notNull(registry, "BeanDefinitionRegistry must not be null");

   if (registry.containsBeanDefinition(AUTO_PROXY_CREATOR_BEAN_NAME)) {
      BeanDefinition apcDefinition = registry.getBeanDefinition(AUTO_PROXY_CREATOR_BEAN_NAME);
      if (!cls.getName().equals(apcDefinition.getBeanClassName())) {
         int currentPriority = findPriorityForClass(apcDefinition.getBeanClassName());
         int requiredPriority = findPriorityForClass(cls);
         if (currentPriority < requiredPriority) {
            apcDefinition.setBeanClassName(cls.getName());
         }
      }
      return null;
   }

   RootBeanDefinition beanDefinition = new RootBeanDefinition(cls);
   beanDefinition.setSource(source);
   beanDefinition.getPropertyValues().add("order", Ordered.HIGHEST_PRECEDENCE);
   beanDefinition.setRole(BeanDefinition.ROLE_INFRASTRUCTURE);
   registry.registerBeanDefinition(AUTO_PROXY_CREATOR_BEAN_NAME, beanDefinition);
   return beanDefinition;
}
复制代码

1.1.2 解析注解

//获取@EnableAspectJAutoProxy属性值
AnnotationAttributes enableAspectJAutoProxy =
      AnnotationConfigUtils.attributesFor(importingClassMetadata, EnableAspectJAutoProxy.class);
if (enableAspectJAutoProxy != null) {
   //1.1.2.1 如果proxyTargetClass为true
   if (enableAspectJAutoProxy.getBoolean("proxyTargetClass")) {
      AopConfigUtils.forceAutoProxyCreatorToUseClassProxying(registry);
   }//1.1.2.2 如果exposeProxy为true
   if (enableAspectJAutoProxy.getBoolean("exposeProxy")) {
      AopConfigUtils.forceAutoProxyCreatorToExposeProxy(registry);
   }
}
复制代码

1.1.2.1 如果proxyTargetClass为true

控制是基于subclass-based的CGLIB动态代理还是使用基于接口的JDK动态代理（默认值为false,即默认使用JDK动态代理方式），判断阶段：2.2.2.2.1

public static void forceAutoProxyCreatorToUseClassProxying(BeanDefinitionRegistry registry) {
   if (registry.containsBeanDefinition(AUTO_PROXY_CREATOR_BEAN_NAME)) {
      BeanDefinition definition = registry.getBeanDefinition(AUTO_PROXY_CREATOR_BEAN_NAME);
      definition.getPropertyValues().add("proxyTargetClass", Boolean.TRUE);
   }
}
复制代码

1.1.2.2 如果exposeProxy为true

控制代理的暴露方式,解决类内部方法之间调用不能使用代理的场景（默认值为false，如果设置为true的话，我们就可以通过AopContext.currentProxy()很容易拿到当前代理对象）

public static void forceAutoProxyCreatorToExposeProxy(BeanDefinitionRegistry registry) {
   if (registry.containsBeanDefinition(AUTO_PROXY_CREATOR_BEAN_NAME)) {
      BeanDefinition definition = registry.getBeanDefinition(AUTO_PROXY_CREATOR_BEAN_NAME);
      definition.getPropertyValues().add("exposeProxy", Boolean.TRUE);
   }
}
复制代码

二、AnnotationAwareAspectJAutoProxyCreator

Spring在创建Bean之前会先判断是否需要创建代理对象AbstractAutowireCapableBeanFactory类的createBean方法

protected Object createBean(String beanName, RootBeanDefinition mbd, @Nullable Object[] args)
      throws BeanCreationException {

   if (logger.isTraceEnabled()) {
      logger.trace("Creating instance of bean '" + beanName + "'");
   }
   RootBeanDefinition mbdToUse