SpringAOP源码

1. 入口

SpringAOP的使用中有这么一个注解@EnableAspectJAutoProxy，按照Spring源码的一贯套路，进入这个注解看一下源码。重点关注这一行。

@Import(AspectJAutoProxyRegistrar.class)

查看该类

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) {

        // 注册 名字internalAutoProxyCreator的 AnnotationAwareAspectJAutoProxyCreator
        AopConfigUtils.registerAspectJAnnotationAutoProxyCreatorIfNecessary(registry);

        // 获得注解的属性
        AnnotationAttributes enableAspectJAutoProxy =
                AnnotationConfigUtils.attributesFor(importingClassMetadata, EnableAspectJAutoProxy.class);

        //根据其中的 proxyTargetClass/exposeProxy 设置beanDefinition属性
        if (enableAspectJAutoProxy != null) {
            if (enableAspectJAutoProxy.getBoolean("proxyTargetClass")) {
                AopConfigUtils.forceAutoProxyCreatorToUseClassProxying(registry);
            }
            if (enableAspectJAutoProxy.getBoolean("exposeProxy")) {
                AopConfigUtils.forceAutoProxyCreatorToExposeProxy(registry);
            }
        }
    }

}

最终会调用AopConfigUtils.registerAspectJAnnotationAutoProxyCreatorIfNecessary方法，注册一个AnnotationAwareAspectJAutoProxyCreator，该类属于AOP的核心类。

2. 整体流程

首先我们先想下，如果让我们自己实现，我们需要做些什么。

• 先查找切面
• 对切面进行解析
• 从切面中拿到所有的增强方法(@Befor、@After)
• 拿到这些解析创建代理，如果该类实现了接口，就用动态代理，没有接口就用CGLIB代理
• 最后调用@Advise里的那些@Before、@After方法

那么顺着这个思路，开始看源码。

2.1 查找切面

现在我们有了AnnotationAwareAspectJAutoProxyCreator这个类，查看该类的继承关系图。(省略一些不必要的类)。

AOP核心类图

首先看第一个接口，BeanPostProcessor，这个接口作为顶层接口，肯定不会被外部直接调用，所以大概率是底下的几个具体实现类被调用，然后通过判断是不是InstantiationAwareBeanPostProcessor接口的类型，再执行相应逻辑，带着这个疑惑，来看源码。

2.1.1 AnnotationConfigApplicationContext.refresh()

如果之前看过SpringIOC的源码篇的，应该记得，Spring最核心的就是Bean，所以如果要调用Bean的逻辑的话，肯定会在创建Bean之后，也就是creatBean方法以后，那么我们先看AnnotationConfigApplicationContext.refresh()这个方法。

    @Override
    public void refresh() throws BeansException, IllegalStateException {
        synchronized (this.startupShutdownMonitor) {
            //1:准备刷新上下文环境
            prepareRefresh();

            //2:获取告诉子类初始化Bean工厂  不同工厂不同实现
            ConfigurableListableBeanFactory beanFactory = obtainFreshBeanFactory();

            //3:对bean工厂进行填充属性
            prepareBeanFactory(beanFactory);

            try {
                // 第四:留个子类去实现该接口
                postProcessBeanFactory(beanFactory);

                // 调用我们的bean工厂的后置处理器. 1. 会在此将class扫描成beanDefinition  2.bean工厂的后置处理器调用
                invokeBeanFactoryPostProcessors(beanFactory);

                // 注册我们bean的后置处理器
                registerBeanPostProcessors(beanFactory);

                // 初始化国际化资源处理器.
                initMessageSource();

                // 创建事件多播器
                initApplicationEventMulticaster();

                // 这个方法同样也是留个子类实现的springboot也是从这个方法进行启动tomcat的.
                onRefresh();

                //把我们的事件监听器注册到多播器上
                registerListeners();

                // 实例化我们剩余的单实例bean.
                finishBeanFactoryInitialization(beanFactory);

                // 最后容器刷新 发布刷新事件(Spring cloud也是从这里启动的)
                finishRefresh();
            }

            catch (BeansException ex) {
                if (logger.isWarnEnabled()) {
                    logger.warn("Exception  encountered during context initialization - " +
                            "cancelling refresh attempt: " + ex);
                }

                // Destroy already created singletons to avoid dangling resources.
                destroyBeans();

                // Reset 'active' flag.
                cancelRefresh(ex);

                // Propagate exception to caller.
                throw ex;
            }

            finally {
                // Reset common introspection caches in Spring's core, since we
                // might not ever need metadata for singleton beans anymore...
                resetCommonCaches();
            }
        }
    }

2.1.2 finishBeanFactoryInitialization(beanFactory)

看finishBeanFactoryInitialization(beanFactory)这个方法。

protected void finishBeanFactoryInitialization(ConfigurableListableBeanFactory beanFactory) {
        // 为我们的bean工厂创建类型转化器  Convert
        if (beanFactory.containsBean(CONVERSION_SERVICE_BEAN_NAME) &&
                beanFactory.isTypeMatch(CONVERSION_SERVICE_BEAN_NAME, ConversionService.class)) {
            beanFactory.setConversionService(
                    beanFactory.getBean(CONVERSION_SERVICE_BEAN_NAME, ConversionService.class));
        }

        /**
         * public class MainConfig implements EmbeddedValueResolverAware{
         *
         *     public void setEmbeddedValueResolver(StringValueResolver resolver) {
                this.jdbcUrl = resolver.resolveStringValue("${ds.jdbcUrl}");
                this.classDriver = resolver.resolveStringValue("${ds.classDriver}");
              }
         }
         */
        if (!beanFactory.hasEmbeddedValueResolver()) {
            beanFactory.addEmbeddedValueResolver(strVal -> getEnvironment().resolvePlaceholders(strVal));
        }

        // 处理关于aspectj
        String[] weaverAwareNames = beanFactory.getBeanNamesForType(LoadTimeWeaverAware.class, false, false);
        for (String weaverAwareName : weaverAwareNames) {
            getBean(weaverAwareName);
        }

        // Stop using the temporary ClassLoader for type matching.
        beanFactory.setTempClassLoader(null);

        //冻结所有的 bean 定义 ， 说明注册的 bean 定义将不被修改或任何进一步的处理
        beanFactory.freezeConfiguration();

        //实例化剩余的单实例bean
        beanFactory.preInstantiateSingletons();
    }

2.1.3 beanFactory.preInstantiateSingletons()

public void preInstantiateSingletons() throws BeansException {
        if (logger.isDebugEnabled()) {
            logger.debug("Pre-instantiating singletons in " + this);
        }

        //获取我们容器中所有bean定义的名称
        List beanNames = new ArrayList<>(this.beanDefinitionNames);

        //循环我们所有的bean定义名称
        for (String beanName : beanNames) {
            //合并我们的bean定义，转换为统一的RootBeanDefinition类型(在)， 方便后续处理
            RootBeanDefinition bd = getMergedLocalBeanDefinition(beanName);
            /**
             * 根据bean定义判断是不是抽象的&& 不是单例的 &&不是懒加载的
             */
            if (!bd.isAbstract() && bd.isSingleton() && !bd.isLazyInit()) {
                //是不是工厂bean
                if (isFactoryBean(beanName)) {
                    // 是factoryBean会先生成实际的bean  &beanName 是用来获取实际bean的
                    Object bean = getBean(FACTORY_BEAN_PREFIX + beanName);
                    if (bean instanceof FactoryBean) {
                        final FactoryBean factory = (FactoryBean) bean;
                        boolean isEagerInit;
                        if (System.getSecurityManager() != null && factory instanceof SmartFactoryBean) {
                            isEagerInit = AccessController.doPrivileged((PrivilegedAction)
                                            ((SmartFactoryBean) factory)::isEagerInit,
                                    getAccessControlContext());
                        }
                        else {
                            isEagerInit = (factory instanceof SmartFactoryBean &&
                                    ((SmartFactoryBean) factory).isEagerInit());
                        }
                        //调用真正的getBean的流程
                        if (isEagerInit) {
                            getBean(beanName);
                        }
                    }
                }
                else {//非工厂Bean 就是普通的bean
                    getBean(beanName);
                }
            }
        }

        //或有的bean的名称 ...........到这里所有的单实例的bean已经记载到单实例bean到缓存中
        for (String beanName : beanNames) {
            //从单例缓存池中获取所有的对象
            Object singletonInstance = getSingleton(beanName);
            //判断当前的bean是否实现了SmartInitializingSingleton接口
            if (singletonInstance instanceof SmartInitializingSingleton) {
                final SmartInitializingSingleton smartSingleton = (SmartInitializingSingleton) singletonInstance;
                if (System.getSecurityManager() != null) {
                    AccessController.doPrivileged((PrivilegedAction