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

谁借莪１个温暖的怀抱￠ 2024-03-23 09:53 34阅读 0赞

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);
             }
          }
    
       }
    
    }
    复制代码

**流程如下图：**

![format_png][]

### 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 ##

![format_png 1][]

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

protected Object createBean(String beanName, RootBeanDefinition

[format_png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/23/2cdfb662641b40b0ae663a4b48dd8483.png
[format_png 1]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/23/c2cda4d5669144de8f3cf39c3f39b453.png