彻底读懂Spring（一）读源码，我们可以从第一行读起


从今天开始我们一步步走进Spring的源码。我们整个源码的解析将以下面这句代码为入口：
AnnotationConfigApplicationContext ac = new AnnotationConfigApplicationContext(Config.class);
下面就跟着我来看看，Spring第一行代码到底干了什么！
本系列文章对应Spring版本为5.x。
”

上面这行代码就是执行了AnnotationConfigApplicationContext中的一个构造函数，其代码如下：

public AnnotationConfigApplicationContext(Class... annotatedClasses) {
    // 1.调用了AnnotationConfigApplicationContext的空参构造方法
    this();
    // 2.将配置类注册到容器中
    register(annotatedClasses);
 // 3.刷新容器    
    refresh();
}

找到第一行代码

我们继续查看AnnotationConfigApplicationContext的空参构造

其代码如下：

public AnnotationConfigApplicationContext() {
    // 1.1 构造一个reader对象
    this.reader = new AnnotatedBeanDefinitionReader(this);
    // 1.2 构造一个scanner对象
    this.scanner = new ClassPathBeanDefinitionScanner(this);
}

它主要做了两件事

创建一个AnnotatedBeanDefinitionReader
创建一个ClassPathBeanDefinitionScanner

本文的重点就是分析第一行代码，也就是创建AnnotatedBeanDefinitionReader的过程。在分析代码前，我们首先应该搞懂一件事情，就是创建的这个AnnotatedBeanDefinitionReader到底是什么呢？

AnnotatedBeanDefinitionReader是什么？


这个类的主要作用就是注册BeanDefinition，与之相类似的功能的类还有一个就是ClassPathBeanDefinitionScanner。它们最大的不同在于AnnotatedBeanDefinitionReader支持注册单个的BeanDefinition，而ClassPathBeanDefinitionScanner会一次注册所有扫描到的BeanDefinition。关于ClassPathBeanDefinitionScanner本文不专门做过多解释，只要能看懂这篇文章ClassPathBeanDefinitionScanner自然就懂了。

”

AnnotatedBeanDefinitionReader源码解析

// 这里只保留了这个类中的部分代码，其余不重要我都没有放出来
public class AnnotatedBeanDefinitionReader {
 
    // 上面我们已经说了，这个reader对象主要的工作就是注册BeanDefinition，那么将BeanDefinition注册到哪里去呢？所以它内部就保存了一个BeanDefinition的注册表。对应的就是我们代码中的AnnotationConfigApplicationContext
 private final BeanDefinitionRegistry registry;

    // 见名知意，Bean名称的生成器，生成BeanName
 private BeanNameGenerator beanNameGenerator = new AnnotationBeanNameGenerator();
 
    // 解析@Scope注解
 private ScopeMetadataResolver scopeMetadataResolver = new AnnotationScopeMetadataResolver();
 
    // 解析@Conditional注解
 private ConditionEvaluator conditionEvaluator;
 
    // 将解析指定的类成为BeanDefinition并注册到容器中
 public void registerBean(Class annotatedClass, String name, Class... qualifiers) {
  doRegisterBean(annotatedClass, null, name, qualifiers);
 }

    // 真正的执行注册的方法
     void doRegisterBean(Class annotatedClass, @Nullable Supplier instanceSupplier, @Nullable String name,
                            @Nullable Class[] qualifiers, BeanDefinitionCustomizer... definitionCustomizers) {
  
        // Spring在这里写死了，直接new了一个AnnotatedGenericBeanDefinition，也就是说通过reader对象注册的BeanDefinition都是AnnotatedGenericBeanDefinition。
        AnnotatedGenericBeanDefinition abd = new AnnotatedGenericBeanDefinition(annotatedClass);
       
        // 调用conditionEvaluator的shouldSkip方法
        // 判断当前的这个bd是否需要被注册
        if (this.conditionEvaluator.shouldSkip(abd.getMetadata())) {
            return;
        }
  // 在注册时可以提供一个instanceSupplier
        abd.setInstanceSupplier(instanceSupplier);
        
        // 解析@Scope注解，得到一个ScopeMetadata
        ScopeMetadata scopeMetadata = this.scopeMetadataResolver.resolveScopeMetadata(abd);
        
        // 将@Scope注解中的信息保存到bd中
        abd.setScope(scopeMetadata.getScopeName());
        
        // 调用beanNameGenerator生成beanName
        // 所谓的注册bd就是指定将bd放入到容器中的一个beanDefinitionMap中
        // 其中的key就是beanName,value就是解析class后得到的bd
        String beanName = (name != null ? name : this.beanNameGenerator.generateBeanName(abd, this.registry));
  
        // 这句代码将进一步解析class上的注解信息，Spring在创建这个abd的信息时候就已经将当前的class放入其中了，所有这行代码主要做的就是通过class对象获取到上面的注解（包括@Lazy，@Primary，@DependsOn注解等等），然后将得到注解中对应的配置信息并放入到bd中的属性中
        AnnotationConfigUtils.processCommonDefinitionAnnotations(abd);
        
        // 下面的这段不用过多关注，为了文章的完整性我这里还是说说我的理解
        // 正常的容器启动阶段qualifiers肯定等于null
        // 我能想到的不为空的方法就是直接在外部调用了register方法并且出入了qualifiers参数
        // 就是说我们手动直接注册了一个类，但是我们没有在类上添加@Lazy，@Primary注解，但是我们又希望能将其标记为Primary为true/LazyInit为true,这个时候就手动传入Primary.class跟Lazy.class即可。
        if (qualifiers != null) {
            for (Class qualifier : qualifiers) {
                if (Primary.class == qualifier) {
                    abd.setPrimary(true);
                }
                else if (Lazy.class == qualifier) {
                    abd.setLazyInit(true);
                }
                else {
                    abd.addQualifier(new AutowireCandidateQualifier(qualifier));
                }
            }
        }
        
        // 我们注册时，我们可以传入一些回调方法，在解析得到bd后调用
        for (BeanDefinitionCustomizer customizer : definitionCustomizers) {
            customizer.customize(abd);
        }
  
        // bd中是没有beanName属性的，BeanDefinitionHolder中就是保存了beanName以及对应的BeanDefinition
        BeanDefinitionHolder definitionHolder = new BeanDefinitionHolder(abd, beanName);
        
        // 这个地方主要是解析Scope中的ProxyMode属性，默认为no，不生成代理对象
  // 后文做详细分析
        definitionHolder = AnnotationConfigUtils.applyScopedProxyMode(scopeMetadata, definitionHolder, this.registry);
        
        // 注册bd到容器中，实际上最终就是将bd放到了beanFactory中的一个map里（beanDefinitionMap）
        // key为beanName,value为bd
        BeanDefinitionReaderUtils.registerBeanDefinition(definitionHolder, this.registry);
    }

}

applyScopedProxyMode做了什么？

上面的代理有一个地方没有将清楚，就是AnnotationConfigUtils.applyScopedProxyMode到底做了什么？

带着这个问题，我们继续看看这个方法的代码

1、applyScopedProxyMode

// 这个方法名称直译过来就是----应用Scoped中的ProxyMode属性
// 这个属性有什么用呢？
// ProxyMode属性一共有下面几种取值
// 1.DEFAULT:默认值，默认情况下取no
// 2.NO:不开启代理
// 3.INTERFACES:使用jdk动态代理
// 4.TARGET_CLASS:使用cglib代理
// 假设我们有一个单例的对象A，其中有一个属性B，B的作用域是session的，这个时候容器在启动时创建A的过程中需要为A注入属性B，但是属性B的作用域为session,这种情况下注入必定会报错的
// 但是当我们将ProxyMode属性配置为INTERFACES/TARGET_CLASS时，它会暴露一个代理对象，ProxyMode可以配置代理对象的生成策略是使用jdk动态代理还是生成cglib动态代理,那么当我们在创建A时，会先注入一个B的代理对象而不是直接报错
static BeanDefinitionHolder applyScopedProxyMode(
    ScopeMetadata metadata, BeanDefinitionHolder definition, BeanDefinitionRegistry registry) {
 // 根据scopedProxyMode进行判断，如果是NO，直接返回原有的bd并添加到容器的bdMap中
    ScopedProxyMode scopedProxyMode = metadata.getScopedProxyMode();
    if (scopedProxyMode.equals(ScopedProxyMode.NO)) {
        return definition;
    }
    // 是否采用cglib代理
    boolean proxyTargetClass = scopedProxyMode.equals(ScopedProxyMode.TARGET_CLASS);
    // 调用ScopedProxyCreator的createScopedProxy，创建代理对象对应的bd
    return ScopedProxyCreator.createScopedProxy(definition, registry, proxyTargetClass);
}

2、ScopedProxyCreator.createScopedProxy

public static BeanDefinitionHolder createScopedProxy(
    BeanDefinitionHolder definitionHolder, BeanDefinitionRegistry registry, boolean proxyTargetClass) {
 // 继续调用ScopedProxyUtils的方法
    return ScopedProxyUtils.createScopedProxy(definitionHolder, registry, proxyTargetClass);
}

3、ScopedProxyUtils.createScopedProxy

// 根据目标对象的bd生成代理对象的bd,并且会将目标对象的bd注册到容器中
public static BeanDefinitionHolder createScopedProxy(BeanDefinitionHolder definition,
                                                     BeanDefinitionRegistry registry, boolean proxyTargetClass) {
 // 目标对象的名称
    String originalBeanName = definition.getBeanName();
    // 目标对象的bd
    BeanDefinition targetDefinition = definition.getBeanDefinition();
    // 将来会将目标对象的bd注册到容器中，targetBeanName作为注册时的key
    // targetBeanName = "scopedTarget."+originalBeanName
    String targetBeanName = getTargetBeanName(originalBeanName);

 // 创建代理对象的bd,可以看到代理对象会是一个factoryBean的介绍请参考《》，关于factoryBean的介绍请参考我的Spring官网阅读系列第七篇，这里不做过多介绍
    RootBeanDefinition proxyDefinition = new RootBeanDefinition(ScopedProxyFactoryBean.class);
    // 代理对象所装饰的bd就是目标对象的bd
    // 拷贝了部分目标对象bd中的属性到代理对象的bd中
    proxyDefinition.setDecoratedDefinition(new BeanDefinitionHolder(targetDefinition, targetBeanName));
    proxyDefinition.setOriginatingBeanDefinition(targetDefinition);
    proxyDefinition.setSource(definition.getSource());
    proxyDefinition.setRole(targetDefinition.getRole());
 
    proxyDefinition.getPropertyValues().add("targetBeanName", targetBeanName);
    if (proxyTargetClass) {
        targetDefinition.setAttribute(AutoProxyUtils.PRESERVE_TARGET_CLASS_ATTRIBUTE, Boolean.TRUE);
        // ScopedProxyFactoryBean's "proxyTargetClass" default is TRUE, so we don't need to set it explicitly here.
    }
    else {
        proxyDefinition.getPropertyValues().add("proxyTargetClass", Boolean.FALSE);
    }

    // Copy autowire settings from original bean definition.
    proxyDefinition.setAutowireCandidate(targetDefinition.isAutowireCandidate());
    proxyDefinition.setPrimary(targetDefinition.isPrimary());
    if (targetDefinition instanceof AbstractBeanDefinition) {
        proxyDefinition.copyQualifiersFrom((AbstractBeanDefinition) targetDefinition);
    }

    // The target bean should be ignored in favor of the scoped proxy.
    targetDefinition.setAutowireCandidate(false);
    targetDefinition.setPrimary(false);

    // 这一步会将原始的bd注册到容器中，其中的key="scopedTarget."+originalBeanName
    registry.registerBeanDefinition(targetBeanName, targetDefinition);

 // 返回这个用于创建代理对象的bd
    return new BeanDefinitionHolder(proxyDefinition, originalBeanName, definition.getAliases());
}

从上面的代码可以看出，当我们选择在@Scope注解中配置了proxyMode属性时（INTERFACES/TARGET_CLASS），那么Spring会在注册bd时，在容器中注册一个代理的bd，这个bd是一个ScopedProxyFactoryBean类型的bd，并且没有特别指定它的作用域，所以它是单例的，并且这个FactoryBean返回就是对应的目标对象的代理对象。基于此，Spring就可以利用这个bd来完成在启动阶段对session/request域对象的注入。

创建AnnotatedBeanDefinitionReader的过程中做了什么?


现在我们已经知道了这个reader对象有什么用，那么接下来我们就一起分析下Spring在创建这个对象的过程中还做了什么，也就是reader对象在执行构造函数时还完成了什么事情
”

1、创建environment

// 第一步：调用了第一个构造函数，在这个过程中创建了environment，关于environment可以参考我的《Spring官网阅读（十一）ApplicationContext详细介绍（上）》
public AnnotatedBeanDefinitionReader(BeanDefinitionRegistry registry) {
    // 这个environment实际上就是包含了系统环境变量以及JVM启动参数
    this(registry, getOrCreateEnvironment(registry));
}

2、对属性进行赋值，并注册容器需要的bd

// 第二步：进一步调用构造函数
public AnnotatedBeanDefinitionReader(BeanDefinitionRegistry registry, Environment environment) {
 // 为read对象中的属性赋值
    this.registry = registry;
    this.conditionEvaluator = new ConditionEvaluator(registry, environment, null);
    
    // 从这个方法可以看出，Spring在创建reader对象的时候就开始注册bd了，那么Spring注册了哪些bd呢？注册的bd有什么用呢？我们接着往下看
    AnnotationConfigUtils.registerAnnotationConfigProcessors(this.registry);
}

3、注册容器需要的bd

public static Set registerAnnotationConfigProcessors(
    BeanDefinitionRegistry registry, @Nullable Object source) {
 
    DefaultListableBeanFactory beanFactory = unwrapDefaultListableBeanFactory(registry);
    if (beanFactory != null) {
        
        // 1.指定容器使用的比较器，通过这个比较器能够解析@Order注解以及Ordered接口
        if (!(beanFactory.getDependencyComparator() instanceof AnnotationAwareOrderComparator)) {
            beanFactory.setDependencyComparator(AnnotationAwareOrderComparator.INSTANCE);
        }
        
        // 2.指定容器使用的AutowireCandidateResolver
        if (!(beanFactory.getAutowireCandidateResolver() instanceof ContextAnnotationAutowireCandidateResolver)) {
            beanFactory.setAutowireCandidateResolver(new ContextAnnotationAutowireCandidateResolver());
        }
    }

    Set beanDefs = new LinkedHashSet<>(8);
 // 3.注册ConfigurationClassPostProcessor
    if (!registry.containsBeanDefinition(CONFIGURATION_ANNOTATION_PROCESSOR_BEAN_NAME)) {
        RootBeanDefinition def = new RootBeanDefinition(ConfigurationClassPostProcessor.class);
        def.setSource(source);
        beanDefs.add(registerPostProcessor(registry, def, CONFIGURATION_ANNOTATION_PROCESSOR_BEAN_NAME));
    }
 // 4.注册AutowiredAnnotationBeanPostProcessor
    if (!registry.containsBeanDefinition(AUTOWIRED_ANNOTATION_PROCESSOR_BEAN_NAME)) {
        RootBeanDefinition def = new RootBeanDefinition(AutowiredAnnotationBeanPostProcessor.class);
        def.setSource(source);
        beanDefs.add(registerPostProcessor(registry, def, AUTOWIRED_ANNOTATION_PROCESSOR_BEAN_NAME));
    }

    // 5.如果支持JSR-250，注册CommonAnnotationBeanPostProcessor
    if (jsr250Present && !registry.containsBeanDefinition(COMMON_ANNOTATION_PROCESSOR_BEAN_NAME)) {
        RootBeanDefinition def = new RootBeanDefinition(CommonAnnotationBeanPostProcessor.class);
        def.setSource(source);
        beanDefs.add(registerPostProcessor(registry, def, COMMON_ANNOTATION_PROCESSOR_BEAN_NAME));
    }

    // 6.如果支持jpa,注册PersistenceAnnotationBeanPostProcessor
    if (jpaPresent && !registry.containsBeanDefinition(PERSISTENCE_ANNOTATION_PROCESSOR_BEAN_NAME)) {
        RootBeanDefinition def = new RootBeanDefinition();
        try {
            def.setBeanClass(ClassUtils.forName(PERSISTENCE_ANNOTATION_PROCESSOR_CLASS_NAME,
                                                AnnotationConfigUtils.class.getClassLoader()));
        }
        catch (ClassNotFoundException ex) {
            throw new IllegalStateException(
                "Cannot load optional framework class: " + PERSISTENCE_ANNOTATION_PROCESSOR_CLASS_NAME, ex);
        }
        def.setSource(source);
        beanDefs.add(registerPostProcessor(registry, def, PERSISTENCE_ANNOTATION_PROCESSOR_BEAN_NAME));
    }
 
    // 7.注册EventListenerMethodProcessor，用于处理@EventListener注解
    if (!registry.containsBeanDefinition(EVENT_LISTENER_PROCESSOR_BEAN_NAME)) {
        RootBeanDefinition def = new RootBeanDefinition(EventListenerMethodProcessor.class);
        def.setSource(source);
        beanDefs.add(registerPostProcessor(registry, def, EVENT_LISTENER_PROCESSOR_BEAN_NAME));
    }
 
    // 8.注册DefaultEventListenerFactory，用于将@EventListener所标注的方法转换成EventListener对象
    if (!registry.containsBeanDefinition(EVENT_LISTENER_FACTORY_BEAN_NAME)) {
        RootBeanDefinition def = new RootBeanDefinition(DefaultEventListenerFactory.class);
        def.setSource(source);
        beanDefs.add(registerPostProcessor(registry, def, EVENT_LISTENER_FACTORY_BEAN_NAME));
    }

    return beanDefs;
}

上面这段代码，主要做了8件事，接下来我们就详细看看

指定容器使用的比较器，通过这个比较器能够解析@Order注解以及Ordered接口


指定容器中使用的比较器为AnnotationAwareOrderComparator,这个比较器继承了OrderComparator。
OrderComparator自身提供了对Ordered接口的处理功能，而AnnotationAwareOrderComparator进一步做了扩展，除了会处理Ordered接口外还会处理@Order注解，但是接口的优先级高于注解。
”

指定容器使用的AutowireCandidateResolver


参考我之前的文章：Spring中的AutowireCandidateResolver
这个类主要是在依赖注入期间起作用
判断一个bean的类型是否符合依赖的条件
处理@Vlaue注解
处理@Qualifier注解
处理@Lazy注解为延迟注入的依赖生成代理
”

注册ConfigurationClassPostProcessor


这个类是Spring启动过程中非常重要的一个后置处理器，它完成了对配置类的解析，并根据配置类上的配置信息去进行扫描并将扫描得到的bd注册到容器中，之后又会去解析注册到容器中的bd（因为在前一次扫描中可能会注册新的配置类），重复上面的操作确保所有的配置类都被解析处理完成。
这个类的源码之后单独用一篇文章分析，本文就不过多介绍了。
只要记住一点，Spring在构建Reader对象时就已经将这个后置处理器添加到容器中了，这个后置处理器属于“开天辟地”的那一类Bean
”


这个后置处理器主要工作于依赖注入阶段，专门用于处理@Autowired注解
”

如果支持JSR-250，注册CommonAnnotationBeanPostProcessor


这个后置处理器也是工作于依赖注入阶段，专门用于处理@Inject注解
”

如果支持jpa,注册PersistenceAnnotationBeanPostProcessor


提供了JPA的支持，不是重点，了解即可
”


在Spring完成Bean的创建后，会调用这个处理器的afterSingletonsInstantiated,在这个方法中会完成@EventListener注解的解析，将所有的@EventListener注解标注的方法通过后面注册的DefaultEventListenerFactory转换成为ApplicationListener并注册到容器中
”