关于spring:SpringSpringAOP源码学习上

前言

本篇文章是SpringAOP的源码学习分享，分为高低两篇，本篇是对SpringAOP中切面织入业务bean时为业务bean生成动静代理对象的这一块的源码学习。

注释

一. 示例工程搭建

通过引入Springboot来实现引入Spring的相干依赖，依赖项如下所示。

<dependencies>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-web</artifactId>
    </dependency>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-aop</artifactId>
    </dependency>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-test</artifactId>
    </dependency>
</dependencies>

应用的Springboot版本为2.4.1，对应的Spring版本为5.3.2。

首先自定义一个注解，用于在切点中定位到指标办法，如下所示。

@Target(ElementType.METHOD)
@Retention(RetentionPolicy.RUNTIME)
@Documented
public @interface MyMethod {
}

而后定义业务接口和实现类，如下所示。

public interface IMyService {

    void executeTask(String message);

    void tempExecute(String message);

}

@Service
public class MyService implements IMyService {

    @Override
    @MyMethod
    public void executeTask(String message) {
        System.out.println(message);
    }

    @Override
    public void tempExecute(String message) {
        executeTask(message);
    }

}

而后定义一个切面，已知切面 = 切点 + 告诉，在本示例工程中，切点是所有由@MyMethod注解润饰的办法，并且抉择前置告诉和后置告诉，如下所示。

@Aspect
@Component
public class MyAspect {

    @Pointcut("@annotation(com.learn.aop.aspect.MyMethod)")
    public void myMethodPointcut() {}

    @Before(value = "myMethodPointcut()")
    public void commonBeforeMethod(JoinPoint joinPoint) {
        System.out.println("Common before method.");
    }

    @After(value = "myMethodPointcut()")
    public void commonAfterMethod(JoinPoint joinPoint) {
        System.out.println("Common after method.");
    }

}

自定义一个配置类，和下面所有类放在同一包门路下，如下所示。

@ComponentScan
@EnableAspectJAutoProxy
public class MyConfig {}

最初编写一个测试程序，如下所示。

public class MyTest {

    public static void main(String[] args) {
        ApplicationContext applicationContext
                = new AnnotationConfigApplicationContext(MyConfig.class);

        IMyService iMyService = applicationContext.getBean(IMyService.class);

        iMyService.tempExecute("Real method execute.");
        iMyService.executeTask("Real method execute.");
    }

}

运行测试程序，打印如下。

能够看到运行executeTask()办法时，切面逻辑失效了。

二. 时序图

SpringAOP中动静代理对象的生成，能够分为两个大的步骤。

步骤一：将作用于以后bean的告诉获取进去，失去告诉链；
步骤二：基于告诉链为以后bean生成AOP动静代理对象，并依据配置和指标bean决定是应用CGLIB动静代理还是JDK动静代理。

告诉链能够示意如下。

List<Advisor> chain

Advisor接口是SpringAOP中对告诉的一个顶层形象，其有两个子接口，类图如下所示。

PointcutAdvisor是对切点相干的告诉的形象，能够将PointcutAdvisor了解为对告诉办法和切点的封装，因为本文的示例工程中的切面中的告诉全副是切点相干的告诉，所以无非凡阐明时，Advisor均指PointcutAdvisor，并且也能够不太谨严的将Advisor称为告诉。

在理清了概念之后，上面给出时序图，时序图有两张，一张是告诉链的获取时序图，一张是AOP动静代理对象的生成时序图，如下所示。

告诉链的获取时序图。

AOP动静代理对象的生成时序图。

后续源码的剖析能够联合上述时序图进行了解。

三. SpringAOP动静代理对象生成工夫点

在示例工程中，如果通过断点调试的办法，察看iMyService字段，能够发现其是一个动静代理对象，如下所示。

在bean生命周期中，bean的实例化，属性注入和初始化都在AbstractAutowireCapableBeanFactory的doCreateBean()办法中，在该办法中会先调用createBeanInstance()办法将bean实例化进去，而后调用populateBean()办法为bean实例实现属性注入，最初调用initializeBean()办法来初始化bean。上面看一下initializeBean()办法的实现。

protected Object initializeBean(String beanName, Object bean, @Nullable RootBeanDefinition mbd) {
    
    ......
    
    if (mbd == null || !mbd.isSynthetic()) {
        //调用BeanPostProcessors的postProcessBeforeInitialization()办法
        wrappedBean = applyBeanPostProcessorsBeforeInitialization(wrappedBean, beanName);
    }

    ......
    
    if (mbd == null || !mbd.isSynthetic()) {
        //调用BeanPostProcessors的postProcessAfterInitialization()办法
        wrappedBean = applyBeanPostProcessorsAfterInitialization(wrappedBean, beanName);
    }

    return wrappedBean;
}

在初始化bean的时候，就会调用到BeanPostProcessors（bean后置处理器）的postProcessBeforeInitialization()和postProcessAfterInitialization()办法，在BeanPostProcessors的实现类AnnotationAwareAspectJAutoProxyCreator的postProcessAfterInitialization()办法中，就会为bean织入切面（为bean生成动静代理对象）。

上面给出AnnotationAwareAspectJAutoProxyCreator的类图。

四. 告诉链的获取

上一节中已知，在BeanPostProcessors的实现类AnnotationAwareAspectJAutoProxyCreator的postProcessAfterInitialization()办法中，就会为bean织入切面（为bean生成动静代理对象），那么就以AnnotationAwareAspectJAutoProxyCreator的postProcessAfterInitialization()办法为入口，开始剖析源码。其实AnnotationAwareAspectJAutoProxyCreator没有对postProcessAfterInitialization()办法做实现，那么理论调用到的是AnnotationAwareAspectJAutoProxyCreator父类AbstractAutoProxyCreator的postProcessAfterInitialization()办法，如下所示。

public Object postProcessAfterInitialization(@Nullable Object bean, String beanName) {
    if (bean != null) {
        Object cacheKey = getCacheKey(bean.getClass(), beanName);
        if (this.earlyProxyReferences.remove(cacheKey) != bean) {
            //如果bean是切面作用指标，就为bean生成动静代理对象
            return wrapIfNecessary(bean, beanName, cacheKey);
        }
    }
    return bean;
}

持续看wrapIfNecessary()办法的实现，如下所示。

protected Object wrapIfNecessary(Object bean, String beanName, Object cacheKey) {
    if (StringUtils.hasLength(beanName) && this.targetSourcedBeans.contains(beanName)) {
        return bean;
    }
    if (Boolean.FALSE.equals(this.advisedBeans.get(cacheKey))) {
        return bean;
    }
    if (isInfrastructureClass(bean.getClass()) || shouldSkip(bean.getClass(), beanName)) {
        this.advisedBeans.put(cacheKey, Boolean.FALSE);
        return bean;
    }

    //把作用在以后bean的告诉获取进去
    Object[] specificInterceptors = getAdvicesAndAdvisorsForBean(bean.getClass(), beanName, null);
    if (specificInterceptors != DO_NOT_PROXY) {
        this.advisedBeans.put(cacheKey, Boolean.TRUE);
        //为以后bean生成动静代理对象
        Object proxy = createProxy(
                bean.getClass(), beanName, specificInterceptors, new SingletonTargetSource(bean));
        this.proxyTypes.put(cacheKey, proxy.getClass());
        //返回以后bean的动静代理对象
        return proxy;
    }

    this.advisedBeans.put(cacheKey, Boolean.FALSE);
    return bean;
}

wrapIfNecessary()办法会先将作用于以后bean的告诉链获取进去，而后再调用createProxy()办法为以后bean创立动静代理对象，那么本大节重点剖析getAdvicesAndAdvisorsForBean()办法的实现。getAdvicesAndAdvisorsForBean()实现如下。

protected Object[] getAdvicesAndAdvisorsForBean(
        Class<?> beanClass, String beanName, @Nullable TargetSource targetSource) {
    //将作用于以后bean的告诉获取进去，并且告诉会被封装成Advisor的实现类
    List<Advisor> advisors = findEligibleAdvisors(beanClass, beanName);
    if (advisors.isEmpty()) {
        return DO_NOT_PROXY;
    }
    return advisors.toArray();
}

持续看findEligibleAdvisors()办法，如下所示。

protected List<Advisor> findEligibleAdvisors(Class<?> beanClass, String beanName) {
    //找到容器中所有由@Aspect注解润饰的切面，并将切面中的每个告诉办法都封装成一个Advisor的实现类
    List<Advisor> candidateAdvisors = findCandidateAdvisors();
    //在candidateAdvisors中将作用于以后bean的Advisor获取进去
    List<Advisor> eligibleAdvisors = findAdvisorsThatCanApply(candidateAdvisors, beanClass, beanName);
    extendAdvisors(eligibleAdvisors);
    if (!eligibleAdvisors.isEmpty()) {
        //对Advisor进行排序
        eligibleAdvisors = sortAdvisors(eligibleAdvisors);
    }
    return eligibleAdvisors;
}

findEligibleAdvisors()办法中会先调用到AnnotationAwareAspectJAutoProxyCreator的findCandidateAdvisors()办法，在findCandidateAdvisors()办法中会再调用BeanFactoryAspectJAdvisorsBuilder的buildAspectJAdvisors()办法来遍历以后容器中的每个由@Aspect注解润饰的切面，而后将每个切面的告诉封装成Advisor并返回，同时每遍历一个切面，都会将这个切面的所有Advisor缓存，以便下次获取时间接从缓存获取。

findEligibleAdvisors()办法中在获取到以后容器中的所有Advisor后，会再调用findAdvisorsThatCanApply()办法来找出可能作用于以后bean的Advisor，判断根据就是依据Advisor中的Pointcut来判断。

findEligibleAdvisors()办法最初还会对作用于以后bean的所有Advisor进行排序，这个前面再剖析。所以findEligibleAdvisors()办法执行完，就获取到了可能作用于以后bean的所有告诉对应的Advisor，也就获取到了告诉链。

最初再剖析一下AnnotationAwareAspectJAutoProxyCreator的findCandidateAdvisors()办法中是如何获取容器中所有告诉以及是如何将每个告诉封装成Advisor的。BeanFactoryAspectJAdvisorsBuilder的buildAspectJAdvisors()办法如下所示。

public List<Advisor> buildAspectJAdvisors() {
    List<String> aspectNames = this.aspectBeanNames;
    //aspectNames不为null示意获取过切面bean的告诉并把这些告诉进行了缓存，那么间接从缓存获取告诉
    if (aspectNames == null) {
        synchronized (this) {
            aspectNames = this.aspectBeanNames;
            if (aspectNames == null) {
                List<Advisor> advisors = new ArrayList<>();
                aspectNames = new ArrayList<>();
                //把容器中的bean的名字获取进去
                String[] beanNames = BeanFactoryUtils.beanNamesForTypeIncludingAncestors(
                        this.beanFactory, Object.class, true, false);
                //遍历每个bean
                for (String beanName : beanNames) {
                    if (!isEligibleBean(beanName)) {
                        continue;
                    }
                    Class<?> beanType = this.beanFactory.getType(beanName, false);
                    if (beanType == null) {
                        continue;
                    }
                    //判断bean是否是切面bean
                    if (this.advisorFactory.isAspect(beanType)) {
                        //把切面bean的名字增加到汇合中，以便后续缓存起来
                        aspectNames.add(beanName);
                        AspectMetadata amd = new AspectMetadata(beanType, beanName);
                        if (amd.getAjType().getPerClause().getKind() == PerClauseKind.SINGLETON) {
                            MetadataAwareAspectInstanceFactory factory =
                                    new BeanFactoryAspectInstanceFactory(this.beanFactory, beanName);
                            //调用到ReflectiveAspectJAdvisorFactory的getAdvisors()办法来获取切面bean里的告诉
                            List<Advisor> classAdvisors = this.advisorFactory.getAdvisors(factory);
                            if (this.beanFactory.isSingleton(beanName)) {
                                //如果切面bean是单例，则缓存切面bean的告诉
                                this.advisorsCache.put(beanName, classAdvisors);
                            }
                            else {
                                //如果切面bean不是单例，则缓存切面bean的工厂
                                //通过切面bean的工厂能够每次都生成切面bean的告诉
                                this.aspectFactoryCache.put(beanName, factory);
                            }
                            advisors.addAll(classAdvisors);
                        }
                        else {
                            if (this.beanFactory.isSingleton(beanName)) {
                                throw new IllegalArgumentException("Bean with name '" + beanName +
                                        "' is a singleton, but aspect instantiation model is not singleton");
                            }
                            MetadataAwareAspectInstanceFactory factory =
                                    new PrototypeAspectInstanceFactory(this.beanFactory, beanName);
                            this.aspectFactoryCache.put(beanName, factory);
                            advisors.addAll(this.advisorFactory.getAdvisors(factory));
                        }
                    }
                }
                this.aspectBeanNames = aspectNames;
                //返回容器中的所有告诉
                return advisors;
            }
        }
    }

    //执行到这里示意曾经生成过告诉并进行了缓存
    if (aspectNames.isEmpty()) {
        return Collections.emptyList();
    }
    List<Advisor> advisors = new ArrayList<>();
    for (String aspectName : aspectNames) {
        //将每个切面bean的告诉从缓存中获取进去并加到后果汇合中
        List<Advisor> cachedAdvisors = this.advisorsCache.get(aspectName);
        if (cachedAdvisors != null) {
            advisors.addAll(cachedAdvisors);
        }
        else {
            //非单例切面bean就应用其对应的工厂新生成告诉，而后也退出到后果汇合中
            MetadataAwareAspectInstanceFactory factory = this.aspectFactoryCache.get(aspectName);
            advisors.addAll(this.advisorFactory.getAdvisors(factory));
        }
    }
    //返回容器中的所有告诉
    return advisors;
}

下面buildAspectJAdvisors()办法中次要是Spring对切面bean的告诉的一个缓存策略，次要思维就是第一次获取时会实在的将所有切面bean的告诉获取进去并生成Advisor，而后缓存起来，后续再获取告诉时就从缓存中获取。上面持续深入分析一下切面bean的告诉是如何被封装成Advisor的，理论的逻辑产生在ReflectiveAspectJAdvisorFactory的getAdvisors()办法中，如下所示。

public List<Advisor> getAdvisors(MetadataAwareAspectInstanceFactory aspectInstanceFactory) {
    //失去切面bean的Class对象
    Class<?> aspectClass = aspectInstanceFactory.getAspectMetadata().getAspectClass();
    //失去切面bean的名字
    String aspectName = aspectInstanceFactory.getAspectMetadata().getAspectName();
    validate(aspectClass);

    MetadataAwareAspectInstanceFactory lazySingletonAspectInstanceFactory =
            new LazySingletonAspectInstanceFactoryDecorator(aspectInstanceFactory);

    List<Advisor> advisors = new ArrayList<>();
    //调用getAdvisorMethods()办法来把非切点办法获取进去，并遍历
    for (Method method : getAdvisorMethods(aspectClass)) {
        //先将告诉上的切点结构成AspectJExpressionPointcut，而后再创立告诉对应的Advisor
        //创立进去的Advisor理论为InstantiationModelAwarePointcutAdvisorImpl
        Advisor advisor = getAdvisor(method, lazySingletonAspectInstanceFactory, 0, aspectName);
        //以后method如果是告诉办法，则将告诉办法对应的Advisor增加到后果汇合中
        //如果不是告诉办法，失去的Advisor会为null，就不会增加到后果汇合中
        if (advisor != null) {
            advisors.add(advisor);
        }
    }

    if (!advisors.isEmpty() && lazySingletonAspectInstanceFactory.getAspectMetadata().isLazilyInstantiated()) {
        Advisor instantiationAdvisor = new SyntheticInstantiationAdvisor(lazySingletonAspectInstanceFactory);
        advisors.add(0, instantiationAdvisor);
    }

    for (Field field : aspectClass.getDeclaredFields()) {
        Advisor advisor = getDeclareParentsAdvisor(field);
        if (advisor != null) {
            advisors.add(advisor);
        }
    }

    return advisors;
}

至此获取告诉链的源码剖析结束。上面对获取作用于某个bean的告诉链步骤进行大节。

如果是第一次获取告诉链，那么会遍历容器中每个由@Aspect注解润饰的切面bean而后将其告诉封装成Advisor并缓存起来，如果不是第一次获取，就间接从缓存中将所有Advisor获取进去；
而后筛选失去作用于以后bean的Advisor，并退出汇合中；
返回筛选失去的汇合，作为后续创立AOP动静代理对象的告诉链。

五. AOP动静代理对象的创立

已知在AbstractAutoProxyCreator的wrapIfNecessary()办法中会先调用getAdvicesAndAdvisorsForBean()办法获取作用于以后bean的告诉链，那么下一步就应该基于告诉链为以后bean生成AOP动静代理对象，生成动静代理对象的逻辑在AbstractAutoProxyCreator的createProxy()办法中，如下所示。

protected Object createProxy(Class<?> beanClass, @Nullable String beanName,
        @Nullable Object[] specificInterceptors, TargetSource targetSource) {

    if (this.beanFactory instanceof ConfigurableListableBeanFactory) {
        AutoProxyUtils.exposeTargetClass((ConfigurableListableBeanFactory) this.beanFactory, beanName, beanClass);
    }

    //创立ProxyFactory来创立动静代理对象
    ProxyFactory proxyFactory = new ProxyFactory();
    proxyFactory.copyFrom(this);

    if (!proxyFactory.isProxyTargetClass()) {
        if (shouldProxyTargetClass(beanClass, beanName)) {
            proxyFactory.setProxyTargetClass(true);
        }
        else {
            evaluateProxyInterfaces(beanClass, proxyFactory);
        }
    }

    Advisor[] advisors = buildAdvisors(beanName, specificInterceptors);
    //为ProxyFactory设置告诉链
    proxyFactory.addAdvisors(advisors);
    //为ProxyFactory设置指标对象
    proxyFactory.setTargetSource(targetSource);
    customizeProxyFactory(proxyFactory);

    proxyFactory.setFrozen(this.freezeProxy);
    if (advisorsPreFiltered()) {
        proxyFactory.setPreFiltered(true);
    }

    //调用ProxyFactory的getProxy()办法创立动静代理对象
    return proxyFactory.getProxy(getProxyClassLoader());
}

在createProxy()办法中会先创立一个ProxyFactory工厂，而后为ProxyFactory工厂设置告诉链和指标对象，后续的动静代理对象的创立就是由ProxyFactory工厂来实现。ProxyFactory工厂类图如下所示。

所以ProxyFactory其实是一个AdvisedSupport。ProxyFactory的getProxy()办法如下所示。

public Object getProxy(@Nullable ClassLoader classLoader) {
    return createAopProxy().getProxy(classLoader);
}

在ProxyFactory的getProxy()办法中会先调用到其父类ProxyCreatorSupport中的createAopProxy()办法，createAopProxy()办法会有两种返回值，一个是JdkDynamicAopProxy，负责JDK动静代理对象的生成，另一个是CglibAopProxy，负责CGLIB动静代理对象的生成，上面看一下ProxyCreatorSupport的createAopProxy()办法的实现。

protected final synchronized AopProxy createAopProxy() {
    if (!this.active) {
        activate();
    }
    //getAopProxyFactory()会返回一个AopProxyFactory
    //AopProxyFactory的createAopProxy()会返回一个AopProxy
    //依据不同的指标类和不同的配置，会最终决定AopProxy是JdkDynamicAopProxy还是CglibAopProxy
    //创立AopProxy时还会将ProxyFactory本人传入，所以创立进去的AopProxy也就持有了告诉链和指标对象
    return getAopProxyFactory().createAopProxy(this);
}

ProxyCreatorSupport的createAopProxy()办法中创立AopProxy时会将ProxyFactory传入，所以创立进去的AopProxy也就通过ProxyFactory持有了告诉链和指标对象。当初回到ProxyFactory的getProxy()办法，在拿到JdkDynamicAopProxy或者CglibAopProxy之后，就会调用其getProxy()办法来生成动静代理对象，上面以JdkDynamicAopProxy的getProxy()办法为例进行阐明，JdkDynamicAopProxy的getProxy()办法如下所示。

public Object getProxy(@Nullable ClassLoader classLoader) {
    if (logger.isTraceEnabled()) {
        logger.trace("Creating JDK dynamic proxy: " + this.advised.getTargetSource());
    }
    //调用Proxy的newProxyInstance()办法来生成动静代理对象
    //proxiedInterfaces中有bean实现的接口
    //JdkDynamicAopProxy本身是实现了InvocationHandler接口，所以这将JdkDynamicAopProxy传到了newProxyInstance()办法中
    return Proxy.newProxyInstance(classLoader, this.proxiedInterfaces, this);
}

JdkDynamicAopProxy的getProxy()办法就是调用Proxy的newProxyInstance()办法来创立JDK动静代理对象。

至此SpringAOP中创立AOP动静代理对象的源码剖析结束。上面给出为bean基于告诉链创立动静代理对象的步骤大节。

创立ProxyFactory，为ProxyFactory设置告诉链和指标对象，后续通过ProxyFactory创立动静代理对象；
通过ProxyFactory先创立AopProxy，依据应用的动静代理形式的不同，创立进去的AopProxy能够为JdkDynamicAopProxy或者ObjenesisCglibAopProxy，并且ProxyFactory在创立AopProxy时传入了本身，所以创立进去的AopProxy也就持有了告诉链和指标对象；
通过创立进去的AopProxy生成动静代理对象。

总结

Spring中有用户自定义的切面以及Spring框架提供的切面，这些切面会在bean的生命周期调用到BeanPostProcessors的postProcessAfterInitialization()办法时织入bean，织入的模式就是为bean生成AOP动静代理对象。为bean生成动静代理对象前会先获取到容器中所有可能作用于这个bean的告诉，这些告诉会被封装成Advisor的实现类并退出到汇合中，能够称这个Advisor的汇合为告诉链，获取到告诉链后，会创立一个ProxyFactory工厂来帮忙创立动静代理对象，创立前会先通过ProxyFactory创立AopProxy，依据应用的动静代理形式的不同，创立进去的AopProxy能够为JdkDynamicAopProxy或者ObjenesisCglibAopProxy，并且ProxyFactory在创立AopProxy时传入了本身，所以创立进去的AopProxy也就持有了告诉链和指标对象，最初就是通过AopProxy将理论的动静代理对象生成进去。

关于spring:SpringSpringAOP源码学习上

前言

注释

一. 示例工程搭建

二. 时序图

三. SpringAOP动静代理对象生成工夫点

四. 告诉链的获取

五. AOP动静代理对象的创立

总结

评论

发表回复取消回复

更多文章

DDN HPC 存储硬件架构设计深度分析

探秘IO500：从Lustre并行文件系统出发，开启HPC存储性能新征程

苹果iOS打包的ipa应用无法安装？一篇文章带你了解可能的原因及排查方法

图解Golang：从零开始实现简易版过期LRU缓存

关于spring:SpringSpringAOP源码学习上

前言

注释

一. 示例工程搭建

二. 时序图

三. SpringAOP动静代理对象生成工夫点

四. 告诉链的获取

五. AOP动静代理对象的创立

总结

评论

发表回复 取消回复

更多文章

DDN HPC 存储硬件架构设计深度分析

探秘IO500：从Lustre并行文件系统出发，开启HPC存储性能新征程

苹果iOS打包的ipa应用无法安装？一篇文章带你了解可能的原因及排查方法

图解Golang：从零开始实现简易版过期LRU缓存

发表回复取消回复