Spring Boot 自动配置 : AopAutoConfiguration & 源码解析

矫情吗；* 2021-08-26 13:26 454阅读 0赞

[https://www.jianshu.com/p/484bae9d1fb2][https_www.jianshu.com_p_484bae9d1fb2]  
概述  
自动配置AopAutoConfiguration类的主要任务是根据配置参数使用注解@EnableAspectJAutoProxy。

该自动配置类通过注解声明了自己生效的条件是 :

1.  以下类必须存在于classpath :
    
    1.  EnableAspectJAutoProxy
    2.  Aspect
    3.  Advice
    4.  AnnotatedElement
2.  配置参数spring.aop.auto值不为false，如果该参数未使用则相当于spring.aop.auto值为true

AopAutoConfiguration又包含了如下两个内置配置类，分别对应配置参数spring.aop.proxy-target-class值为true/false两种情况 :

注意，如果配置参数spring.aop.proxy-target-class未被设置，则将这种情况作为spring.aop.proxy-target-class值为true来理解。

*  JdkDynamicAutoProxyConfiguration
    
     *  在spring.aop.proxy-target-class为false时生效
     *  生效时使用注解@EnableAspectJAutoProxy(proxyTargetClass = false)
 *  CglibAutoProxyConfiguration
    
     *  在spring.aop.proxy-target-class为false或者缺失时生效
     *  生效时使用注解@EnableAspectJAutoProxy(proxyTargetClass = true)

从上面分析可以看出，AopAutoConfiguration主要是综合使用如下两个配置参数决定如何使用注解@EnableAspectJAutoProxy

*  spring.aop.auto
 *  spring.aop.proxy-target-class

如果spring.aop.auto未被设置为false,则@EnableAspectJAutoProxy一定会被使用。而@EnableAspectJAutoProxy使用的效果，主要就是导入AspectJAutoProxyRegistrar。而AspectJAutoProxyRegistrar最终是通过AopConfigUtils注册了一个AOP代理对象创建器bean到容器 :

*  bean名称 : org.springframework.aop.config.internalAutoProxyCreator
 *  bean类型: AnnotationAwareAspectJAutoProxyCreator
 *  属性 order : HIGHEST\_PRECEDENCE
 *  bean角色 : ROLE\_INFRASTRUCTURE

源代码  
源代码版本 : spring-boot-autoconfigure-2.1.3.RELEASE

package org.springframework.boot.autoconfigure.aop;
    
    // 忽略 import 行
    /**
     * org.springframework.boot.autoconfigure.EnableAutoConfiguration
     * Auto-configuration for Spring's AOP support. Equivalent to enabling
     * org.springframework.context.annotation.EnableAspectJAutoProxy in your
     * configuration.
     * 
     * The configuration will not be activated if spring.aop.auto=false. The
     * proxyTargetClass attribute will be true, by default, but can be
     * overridden by specifying spring.aop.proxy-target-class=false.
     *
     */
    @Configuration
    // 仅在这些类存在于 classpath 时生效
    @ConditionalOnClass({ EnableAspectJAutoProxy.class, Aspect.class, Advice.class,
            AnnotatedElement.class })
    // 仅在属性 spring.aop.auto 缺失或者明确指定为 true 时生效         
    @ConditionalOnProperty(prefix = "spring.aop", name = "auto", havingValue = "true", matchIfMissing = true)
    public class AopAutoConfiguration {
    
        @Configuration
        @EnableAspectJAutoProxy(proxyTargetClass = false)
        // 在配置参数 spring.aop.proxy-target-class 值被明确设置为 false 时生效
        @ConditionalOnProperty(prefix = "spring.aop", name = "proxy-target-class", 
            havingValue = "false", matchIfMissing = false)
        public static class JdkDynamicAutoProxyConfiguration {
    
        }
    
        
        @Configuration
        @EnableAspectJAutoProxy(proxyTargetClass = true)
        // 在配置参数 spring.aop.proxy-target-class 缺失或者值被明确设置为 true 时生效    
        @ConditionalOnProperty(prefix = "spring.aop", name = "proxy-target-class", 
            havingValue = "true", matchIfMissing = true)
        public static class CglibAutoProxyConfiguration {
    
        }
    
    }

相关文章  
Spring BeanPostProcessor : AnnotationAwareAspectJAutoProxyCreator：[https://blog.csdn.net/andy\_zhang2007/article/details/86475524][https_blog.csdn.net_andy_zhang2007_article_details_86475524]

源码解析：

## 1.Spring Boot aop启动配置 ##

spring boot 会引入 AopAutoConfiguration类，此类内部类上注解@ EnableAspectJAutoProxy(默认使用JDK动态代理)引入aop的配置

@Configuration
    @ConditionalOnClass({ EnableAspectJAutoProxy.class, Aspect.class, Advice.class })
    @ConditionalOnProperty(prefix = "spring.aop", name = "auto", havingValue = "true", matchIfMissing = true)
    public class AopAutoConfiguration {
    
        @Configuration
        @EnableAspectJAutoProxy(proxyTargetClass = false)
        @ConditionalOnProperty(prefix = "spring.aop", name = "proxy-target-class", havingValue = "false", matchIfMissing = true)
        public static class JdkDynamicAutoProxyConfiguration {
    
        }
    
        @Configuration
        @EnableAspectJAutoProxy(proxyTargetClass = true)
        @ConditionalOnProperty(prefix = "spring.aop", name = "proxy-target-class", havingValue = "true", matchIfMissing = false)
        public static class CglibAutoProxyConfiguration {
    
        }
    
    }

## 2.EnableAspectJAutoProxy ##

此注解会将AspectJAutoProxyRegistrar注入spring容器中

@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;
    
    }

## 3. AspectJAutoProxyRegistrar ##

AopConfigUtils.registerAspectJAnnotationAutoProxyCreatorIfNecessary(registry)配置aop

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) {
    
         //配置aop
            AopConfigUtils.registerAspectJAnnotationAutoProxyCreatorIfNecessary(registry);
    
            AnnotationAttributes enableAspectJAutoProxy =
                    AnnotationConfigUtils.attributesFor(importingClassMetadata, EnableAspectJAutoProxy.class);
            if (enableAspectJAutoProxy.getBoolean("proxyTargetClass")) {
                //强制使用cglib
                AopConfigUtils.forceAutoProxyCreatorToUseClassProxying(registry);
            }
            if (enableAspectJAutoProxy.getBoolean("exposeProxy")) {
                AopConfigUtils.forceAutoProxyCreatorToExposeProxy(registry);
            }
        }
    
    }

## 4. aop使用AnnotationAwareAspectJAutoProxyCreator注入Spring容器 ##

public static BeanDefinition registerAspectJAnnotationAutoProxyCreatorIfNecessary(BeanDefinitionRegistry registry) {
            return registerAspectJAnnotationAutoProxyCreatorIfNecessary(registry, null);
        }
    
        public static BeanDefinition registerAspectJAnnotationAutoProxyCreatorIfNecessary(BeanDefinitionRegistry registry, Object source) {
            return registerOrEscalateApcAsRequired(AnnotationAwareAspectJAutoProxyCreator.class, registry, source);
        }
        private static BeanDefinition registerOrEscalateApcAsRequired(Class<?> cls, BeanDefinitionRegistry registry, Object source) {
            Assert.notNull(registry, "BeanDefinitionRegistry must not be null");
    
          //如果容易中已经有aop配置类,则取出对比优先级，如果AnnotationAwareAspectJAutoProxyCreator更高则替换原有的配置类     
           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;
            }
           //如果代码走到这里则说明spring容易无aop配置类，则将AnnotationAwareAspectJAutoProxyCreator注入容器中
            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;
        }

## 5. AnnotationAwareAspectJAutoProxyCreator ##

此类的父类实现了接口SmartInstantiationAwareBeanPostProcessor，在bean的创建过程中会调用它的postProcessAfterInitialization方法

@Override
        public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
            if (bean != null) {
                Object cacheKey = getCacheKey(bean.getClass(), beanName);
                //判断是否过早暴露的Bean，IOC解决循环依赖的有用到
                //如果是过早暴露的Bean，则此时依赖注入没完成，则不对其进行代理
                if (!this.earlyProxyReferences.contains(cacheKey)) {
                    //开始代理
                    return wrapIfNecessary(bean, beanName, cacheKey);
                }
            }
            return bean;
        }
        protected Object wrapIfNecessary(Object bean, String beanName, Object cacheKey) {
            //如果已经处理过的，不进行代理
            if (beanName != null && this.targetSourcedBeans.contains(beanName)) {
                return bean;
            }
            //如果已经标记未不能代理，则不进行代理
            if (Boolean.FALSE.equals(this.advisedBeans.get(cacheKey))) {
                return bean;
            }
          //如果是Advice，Pointcut，Advisor，AopInfrastructureBean的实现类或需要跳过的类，则标记未不需要代理
            if (isInfrastructureClass(bean.getClass()) || shouldSkip(bean.getClass(), beanName)) {
                this.advisedBeans.put(cacheKey, Boolean.FALSE);
                return bean;
            }
            //开始代理
            // Create proxy if we have advice.   
            //寻找合适此bean的advice
            Object[] specificInterceptors = getAdvicesAndAdvisorsForBean(bean.getClass(), beanName, null);
            if (specificInterceptors != DO_NOT_PROXY) {
                this.advisedBeans.put(cacheKey, Boolean.TRUE);
                Object proxy = createProxy(
                        bean.getClass(), beanName, specificInterceptors, new SingletonTargetSource(bean));
                this.proxyTypes.put(cacheKey, proxy.getClass());
                return proxy;
            }
    
            this.advisedBeans.put(cacheKey, Boolean.FALSE);
            return bean;
        }

protected List<Advisor> findEligibleAdvisors(Class<?> beanClass, String beanName) {
            //寻找所有的advice
            List<Advisor> candidateAdvisors = findCandidateAdvisors();
            //挑选适合此bean的advice
            List<Advisor> eligibleAdvisors = findAdvisorsThatCanApply(candidateAdvisors, beanClass, beanName);
            extendAdvisors(eligibleAdvisors);
            if (!eligibleAdvisors.isEmpty()) {
                eligibleAdvisors = sortAdvisors(eligibleAdvisors);
            }
            return eligibleAdvisors;
        }
    
        public List<Advisor> findAdvisorBeans() {
            // Determine list of advisor bean names, if not cached already.
            String[] advisorNames = this.cachedAdvisorBeanNames;
            if (advisorNames == null) {
                // Do not initialize FactoryBeans here: We need to leave all regular beans
                // uninitialized to let the auto-proxy creator apply to them!
                  //从spring容器中找出所有实现Advisor的beanName
                advisorNames = BeanFactoryUtils.beanNamesForTypeIncludingAncestors(
                        this.beanFactory, Advisor.class, true, false);
                this.cachedAdvisorBeanNames = advisorNames;
            }
            if (advisorNames.length == 0) {
                return new ArrayList<Advisor>();
            }
    
            List<Advisor> advisors = new ArrayList<Advisor>();
            for (String name : advisorNames) {
                if (isEligibleBean(name)) {
                    if (this.beanFactory.isCurrentlyInCreation(name)) {
                        if (logger.isDebugEnabled()) {
                            logger.debug("Skipping currently created advisor '" + name + "'");
                        }
                    }
                    else {
                        try {
                           //从beanFactory获取advice
                            advisors.add(this.beanFactory.getBean(name, Advisor.class));
                        }
                        catch (BeanCreationException ex) {
                            Throwable rootCause = ex.getMostSpecificCause();
                            if (rootCause instanceof BeanCurrentlyInCreationException) {
                                BeanCreationException bce = (BeanCreationException) rootCause;
                                if (this.beanFactory.isCurrentlyInCreation(bce.getBeanName())) {
                                    if (logger.isDebugEnabled()) {
                                        logger.debug("Skipping advisor '" + name +
                                                "' with dependency on currently created bean: " + ex.getMessage());
                                    }
                                    // Ignore: indicates a reference back to the bean we're trying to advise.
                                    // We want to find advisors other than the currently created bean itself.
                                    continue;
                                }
                            }
                            throw ex;
                        }
                    }
                }
            }
            return advisors;
        }

## 6.AopUtils.findAdvisorsThatCanApply去寻找合适此bean的adivce ##

public static List<Advisor> findAdvisorsThatCanApply(List<Advisor> candidateAdvisors, Class<?> clazz) {
            if (candidateAdvisors.isEmpty()) {
                return candidateAdvisors;
            }
            List<Advisor> eligibleAdvisors = new LinkedList<Advisor>();
            for (Advisor candidate : candidateAdvisors) {
                //优先处理IntroductionAdvisor
                if (candidate instanceof IntroductionAdvisor && canApply(candidate, clazz)) {
                    eligibleAdvisors.add(candidate);
                }
            }
            boolean hasIntroductions = !eligibleAdvisors.isEmpty();
            for (Advisor candidate : candidateAdvisors) {
                if (candidate instanceof IntroductionAdvisor) {
                    // already processed
                    continue;
                }
                if (canApply(candidate, clazz, hasIntroductions)) {
                    eligibleAdvisors.add(candidate);
                }
            }
            return eligibleAdvisors;
        }
    
        public static boolean canApply(Advisor advisor, Class<?> targetClass, boolean hasIntroductions) {
            if (advisor instanceof IntroductionAdvisor) {
                return ((IntroductionAdvisor) advisor).getClassFilter().matches(targetClass);
            }
            else if (advisor instanceof PointcutAdvisor) {
                //找到Pointcut来判断是否advice匹配
                PointcutAdvisor pca = (PointcutAdvisor) advisor;
                return canApply(pca.getPointcut(), targetClass, hasIntroductions);
            }
            else {
                // It doesn't have a pointcut so we assume it applies.
                return true;
            }
        }
    
        public static boolean canApply(Pointcut pc, Class<?> targetClass, boolean hasIntroductions) {
            Assert.notNull(pc, "Pointcut must not be null");
            if (!pc.getClassFilter().matches(targetClass)) {
                return false;
            }
            //拿到pointcut的方法匹配器如果为true则说明此advice合适
            MethodMatcher methodMatcher = pc.getMethodMatcher();
            if (methodMatcher == MethodMatcher.TRUE) {
                // No need to iterate the methods if we're matching any method anyway...
                return true;
            }
    
            IntroductionAwareMethodMatcher introductionAwareMethodMatcher = null;
            if (methodMatcher instanceof IntroductionAwareMethodMatcher) {
                introductionAwareMethodMatcher = (IntroductionAwareMethodMatcher) methodMatcher;
            }
            //寻找到targetClass所有实现的接口，遍历接口
            Set<Class<?>> classes = new LinkedHashSet<Class<?>>(ClassUtils.getAllInterfacesForClassAsSet(targetClass));
            classes.add(targetClass);
            for (Class<?> clazz : classes) {
                Method[] methods = ReflectionUtils.getAllDeclaredMethods(clazz);
              //遍历此接口所有的方法
                for (Method method : methods) {
                    if ((introductionAwareMethodMatcher != null &&
                            introductionAwareMethodMatcher.matches(method, targetClass, hasIntroductions)) ||
                            methodMatcher.matches(method, targetClass)) {
                        return true;
                    }
                }
            }
    
            return false;
        }

## 7. 查找到合适的advice后，即开始createProxy ##

protected Object createProxy(
                Class<?> beanClass, String beanName, Object[] specificInterceptors, TargetSource targetSource) {
    
            if (this.beanFactory instanceof ConfigurableListableBeanFactory) {
                AutoProxyUtils.exposeTargetClass((ConfigurableListableBeanFactory) this.beanFactory, beanName, beanClass);
            }
    
            ProxyFactory proxyFactory = new ProxyFactory();
            proxyFactory.copyFrom(this);
              //如果已经标记proxyTargetClass为true了，则直接判定为cglib，不需要再判断是使用jdk动态代理还是使用cglib了
            if (!proxyFactory.isProxyTargetClass()) {
                if (shouldProxyTargetClass(beanClass, beanName)) {
                    proxyFactory.setProxyTargetClass(true);
                }
                else {
                    //如果beanClass存在有接口(接口至少有一个方法)则使用jdk动态代理，否则使用cglib
                    evaluateProxyInterfaces(beanClass, proxyFactory);
                }
            }
    
            Advisor[] advisors = buildAdvisors(beanName, specificInterceptors);
            proxyFactory.addAdvisors(advisors);
            proxyFactory.setTargetSource(targetSource);
            customizeProxyFactory(proxyFactory);
    
            proxyFactory.setFrozen(this.freezeProxy);
            if (advisorsPreFiltered()) {
                proxyFactory.setPreFiltered(true);
            }
                  //创建代理对象 根据proxyTargetClass使用JDK动态代理还是Cglib
            return proxyFactory.getProxy(getProxyClassLoader());
        }

[https_www.jianshu.com_p_484bae9d1fb2]: https://www.jianshu.com/p/484bae9d1fb2
[https_blog.csdn.net_andy_zhang2007_article_details_86475524]: https://blog.csdn.net/andy_zhang2007/article/details/86475524