简介

开启@Aspect注解驱动的自动代理的功能；

源码

@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Import(AspectJAutoProxyRegistrar.class)
public @interface EnableAspectJAutoProxy {

    // 代理模式：CGLIB or JDK Interface
    // 默认为false，表示基于JDK Interface
    // 设置为true，会影响所有需要代理的Spring管理的Bean
    boolean proxyTargetClass() default false;

    // 表示代理是否暴露，以便通过AopContext可以获取到代理
    // 默认为false
    boolean exposeProxy() default false;
}

配置

配合@Configuration使用，表示开启@Aspect注解驱动的自动代理的功能；

@Configuration
@EnableAspectJAutoProxy
public class AppConfig {

    @Bean
    public FooService fooService() {
        return new FooService();
    }
 
    @Bean
    public MyAspect myAspect() {
        return new MyAspect();
    }
}

public class FooService {
    // various methods
}

@Aspect
public class MyAspect {
    @Before("execution(* FooService+.*(..))")
    public void advice() {
        // advise FooService methods as appropriate
    }
}

简析

通过Import机制，@EnableAspectJAutoProxy引入AspectJAutoProxyRegistrar.class，代码如下：

@Import(AspectJAutoProxyRegistrar.class)

AspectJAutoProxyRegistrar

AspectJAutoProxyRegistrar实现了ImportBeanDefinitionRegistrar，用于向容器里注册自动代理创建器AbstractAutoProxyCreator，代码如下：

/**
 * importingClassMetadata : 通过Import引入该类的配置类的元数据信息，本例中配置类为CglibAutoProxyConfiguration
 * registry ： Bean定义容器
 */
public void registerBeanDefinitions(
        AnnotationMetadata importingClassMetadata, BeanDefinitionRegistry registry) {

    // 向Bean定义容器注册AnnotationAwareAspectJAutoProxyCreator如果需要的话
    AopConfigUtils.registerAspectJAnnotationAutoProxyCreatorIfNecessary(registry);

    // 获取@EnableAspectJAutoProxy注解的属性数据
    AnnotationAttributes enableAspectJAutoProxy =
            AnnotationConfigUtils.attributesFor(importingClassMetadata, EnableAspectJAutoProxy.class);
    if (enableAspectJAutoProxy != null) {
        // @EnableAspectJAutoProxy注解的属性数据存在，则解析配置
        if (enableAspectJAutoProxy.getBoolean("proxyTargetClass")) {
            // 如果proxyTargetClass属性值为true，则强制使用CGLIB代理
            AopConfigUtils.forceAutoProxyCreatorToUseClassProxying(registry);
        }
        if (enableAspectJAutoProxy.getBoolean("exposeProxy")) {
            // 如果exposeProxy属性值为true，则强制暴露代理代理
            AopConfigUtils.forceAutoProxyCreatorToExposeProxy(registry);
        }
    }
}

核心逻辑为
AopConfigUtils.registerAspectJAnnotationAutoProxyCreatorIfNecessary(registry);、AopConfigUtils.forceAutoProxyCreatorToUseClassProxying(registry);、AopConfigUtils.forceAutoProxyCreatorToExposeProxy(registry);，代码如下：

@Nullable
public static BeanDefinition registerAspectJAnnotationAutoProxyCreatorIfNecessary(BeanDefinitionRegistry registry) {
    return registerAspectJAnnotationAutoProxyCreatorIfNecessary(registry, null);
}

@Nullable
public static BeanDefinition registerAspectJAnnotationAutoProxyCreatorIfNecessary(
        BeanDefinitionRegistry registry, @Nullable Object source) {
    // 注册AnnotationAwareAspectJAutoProxyCreator
    return registerOrEscalateApcAsRequired(AnnotationAwareAspectJAutoProxyCreator.class, registry, source);
}

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

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

    // 判断当前容器中是否存在自动代理创建器的Bean定义
    if (registry.containsBeanDefinition(AUTO_PROXY_CREATOR_BEAN_NAME)) {
        // 获取已存在的Bean定义
        BeanDefinition apcDefinition = registry.getBeanDefinition(AUTO_PROXY_CREATOR_BEAN_NAME);
        // 判断已存在的Bean定义的className和当前是否一致
        if (!cls.getName().equals(apcDefinition.getBeanClassName())) {
            // 不一致则使用优先级更高的
            int currentPriority = findPriorityForClass(apcDefinition.getBeanClassName());
            int requiredPriority = findPriorityForClass(cls);
            if (currentPriority < requiredPriority) {
                apcDefinition.setBeanClassName(cls.getName());
            }
        }
        // 已存在，则不需要注册
        return null;
    }

    // 不存在，则需要注册

    // 根据当前class创建Bean定义并放入容器中
    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;
}

public static void forceAutoProxyCreatorToUseClassProxying(BeanDefinitionRegistry registry) {
    if (registry.containsBeanDefinition(AUTO_PROXY_CREATOR_BEAN_NAME)) {
        BeanDefinition definition = registry.getBeanDefinition(AUTO_PROXY_CREATOR_BEAN_NAME);
        // 添加Bean定义的proxyTargetClass属性
        definition.getPropertyValues().add("proxyTargetClass", Boolean.TRUE);
    }
}

public static void forceAutoProxyCreatorToExposeProxy(BeanDefinitionRegistry registry) {
    if (registry.containsBeanDefinition(AUTO_PROXY_CREATOR_BEAN_NAME)) {
        BeanDefinition definition = registry.getBeanDefinition(AUTO_PROXY_CREATOR_BEAN_NAME);
        // 添加Bean定义的exposeProxy属性
        definition.getPropertyValues().add("exposeProxy", Boolean.TRUE);
    }
}

AnnotationAwareAspectJAutoProxyCreator

简介

自动代理创建器AbstractAutoProxyCreator是Spring AOP自动代理的核心，详见：Spring AOP基础组件 AbstractAutoProxyCreator

AnnotationAwareAspectJAutoProxyCreator属于AbstractAutoProxyCreator的继承层次，用于处理AspectJ注解定义的切面以及Spring的Advisor；
如果配置文件中定义了<aop:include>元素，则仅那些名称于包含模式匹配的@AspectJ Bean才会被当作定义用于Spring自动代理的切面；

核心代码

public class AnnotationAwareAspectJAutoProxyCreator extends AspectJAwareAdvisorAutoProxyCreator {

    // 配置的模式，正则形式
    @Nullable
    private List<Pattern> includePatterns;


    // 设置模式
    public void setIncludePatterns(List<String> patterns) {
        this.includePatterns = new ArrayList<>(patterns.size());
        for (String patternText : patterns) {
            this.includePatterns.add(Pattern.compile(patternText));
        }
    }

    @Override
    protected List<Advisor> findCandidateAdvisors() {
        // Add all the Spring advisors found according to superclass rules.
        List<Advisor> advisors = super.findCandidateAdvisors();
        // Build Advisors for all AspectJ aspects in the bean factory.
        if (this.aspectJAdvisorsBuilder != null) {
            // 为所有AspectJ切面构建Advisor
            advisors.addAll(this.aspectJAdvisorsBuilder.buildAspectJAdvisors());
        }
        return advisors;
    }

    @Override
    protected boolean isInfrastructureClass(Class<?> beanClass) {
        return (super.isInfrastructureClass(beanClass) ||
                // AspectJ切面类也认为是基础类型
                (this.aspectJAdvisorFactory != null && this.aspectJAdvisorFactory.isAspect(beanClass)));
    }

    protected boolean isEligibleAspectBean(String beanName) {
        if (this.includePatterns == null) {
            // 未配置匹配模式，则认为都满足
            return true;
        }
        else {
            // 配置了匹配模式，则必须匹配上配置的模式才认为满足
            for (Pattern pattern : this.includePatterns) {
                if (pattern.matcher(beanName).matches()) {
                    return true;
                }
            }
            return false;
        }
    }


    // 将AspectJ切面转换为Advisor的适配器
    private class BeanFactoryAspectJAdvisorsBuilderAdapter extends BeanFactoryAspectJAdvisorsBuilder {

        public BeanFactoryAspectJAdvisorsBuilderAdapter(
                ListableBeanFactory beanFactory, AspectJAdvisorFactory advisorFactory) {

            super(beanFactory, advisorFactory);
        }

        @Override
        protected boolean isEligibleBean(String beanName) {
            return AnnotationAwareAspectJAutoProxyCreator.this.isEligibleAspectBean(beanName);
        }
    }
}