AOP（Aspect Oriented Programming）是基于切面编程的，可无侵入的在原本功能的切面层添加自定义代码，一般用于日志收集、权限认证等场景。

AOP基本概念

　　通知（Advice）: AOP 框架中的增强处理。通知描述了切面何时执行以及如何执行增强处理；

Before ：前置通知，在连接点方法前调用；对应Spring中@Before注解；
After ：后置通知，在连接点方法后调用；对应Spring中的@After注解；
AfterReturning：返回通知，在连接点方法执行并正常返回后调用，要求连接点方法在执行过程中没有发生异常；对应Spring中的@AfterReturning注解；
AfterThrowing：异常通知，当连接点方法异常时调用；对应Spring中的@AfterThrowing注解；
Around：环绕通知，它将覆盖原有方法，但是允许你通过反射调用原有方法；对应Spring中的@Around注解；

　　连接点（Join Point）: 连接点表示应用执行过程中能够插入切面的一个点。在 Spring AOP 中，连接点总是方法的调用，可以说目标对象中的方法就是一个连接点；
　　切点（Pointcut）: 就是连接点的集合；对应Spring中的@Pointcut注解；

目前Spring支持的切点匹配表达式主要有以下几种：
execution：可以定义到的最小粒度是方法，修饰符，包名，类名，方法名，Spring AOP主要也是使用这个匹配表达式；
within：只能定义到类；例如@Pointcut(within(com.jnu.example.*))
this：当前生成的代理对象的类型匹配；
target：目标对象类型匹配；
annotation：针对注解；
args：只针对参数；

例如： execution (* com.sample.service..*. *(..)) 整个表达式可以分为五个部分：
1、execution():：表达式主体；
2、第一个*号：表示返回类型， *号表示所有的类型；
3、包名：表示需要拦截的包名，包名后面的..，表明com.sample.service包、及其子包；
4、第二个*号：表示类名，*号表示所有的类；
5、*(..)：最后这个星号表示方法名，*号表示所有的方法，后面括弧里面表示方法的参数，两个点表示任何参数；　

　　切面（Aspect）: 切面是通知和切点的结合；对应Spring中的注解@Aspect修饰的一个类；
　　目标对象（Target object）：即被代理的对象；　　　　
　　代理对象（AOP proxy）：包含了目标对象的代码和增强后的代码的那个对象；

 

@EnableAspectJAutoProxy分析

　　在spring-boot-autoconfigure-**.jar中，有个配置类，来控制AOP功能的开启和关闭：

@Configuration(proxyBeanMethods = false)
@ConditionalOnProperty(prefix = "spring.aop", name = "auto", havingValue = "true", matchIfMissing = true)
public class AopAutoConfiguration {

    @Configuration(proxyBeanMethods = false)
    @ConditionalOnClass(Advice.class)
    static class AspectJAutoProxyingConfiguration {

        @Configuration(proxyBeanMethods = false)
        @EnableAspectJAutoProxy(proxyTargetClass = false)
        @ConditionalOnProperty(prefix = "spring.aop", name = "proxy-target-class", havingValue = "false",
                matchIfMissing = false)
        static class JdkDynamicAutoProxyConfiguration {

        }

        @Configuration(proxyBeanMethods = false)
        @EnableAspectJAutoProxy(proxyTargetClass = true)
        @ConditionalOnProperty(prefix = "spring.aop", name = "proxy-target-class", havingValue = "true",
                matchIfMissing = true)
        static class CglibAutoProxyConfiguration {

        }

    }

    @Configuration(proxyBeanMethods = false)
    @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;
                AopConfigUtils.registerAutoProxyCreatorIfNecessary(registry);
                AopConfigUtils.forceAutoProxyCreatorToUseClassProxying(registry);
            }
        }

    }

}

AopAutoConfiguration

• 使用@ConditionalOnProperty注解，默认开启AOP功能；
• spring.aop.proxy-target-class没有配置时，默认开启Cglib动态代理；
• @EnableAspectJAutoProxy注解，声明开启AOP功能。

 　　@EnableAspectJAutoProxy注解的核心是引入了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) {

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

}

registerBeanDefinitions

　　此时下面源码中的第三个方法会进入if代码块内，然后返回null：

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

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

        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");

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

AopConfigUtils

 

AnnotationAwareAspectJAutoProxyCreator分析

　　在AnnotationAwareAspectJAutoProxyCreator的继承关系中，有一个AbstractAutoProxyCreator类。该类定义了下面两个方法，它们分别拦截目标bean创建，和初始化流程：

    @Override
    public Object postProcessBeforeInstantiation(Class<?> beanClass, String beanName) throws BeansException {
        Object cacheKey = getCacheKey(beanClass, beanName);
        if (beanName == null || !this.targetSourcedBeans.contains(beanName)) {
            if (this.advisedBeans.containsKey(cacheKey)) {
                return null;
            }
            if (isInfrastructureClass(beanClass) || shouldSkip(beanClass, beanName)) {
                this.advisedBeans.put(cacheKey, Boolean.FALSE);
                return null;
            }
        }
        // Create proxy here if we have a custom TargetSource.
        // Suppresses unnecessary default instantiation of the target bean:
        // The TargetSource will handle target instances in a custom fashion.
        if (beanName != null) {
            TargetSource targetSource = getCustomTargetSource(beanClass, beanName);
            if (targetSource != null) {
                this.targetSourcedBeans.add(beanName);
                Object[] specificInterceptors = getAdvicesAndAdvisorsForBean(beanClass, beanName, targetSource);
                Object proxy = createProxy(beanClass, beanName, specificInterceptors, targetSource);
                this.proxyTypes.put(cacheKey, proxy.getClass());
                return proxy;
            }
        }

        return null;
    }

　　//在创建其他bean时，调用该方法，创建代理的bean，从而将AOP方式注入的方法，注入到目标bean中
　　@Override
　　public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
    　　if (bean != null) {
        　　Object cacheKey = getCacheKey(bean.getClass(), beanName);
        　　if (!this.earlyProxyReferences.contains(cacheKey)) {
                return wrapIfNecessary(bean, beanName, cacheKey);
        　　}
    }
    return bean;

　　postProcessAfterInitialization方法中的wrapIfNecessary方法，会为目标对象动态地创建JdkDynamicAopProxy或者ObjenesisCglibAopProxy的代理对象。