SpringBoot启动流程分析（三）：SpringApplication的run方法之prepareContext()方法

SpringBoot系列文章简介

SpringBoot源码阅读辅助篇：

　　Spring IoC容器与应用上下文的设计与实现

SpringBoot启动流程源码分析：

1. SpringBoot启动流程分析（一）：SpringApplication类初始化过程
2. SpringBoot启动流程分析（二）：SpringApplication的run方法
3. SpringBoot启动流程分析（三）：SpringApplication的run方法之prepareContext()方法
4. SpringBoot启动流程分析（四）：IoC容器的初始化过程
5. SpringBoot启动流程分析（五）：SpringBoot自动装配原理实现
6. SpringBoot启动流程分析（六）：IoC容器依赖注入

笔者注释版Spring Framework与SpringBoot源码git传送门：请不要吝啬小星星

1. spring-framework-5.0.8.RELEASE
2. SpringBoot-2.0.4.RELEASE

第四步：刷新应用上下文前的准备阶段

一、prepareContext()方法

　　前面我们介绍了SpringBoot 启动流程run()方法的前三步，本章，我们将用一个章节介绍：第四步：刷新应用上下文前的准备阶段。也就是prepareContext()方法。

　　首先看prepareContext()方法。

 private void prepareContext(ConfigurableApplicationContext context,
                             ConfigurableEnvironment environment, SpringApplicationRunListeners listeners,
                             ApplicationArguments applicationArguments, Banner printedBanner) {
     //设置容器环境
     context.setEnvironment(environment);
     //执行容器后置处理
     postProcessApplicationContext(context);
     //执行容器中的 ApplicationContextInitializer 包括spring.factories和通过三种方式自定义的
     applyInitializers(context);
     //向各个监听器发送容器已经准备好的事件
     listeners.contextPrepared(context);
     if (this.logStartupInfo) {
         logStartupInfo(context.getParent() == null);
         logStartupProfileInfo(context);
     }

     // Add boot specific singleton beans
     //将main函数中的args参数封装成单例Bean，注册进容器
     context.getBeanFactory().registerSingleton("springApplicationArguments",
             applicationArguments);
     //将 printedBanner 也封装成单例，注册进容器
     if (printedBanner != null) {
         context.getBeanFactory().registerSingleton("springBootBanner", printedBanner);
     }

     // Load the sources
     Set<Object> sources = getAllSources();
     Assert.notEmpty(sources, "Sources must not be empty");
     //加载我们的启动类，将启动类注入容器
     load(context, sources.toArray(new Object[0]));
     //发布容器已加载事件
     listeners.contextLoaded(context);
 }

　　首先看这行 Set<Object> sources = getAllSources(); 在getAllSources()中拿到了我们的启动类。　　

　　我们本文重点讲解这行 load(context, sources.toArray(new Object[0])); ，其他的方法请参阅注释。

　　跟进load()方法，看源码

 protected void load(ApplicationContext context, Object[] sources) {
     if (logger.isDebugEnabled()) {
         logger.debug(
                 "Loading source " + StringUtils.arrayToCommaDelimitedString(sources));
     }
     //创建 BeanDefinitionLoader
     BeanDefinitionLoader loader = createBeanDefinitionLoader(
             getBeanDefinitionRegistry(context), sources);
     if (this.beanNameGenerator != null) {
         loader.setBeanNameGenerator(this.beanNameGenerator);
     }
     if (this.resourceLoader != null) {
         loader.setResourceLoader(this.resourceLoader);
     }
     if (this.environment != null) {
         loader.setEnvironment(this.environment);
     }
     loader.load();
 }

1.1、getBeanDefinitionRegistry()

　　继续看getBeanDefinitionRegistry()方法的源码

 private BeanDefinitionRegistry getBeanDefinitionRegistry(ApplicationContext context) {
     if (context instanceof BeanDefinitionRegistry) {
         return (BeanDefinitionRegistry) context;
     }
     ...
 }

　　这里将我们前文创建的上下文强转为BeanDefinitionRegistry，是不是很熟悉，前面的文章中咱们也介绍过，他们之间是有继承关系的。BeanDefinitionRegistry定义了很重要的方法registerBeanDefinition()，该方法将BeanDefinition注册进DefaultListableBeanFactory容器的beanDefinitionMap中。

1.2、createBeanDefinitionLoader()

　　继续看createBeanDefinitionLoader()方法，最终进入了BeanDefinitionLoader类的构造方法，如下

 BeanDefinitionLoader(BeanDefinitionRegistry registry, Object... sources) {
     Assert.notNull(registry, "Registry must not be null");
     Assert.notEmpty(sources, "Sources must not be empty");
     this.sources = sources;
     //注解形式的Bean定义读取器 比如：@Configuration @Bean @Component @Controller @Service等等
     this.annotatedReader = new AnnotatedBeanDefinitionReader(registry);
     //XML形式的Bean定义读取器
     this.xmlReader = new XmlBeanDefinitionReader(registry);
     if (isGroovyPresent()) {
         this.groovyReader = new GroovyBeanDefinitionReader(registry);
     }
     //类路径扫描器
     this.scanner = new ClassPathBeanDefinitionScanner(registry);
     //扫描器添加排除过滤器
     this.scanner.addExcludeFilter(new ClassExcludeFilter(sources));
 }

　　先记住上面的三个属性，具体有什么用，先看看注释。前面的文章，我们说过，IoC容器的初始化分为三个步骤，上面三个属性在，BeanDefinition的Resource定位，和BeanDefinition的注册中起到了很重要的作用。

1.3、loader.load();

　　跟进load()方法

 private int load(Object source) {
     Assert.notNull(source, "Source must not be null");
     // 从Class加载
     if (source instanceof Class<?>) {
         return load((Class<?>) source);
     }
     // 从Resource加载
     if (source instanceof Resource) {
         return load((Resource) source);
     }
     // 从Package加载
     if (source instanceof Package) {
         return load((Package) source);
     }
     // 从 CharSequence 加载 ？？？
     if (source instanceof CharSequence) {
         return load((CharSequence) source);
     }
     throw new IllegalArgumentException("Invalid source type " + source.getClass());
 }

　　当前我们的主类会按Class加载。

　　继续跟进load()方法。

 private int load(Class<?> source) {
     if (isGroovyPresent()
             && GroovyBeanDefinitionSource.class.isAssignableFrom(source)) {
         // Any GroovyLoaders added in beans{} DSL can contribute beans here
         GroovyBeanDefinitionSource loader = BeanUtils.instantiateClass(source,
                 GroovyBeanDefinitionSource.class);
         load(loader);
     }
     if (isComponent(source)) {
         //将 启动类的 BeanDefinition注册进 beanDefinitionMap
         this.annotatedReader.register(source);
         return 1;
     }
     return 0;
 }

　　isComponent(source)判断主类是不是存在@Component注解，主类@SpringBootApplication是一个组合注解（后面讲解自动装配会讲解<SpringBoot启动流程分析（五）：SpringBoot自动装配原理实现>），包含@Component。

　　this.annotatedReader.register(source);跟进register()方法，最终进到AnnotatedBeanDefinitionReader类的doRegisterBean()方法。

 <T> void doRegisterBean(Class<T> annotatedClass, @Nullable Supplier<T> instanceSupplier, @Nullable String name,
         @Nullable Class<? extends Annotation>[] qualifiers, BeanDefinitionCustomizer... definitionCustomizers) {

     //将指定的类 封装为AnnotatedGenericBeanDefinition
     AnnotatedGenericBeanDefinition abd = new AnnotatedGenericBeanDefinition(annotatedClass);
     if (this.conditionEvaluator.shouldSkip(abd.getMetadata())) {
         return;
     }

     abd.setInstanceSupplier(instanceSupplier);
     // 获取该类的 scope 属性
     ScopeMetadata scopeMetadata = this.scopeMetadataResolver.resolveScopeMetadata(abd);
     abd.setScope(scopeMetadata.getScopeName());
     String beanName = (name != null ? name : this.beanNameGenerator.generateBeanName(abd, this.registry));

     AnnotationConfigUtils.processCommonDefinitionAnnotations(abd);
     if (qualifiers != null) {
         for (Class<? extends Annotation> qualifier : qualifiers) {
             if (Primary.class == qualifier) {
                 abd.setPrimary(true);
             }
             else if (Lazy.class == qualifier) {
                 abd.setLazyInit(true);
             }
             else {
                 abd.addQualifier(new AutowireCandidateQualifier(qualifier));
             }
         }
     }
     for (BeanDefinitionCustomizer customizer : definitionCustomizers) {
         customizer.customize(abd);
     }

     BeanDefinitionHolder definitionHolder = new BeanDefinitionHolder(abd, beanName);
     definitionHolder = AnnotationConfigUtils.applyScopedProxyMode(scopeMetadata, definitionHolder, this.registry);
     // 将该BeanDefinition注册到IoC容器的beanDefinitionMap中
     BeanDefinitionReaderUtils.registerBeanDefinition(definitionHolder, this.registry);
 }

　　在该方法中将主类封装成AnnotatedGenericBeanDefinition

　　BeanDefinitionReaderUtils.registerBeanDefinition(definitionHolder, this.registry);方法将BeanDefinition注册进beanDefinitionMap

 public static void registerBeanDefinition(
         BeanDefinitionHolder definitionHolder, BeanDefinitionRegistry registry)
         throws BeanDefinitionStoreException {
     // Register bean definition under primary name.
     // primary name 其实就是id吧
     String beanName = definitionHolder.getBeanName();
     registry.registerBeanDefinition(beanName, definitionHolder.getBeanDefinition());
     // Register aliases for bean name, if any.
     // 然后就是注册别名
     String[] aliases = definitionHolder.getAliases();
     if (aliases != null) {
         for (String alias : aliases) {
             registry.registerAlias(beanName, alias);
         }
     }
 }

　　继续跟进registerBeanDefinition()方法。

 @Override
 public void registerBeanDefinition(String beanName, BeanDefinition beanDefinition)
         throws BeanDefinitionStoreException {

     Assert.hasText(beanName, "Bean name must not be empty");
     Assert.notNull(beanDefinition, "BeanDefinition must not be null");

     if (beanDefinition instanceof AbstractBeanDefinition) {
         try {
             // 最后一次校验了
             // 对bean的Overrides进行校验，还不知道会在哪处理这些overrides
             ((AbstractBeanDefinition) beanDefinition).validate();
         } catch (BeanDefinitionValidationException ex) {
             throw new BeanDefinitionStoreException(beanDefinition.getResourceDescription(), beanName,
                     "Validation of bean definition failed", ex);
         }
     }
     // 判断是否存在重复名字的bean，之后看允不允许override
     // 以前使用synchronized实现互斥访问，现在采用ConcurrentHashMap
     BeanDefinition existingDefinition = this.beanDefinitionMap.get(beanName);
     if (existingDefinition != null) {
         //如果该类不允许 Overriding 直接抛出异常
         if (!isAllowBeanDefinitionOverriding()) {
             throw new BeanDefinitionStoreException(beanDefinition.getResourceDescription(), beanName,
                     "Cannot register bean definition [" + beanDefinition + "] for bean '" + beanName +
                             "': There is already [" + existingDefinition + "] bound.");
         } else if (existingDefinition.getRole() < beanDefinition.getRole()) {
             // e.g. was ROLE_APPLICATION, now overriding with ROLE_SUPPORT or ROLE_INFRASTRUCTURE
             if (logger.isWarnEnabled()) {
                 logger.warn("Overriding user-defined bean definition for bean '" + beanName +
                         "' with a framework-generated bean definition: replacing [" +
                         existingDefinition + "] with [" + beanDefinition + "]");
             }
         } else if (!beanDefinition.equals(existingDefinition)) {
             if (logger.isInfoEnabled()) {
                 logger.info("Overriding bean definition for bean '" + beanName +
                         "' with a different definition: replacing [" + existingDefinition +
                         "] with [" + beanDefinition + "]");
             }
         } else {
             if (logger.isDebugEnabled()) {
                 logger.debug("Overriding bean definition for bean '" + beanName +
                         "' with an equivalent definition: replacing [" + existingDefinition +
                         "] with [" + beanDefinition + "]");
             }
         }
         //注册进beanDefinitionMap
         this.beanDefinitionMap.put(beanName, beanDefinition);
     } else {
         if (hasBeanCreationStarted()) {
             // Cannot modify startup-time collection elements anymore (for stable iteration)
             synchronized (this.beanDefinitionMap) {
                 this.beanDefinitionMap.put(beanName, beanDefinition);
                 List<String> updatedDefinitions = new ArrayList<>(this.beanDefinitionNames.size() + 1);
                 updatedDefinitions.addAll(this.beanDefinitionNames);
                 updatedDefinitions.add(beanName);
                 this.beanDefinitionNames = updatedDefinitions;
                 if (this.manualSingletonNames.contains(beanName)) {
                     Set<String> updatedSingletons = new LinkedHashSet<>(this.manualSingletonNames);
                     updatedSingletons.remove(beanName);
                     this.manualSingletonNames = updatedSingletons;
                 }
             }
         } else {
             // Still in startup registration phase
             //如果仍处于启动注册阶段，注册进beanDefinitionMap
             this.beanDefinitionMap.put(beanName, beanDefinition);
             this.beanDefinitionNames.add(beanName);
             this.manualSingletonNames.remove(beanName);
         }
         this.frozenBeanDefinitionNames = null;
     }

     if (existingDefinition != null || containsSingleton(beanName)) {
         resetBeanDefinition(beanName);
     }
 }

　　最终来到DefaultListableBeanFactory类的registerBeanDefinition()方法，DefaultListableBeanFactory类还熟悉吗？相信大家一定非常熟悉这个类了。DefaultListableBeanFactory是IoC容器的具体产品。

　　仔细看这个方法registerBeanDefinition()，首先会检查是否已经存在，如果存在并且不允许被覆盖则直接抛出异常。不存在的话就直接注册进beanDefinitionMap中。

　　debug跳过prepareContext()方法，可以看到，启动类的BeanDefinition已经注册进来了。

　　OK，到这里启动流程的第五步就算讲完了，其实在这没必要讲这么细，因为启动类BeanDefinition的注册流程和后面我们自定义的BeanDefinition的注册流程是一样的。这先介绍一遍这个流程，后面熟悉了这个流程就好理解了。后面马上就到最最最重要的refresh()方法了。

　　

　　

　　原创不易，转载请注明出处。

　　如有错误的地方还请留言指正。