spirng-源码-@EnableAspectJAutoProxy-注册

前言

需要了解 BeanDefinition和 @import

AnnotationAwareAspectJAutoProxyCreator

主要是分析这个Bean，看看这实现

1. 继承：AspectJAwareAdvisorAutoProxyCreator
   1. 继承：AbstractAdvisorAutoProxyCreator
      1. 继承：AbstractAutoProxyCreator
         1. 继承：ProxyProcessorSupport
            1. 继承：ProxyConfig
               1. 实现了：Ordered、BeanClassLoaderAware、AopInfrastructureBean
         2. 实现了：
            1. SmartInstantiationAwareBeanPostProcessor
               1. InstantiationAwareBeanPostProcessor
                  1. BeanPostProcessor
            2. BeanFactoryAware

开启注解AOP

@Configuration
@EnableAspectJAutoProxy
public class EnableAspectJAutoProxyConfig {}

注解分析

这个注解有两个属性，和一个@Import导入了 AspectJAutoProxyRegistrar 组件

@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
@Documented
@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;
 
}
 

一、注册配置类

可参考 @import

也就是说注册EnableAspectJAutoProxyConfig，因为入口是从这里开始的，

处理 @EnableAspectJAutoProxy

或者说处理 @Import ，这里是 通过 @Import 获取到 AspectJAutoProxyRegistrar 的相关信息

protected final SourceClass doProcessConfigurationClass(
    ConfigurationClass configClass, SourceClass sourceClass, Predicate<String> filter)
    throws IOException {
 
    // Process any @Import annotations
    processImports(configClass, sourceClass, getImports(sourceClass), filter, true);
 
    return null;
}
private Set<SourceClass> getImports(SourceClass sourceClass) throws IOException {
    Set<SourceClass> imports = new LinkedHashSet<>();
    Set<SourceClass> visited = new LinkedHashSet<>();
    collectImports(sourceClass, imports, visited);
    return imports;
}
private void collectImports(SourceClass sourceClass, Set<SourceClass> imports, Set<SourceClass> visited)
    throws IOException {
 
    if (visited.add(sourceClass)) {
        // 循环 目标类 上所有注解，并且会将其包装成 SourceClass，方便递归的时候调用
        for (SourceClass annotation : sourceClass.getAnnotations()) {
            String annName = annotation.getMetadata().getClassName();
            // 如果不是 Import 则进行下一次循环，
            // 简单说判断了是不是包装成 Import了 比如很多@Enable***
            if (!annName.equals(Import.class.getName())) {
                 // 进行递归，比如 @Enable***
                collectImports(annotation, imports, visited);
            }
        }
 
        imports.addAll(sourceClass.getAnnotationAttributes(Import.class.getName(), "value"));
    }
}

分析 processImports

private void processImports(ConfigurationClass configClass, SourceClass currentSourceClass,
                            Collection<SourceClass> importCandidates, Predicate<String> exclusionFilter,
                            boolean checkForCircularImports) {
    //判断 有没有 Import
    if (importCandidates.isEmpty()) {
        return;
    }
 
    if (checkForCircularImports && isChainedImportOnStack(configClass)) {
        this.problemReporter.error(new CircularImportProblem(configClass, this.importStack));
    } else {
        this.importStack.push(configClass);
        try {
            // 循环所有 import
            for (SourceClass candidate : importCandidates) {
                //判断是不是实现了这个接口的
                if (candidate.isAssignable(ImportSelector.class)) {
                    // 省略~~
                } else if (candidate.isAssignable(ImportBeanDefinitionRegistrar.class)) {
                    // 也就是说 通过 ImportBeanDefinitionRegistrar 来创建 了这个 Bean
                    Class<?> candidateClass = candidate.loadClass();
                    //去 实例化 这个对象
                    ImportBeanDefinitionRegistrar registrar =
                        ParserStrategyUtils.instantiateClass(candidateClass, ImportBeanDefinitionRegistrar.class,
                                                             this.environment, this.resourceLoader, this.registry);
                    // 放入到一个 importBeanDefinitionRegistrars Map 中去~~~
                    configClass.addImportBeanDefinitionRegistrar(registrar, currentSourceClass.getMetadata());
                } else {
                   // 省略~~
                }
            }
        }  catch (Throwable ex) {
        }
    }
}
 

分析 instantiateClass

这个方法是创建 @Import("AspectJAutoProxyRegistrar")对象

@SuppressWarnings("unchecked")
static <T> T instantiateClass(Class<?> clazz, Class<T> assignableTo, Environment environment,
                              ResourceLoader resourceLoader, BeanDefinitionRegistry registry) {
 
    // 判断是不是 接口
    if (clazz.isInterface()) {
        throw new BeanInstantiationException(clazz, "Specified class is an interface");
    }
    // 获取classLoader
    ClassLoader classLoader = (registry instanceof ConfigurableBeanFactory ?
                               ((ConfigurableBeanFactory) registry).getBeanClassLoader() : resourceLoader.getClassLoader());
    //这里是去创建 AspectJAutoProxyRegistrar 这个对象去了
    T instance = (T) createInstance(clazz, environment, resourceLoader, registry, classLoader);
    // 判断是不是 实现了一些 XXXAware 接口的类，用于方法回调
    ParserStrategyUtils.invokeAwareMethods(instance, environment, resourceLoader, registry, classLoader);
    return instance;
}

二、处理 AspectJAutoProxyRegistrar

精简了大量的代码

//处理
public void processConfigBeanDefinitions(BeanDefinitionRegistry registry) {
    this.reader.loadBeanDefinitions(configClasses);
}
 
// 循环所有的 ConfigurationClass
public void loadBeanDefinitions(Set<ConfigurationClass> configurationModel) {
    TrackedConditionEvaluator trackedConditionEvaluator = new TrackedConditionEvaluator();
    for (ConfigurationClass configClass : configurationModel) {
        loadBeanDefinitionsForConfigurationClass(configClass, trackedConditionEvaluator);
    }
}
 
 
private void loadBeanDefinitionsForConfigurationClass(
    ConfigurationClass configClass, TrackedConditionEvaluator trackedConditionEvaluator) {
    // 这里是去注册实现了  ImportBeanDefinitionRegistrars 接口的
    loadBeanDefinitionsFromRegistrars(configClass.getImportBeanDefinitionRegistrars());
}
 

注册 AnnotationAwareAspectJAutoProxyCreator

// 这里是去注册去了，当走到这里就会去调用 AspectJAutoProxyRegistrar.registerBeanDefinitions() 方法
private void loadBeanDefinitionsFromRegistrars(Map<ImportBeanDefinitionRegistrar, AnnotationMetadata> registrars) {
    registrars.forEach((registrar, metadata) ->
                       registrar.registerBeanDefinitions(metadata, this.registry, this.importBeanNameGenerator));
}

三、分析 AspectJAutoProxyRegistrar

也可以是认为去注册 AnnotationAwareAspectJAutoProxyCreator

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) {
        // 注册 AspectJAnnotationAutoProxyCreator 如果需要的话
        AopConfigUtils.registerAspectJAnnotationAutoProxyCreatorIfNecessary(registry);
        // 获取注解信息
        AnnotationAttributes enableAspectJAutoProxy =
                AnnotationConfigUtils.attributesFor(importingClassMetadata, EnableAspectJAutoProxy.class);
        if (enableAspectJAutoProxy != null) {
            // 判断属性有没有被使用
            if (enableAspectJAutoProxy.getBoolean("proxyTargetClass")) {
                AopConfigUtils.forceAutoProxyCreatorToUseClassProxying(registry);
            }
            // 判断属性有没有被使用
            if (enableAspectJAutoProxy.getBoolean("exposeProxy")) {
                AopConfigUtils.forceAutoProxyCreatorToExposeProxy(registry);
            }
        }
    }
 
}
 

• 调用 AopConfigUtils.registerAspectJAnnotationAutoProxyCreatorIfNecessary(registry);

public static BeanDefinition registerAspectJAnnotationAutoProxyCreatorIfNecessary(BeanDefinitionRegistry registry) {
    //注册 AspectJAnnotationAutoProxyCreator 如果 需要
    return registerAspectJAnnotationAutoProxyCreatorIfNecessary(registry, null);
}
public static BeanDefinition registerAspectJAnnotationAutoProxyCreatorIfNecessary(
    BeanDefinitionRegistry registry, @Nullable Object source) {
    // 注册或者升级
    return registerOrEscalateApcAsRequired(AnnotationAwareAspectJAutoProxyCreator.class, registry, source);
}

• 分析registerOrEscalateApcAsRequired

public static final String AUTO_PROXY_CREATOR_BEAN_NAME =
    "org.springframework.aop.config.internalAutoProxyCreator";
 
@Nullable
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);
    // 去注册这个Bean
    registry.registerBeanDefinition(AUTO_PROXY_CREATOR_BEAN_NAME, beanDefinition);
     // 并且返回 RootBeanDefinition
    return beanDefinition;
}
 
// 注册Bean
@Override
public void registerBeanDefinition(String beanName, BeanDefinition beanDefinition)
    throws BeanDefinitionStoreException {
    this.beanDefinitionMap.put(beanName, beanDefinition);
    this.beanDefinitionNames.add(beanName);
}
 

四、创建 AnnotationAwareAspectJAutoProxyCreator

1. refresh() 刷新容器
2. registerBeanPostProcessors() 注册
3. PostProcessorRegistrationDelegate.registerBeanPostProcessors()注册

 
    public static void registerBeanPostProcessors(
            ConfigurableListableBeanFactory beanFactory, AbstractApplicationContext applicationContext) {
 
        //获取到所有的实现了 BeanPostProcessor 的postProcessorName
        //获取 BeanPostProcessor 获取所有
        //而我们注册 AnnotationAwareAspectJAutoProxyCreator  也是属于 BeanPostProcessor 的类型，在上面已经注册过了
        String[] postProcessorNames = beanFactory.getBeanNamesForType(BeanPostProcessor.class, true, false);
 
 
        int beanProcessorTargetCount = beanFactory.getBeanPostProcessorCount() + 1 + postProcessorNames.length;
        // 注册 BeanPostProcessorChecker 它用于记录info信息，什么时候记录呢，当一个bean在BeanPostProcessor 实例化时被创建时记录。
        // 可能会有些情况当spring 的配置中的后置处理器(BeanPostProcessor)还没有被注册就已经开始了bean的初始化时,便会打印出 BeanPostProcessorChecker 中设定的值
        beanFactory.addBeanPostProcessor(new BeanPostProcessorChecker(beanFactory, beanProcessorTargetCount));
 
        // 将实现PriorityOrdered的 BeanPostProcessor 分开，
        // 因为执行有一个先后顺序
        List<BeanPostProcessor> priorityOrderedPostProcessors = new ArrayList<>();
        List<BeanPostProcessor> internalPostProcessors = new ArrayList<>();
        List<String> orderedPostProcessorNames = new ArrayList<>();
        List<String> nonOrderedPostProcessorNames = new ArrayList<>();
        //循环所有postProcessor
        for (String ppName : postProcessorNames) {
            //判断这个 postProcessor 是不是这个类型的
            if (beanFactory.isTypeMatch(ppName, PriorityOrdered.class)) {
            }
            // 我们的 AnnotationAwareAspectJAutoProxyCreator 最终是实现 Ordered 的
            else if (beanFactory.isTypeMatch(ppName, Ordered.class)) {
                // 将 实现 Ordered 的 BeanPostProcessor 放到 这个集合
                orderedPostProcessorNames.add(ppName);
            } else {
                // 将没有 实现任何 排序 接口的 放到这个集合
                nonOrderedPostProcessorNames.add(ppName);
            }
        }
 
        //去注册实现 Ordered 的 BeanPostProcessor。
        List<BeanPostProcessor> orderedPostProcessors = new ArrayList<>(orderedPostProcessorNames.size());
        // 循环所有实现 Ordered 接口的 BeanPostProcessor 的 name
        for (String ppName : orderedPostProcessorNames) {
            // 如果有 AOP 的会 AnnotationAwareAspectAutoProxyCreator 注册这个，
            // 因为 AnnotationAwareAspectAutoProxyCreator 实现的是 Ordered
            // 这里的getBean 相当于是去创建 AnnotationAwareAspectAutoProxyCreator 对象
            BeanPostProcessor pp = beanFactory.getBean(ppName, BeanPostProcessor.class);
            // 将其放入到 集合当中
            orderedPostProcessors.add(pp);
            // 如果 是 实现这个接口的 则放到这个集合
            if (pp instanceof MergedBeanDefinitionPostProcessor) {
                internalPostProcessors.add(pp);
            }
        }
        // 排序
        sortPostProcessors(orderedPostProcessors, beanFactory);
        // 注册到容器当中
        registerBeanPostProcessors(beanFactory, orderedPostProcessors);
 
    }

1. 从注册的方法看我们向容器中注册了 AnnotationAwareAspectJAutoProxyCreator 这个类
2. 而 AnnotationAwareAspectJAutoProxyCreato 继承了…–> AbstractAutoProxyCreator 实现了…–> BeanPostProcessor 也就说可以通过 getBeanNamesForType(BeanPostProcessor.class) 获取到我们的 AnnotationAwareAspectJAutoProxyCreator 类型的 Name
3. AbstractAutoProxyCreator 继承了 ProxyProcessorSupport–> 实现了Ordered接口，这里可以看一下继承关系图

分析 getBean() 过程

主要分析一个这个Bean 在创建的时候都做了一些啥东西，为啥要实现这么多接口 这里比较关注两个点

1. beanFactory.getBean(ppName, BeanPostProcessor.class);
2. doGetBean();
3. getSingleton();
4. createBean();
5. doCreateBean();
6. initializeBean();

protected Object initializeBean(String beanName, Object bean, @Nullable RootBeanDefinition mbd) {
 
    if (System.getSecurityManager() != null) {
        AccessController.doPrivileged((PrivilegedAction<Object>) () -> {
            invokeAwareMethods(beanName, bean);
            return null;
        }, getAccessControlContext());
    } else {
        //处理 BeanNameAware、BeanClassLoaderAware、BeanFactoryAware
        invokeAwareMethods(beanName, bean);
    }
    //
    Object wrappedBean = bean;
    if (mbd == null || !mbd.isSynthetic()) {
        //应用Bean前置处理器，需要注意的是里面是一个循环，返回的是一个包装Bean
        wrappedBean = applyBeanPostProcessorsBeforeInitialization(wrappedBean, beanName);
    }
 
    try {
        //执行初始化方法...
        invokeInitMethods(beanName, wrappedBean, mbd);
    } catch (Throwable ex) {
        throw new BeanCreationException(
            (mbd != null ? mbd.getResourceDescription() : null),
            beanName, "Invocation of init method failed", ex);
    }
    if (mbd == null || !mbd.isSynthetic()) {
        //后置初始化
        wrappedBean = applyBeanPostProcessorsAfterInitialization(wrappedBean, beanName);
    }
 
    return wrappedBean;
}

AnnotationAwareAspectJAutoProxyCreator实现了 BeanClassLoaderAware、BeanFactoryAware 也就是说当创建完对象后会回调这两个方法

BeanClassLoaderAware

该接口的回调并没什么特殊的操作，仅仅将ClassLoader 进行了传递

BeanFactoryAware

通过分析我们得知AbstractAutoProxyCreator ，是实现了BeanFactoryAware 接口的，所以在创建对象完成后会进行一个回调

AbstractAdvisorAutoProxyCreator子类重写了父类的方法~

@Override
public void setBeanFactory(BeanFactory beanFactory) {
    super.setBeanFactory(beanFactory);
    if (!(beanFactory instanceof ConfigurableListableBeanFactory)) {
        throw new IllegalArgumentException("AdvisorAutoProxyCreator requires a ConfigurableListableBeanFactory: " + beanFactory);
    }
    initBeanFactory((ConfigurableListableBeanFactory) beanFactory);
}

分析 initBeanFactory

AnnotationAwareAspectJAutoProxyCreator重写了父类的initBeanFactory()方法

初始化了三个类

1. BeanFactoryAdvisorRetrievalHelperAdapter
2. ReflectiveAspectJAdvisorFactory
3. BeanFactoryAspectJAdvisorsBuilderAdapter

@Override
protected void initBeanFactory(ConfigurableListableBeanFactory beanFactory) {
    super.initBeanFactory(beanFactory);
    if (this.aspectJAdvisorFactory == null) {
        this.aspectJAdvisorFactory = new ReflectiveAspectJAdvisorFactory(beanFactory);
    }
    this.aspectJAdvisorsBuilder = new BeanFactoryAspectJAdvisorsBuilderAdapter(beanFactory, this.aspectJAdvisorFactory);
}
 
// 这里是 super 的 initBeanFactory
protected void initBeanFactory(ConfigurableListableBeanFactory beanFactory) {
    this.advisorRetrievalHelper = new BeanFactoryAdvisorRetrievalHelperAdapter(beanFactory);
}