Springboot启动核心代码
1. run
public ConfigurableApplicationContext run(String... args) {
StopWatch stopWatch = new StopWatch(); // 创建一个计时器
stopWatch.start(); // 开始计时
ConfigurableApplicationContext context = null; // 初始化Spring上下文
FailureAnalyzers analyzers = null; // 初始化错误分析器
this.configureHeadlessProperty(); // 配置无头属性
SpringApplicationRunListeners listeners = this.getRunListeners(args); // 获取Spring应用运行监听器
listeners.starting(); // 通知监听器，应用正在启动
try {
ApplicationArguments applicationArguments = new DefaultApplicationArguments(args); // 解析应用参数
ConfigurableEnvironment environment = this.prepareEnvironment(listeners, applicationArguments); // 准备环境
Banner printedBanner = this.printBanner(environment); // 打印banner
context = this.createApplicationContext(); // 创建Spring上下文
new FailureAnalyzers(context); // 创建错误分析器
this.prepareContext(context, environment, listeners, applicationArguments, printedBanner); // 准备Spring上下文
// **********核心方法****************
this.refreshContext(context); // 刷新Spring上下文，加载bean等
this.afterRefresh(context, applicationArguments); // 刷新后的处理
listeners.finished(context, (Throwable)null); // 通知监听器，应用启动完成
stopWatch.stop(); // 停止计时
if (this.logStartupInfo) {
(new StartupInfoLogger(this.mainApplicationClass)).logStarted(this.getApplicationLog(), stopWatch); // 如果需要记录启动信息，则记录
}
return context; // 返回Spring上下文
} catch (Throwable var9) {
this.handleRunFailure(context, listeners, (FailureAnalyzers)analyzers, var9); // 处理启动失败
throw new IllegalStateException(var9); // 抛出异常
}
}
1.1 prepareContext
private void prepareContext(ConfigurableApplicationContext context, ConfigurableEnvironment environment, SpringApplicationRunListeners listeners, ApplicationArguments applicationArguments, Banner printedBanner) {
context.setEnvironment(environment); // 设置Spring上下文的环境
this.postProcessApplicationContext(context); // 对Spring上下文进行后处理
this.applyInitializers(context); // 应用初始化器
listeners.contextPrepared(context); // 通知监听器，Spring上下文已经准备好
if (this.logStartupInfo) { // 如果需要记录启动信息
this.logStartupInfo(context.getParent() == null); // 记录启动信息
this.logStartupProfileInfo(context); // 记录启动配置信息
}
// 将应用参数注册到Spring上下文中，以便后续使用
context.getBeanFactory().registerSingleton("springApplicationArguments", applicationArguments);
if (printedBanner != null) { // 如果有打印的banner
// 将banner注册到Spring上下文中，以便后续使用
context.getBeanFactory().registerSingleton("springBootBanner", printedBanner);
}
Set<Object> sources = this.getSources(); // 获取应用的源信息
Assert.notEmpty(sources, "Sources must not be empty"); // 检查源信息不能为空
this.load(context, sources.toArray(new Object[sources.size()])); // 加载应用的源信息
listeners.contextLoaded(context); // 通知监听器，Spring上下文已经加载完毕
}
1.1.1 postProcessApplicationContext
对beanName生成器和资源加载器进行处理
protected void postProcessApplicationContext(ConfigurableApplicationContext context) {
if (this.beanNameGenerator != null) { // 如果Bean名称生成器不为空
// 将Bean名称生成器注册到Spring上下文的BeanFactory中，Bean的名字为"org.springframework.context.annotation.internalConfigurationBeanNameGenerator"
context.getBeanFactory().registerSingleton("org.springframework.context.annotation.internalConfigurationBeanNameGenerator", this.beanNameGenerator);
}
if (this.resourceLoader != null) { // 如果资源加载器不为空
if (context instanceof GenericApplicationContext) { // 如果Spring上下文是GenericApplicationContext的实例
// 将资源加载器设置到Spring上下文中
((GenericApplicationContext)context).setResourceLoader(this.resourceLoader);
}
if (context instanceof DefaultResourceLoader) { // 如果Spring上下文是DefaultResourceLoader的实例
// 将资源加载器的类加载器设置到Spring上下文的资源加载器中
((DefaultResourceLoader)context).setClassLoader(this.resourceLoader.getClassLoader());
}
}
}
1.1.2 applyInitializers
protected void applyInitializers(ConfigurableApplicationContext context) {
Iterator var2 = this.getInitializers().iterator(); // 获取所有的初始化器
while(var2.hasNext()) { // 遍历所有的初始化器
ApplicationContextInitializer initializer = (ApplicationContextInitializer)var2.next(); // 获取下一个初始化器
// 获取初始化器的泛型参数类型
Class<?> requiredType = GenericTypeResolver.resolveTypeArgument(initializer.getClass(), ApplicationContextInitializer.class);
// 断言Spring上下文的类型是否与初始化器的泛型参数类型相同，如果不同则抛出异常
Assert.isInstanceOf(requiredType, context, "Unable to call initializer.");
initializer.initialize(context); // 调用初始化器的initialize方法对Spring上下文进行初始化
}
}
1.2 refreshContext
最终调用的是refresh方法
public void refresh() throws BeansException, IllegalStateException {
synchronized(this.startupShutdownMonitor) { // 同步代码块，保证线程安全
this.prepareRefresh(); // 准备刷新，设置Spring上下文的状态和初始化一些属性
ConfigurableListableBeanFactory beanFactory = this.obtainFreshBeanFactory(); // 获取新的BeanFactory
this.prepareBeanFactory(beanFactory); // 准备BeanFactory，设置类加载器，添加一些BeanPostProcessor
try {
this.postProcessBeanFactory(beanFactory); // 对BeanFactory进行后处理
this.invokeBeanFactoryPostProcessors(beanFactory); // 调用BeanFactory的后处理器
this.registerBeanPostProcessors(beanFactory); // 注册Bean的后处理器
this.initMessageSource(); // 初始化消息源
this.initApplicationEventMulticaster(); // 初始化应用事件多播器
// 在此过程中调用ServletWebServerApplicationContext.onRefresh()启动tomacat服务器
this.onRefresh(); // 自定义刷新行为（可以覆盖这个方法实现特殊bean的初始化）
this.registerListeners(); // 注册监听器
// ******实现SpringBean生命周期过程******
this.finishBeanFactoryInitialization(beanFactory); // 完成BeanFactory的初始化工作，包括实例化所有剩余的（非lazy-init）单例
this.finishRefresh(); // 完成刷新过程，通知生命周期处理器lifecycleProcessor刷新过程，同时发出ContextRefreshEvent通知其他监听者
} catch (BeansException var9) {
if (this.logger.isWarnEnabled()) {
this.logger.warn("Exception encountered during context initialization - cancelling refresh attempt: " + var9); // 如果在刷新过程中遇到异常，记录警告信息
}
this.destroyBeans(); // 销毁已创建的Bean
this.cancelRefresh(var9); // 取消刷新
throw var9; // 抛出异常
} finally {
this.resetCommonCaches(); // 重置Spring内部的一些公共缓存
}
}
}
1.2.1 prepareRefresh
protected void prepareRefresh() {
this.startupDate = System.currentTimeMillis(); // 记录当前时间作为启动时间
this.closed.set(false); // 设置Spring上下文为未关闭状态
this.active.set(true); // 设置Spring上下文为活动状态
if (this.logger.isInfoEnabled()) { // 如果日志级别为info级别
// 记录一条信息级别的日志，内容为"Refreshing " + 当前对象的toString()方法的结果
this.logger.info("Refreshing " + this);
}
this.initPropertySources(); // 初始化属性源
this.getEnvironment().validateRequiredProperties(); // 验证环境中必需的属性是否都存在
this.earlyApplicationEvents = new LinkedHashSet(); // 初始化早期的应用事件集合
}
这段代码的主要工作是对Spring上下文进行刷新准备，包括记录启动时间，设置Spring上下文的状态，记录日志，初始化属性源，验证环境中必需的属性，以及初始化早期的应用事件集合。
1.2.2 prepareBeanFactory
protected void prepareBeanFactory(ConfigurableListableBeanFactory beanFactory) {
beanFactory.setBeanClassLoader(this.getClassLoader()); // 设置Bean的类加载器
// 设置Bean的表达式解析器
beanFactory.setBeanExpressionResolver(new StandardBeanExpressionResolver(beanFactory.getBeanClassLoader()));
// 添加一个属性编辑器注册器
beanFactory.addPropertyEditorRegistrar(new ResourceEditorRegistrar(this, this.getEnvironment()));
// 添加一个Bean后处理器
beanFactory.addBeanPostProcessor(new ApplicationContextAwareProcessor(this));
// 让BeanFactory忽略一些接口的自动装配
beanFactory.ignoreDependencyInterface(EnvironmentAware.class);
beanFactory.ignoreDependencyInterface(EmbeddedValueResolverAware.class);
beanFactory.ignoreDependencyInterface(ResourceLoaderAware.class);
beanFactory.ignoreDependencyInterface(ApplicationEventPublisherAware.class);
beanFactory.ignoreDependencyInterface(MessageSourceAware.class);
beanFactory.ignoreDependencyInterface(ApplicationContextAware.class);
// 注册一些可以解析的依赖
beanFactory.registerResolvableDependency(BeanFactory.class, beanFactory);
beanFactory.registerResolvableDependency(ResourceLoader.class, this);
beanFactory.registerResolvableDependency(ApplicationEventPublisher.class, this);
beanFactory.registerResolvableDependency(ApplicationContext.class, this);
// 添加一个Bean后处理器
beanFactory.addBeanPostProcessor(new ApplicationListenerDetector(this));
// 如果BeanFactory中包含名为"loadTimeWeaver"的Bean，则添加一个Bean后处理器，并设置临时类加载器
if (beanFactory.containsBean("loadTimeWeaver")) {
beanFactory.addBeanPostProcessor(new LoadTimeWeaverAwareProcessor(beanFactory));
beanFactory.setTempClassLoader(new ContextTypeMatchClassLoader(beanFactory.getBeanClassLoader()));
}
// 如果BeanFactory中不包含名为"environment"的Bean，则注册一个单例Bean
if (!beanFactory.containsLocalBean("environment")) {
beanFactory.registerSingleton("environment", this.getEnvironment());
}
// 如果BeanFactory中不包含名为"systemProperties"的Bean，则注册一个单例Bean
if (!beanFactory.containsLocalBean("systemProperties")) {
beanFactory.registerSingleton("systemProperties", this.getEnvironment().getSystemProperties());
}
// 如果BeanFactory中不包含名为"systemEnvironment"的Bean，则注册一个单例Bean
if (!beanFactory.containsLocalBean("systemEnvironment")) {
beanFactory.registerSingleton("systemEnvironment", this.getEnvironment().getSystemEnvironment());
}
}
这段代码的主要工作是对BeanFactory进行一些准备工作，包括设置Bean的类加载器和表达式解析器，添加属性编辑器注册器和Bean后处理器，让BeanFactory忽略一些接口的自动装配，注册一些可以解析的依赖，以及在特定情况下添加Bean后处理器、设置临时类加载器和注册单例Bean。
1.2.3 invokeBeanFactoryPostProcessors（自动装配过程在此完成）
public static void invokeBeanFactoryPostProcessors(
ConfigurableListableBeanFactory beanFactory, List<BeanFactoryPostProcessor> beanFactoryPostProcessors) {
// 创建一个集合来存储已经处理过的beans的名称
Set<String> processedBeans = new HashSet<String>();
// 判断beanFactory是否是BeanDefinitionRegistry类型的
if (beanFactory instanceof BeanDefinitionRegistry) {
BeanDefinitionRegistry registry = (BeanDefinitionRegistry) beanFactory;
List<BeanFactoryPostProcessor> regularPostProcessors = new LinkedList<BeanFactoryPostProcessor>();
List<BeanDefinitionRegistryPostProcessor> registryProcessors = new LinkedList<BeanDefinitionRegistryPostProcessor>();
// 遍历beanFactoryPostProcessors，对其中的每个后处理器进行操作
for (BeanFactoryPostProcessor postProcessor : beanFactoryPostProcessors) {
// 如果后处理器是BeanDefinitionRegistryPostProcessor类型的，调用其postProcessBeanDefinitionRegistry方法
// 并将其添加到registryProcessors列表中
if (postProcessor instanceof BeanDefinitionRegistryPostProcessor) {
BeanDefinitionRegistryPostProcessor registryProcessor =
(BeanDefinitionRegistryPostProcessor) postProcessor;
registryProcessor.postProcessBeanDefinitionRegistry(registry);
registryProcessors.add(registryProcessor);
}
// 如果后处理器不是BeanDefinitionRegistryPostProcessor类型的，将其添加到regularPostProcessors列表中
else {
regularPostProcessors.add(postProcessor);
}
}
// 创建一个列表来存储当前的BeanDefinitionRegistryPostProcessor
List<BeanDefinitionRegistryPostProcessor> currentRegistryProcessors = new ArrayList<BeanDefinitionRegistryPostProcessor>();
// 首先，调用实现了PriorityOrdered接口的BeanDefinitionRegistryPostProcessors
String[] postProcessorNames =
beanFactory.getBeanNamesForType(BeanDefinitionRegistryPostProcessor.class, true, false);
for (String ppName : postProcessorNames) {
if (beanFactory.isTypeMatch(ppName, PriorityOrdered.class)) {
currentRegistryProcessors.add(beanFactory.getBean(ppName, BeanDefinitionRegistryPostProcessor.class));
processedBeans.add(ppName);
}
}
sortPostProcessors(currentRegistryProcessors, beanFactory);
registryProcessors.addAll(currentRegistryProcessors);
invokeBeanDefinitionRegistryPostProcessors(currentRegistryProcessors, registry);
currentRegistryProcessors.clear();
// 接下来，调用实现了Ordered接口的BeanDefinitionRegistryPostProcessors
postProcessorNames = beanFactory.getBeanNamesForType(BeanDefinitionRegistryPostProcessor.class, true, false);
for (String ppName : postProcessorNames) {
if (!processedBeans.contains(ppName) && beanFactory.isTypeMatch(ppName, Ordered.class)) {
currentRegistryProcessors.add(beanFactory.getBean(ppName, BeanDefinitionRegistryPostProcessor.class));
processedBeans.add(ppName);
}
}
sortPostProcessors(currentRegistryProcessors, beanFactory);
registryProcessors.addAll(currentRegistryProcessors);
invokeBeanDefinitionRegistryPostProcessors(currentRegistryProcessors, registry);
currentRegistryProcessors.clear();
// 最后，调用所有其他的BeanDefinitionRegistryPostProcessors，直到没有新的出现
boolean reiterate = true;
while (reiterate) {
reiterate = false;
postProcessorNames = beanFactory.getBeanNamesForType(BeanDefinitionRegistryPostProcessor.class, true, false);
for (String ppName : postProcessorNames) {
if (!processedBeans.contains(ppName)) {
currentRegistryProcessors.add(beanFactory.getBean(ppName, BeanDefinitionRegistryPostProcessor.class));
processedBeans.add(ppName);
reiterate = true;
}
}
sortPostProcessors(currentRegistryProcessors, beanFactory);
registryProcessors.addAll(currentRegistryProcessors);
invokeBeanDefinitionRegistryPostProcessors(currentRegistryProcessors, registry);
currentRegistryProcessors.clear();
}
// 现在，调用所有处理器的postProcessBeanFactory回调方法
invokeBeanFactoryPostProcessors(registryProcessors, beanFactory);
invokeBeanFactoryPostProcessors(regularPostProcessors, beanFactory);
}
else {
// 如果beanFactory不是BeanDefinitionRegistry类型的，直接调用后处理器
invokeBeanFactoryPostProcessors(beanFactoryPostProcessors, beanFactory);
}
// 获取所有的BeanFactoryPostProcessor类型的bean的名称
String[] postProcessorNames =
beanFactory.getBeanNamesForType(BeanFactoryPostProcessor.class, true, false);
// 创建三个列表，分别用来存储实现了PriorityOrdered接口的后处理器，实现了Ordered接口的后处理器和其他后处理器
List<BeanFactoryPostProcessor> priorityOrderedPostProcessors = new ArrayList<BeanFactoryPostProcessor>();
List<String> orderedPostProcessorNames = new ArrayList<String>();
List<String> nonOrderedPostProcessorNames = new ArrayList<String>();
for (String ppName : postProcessorNames) {
if (processedBeans.contains(ppName)) {
// 如果后处理器已经被处理过，跳过
}
else if (beanFactory.isTypeMatch(ppName, PriorityOrdered.class)) {
priorityOrderedPostProcessors.add(beanFactory.getBean(ppName, BeanFactoryPostProcessor.class));
}
else if (beanFactory.isTypeMatch(ppName, Ordered.class)) {
orderedPostProcessorNames.add(ppName);
}
else {
nonOrderedPostProcessorNames.add(ppName);
}
}
// 首先，调用实现了PriorityOrdered接口的BeanFactoryPostProcessors
sortPostProcessors(priorityOrderedPostProcessors, beanFactory);
invokeBeanFactoryPostProcessors(priorityOrderedPostProcessors, beanFactory);
// 接下来，调用实现了Ordered接口的BeanFactoryPostProcessors
List<BeanFactoryPostProcessor> orderedPostProcessors = new ArrayList<BeanFactoryPostProcessor>();
for (String postProcessorName : orderedPostProcessorNames) {
orderedPostProcessors.add(beanFactory.getBean(postProcessorName, BeanFactoryPostProcessor.class));
}
sortPostProcessors(orderedPostProcessors, beanFactory);
invokeBeanFactoryPostProcessors(orderedPostProcessors, beanFactory);
// 最后，调用所有其他的BeanFactoryPostProcessors
List<BeanFactoryPostProcessor> nonOrderedPostProcessors = new ArrayList<BeanFactoryPostProcessor>();
for (String postProcessorName : nonOrderedPostProcessorNames) {
nonOrderedPostProcessors.add(beanFactory.getBean(postProcessorName, BeanFactoryPostProcessor.class));
}
invokeBeanFactoryPostProcessors(nonOrderedPostProcessors, beanFactory);
// 清理元数据缓存
beanFactory.clearMetadataCache();
1.2.4 registerBeanPostProcessors
public static void registerBeanPostProcessors(
ConfigurableListableBeanFactory beanFactory, AbstractApplicationContext applicationContext) {
// 获取所有的BeanPostProcessor类型的bean的名称
String[] postProcessorNames = beanFactory.getBeanNamesForType(BeanPostProcessor.class, true, false);
// 注册BeanPostProcessorChecker，当一个bean在BeanPostProcessor实例化期间被创建时，它会记录一个信息消息
// 也就是说，当一个bean不适合被所有的BeanPostProcessors处理时
int beanProcessorTargetCount = beanFactory.getBeanPostProcessorCount() + 1 + postProcessorNames.length;
beanFactory.addBeanPostProcessor(new BeanPostProcessorChecker(beanFactory, beanProcessorTargetCount));
// 区分实现了PriorityOrdered接口的BeanPostProcessors，实现了Ordered接口的BeanPostProcessors，以及其他的BeanPostProcessors
List<BeanPostProcessor> priorityOrderedPostProcessors = new ArrayList<BeanPostProcessor>();
List<BeanPostProcessor> internalPostProcessors = new ArrayList<BeanPostProcessor>();
List<String> orderedPostProcessorNames = new ArrayList<String>();
List<String> nonOrderedPostProcessorNames = new ArrayList<String>();
for (String ppName : postProcessorNames) {
if (beanFactory.isTypeMatch(ppName, PriorityOrdered.class)) {
BeanPostProcessor pp = beanFactory.getBean(ppName, BeanPostProcessor.class);
priorityOrderedPostProcessors.add(pp);
if (pp instanceof MergedBeanDefinitionPostProcessor) {
internalPostProcessors.add(pp);
}
}
else if (beanFactory.isTypeMatch(ppName, Ordered.class)) {
orderedPostProcessorNames.add(ppName);
}
else {
nonOrderedPostProcessorNames.add(ppName);
}
}
// 首先，注册实现了PriorityOrdered接口的BeanPostProcessors
sortPostProcessors(priorityOrderedPostProcessors, beanFactory);
registerBeanPostProcessors(beanFactory, priorityOrderedPostProcessors);
// 接下来，注册实现了Ordered接口的BeanPostProcessors
List<BeanPostProcessor> orderedPostProcessors = new ArrayList<BeanPostProcessor>();
for (String ppName : orderedPostProcessorNames) {
BeanPostProcessor pp = beanFactory.getBean(ppName, BeanPostProcessor.class);
orderedPostProcessors.add(pp);
if (pp instanceof MergedBeanDefinitionPostProcessor) {
internalPostProcessors.add(pp);
}
}
sortPostProcessors(orderedPostProcessors, beanFactory);
registerBeanPostProcessors(beanFactory, orderedPostProcessors);
// 现在，注册所有其他的BeanPostProcessors
List<BeanPostProcessor> nonOrderedPostProcessors = new ArrayList<BeanPostProcessor>();
for (String ppName : nonOrderedPostProcessorNames) {
BeanPostProcessor pp = beanFactory.getBean(ppName, BeanPostProcessor.class);
nonOrderedPostProcessors.add(pp);
if (pp instanceof MergedBeanDefinitionPostProcessor) {
internalPostProcessors.add(pp);
}
}
registerBeanPostProcessors(beanFactory, nonOrderedPostProcessors);
// 最后，重新注册所有的内部BeanPostProcessors
sortPostProcessors(internalPostProcessors, beanFactory);
registerBeanPostProcessors(beanFactory, internalPostProcessors);
// 重新注册用于检测内部beans作为ApplicationListeners的后处理器
// 将它移到处理器链的末端（用于获取代理等）
beanFactory.addBeanPostProcessor(new ApplicationListenerDetector(applicationContext));
}
1.2.5 initApplicationEventMulticaster
初始化应用事件多播器（Application Event Multicaster）是Spring框架中的一个重要步骤，它用于设置和配置Spring的事件发布机制。
在Spring中，事件处理是通过ApplicationEvent类和ApplicationListener接口来实现的。当我们在应用中需要进行事件驱动的开发时，就会用到这个机制。例如，可以在某个特定的业务流程完成后触发一个事件，这个事件会被发送到对应的监听器进行处理。
而应用事件多播器（Application Event Multicaster）就是这个事件发布机制的核心部分，它负责将事件（ApplicationEvent）广播给所有对该事件感兴趣的监听器（ApplicationListener）。初始化应用事件多播器就是在Spring的上下文中配置和设置这个事件多播器。
通过这个机制，我们可以将不同的业务逻辑解耦，使得代码更加模块化，更易于维护和扩展。
1.2.6 registerListeners
protected void registerListeners() {
// 首先注册静态指定的监听器
for (ApplicationListener<?> listener : getApplicationListeners()) {
getApplicationEventMulticaster().addApplicationListener(listener);
}
// 不在这里初始化FactoryBeans：我们需要保留所有常规beans未初始化，以便让后处理器应用到它们！
String[] listenerBeanNames = getBeanNamesForType(ApplicationListener.class, true, false);
for (String listenerBeanName : listenerBeanNames) {
getApplicationEventMulticaster().addApplicationListenerBean(listenerBeanName);
}
// 现在我们终于有了一个多播器，发布早期的应用事件...
Set<ApplicationEvent> earlyEventsToProcess = this.earlyApplicationEvents;
this.earlyApplicationEvents = null;
if (earlyEventsToProcess != null) {
for (ApplicationEvent earlyEvent : earlyEventsToProcess) {
getApplicationEventMulticaster().multicastEvent(earlyEvent);
}
}
}
这段代码的主要工作是注册监听器，包括注册静态指定的监听器，不在这里初始化FactoryBeans，以便让后处理器应用到它们，注册ApplicationListener类型的bean为监听器，以及发布早期的应用事件。
1.2.7 finishBeanFactoryInitialization（实现bean生命周期）
protected void finishBeanFactoryInitialization(ConfigurableListableBeanFactory beanFactory) {
// 如果beanFactory中包含名为"conversionService"的bean且其类型为ConversionService，
// 则将此bean设置为beanFactory的ConversionService
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));
}
// 如果beanFactory没有嵌入值解析器，为其添加一个默认的嵌入值解析器，
// 主要用于注解属性值的解析
if (!beanFactory.hasEmbeddedValueResolver()) {
beanFactory.addEmbeddedValueResolver(new StringValueResolver() {
@Override
public String resolveStringValue(String strVal) {
return getEnvironment().resolvePlaceholders(strVal);
}
});
}
// 初始化LoadTimeWeaverAware类型的bean，早期注册其转换器
String[] weaverAwareNames = beanFactory.getBeanNamesForType(LoadTimeWeaverAware.class, false, false);
for (String weaverAwareName : weaverAwareNames) {
getBean(weaverAwareName);
}
// 停止使用临时ClassLoader进行类型匹配
beanFactory.setTempClassLoader(null);
// 允许缓存所有bean定义元数据，不再期待进一步的改变
beanFactory.freezeConfiguration();
// 实例化所有剩余的（非懒加载）单例（*******bean生命周期实现******）
beanFactory.preInstantiateSingletons();
}
这段代码的主要工作是完成Bean工厂的初始化，包括设置转换服务，添加嵌入值解析器，初始化LoadTimeWeaverAware类型的bean，停止使用临时ClassLoader，冻结配置，以及预实例化单例。
1.2.8 finishRefresh
protected void finishRefresh() {
// 初始化此上下文的生命周期处理器
initLifecycleProcessor();
// 首先将刷新传播给生命周期处理器
getLifecycleProcessor().onRefresh();
// 发布最终事件
publishEvent(new ContextRefreshedEvent(this));
// 如果活动，参与LiveBeansView MBean
LiveBeansView.registerApplicationContext(this);
}
这段代码的主要工作是完成上下文的刷新，包括初始化生命周期处理器，将刷新传播给生命周期处理器，发布最终的上下文刷新事件，以及注册LiveBeansView MBean。
1.3 afterRefresh
afterRefresh方法中调用了callRunners方法，主要工作是调用运行器，包括获取所有的ApplicationRunner和CommandLineRunner类型的bean，将它们添加到运行器列表中，然后对列表进行排序，最后遍历列表，对每个运行器调用对应的callRunner方法
private void callRunners(ApplicationContext context, ApplicationArguments args) {
// 创建一个列表来存储所有的运行器
List<Object> runners = new ArrayList<Object>();
// 将所有的ApplicationRunner类型的bean添加到运行器列表中
runners.addAll(context.getBeansOfType(ApplicationRunner.class).values());
// 将所有的CommandLineRunner类型的bean添加到运行器列表中
runners.addAll(context.getBeansOfType(CommandLineRunner.class).values());
// 使用注解感知的顺序比较器对运行器列表进行排序
AnnotationAwareOrderComparator.sort(runners);
// 对运行器列表中的每一个运行器进行操作
for (Object runner : new LinkedHashSet<Object>(runners)) {
// 如果运行器是ApplicationRunner类型的，调用callRunner方法
if (runner instanceof ApplicationRunner) {
callRunner((ApplicationRunner) runner, args);
}
// 如果运行器是CommandLineRunner类型的，调用callRunner方法
if (runner instanceof CommandLineRunner) {
callRunner((CommandLineRunner) runner, args);
}
}
}
330
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
