IOC 启动流程
初始化12步骤
容器创建会进入 refresh 方法，总共 12 个步骤
// org.springframework.context.support.AbstractApplicationContext#refresh
@Override
public void refresh() throws BeansException, IllegalStateException {
synchronized (this.startupShutdownMonitor) {
StartupStep contextRefresh = this.applicationStartup.start("spring.context.refresh");
// 步骤一：准备阶段
prepareRefresh();
// 步骤二：获得一个 BeanFactory（bean 定义信息在这一步会保存好）
ConfigurableListableBeanFactory beanFactory = obtainFreshBeanFactory();
// 步骤三：给 BeanFactory 赋能
prepareBeanFactory(beanFactory);
try {
// 步骤四：扩展 BeanFactory（这是个钩子方法，目的是留给子类的，子类可根据需要再次赋予 BeanFactory 更多能力）
postProcessBeanFactory(beanFactory);
StartupStep beanPostProcess = this.applicationStartup.start("spring.context.beans.post-process");
// 步骤五：执行 BeanFactoryProPercessor
invokeBeanFactoryPostProcessors(beanFactory);
// Register bean processors that intercept bean creation.
registerBeanPostProcessors(beanFactory);
beanPostProcess.end();
// Initialize message source for this context.
initMessageSource();
// Initialize event multicaster for this context.
initApplicationEventMulticaster();
// Initialize other special beans in specific context subclasses.
onRefresh();
// Check for listener beans and register them.
registerListeners();
// Instantiate all remaining (non-lazy-init) singletons.
finishBeanFactoryInitialization(beanFactory);
// Last step: publish corresponding event.
finishRefresh();
}
...
}
}
步骤1：准备容器
// org.springframework.context.support.AbstractApplicationContext#prepareRefresh
protected void prepareRefresh() {
// 计时
this.startupDate = System.currentTimeMillis();
this.closed.set(false);
this.active.set(true);
// 这是一个模板方法，子类复写自定义配置 spring 信息，MVC、Boot、Cloud 等很多框架都复写过
initPropertySources();
// 必要参数验证
getEnvironment().validateRequiredProperties();
// 初始化事件监听器和事件，都置为空列表
if (this.earlyApplicationListeners == null) {
this.earlyApplicationListeners = new LinkedHashSet<>(this.applicationListeners);
}
else {
this.applicationListeners.clear();
this.applicationListeners.addAll(this.earlyApplicationListeners);
}
this.earlyApplicationEvents = new LinkedHashSet<>();
}
步骤2：获得 BeanFactory
- 产生一个新鲜的 BeanFactory
- 保存好 bean 定义信息
ApplicationContext 一般叫容器，BeanFactory 是真正保存 bean 的地方
// org.springframework.context.support.AbstractApplicationContext#obtainFreshBeanFactory
protected ConfigurableListableBeanFactory obtainFreshBeanFactory() {
refreshBeanFactory();
return getBeanFactory();
}
// org.springframework.context.support.AbstractRefreshableApplicationContext#refreshBeanFactory
@Override
protected final void refreshBeanFactory() throws BeansException {
if (hasBeanFactory()) {
destroyBeans();
closeBeanFactory();
}
try {
DefaultListableBeanFactory beanFactory = createBeanFactory();
beanFactory.setSerializationId(getId());
customizeBeanFactory(beanFactory);
// 这里会把 bean 定义信息准备好
loadBeanDefinitions(beanFactory);
this.beanFactory = beanFactory;
}
catch (IOException ex) {
throw new ApplicationContextException("I/O error parsing bean definition source for " + getDisplayName(), ex);
}
}
步骤3：初始化 BeanFactory
上一步刚初始化了 BeanFactory，还没什么能力，这一步是配置 BeanFactory 的属性，让其具有处理某些动作的能力
当遇到相关动作，就会使用这里赋予的能力，所以这里代码比较简单，就是给不同属性赋值
- 比如 addBeanPostProcessor 给 BeanFactory 添加了一些后置处理器
- 加入到 beanPostProcessors 属性中
- 比如 SPEL 解析器，各种 Aware 回调处理器
- 比如 ignoreDependencyInterface 忽略了一些自动装配的类
- 加入到 ignoredDependencyInterfaces 属性中
- 1，这些接口的实现类的属性@Autowired 不生效（不能注入别的 bean）
- 2，别的 bean 里也使用 @Autowired 给属性赋值也不生效（不能被别的 bean 注入）
- 比如 registerResolvableDependency 提前放入一些可能需要别的依赖的 bean
- 是加入到 resolvableDependencies 属性中
- 这一步是为了提升效率的，如果不提前放，后面找到这些 bean 也会放进去（事先就放进去）
// org.springframework.context.support.AbstractApplicationContext#prepareBeanFactory
protected void prepareBeanFactory(ConfigurableListableBeanFactory beanFactory) {
// 类加载器
beanFactory.setBeanClassLoader(getClassLoader());
// 是否不解析 SPEL，spring.spel.ignore 配置项来控制
if (!shouldIgnoreSpel) {
// StandardBeanExpressionResolver：SPEL 表达式解析器
beanFactory.setBeanExpressionResolver(new StandardBeanExpressionResolver(beanFactory.getBeanClassLoader()));
}
// ResourceEditorRegistrar：用于把配置文件转成一个 Resource 对象
beanFactory.addPropertyEditorRegistrar(new ResourceEditorRegistrar(this, getEnvironment()));
// 添加后置处理器，如果有 bean 实现了 ApplicationContextAware，BeanFactory 使用 ApplicationContextAwareProcessor 去处理
beanFactory.addBeanPostProcessor(new ApplicationContextAwareProcessor(this));
// 忽略一些自动装配
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.ignoreDependencyInterface(ApplicationStartupAware.class);
// 这些注册为 bean，比如可以直接 @Autorired BeanFactory beanFactory 来注入 BeanFactory
beanFactory.registerResolvableDependency(BeanFactory.class, beanFactory);
beanFactory.registerResolvableDependency(ResourceLoader.class, this);
beanFactory.registerResolvableDependency(ApplicationEventPublisher.class, this);
beanFactory.registerResolvableDependency(ApplicationContext.class, this);
// 添加后置处理器，让 BeanFactory 可以处理时间发布与监听
beanFactory.addBeanPostProcessor(new ApplicationListenerDetector(this));
// GraalVM 支持，java 虚拟机一般都是 hotspot VM
if (!NativeDetector.inNativeImage() && beanFactory.containsBean(LOAD_TIME_WEAVER_BEAN_NAME)) {
beanFactory.addBeanPostProcessor(new LoadTimeWeaverAwareProcessor(beanFactory));
beanFactory.setTempClassLoader(new ContextTypeMatchClassLoader(beanFactory.getBeanClassLoader()));
}
// 再实现注册一些默认的 bean
if (!beanFactory.containsLocalBean(ENVIRONMENT_BEAN_NAME)) {
beanFactory.registerSingleton(ENVIRONMENT_BEAN_NAME, getEnvironment());
}
if (!beanFactory.containsLocalBean(SYSTEM_PROPERTIES_BEAN_NAME)) {
beanFactory.registerSingleton(SYSTEM_PROPERTIES_BEAN_NAME, getEnvironment().getSystemProperties());
}
if (!beanFactory.containsLocalBean(SYSTEM_ENVIRONMENT_BEAN_NAME)) {
beanFactory.registerSingleton(SYSTEM_ENVIRONMENT_BEAN_NAME, getEnvironment().getSystemEnvironment());
}
if (!beanFactory.containsLocalBean(APPLICATION_STARTUP_BEAN_NAME)) {
beanFactory.registerSingleton(APPLICATION_STARTUP_BEAN_NAME, getApplicationStartup());
}
}
步骤4：扩展 BeanFactory
上一步已经赋能了，这里再次赋能，这是一个钩子方法，没有实现，所以专门提供给子类的
比如 SpringMVC 扩展后我们标注 @Controller 就会把这个 bean 注入到容器中
步骤5：执行 BeanFactoryPostProcesser
步骤 3 给 BeanFactory 放入了一批后置处理器，这一步就是要执行他们
// org.springframework.context.support.AbstractApplicationContext#invokeBeanFactoryPostProcessors
protected void invokeBeanFactoryPostProcessors(ConfigurableListableBeanFactory beanFactory) {
// this.getBeanFactoryPostProcessors() 就是获取所有 bean 工厂后置处理器，此时是空的 invokeBeanFactoryPostProcessors 会去找
// invokeBeanFactoryPostProcessors 首先找到所有实现了 BeanFactoryPostProcessor 接口的 bean，然后挨个调用其 postProcessBeanFactory 方法
// BeanFactoryPostProcessor 干嘛的？修改 bean 定义的，在创建前对 bean 定义做一些修改，后续根据修改后的定义来创建 bean
PostProcessorRegistrationDelegate.invokeBeanFactoryPostProcessors(beanFactory, this.getBeanFactoryPostProcessors());
// GraalVM 支持
if (!NativeDetector.inNativeImage() && beanFactory.getTempClassLoader() == null && beanFactory.containsBean("loadTimeWeaver")) {
beanFactory.addBeanPostProcessor(new LoadTimeWeaverAwareProcessor(beanFactory));
beanFactory.setTempClassLoader(new ContextTypeMatchClassLoader(beanFactory.getBeanClassLoader()));
}
}
// org.springframework.context.support.PostProcessorRegistrationDelegate#invokeBeanFactoryPostProcessors(org.springframework.beans.factory.config.ConfigurableListableBeanFactory, java.util.List<org.springframework.beans.factory.config.BeanFactoryPostProcessor>)
public static void invokeBeanFactoryPostProcessors(
ConfigurableListableBeanFactory beanFactory, List<BeanFactoryPostProcessor> beanFactoryPostProcessors) {
...
List<BeanFactoryPostProcessor> priorityOrderedPostProcessors = new ArrayList<>();
List<String> orderedPostProcessorNames = new ArrayList<>();
List<String> nonOrderedPostProcessorNames = new ArrayList<>();
for (String ppName : postProcessorNames) {
if (processedBeans.contains(ppName)) {
// skip - already processed in first phase above
}
else if (beanFactory.isTypeMatch(ppName, PriorityOrdered.class)) {
// 找到所有实现了 BeanFactoryPostProcessor 的类
priorityOrderedPostProcessors.add(beanFactory.getBean(ppName, BeanFactoryPostProcessor.class));
}
else if (beanFactory.isTypeMatch(ppName, Ordered.class)) {
orderedPostProcessorNames.add(ppName);
}
else {
nonOrderedPostProcessorNames.add(ppName);
}
}
...
}