class AbstractApplicationContext {
refresh() {
synchronized (this.startupShutdownMonitor) {
// 准备刷新的前置处理
prepareRefresh();
{
// 初始化上下文环境中的任何占位符属性源,空实现
initPropertySources();
// 校验必须属性,如果不存在该属性,报错
// 就是当前环境对象中必须含有xx属性值
getEnvironment().validateRequiredProperties();
// 初始化需要提前处理的Listener集合
if (this.earlyApplicationListeners == null) {
this.earlyApplicationListeners = new LinkedHashSet<>(this.applicationListeners);
}
// 如果存在,重置这些Listener
else {
this.applicationListeners.clear();
this.applicationListeners.addAll(this.earlyApplicationListeners);
}
// 初始化需要提前发布的事件
// 这个变量是Spring框架自身负责管理和处理,用户无法正常操作这个变量
this.earlyApplicationEvents = new LinkedHashSet<>();
}
// 获取BeanFactory,并且校验不能重复刷新容器
ConfigurableListableBeanFactory beanFactory = obtainFreshBeanFactory();
// 初始化BeanFactory
prepareBeanFactory(beanFactory);
{
// 设置类加载器
beanFactory.setBeanClassLoader(getClassLoader());
// 设置Bean的表达式解析器
beanFactory.setBeanExpressionResolver(new StandardBeanExpressionResolver(beanFactory.getBeanClassLoader()));
// 添加属性的类型转换器
beanFactory.addPropertyEditorRegistrar(new ResourceEditorRegistrar(this, getEnvironment()));
// 添加处理Aware接口的BeanPostProcessor处理器
beanFactory.addBeanPostProcessor(new ApplicationContextAwareProcessor(this) {
private void invokeAwareInterfaces(Object bean) {
if (bean instanceof EnvironmentAware) {
((EnvironmentAware) bean).setEnvironment(this.applicationContext.getEnvironment());
}
if (bean instanceof EmbeddedValueResolverAware) {
((EmbeddedValueResolverAware) bean).setEmbeddedValueResolver(this.embeddedValueResolver);
}
if (bean instanceof ResourceLoaderAware) {
((ResourceLoaderAware) bean).setResourceLoader(this.applicationContext);
}
if (bean instanceof ApplicationEventPublisherAware) {
((ApplicationEventPublisherAware) bean).setApplicationEventPublisher(this.applicationContext);
}
if (bean instanceof MessageSourceAware) {
((MessageSourceAware) bean).setMessageSource(this.applicationContext);
}
if (bean instanceof ApplicationContextAware) {
((ApplicationContextAware) bean).setApplicationContext(this.applicationContext);
}
}
});
// 设置忽略成Bean的类型接口,也就是无法通过@Autowired注入这些接口
beanFactory.ignoreDependencyInterface(EnvironmentAware.class);
beanFactory.ignoreDependencyInterface(EmbeddedValueResolverAware.class);
beanFactory.ignoreDependencyInterface(ResourceLoaderAware.class);
beanFactory.ignoreDependencyInterface(ApplicationEventPublisherAware.class);
beanFactory.ignoreDependencyInterface(MessageSourceAware.class);
beanFactory.ignoreDependencyInterface(ApplicationContextAware.class);
// 设置可以解析的接口类型,也就是可以通过@Autowired注入这些接口
beanFactory.registerResolvableDependency(BeanFactory.class, beanFactory);
beanFactory.registerResolvableDependency(ResourceLoader.class, this);
beanFactory.registerResolvableDependency(ApplicationEventPublisher.class, this);
beanFactory.registerResolvableDependency(ApplicationContext.class, this);
// 添加处理的ApplicationListener的后置处理器
beanFactory.addBeanPostProcessor(new ApplicationListenerDetector(this));
// 添加处理动态增强配置LoadTimeWeaverAwareProcessor
if (beanFactory.containsBean(LOAD_TIME_WEAVER_BEAN_NAME)) {
beanFactory.addBeanPostProcessor(new LoadTimeWeaverAwareProcessor(beanFactory));
beanFactory.setTempClassLoader(new ContextTypeMatchClassLoader(beanFactory.getBeanClassLoader()));
}
// 注册Environment成Bean
if (!beanFactory.containsLocalBean(ENVIRONMENT_BEAN_NAME)) {
beanFactory.registerSingleton(ENVIRONMENT_BEAN_NAME, getEnvironment());
}
// 将系统变量作为Map注册成Bean,"systemProperties"
if (!beanFactory.containsLocalBean(SYSTEM_PROPERTIES_BEAN_NAME)) {
beanFactory.registerSingleton(SYSTEM_PROPERTIES_BEAN_NAME, getEnvironment().getSystemProperties());
}
// 将系统环境作为Map注册Bean,"systemEnvironment"
if (!beanFactory.containsLocalBean(SYSTEM_ENVIRONMENT_BEAN_NAME)) {
beanFactory.registerSingleton(SYSTEM_ENVIRONMENT_BEAN_NAME, getEnvironment().getSystemEnvironment());
}
}
try {
// 给子类实现,在BeanFactory初始化完毕之后,可以设置一些默认的Bean,beanDefinition等等,还可以对beanFactory做处理
// 还可以注册后置处理器等等
postProcessBeanFactory(beanFactory);
// 执行实现了BeanFactoryPostProcessor的bean
invokeBeanFactoryPostProcessors(beanFactory);
{
// 先执行内置的实现了BeanFactoryPostProcessor的bean,再实现用户的
PostProcessorRegistrationDelegate.invokeBeanFactoryPostProcessors(beanFactory, getBeanFactoryPostProcessors());
{
// 保存所有post的beanName
Set<String> processedBeans = new HashSet<>();
// 无论如何,先调用BeanDefinitionRegistryPostProcessor类的实现,他是用于注册BD的
if (beanFactory instanceof BeanDefinitionRegistry) {
// 强转
BeanDefinitionRegistry registry = (BeanDefinitionRegistry) beanFactory;
// 保存普通的BeanFactoryPostProcessor这种类型的processor
List<BeanFactoryPostProcessor> regularPostProcessors = new ArrayList<>();
// 保存特殊的BeanFactoryPostProcessor,类型为BeanDefinitionRegistryPostProcessor的processor
// 包括所有的BeanDefinitionRegistryPostProcessor
List<BeanDefinitionRegistryPostProcessor> registryProcessors = new ArrayList<>();
// 遍历当前ApplicationContext中已经存在的beanFactoryPostProcessors,默认是空的
// 如果将在这之前,将beanFactoryPostProcessors添加到了ApplicationContext中
// 如果没有存入,就不需要执行
for (BeanFactoryPostProcessor postProcessor : beanFactoryPostProcessors) {
if (postProcessor instanceof BeanDefinitionRegistryPostProcessor) {
BeanDefinitionRegistryPostProcessor registryProcessor = (BeanDefinitionRegistryPostProcessor) postProcessor;
// 立即执行BeanDefinitionRegistryPostProcessor的方法,用于注册BD
registryProcessor.postProcessBeanDefinitionRegistry(registry);
// 再保存下来,因为其他的它和BeanFactory一样,只是postProcessBeanDefinitionRegistry这个必须要优先执行
registryProcessors.add(registryProcessor);
} else {
// 普通的后置处理器不需要处理
regularPostProcessors.add(postProcessor);
}
}
// 这里是处理内置的和用户的BeanDefinitionRegistryPostProcessor
List<BeanDefinitionRegistryPostProcessor> currentRegistryProcessors = new ArrayList<>();
// 执行实现了PriorityOrdered接口的BeanDefinitionRegistryPostProcessor
// 首先找到所有的BeanDefinitionRegistryPostProcessor
// 此时只会有一个,那就是ConfigurationClassPostProcessor,其他的都是被ConfigurationClassPostProcessor扫描之后才存在的
String[] postProcessorNames = beanFactory.getBeanNamesForType(BeanDefinitionRegistryPostProcessor.class, true, false);
// 遍历所有的beanName
for (String ppName : postProcessorNames) {
// 判断当前bean是否实现了PriorityOrdered优先级接口
// 先保存PriorityOrdered优先级高的
if (beanFactory.isTypeMatch(ppName, PriorityOrdered.class)) {
// 实现了优先级接口的BeanDefinitionRegistryPostProcessor,直接创建对象,优先保存
currentRegistryProcessors.add(beanFactory.getBean(ppName, BeanDefinitionRegistryPostProcessor.class));
// 保存beanName
processedBeans.add(ppName);
}
}
// 将所有的BeanDefinitionRegistryPostProcessor进行排序,都实现了PriorityOrdered接口
sortPostProcessors(currentRegistryProcessors, beanFactory);
// 先保存到registryProcessors
registryProcessors.addAll(currentRegistryProcessors);
// 执行所有的BeanDefinitionRegistryPostProcessor,按照优先级
// 这里执行的实容器中存在的BeanDefinitionRegistryPostProcessor
// ConfigurationClassPostProcessor
invokeBeanDefinitionRegistryPostProcessors(currentRegistryProcessors, registry);
{
// 其中包含org.springframework.context.annotation.ConfigurationClassPostProcessor
// 处理Configuration注解的后置处理器,详见Configuration注解ConfigurationClassPostProcessor运行原理
for (BeanDefinitionRegistryPostProcessor postProcessor : postProcessors) {
postProcessor.postProcessBeanDefinitionRegistry(registry);
}
}
// 清空执行过的后置处理器
currentRegistryProcessors.clear();
// 执行实现了Order接口的BeanDefinitionRegistryPostProcessor
// 再次获取BeanDefinitionRegistryPostProcessor类型,因为ConfigurationClassPostProcessor执行了
// 它会扫描配置的所有类,内部可能就包含BeanDefinitionRegistryPostProcessor
postProcessorNames = beanFactory.getBeanNamesForType(BeanDefinitionRegistryPostProcessor.class, true, false);
// 遍历所有的bean
for (String ppName : postProcessorNames) {
// 如果当前beanName没有被执行过,并且实现了Order接口
if (!processedBeans.contains(ppName) && beanFactory.isTypeMatch(ppName, Ordered.class)) {
// 保存起来
currentRegistryProcessors.add(beanFactory.getBean(ppName, BeanDefinitionRegistryPostProcessor.class));
// 标识该Bean即将执行
processedBeans.add(ppName);
}
}
// 根据Order进行排序
sortPostProcessors(currentRegistryProcessors, beanFactory);
// 保存这些BeanDefinitionRegistryPostProcessor
registryProcessors.addAll(currentRegistryProcessors);
// 执行BeanDefinitionRegistryPostProcessor
invokeBeanDefinitionRegistryPostProcessors(currentRegistryProcessors, registry);
// 清空已经执行的BeanDefinitionRegistryPostProcessor
currentRegistryProcessors.clear();
// 最后,执行所有的BeanDefinitionRegistryPostProcessor
// 是否需要重复执行
boolean reiterate = true;
while (reiterate) {
// 修改标识
reiterate = false;
// 再次获取最新的所有BeanDefinitionRegistryPostProcessor类型
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);
// 还要再次执行,因为下面要执行当前Bean
// 当前Bean可能又会注册一些BeanDefinitionRegistryPostProcessor的Bean
// 不能漏掉
reiterate = true;
}
}
// 排序
sortPostProcessors(currentRegistryProcessors, beanFactory);
// 保存需要执行的BeanDefinitionRegistryPostProcessor
registryProcessors.addAll(currentRegistryProcessors);
// 执行
invokeBeanDefinitionRegistryPostProcessors(currentRegistryProcessors, registry);
// 清空已经执行过的BeanDefinitionRegistryPostProcessor
currentRegistryProcessors.clear();
}
// 现在执行所有注册的BeanDefinitionRegistryPostProcessor的Bean
invokeBeanFactoryPostProcessors(registryProcessors, beanFactory);
// 接着执行用户添加到ApplicantionContext中的BeanFactoryPostProcessor
invokeBeanFactoryPostProcessors(regularPostProcessors, beanFactory);
}
// 如果beanFactory不是BeanDefinitionRegistry这种类型
// 就只执行给定的后置处理器(存在ApplicationContext中的处理器),这个就是为了区分BeanDefinitionRegistry的逻辑
else {
// 调用用上下文实例注册的工厂处理器
//用户添加到ApplicantionContext中的BeanFactoryPostProcessor
invokeBeanFactoryPostProcessors(beanFactoryPostProcessors, beanFactory);
}
// 获取所有的BeanFactoryPostProcessor
String[] postProcessorNames = beanFactory.getBeanNamesForType(BeanFactoryPostProcessor.class, true, false);
// 保存实现了PriorityOrdered接口的BeanFactoryPostProcessor
List<BeanFactoryPostProcessor> priorityOrderedPostProcessors = new ArrayList<>();
// 保存实现了Ordered接口的BeanFactoryPostProcessor
List<String> orderedPostProcessorNames = new ArrayList<>();
// 保存其他的BeanFactoryPostProcessor
List<String> nonOrderedPostProcessorNames = new ArrayList<>();
for (String ppName : postProcessorNames) {
// 以及被执行过的BeanFactoryPostProcessor
if (processedBeans.contains(ppName)) {
continue;
}
// 实现了PriorityOrdered接口
if (beanFactory.isTypeMatch(ppName, PriorityOrdered.class)) {
priorityOrderedPostProcessors.add(beanFactory.getBean(ppName, BeanFactoryPostProcessor.class));
continue;
}
// 实现了Ordered接口
if (beanFactory.isTypeMatch(ppName, Ordered.class)) {
orderedPostProcessorNames.add(ppName);
continue;
}
// 其他类型的BeanFactoryPostProcessor
nonOrderedPostProcessorNames.add(ppName);
}
// 首先，调用实现PriorityOrdered的BeanFactoryPostProcessors。
sortPostProcessors(priorityOrderedPostProcessors, beanFactory);
invokeBeanFactoryPostProcessors(priorityOrderedPostProcessors, beanFactory);
// 接下来，调用实现Ordered的BeanFactoryPostProcessors。
List<BeanFactoryPostProcessor> orderedPostProcessors = new ArrayList<>(orderedPostProcessorNames.size());
for (String postProcessorName : orderedPostProcessorNames) {
orderedPostProcessors.add(beanFactory.getBean(postProcessorName, BeanFactoryPostProcessor.class));
}
sortPostProcessors(orderedPostProcessors, beanFactory);
invokeBeanFactoryPostProcessors(orderedPostProcessors, beanFactory);
// 最后，调用所有其他BeanFactoryPostProcessors.
List<BeanFactoryPostProcessor> nonOrderedPostProcessors = new ArrayList<>(nonOrderedPostProcessorNames.size());
for (String postProcessorName : nonOrderedPostProcessorNames) {
nonOrderedPostProcessors.add(beanFactory.getBean(postProcessorName, BeanFactoryPostProcessor.class));
}
invokeBeanFactoryPostProcessors(nonOrderedPostProcessors, beanFactory);
// 清空bean的元数据缓存
beanFactory.clearMetadataCache();
}
// 添加LoadTimeWeaver处理,根据不同环境,通过调节jvm参数就能控制切面动态织入
if (beanFactory.getTempClassLoader() == null && beanFactory.containsBean(LOAD_TIME_WEAVER_BEAN_NAME)) {
beanFactory.addBeanPostProcessor(new LoadTimeWeaverAwareProcessor(beanFactory));
beanFactory.setTempClassLoader(new ContextTypeMatchClassLoader(beanFactory.getBeanClassLoader()));
}
}
// 注册实现了BeanPostProcessor的实例
registerBeanPostProcessors(beanFactory) {
PostProcessorRegistrationDelegate.registerBeanPostProcessors(beanFactory, this) {
// 找到容器中所有的BeanPostProcessor的名称
String[] postProcessorNames = beanFactory.getBeanNamesForType(BeanPostProcessor.class, true, false);
// getBeanPostProcessorCount,之前在AbstractApplicationContext.prepareBeanFactory已经添加了一些
// 而且添加的直接是对象,然后工厂中还存在没有创建实例的postProcessorNames,再加上下面代码添加的BeanPostProcessorChecker
int beanProcessorTargetCount = beanFactory.getBeanPostProcessorCount() + 1 + postProcessorNames.length;
// 新建一个BeanPostProcessorChecker
// 当一个bean没有资格被所有BeanPostProcessor处理时，记录一个信息消息
// 换一句话说,当一个bean没有经过所有的BeanPostProcessor处理,那么就记录一个日志消息
beanFactory.addBeanPostProcessor(new BeanPostProcessorChecker(beanFactory, beanProcessorTargetCount));
// 实现了priorityOrdered接口的后置处理器
List<BeanPostProcessor> priorityOrderedPostProcessors = new ArrayList<>();
// 内置的后置处理器
List<BeanPostProcessor> internalPostProcessors = new ArrayList<>();
// 实现了Order接口的内置处理器
List<String> orderedPostProcessorNames = new ArrayList<>();
// 其他的后置处理器
List<String> nonOrderedPostProcessorNames = new ArrayList<>();
// 遍历所有的BeanName
for (String ppName : postProcessorNames) {
// 如果实现了PriorityOrdered接口
if (beanFactory.isTypeMatch(ppName, PriorityOrdered.class)) {
// 保存
BeanPostProcessor pp = beanFactory.getBean(ppName, BeanPostProcessor.class);
priorityOrderedPostProcessors.add(pp);
// 如果是MergedBeanDefinitionPostProcessor,表示当前PostProcessor是内置的bean
if (pp instanceof MergedBeanDefinitionPostProcessor) {
internalPostProcessors.add(pp);
}
}
// 实现了Order接口
else if (beanFactory.isTypeMatch(ppName, Ordered.class)) {
orderedPostProcessorNames.add(ppName);
} else {
// 其他类型接口
nonOrderedPostProcessorNames.add(ppName);
}
}
// 先按照优先顺序注册实现了PriorityOrdered的PostProcessors
sortPostProcessors(priorityOrderedPostProcessors, beanFactory);
registerBeanPostProcessors(beanFactory, priorityOrderedPostProcessors);
// 接下来，注册实现Ordered的BeanPostProcessors。
List<BeanPostProcessor> orderedPostProcessors = new ArrayList<>(orderedPostProcessorNames.size());
for (String ppName : orderedPostProcessorNames) {
BeanPostProcessor pp = beanFactory.getBean(ppName, BeanPostProcessor.class);
orderedPostProcessors.add(pp);
// 如果是MergedBeanDefinitionPostProcessor,表示当前PostProcessor是内置的bean
if (pp instanceof MergedBeanDefinitionPostProcessor) {
internalPostProcessors.add(pp);
}
}
// 再按照优先顺序注册实现了Ordered的PostProcessors
sortPostProcessors(orderedPostProcessors, beanFactory);
registerBeanPostProcessors(beanFactory, orderedPostProcessors);
// 然后注册所有常规BeanPostProcessors。
List<BeanPostProcessor> nonOrderedPostProcessors = new ArrayList<>(nonOrderedPostProcessorNames.size());
for (String ppName : nonOrderedPostProcessorNames) {
BeanPostProcessor pp = beanFactory.getBean(ppName, BeanPostProcessor.class);
nonOrderedPostProcessors.add(pp);
// 如果是MergedBeanDefinitionPostProcessor,表示当前PostProcessor是内置的bean
if (pp instanceof MergedBeanDefinitionPostProcessor) {
internalPostProcessors.add(pp);
}
}
registerBeanPostProcessors(beanFactory, nonOrderedPostProcessors);
// 最后重新注册所有内置的BeanPostProcessors
sortPostProcessors(internalPostProcessors, beanFactory);
// 重新注册内置的PostProcessor,因为可能内置PostProcessor在上面已经被注册过了
// 例如这个内置的PostProcessor实现了Order,PriorityOrdered接口
registerBeanPostProcessors(beanFactory, internalPostProcessors) {
for (BeanPostProcessor postProcessor : postProcessors) {
beanFactory.addBeanPostProcessor(postProcessor) {
// 移除之前保存过的
this.beanPostProcessors.remove(beanPostProcessor);
// 跟踪它是否具有实例化/销毁的BeanPostProcessor功能
if (beanPostProcessor instanceof InstantiationAwareBeanPostProcessor) {
this.hasInstantiationAwareBeanPostProcessors = true;
}
if (beanPostProcessor instanceof DestructionAwareBeanPostProcessor) {
this.hasDestructionAwareBeanPostProcessors = true;
}
// 添加到最后
this.beanPostProcessors.add(beanPostProcessor);
}
}
}
// 检查之前是否注册了ApplicationListenerDetector,在prepareBeanFactory添加过一次
// 现在重新注册,如果之前存在,删除,添加到最后
// 用于注册实现了ApplicationListener的类
beanFactory.addBeanPostProcessor(new ApplicationListenerDetector(applicationContext));
}
}
// 初始化国际化相关的类MessageSource
initMessageSource() {
// 获取Bean工厂
ConfigurableListableBeanFactory beanFactory = getBeanFactory();
// 如果存在"messageSource"这个Bean
if (beanFactory.containsLocalBean(MESSAGE_SOURCE_BEAN_NAME)) {
// 获取到这个MessageSource的Bean
// 就算配置了,beanName不是messageSource也没有用,还是使用默认的DelegatingMessageSource
this.messageSource = beanFactory.getBean(MESSAGE_SOURCE_BEAN_NAME, MessageSource.class);
// 如果存在父Context,并且类型为HierarchicalMessageSource
if (this.parent != null && this.messageSource instanceof HierarchicalMessageSource) {
HierarchicalMessageSource hms = (HierarchicalMessageSource) this.messageSource;
// 如果HierarchicalMessageSource不存在父MessageSource
if (hms.getParentMessageSource() == null) {
// 如果没有父MessageSource
hms.setParentMessageSource(getInternalParentMessageSource() {
// 如果存在父ApplicationContext存在messageSource,那就设置父ApplicationContext的messageSource作为当前messageSource的父亲
// 如果父ApplicationContext存在messageSource,那就将父父ApplicationContext本身作为当前messageSource的父亲
return (getParent() instanceof AbstractApplicationContext ? ((AbstractApplicationContext) getParent()).messageSource : getParent());
})
}
}
} else {
// 创建一个新的DelegatingMessageSource
DelegatingMessageSource dms = new DelegatingMessageSource();
// 设置父MessageSource
dms.setParentMessageSource(getInternalParentMessageSource());
// 赋值给当前ApplicationContext
this.messageSource = dms;
// 注册成Bean
beanFactory.registerSingleton(MESSAGE_SOURCE_BEAN_NAME, this.messageSource);
}
}
// 初始化事件分发器,触发ApplicationListener
initApplicationEventMulticaster() {
ConfigurableListableBeanFactory beanFactory = getBeanFactory();
// Bean工厂中有没有配置"applicationEventMulticaster"这个BD
// 就算配置了ApplicationEventMulticaster,BeanName不为applicationEventMulticaster也没有,还是使用默认的
if (beanFactory.containsLocalBean(APPLICATION_EVENT_MULTICASTER_BEAN_NAME)) {
// 如果存在,获取Bean
this.applicationEventMulticaster = beanFactory.getBean(APPLICATION_EVENT_MULTICASTER_BEAN_NAME, ApplicationEventMulticaster.class);
} else {
// 没有配置,使用默认的SimpleApplicationEventMulticaster分发器
this.applicationEventMulticaster = new SimpleApplicationEventMulticaster(beanFactory);
beanFactory.registerSingleton(APPLICATION_EVENT_MULTICASTER_BEAN_NAME, this.applicationEventMulticaster);
}
}
// 给子类实现的钩子函数,内置的事情的都处理好了,即将刷新容器
// 1. 创建了beanFactory
// 2. 执行了所有的BeanFactoryPostProcessor
// 3. 注册所有的BeanPostProcessor
// 4. 初始化国际化资源
// 5. 初始化事件分发器
onRefresh();
// 注册监听器
registerListeners() {
// 遍历当前Context上的已存在的applicationListener
// 也就自己静态设置到Context中的监听器
for (ApplicationListener<?> listener : getApplicationListeners()) {
// 将监听器保存到事件派发器中
getApplicationEventMulticaster().addApplicationListener(listener);
}
// 从Spring容器中获取ApplicationListener
String[] listenerBeanNames = getBeanNamesForType(ApplicationListener.class, true, false);
// 遍历所有的监听器
for (String listenerBeanName : listenerBeanNames) {
// 将监听器保存到事件派发器中
getApplicationEventMulticaster().addApplicationListenerBean(listenerBeanName);
}
// 获取需要提前发布的事件
Set<ApplicationEvent> earlyEventsToProcess = this.earlyApplicationEvents;
// 将事件置空,不管有没有,这个变量是Spring框架自身负责管理和处理,用户无法正常操作这个变量
this.earlyApplicationEvents = null;
// 如果存在需要提前发布的事件
if (earlyEventsToProcess != null) {
// 遍历所有的事件
for (ApplicationEvent earlyEvent : earlyEventsToProcess) {
// 使用事件派发器分发事件,详见Spring事件分发器ApplicationEventMulticaster分发事件原理
getApplicationEventMulticaster().multicastEvent(earlyEvent);
}
}
}
// 实例化剩下的所有非懒加载的Bean
finishBeanFactoryInitialization(beanFactory) {
// 为此上下文初始化转换服务,类型转换器
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));
}
// 如果没有bean后处理器，注册一个默认的嵌入值解析器,解析${},#{}表达式
// 例如:PropertyPlaceholderConfigurer
// 主要用于解析注解的属性值
if (!beanFactory.hasEmbeddedValueResolver()) {
beanFactory.addEmbeddedValueResolver(strVal -> getEnvironment().resolvePlaceholders(strVal));
}
// 初始化LoadTimeWeaverAware,用于获取LoadTimeWeaverAware切面回调接口,用于设置LoadTimeWeaver
// LoadTimeWeaver接口是用于动态织入,运行是通过字节码增强
String[] weaverAwareNames = beanFactory.getBeanNamesForType(LoadTimeWeaverAware.class, false, false);
for (String weaverAwareName : weaverAwareNames) {
// 执行bean的生命周期
getBean(weaverAwareName);
}
// 停止使用临时ClassLoader
beanFactory.setTempClassLoader(null);
// 冻结Bean的元数据,将所有的beanName冻结,然后缓存这些bean的元数据信息
// 在getBeanNamesForType会用到,如果被冻结了,可以从缓存获取beanName,如果没有,需要解析所有的beanName
beanFactory.freezeConfiguration() {
this.configurationFrozen = true;
this.frozenBeanDefinitionNames = StringUtils.toStringArray(this.beanDefinitionNames);
}
// 实例化所有剩余的(非lazy-init)单例
beanFactory.preInstantiateSingletons() {
// 所有的beanName
List<String> beanNames = new ArrayList<>(this.beanDefinitionNames);
// 遍历所有的beanName
for (String beanName : beanNames) {
// 获取到BD
RootBeanDefinition bd = getMergedLocalBeanDefinition(beanName);
// 如果不是抽象的Bean,并且是单例,而且还不能是懒加载
// 说白了,就是准备初始化非懒加载的具体单例Bean
if (!bd.isAbstract() && bd.isSingleton() && !bd.isLazyInit()) {
// 如果bean是FactoryBean
if (isFactoryBean(beanName) {
// 转换beanName
String beanName = transformedBeanName(name);
// 获取单例Bean
Object beanInstance = getSingleton(beanName, false);
// 如果不为空
if (beanInstance != null) {
// 返回类是不是FactoryBean的实例
return (beanInstance instanceof FactoryBean);
}
// 如果不存在单例Bean
// 如果当前容器不存在beanName,并且存在父容器
if (!containsBeanDefinition(beanName) && getParentBeanFactory() instanceof ConfigurableBeanFactory) {
// 去父容器中找,然后判断
return ((ConfigurableBeanFactory) getParentBeanFactory()).isFactoryBean(name);
}
// 根据BD设置的类型判断
return isFactoryBean(beanName, getMergedLocalBeanDefinition(beanName)) {
// 获取BD的标识
Boolean result = mbd.isFactoryBean;
// 如果为空
if (result == null) {
// 获取Bean的类型
Class<?> beanType = predictBeanType(beanName, mbd, FactoryBean.class);
// 如果bean的类型是FactoryBean,返回true
result = (beanType != null && FactoryBean.class.isAssignableFrom(beanType));
// 标记BD
mbd.isFactoryBean = result;
}
return result;
}
}){
// 如果是FactoryBean,获取Bean对象
// FactoryBean的beanName为"&"+beanName
Object bean = getBean(FACTORY_BEAN_PREFIX + beanName);
// 通过&+beanName如果是获取到的bean是FactoryBean的实例
if (bean instanceof FactoryBean) {
// 强转
final FactoryBean<?> factory = (FactoryBean<?>) bean;
// 是否立即初始化
boolean isEagerInit;
if (System.getSecurityManager() != null && factory instanceof SmartFactoryBean) {
isEagerInit = AccessController.doPrivileged((PrivilegedAction<Boolean>) ((SmartFactoryBean<?>) factory)::isEagerInit, getAccessControlContext());
}
// 如果是SmartFactoryBean类型,获取设置的isEagerInit的值
// 其他类型的FactoryBean都为false
else {
isEagerInit = (factory instanceof SmartFactoryBean && ((SmartFactoryBean<?>) factory).isEagerInit());
}
// 如果SmartFactoryBean设置了要立刻初始化
if (isEagerInit) {
// 初始化Bean,执行Bean的生命周期,详见Spring中Bean的生命周期
getBean(beanName);
}
}
}
// 如果不是factoryBean,执行Bean的生命周期,详见Spring中Bean的生命周期
else{
getBean(beanName);
}
}
}
// 遍历所有的bean,到这里,所有的Bean都已经初始化完毕了
for (String beanName : beanNames) {
// 当前Bean是否已经初始化了,都已经初始化了
Object singletonInstance = getSingleton(beanName);
// 如果当前Bean是SmartInitializingSingleton类型
if (singletonInstance instanceof SmartInitializingSingleton) {
// 强转为SmartInitializingSingleton
final SmartInitializingSingleton smartSingleton = (SmartInitializingSingleton) singletonInstance;
// 调用实例的afterSingletonsInstantiated方法
// 因为所有的Bean都初始化完毕,我们可以统一对Bean进行一些操作
// 例如:@Schedule注解是在这里处理的
if (System.getSecurityManager() != null) {
AccessController.doPrivileged((PrivilegedAction<Object>) () -> {
smartSingleton.afterSingletonsInstantiated();
return null;
}, getAccessControlContext());
} else {
smartSingleton.afterSingletonsInstantiated();
}
}
}
}
}
// 容器刷新完成
finishRefresh() {
// 清除上下文级资源缓存(例如扫描ASM元数据).
clearResourceCaches();
// 为此上下文初始化生命周期处理器。
initLifecycleProcessor() {
ConfigurableListableBeanFactory beanFactory = getBeanFactory();
// LIFECYCLE_PROCESSOR_BEAN_NAME = lifecycleProcessor
// 如果存在LifecycleProcessor生命周期的后置处理器,从容器中获取
if (beanFactory.containsLocalBean(LIFECYCLE_PROCESSOR_BEAN_NAME)) {
this.lifecycleProcessor = beanFactory.getBean(LIFECYCLE_PROCESSOR_BEAN_NAME, LifecycleProcessor.class);
} else {
// 否则创建默认的DefaultLifecycleProcessor生命周期处理器
DefaultLifecycleProcessor defaultProcessor = new DefaultLifecycleProcessor();
// 设置BeanFactory
defaultProcessor.setBeanFactory(beanFactory);
// 保存到上下文中ApplicationContext中
this.lifecycleProcessor = defaultProcessor;
// 注册成Bean
beanFactory.registerSingleton(LIFECYCLE_PROCESSOR_BEAN_NAME, this.lifecycleProcessor);
}
}
getLifecycleProcessor().onRefresh() {
// 调用上面创建的生命周期后置处理器的onRefresh方法
startBeans(true) {
// 获取所有生命周期的Bean
Map<String, Lifecycle> lifecycleBeans = getLifecycleBeans() {
// 获取到容器
ConfigurableListableBeanFactory beanFactory = getBeanFactory();
Map<String, Lifecycle> beans = new LinkedHashMap<>();
// 获取实现了Lifecycle接口的类
String[] beanNames = beanFactory.getBeanNamesForType(Lifecycle.class, false, false);
// 遍历所有的类
for (String beanName : beanNames) {
// 转换BeanName
String beanNameToRegister = BeanFactoryUtils.transformedBeanName(beanName);
// 是不是FactoryBean
boolean isFactoryBean = beanFactory.isFactoryBean(beanNameToRegister);
// 是否需要校验BeanName
String beanNameToCheck = (isFactoryBean ? BeanFactory.FACTORY_BEAN_PREFIX + beanName : beanName);
// 存在生命周期对应的bean,并且不是FactoryBean,或者是类型是Lifecycle/SmartLifecycle的类型也行
if ((beanFactory.containsSingleton(beanNameToRegister) &&
(!isFactoryBean || matchesBeanType(Lifecycle.class, beanNameToCheck, beanFactory))) ||
matchesBeanType(SmartLifecycle.class, beanNameToCheck, beanFactory)) {
// 获取Lifecycle对应的Bean
Object bean = beanFactory.getBean(beanNameToCheck);
if (bean != this && bean instanceof Lifecycle) {
// 保存Lifecycle的Bean
beans.put(beanNameToRegister, (Lifecycle) bean);
}
}
}
return beans;
}
// 逐步实行的生命周期分组
Map<Integer, LifecycleGroup> phases = new HashMap<>();
lifecycleBeans.forEach((beanName, bean) -> {
// 判断当前bean不是仅支持自动启动,参数传递的是true,仅支持自动启动
// 或者bean设置了自动启动
if (!autoStartupOnly || (bean instanceof SmartLifecycle && ((SmartLifecycle) bean).isAutoStartup())) {
// 获取到bean设置的分段值
int phase = getPhase(bean);
// 是否创建过分组
LifecycleGroup group = phases.get(phase);
// 没有创建过
if (group == null) {
// 创建一个新的生命周期组
group = new LifecycleGroup(phase, this.timeoutPerShutdownPhase, lifecycleBeans, autoStartupOnly);
// 保存同一个分段值的所有生命周期的信息
phases.put(phase, group);
}
// 保存当前生命周期bean
group.add(beanName, bean);
}
});
// 如果通过分段值进行了分组,兵器
if (!phases.isEmpty()) {
// 获取到所有的分段值
List<Integer> keys = new ArrayList<>(phases.keySet());
// 排序
Collections.sort(keys);
// 按照分段值顺序执行分组内部的所有生命周期接口
for (Integer key : keys) {
phases.get(key).start();
}
}
} ;
// 标记当前运行成功
this.running = true;
}
// 发布事件,容器刷新完成事件
publishEvent(new ContextRefreshedEvent(this));
// 监控Bean的方法
LiveBeansView.registerApplicationContext(this);
}
} catch (BeansException ex) {
// 销毁所有的Bean,并执行实现了DisposableBean接口的bean的销毁方法
destroyBeans() {
// 对单例池加锁
synchronized (this.singletonObjects) {
// 标记当前单例Bean正在被销毁
this.singletonsCurrentlyInDestruction = true;
}
// 实现了DisposableBean的beanName
String[] disposableBeanNames;
synchronized (this.disposableBeans) {
// 在实例化的时候,如果Bena是DisposableBean类型,会保存到disposableBeans中
disposableBeanNames = StringUtils.toStringArray(this.disposableBeans.keySet());
}
for (int i = disposableBeanNames.length - 1; i >= 0; i--) {
// 一一销毁
destroySingleton(disposableBeanNames[i]) {
// 从单例池删除
removeSingleton(beanName) {
synchronized (this.singletonObjects) {
this.singletonObjects.remove(beanName);
this.singletonFactories.remove(beanName);
this.earlySingletonObjects.remove(beanName);
this.registeredSingletons.remove(beanName);
}
}
// 销毁相应的DisposableBean实例
DisposableBean disposableBean;
synchronized (this.disposableBeans) {
disposableBean = (DisposableBean) this.disposableBeans.remove(beanName);
}
destroyBean(beanName, disposableBean) {
Set<String> dependencies;
// 获取所有依赖该Bean的Bean
synchronized (this.dependentBeanMap) {
dependencies = this.dependentBeanMap.remove(beanName);
}
// 如果存在依赖该Bean的Bena
if (dependencies != null) {
// 将依赖该Bean的Bean也进行销毁
for (String dependentBeanName : dependencies) {
destroySingleton(dependentBeanName);
}
}
// 执行当前Bean的销毁方法
if (bean != null) {
bean.destroy();
}
Set<String> containedBeans;
// 获取当前Bean包含的Bean的关系
synchronized (this.containedBeanMap) {
containedBeans = this.containedBeanMap.remove(beanName);
}
// 销毁该Bean包含的Bean
if (containedBeans != null) {
for (String containedBeanName : containedBeans) {
destroySingleton(containedBeanName);
}
}
// 删除这个Bean的被依赖关系
synchronized (this.dependentBeanMap) {
for (Iterator<Map.Entry<String, Set<String>>> it = this.dependentBeanMap.entrySet().iterator(); it.hasNext(); ) {
Map.Entry<String, Set<String>> entry = it.next();
Set<String> dependenciesToClean = entry.getValue();
dependenciesToClean.remove(beanName);
if (dependenciesToClean.isEmpty()) {
it.remove();
}
}
}
// 删除该类的依赖关系
this.dependenciesForBeanMap.remove(beanName);
}
}
}
// 清空bean的包含关系
this.containedBeanMap.clear();
// 清空bean的被依赖关系
this.dependentBeanMap.clear();
// 清空bena的依赖关系
this.dependenciesForBeanMap.clear();
// 清空单例的缓存
clearSingletonCache() {
synchronized (this.singletonObjects) {
this.singletonObjects.clear();
this.singletonFactories.clear();
this.earlySingletonObjects.clear();
this.registeredSingletons.clear();
this.singletonsCurrentlyInDestruction = false;
}
}
}
// 取消刷新容器,设置相关标识,标识容器不在刷新
cancelRefresh(ex) {
this.active.set(false);
}
throw ex;
} finally {
// 清空公共的缓存,例如反射,注解等等缓存都清空
resetCommonCaches();
}
}
}
}
02-23
2608
2608
01-08
5万+
5万+
“相关推荐”对你有帮助么？
-
非常没帮助 -
没帮助 -
一般 -
有帮助 -
非常有帮助
提交
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
