springboot启动流程（六）ioc容器刷新前prepareContext
所有文章
https://www.cnblogs.com/lay2017/p/11478237.html
prepareContext方法核心逻辑
上一篇文章中，我们通过createApplicationContext方法创建了一个ApplicationContext的实例对象。本文将阅读一下在ApplicationContext在refresh之前的prepareContext中做了哪些事情。
我们跟进prepareContext方法
private void prepareContext( ConfigurableApplicationContext context, ConfigurableEnvironment environment, SpringApplicationRunListeners listeners, ApplicationArguments applicationArguments, Banner printedBanner ) { // 设置Environment context.setEnvironment(environment); // 后置处理 postProcessApplicationContext(context); // 调用ApplicationContextInitializer接口的实现 applyInitializers(context); // 发布ApplicationContext准备事件 listeners.contextPrepared(context); ConfigurableListableBeanFactory beanFactory = context.getBeanFactory(); // 注册args参数为单例bean beanFactory.registerSingleton("springApplicationArguments", applicationArguments); if (printedBanner != null) { // 注册banner为单例bean beanFactory.registerSingleton("springBootBanner", printedBanner); } if (beanFactory instanceof DefaultListableBeanFactory) { // 设置beanFactory中是否允许重复bean覆盖 ((DefaultListableBeanFactory) beanFactory).setAllowBeanDefinitionOverriding(this.allowBeanDefinitionOverriding); } // 加载main方法所在类 Set<Object> sources = getAllSources(); // 注册main方法所在类到beanFactory load(context, sources.toArray(new Object[0])); // 发布Context加载事件 listeners.contextLoaded(context); }
我们看到prepareContext方法主要逻辑包含了三块内容
1）基本的初始化，如设置Environment，调用ApplicationContextInitializer接口的实现类
2）注册现有的对象为单例bean，如args、banner
3）加载main方法所在的主类
load方法加载主类
很显然，加载main方法的主类是我们关注的重点。我们先看看getAllSources方法返回
public Set<Object> getAllSources() { Set<Object> allSources = new LinkedHashSet<>(); // 添加主类 if (!CollectionUtils.isEmpty(this.primarySources)) { allSources.addAll(this.primarySources); } // 添加附加资源类 if (!CollectionUtils.isEmpty(this.sources)) { allSources.addAll(this.sources); } return Collections.unmodifiableSet(allSources); }
primarySources是在SpringApplication初始化的时候设置的，而sources默认是没有的。所在getAllSoures方法将返回main方法所在的主类。
下面，我们跟进load方法，阅读一下加载main所在主类的逻辑
protected void load(ApplicationContext context, Object[] sources) { // 获取BeanDefinition加载器 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(); }
load方法中，先是获得了BeanDefinitionLoader，然后去加载资源。这里要注意！为什么是BeanDefinitionLoader呢？
首先，我们得知道Spring的bean资源来自各种地方，如xml、annotation等，那么这些bean在配置的时候也就是对bean进行定义，而这些定义映射到内存中的对象就是BeanDefinition的对象，Spring后续会根据BeanDefinition再获取具体的bean。
简单来说就是：配置 --> BeanDefinition --> Bean 这样一个逻辑
所以，后续我们会看到BeanDefinitionLoader会将主类加载成BeanDefinition，然后注册到ApplicationContext当中。
先跟进getBeanDefinitionRegistry方法，看看BeanDefinition会被注册到哪里去
private BeanDefinitionRegistry getBeanDefinitionRegistry(ApplicationContext context) { // 返回当前ApplicationContext if (context instanceof BeanDefinitionRegistry) { return (BeanDefinitionRegistry) context; } if (context instanceof AbstractApplicationContext) { return (BeanDefinitionRegistry) ((AbstractApplicationContext) context).getBeanFactory(); } throw new IllegalStateException("Could not locate BeanDefinitionRegistry"); }
我们注意，springboot的AnnotationConfigServletWebServerApplicationContext这个ApplicationContext的实现类，随着继承链路向上走是继承自GenericApplicationContext的，而GenericApplicationContext实现了BeanDefinitionRegistry。
所以，getBeanDefinitionRegistry将最终返回强转过的ApplicationContext。也就是说BeanDefinition将被注册到ApplicationContext里面。
回到load方法中，我们再跟进createBeanDefinitionLoader方法
protected BeanDefinitionLoader createBeanDefinitionLoader(BeanDefinitionRegistry registry, Object[] sources) { return new BeanDefinitionLoader(registry, sources); }
再跟进构造方法
BeanDefinitionLoader(BeanDefinitionRegistry registry, Object... sources) { this.sources = sources; // 注解方式的读取器 this.annotatedReader = new AnnotatedBeanDefinitionReader(registry); // xml方式的读取器 this.xmlReader = new XmlBeanDefinitionReader(registry); // 类路径下的扫描器 this.scanner = new ClassPathBeanDefinitionScanner(registry); // 扫描排除当前main方法的主类 this.scanner.addExcludeFilter(new ClassExcludeFilter(sources)); }
我们看到加载器支持注解、xml两种方式。类路径下的扫描器排除了当前的主类
回到load方法
protected void load(ApplicationContext context, Object[] sources) { // 获取BeanDefinition加载器 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(); }
此时，我们已经获取了BeanDefinitionLoader，下面调用该loader的load方法开始加载
跟进第二个load方法
public int load() { int count = 0; for (Object source : this.sources) { count += load(source); } return count; }
再跟进第三个load方法
private int load(Object source) { if (source instanceof Class<?>) { return load((Class<?>) source); } if (source instanceof Resource) { return load((Resource) source); } if (source instanceof Package) { return load((Package) source); } if (source instanceof CharSequence) { return load((CharSequence) source); } throw new IllegalArgumentException("Invalid source type " + source.getClass()); }
由于我们的主类是一个class，所以进入第一个if分支的load方法
继续跟进
private int load(Class<?> source) { // 省略 if (isComponent(source)) { this.annotatedReader.register(source); return 1; } return 0; }
该方法先通过isComponent方法判断了主类是不是被@Component注解，如果是，那么调用注解方式的阅读器，注册该资源。
跟进isComponent方法，看看怎么判断的
private boolean isComponent(Class<?> type) { // 找到是否匹配@Component注解 if (AnnotationUtils.findAnnotation(type, Component.class) != null) { return true; } // 省略 }
其实就是找这个类是否有@Component注解，但请注意我们通常都使用@SpringBootApplication这个注解，并没有直接注解@Component。而@SpringBootApplication是一个组合注解，其中就组合了@Component
而AnnotationUtils.findAnnotation方法将会递归遍历注解，最终找到@Component。
isComponent判断为true以后，我们再跟进annotationReader.register(source)阅读一下读取主类的过程
public void register(Class<?>... annotatedClasses) { for (Class<?> annotatedClass : annotatedClasses) { registerBean(annotatedClass); } }
继续跟进registerBean方法
public void registerBean(Class<?> annotatedClass) { doRegisterBean(annotatedClass, null, null, null); }
再跟进doRegisterBean方法，该方法比较长，我们省略掉一些次要的部分
<T> void doRegisterBean( Class<T> annotatedClass, @Nullable Supplier<T> instanceSupplier, @Nullable String name, @Nullable Class<? extends Annotation>[] qualifiers, BeanDefinitionCustomizer... definitionCustomizers ) { // 先包装成BeanDefinition AnnotatedGenericBeanDefinition abd = new AnnotatedGenericBeanDefinition(annotatedClass); // 解析scope元数据 ScopeMetadata scopeMetadata = this.scopeMetadataResolver.resolveScopeMetadata(abd); abd.setScope(scopeMetadata.getScopeName()); // 生成bean的名 String beanName = (name != null ? name : this.beanNameGenerator.generateBeanName(abd, this.registry)); // 解析一些常见的注解元数据 AnnotationConfigUtils.processCommonDefinitionAnnotations(abd); BeanDefinitionHolder definitionHolder = new BeanDefinitionHolder(abd, beanName); definitionHolder = AnnotationConfigUtils.applyScopedProxyMode(scopeMetadata, definitionHolder, this.registry); // 注册BeanDefinition到ApplicationContext BeanDefinitionReaderUtils.registerBeanDefinition(definitionHolder, this.registry); }
可以看到，doRegisterBean方法的主要逻辑就是包装并解析出一个BeanDefinition，然后调用registerBeanDefinition方法把BeanDefinition给注册到ApplicationContext中。
注册相关的本文就不再继续展开了，后续的文章会跟进这些内容。
总结
总的来说，prepareContext方法主要就是为了加载并注册主类的BeanDefinition到ApplicationContext。这里注意！我们一直都在说注册到ApplicationContext，但熟悉spring的都会知道无论是Bean还是BeanDefinition都是注册到BeanFactory中的。但我们一直没有严格区分它，后续的文章我们将会把ApplicationContext和BeanFactory进行区分。
