spring之refresh流程-Java八股面试(六)

系列文章目录

第一章 ArrayList-Java八股面试(一)

第二章 HashMap-Java八股面试(二)

第三章 单例模式-Java八股面试(三)

第四章 线程池和Volatile关键字-Java八股面试(四)

第五章ConcurrentHashMap-Java八股面试(五)

---

动态每日更新算法题，想要学习的可以关注一下

---

---

提示：以下是本篇文章正文内容，下面案例可供参考

一、refresh的12个阶段

refresh()是 Spring 最核心的方法，没有之一。主要是用来初始化ApplicationContext
，拆分开来分为12个阶段
1 为准备环境
2 -6 为准备 BeanFactory
7 -12 为准备 ApplicationContext
11 为初始化 BeanFactory 中非延迟单例 bean

1.1 prepareRefresh()

该方法用于容器刷新前的准备，包括设置上下文状态，获取属性，验证必要的属性等。这一步创建和准备了 Environment 对象。

诸如类似上述操作，主要获取属性值，可以分为下面三个方面

• systemProperties - 保存 java 环境键值
• systemEnvironment - 保存系统环境键值
• 自定义 PropertySource - 保存自定义键值，例如来自于 *.properties 文件的键值

1.2 obtainFreshBeanFactory()

该方法获取新的beanFactory。该方法很简单，刷新 BeanFactory 和获取 getBeanFactory。

// 刷新 BeanFactory
refreshBeanFactory();
// 获取 getBeanFactory
return getBeanFactory();
这两个方法都是需要子类去实现的，如果是基于 XML 配置的方法启动，在刷新阶段将会做如下事情。

//创建 beanFactory
DefaultListableBeanFactory beanFactory = createBeanFactory();
// 指定序列化 id
beanFactory.setSerializationId(getId());
// 定制 beanFactory，设置相关属性，包括是否允许覆盖同名称的不同定义的对象以及循环依赖及设置 @Autowired 和 @Qualifier 注解解析器
customizeBeanFactory(beanFactory);
// 初始化 DocumentReader,并进行 XML 文件的读取及解析，生成 BeanDefinition
loadBeanDefinitions(beanFactory);

BeanDefinition 的来源有多种多样，可以是通过 xml 获得、配置类获得、组件扫描获得，也可以是编程添加

1.3 prepareBeanFactory(beanFactory)

这一步会进一步完善 BeanFactory，为它的各项成员变量赋值，主要是为下面的4个变量赋值。

• beanExpressionResolver 用来解析 SpEL，常见实现StandardBeanExpressionResolver
• propertyEditorRegistrars 会注册类型转换器
• registerResolvableDependency 来注册 beanFactory 以及
  ApplicationContext，让它们也能用于依赖注入
• beanPostProcessors 是 bean 后处理器集合，会工作在 bean 的生命周期各个阶段

// 设置支持表达式解析器
beanFactorphpy.setBeanExpressionResolver(new StandardBeanExpressionResolver(beanFactory.getBeanClassLoader()));
// 为 beanFactory 增加了一个默认的 propertyEditor ，这个主要是对 bean 的属性等设置管理的一个工具
beanFactory.addPropertyEditorRegistrar(new ResourceEditorRegistrar(this, getEnvironment()));
// 添加部分BeanPostProcessor【ApplicationContextAwareProcessor】
beanFactory.addBeanPostProcessor(new ApplicationContextAwareProcessor(this));
//设置忽略的自动装配的接口EnvironmentAware、EmbeddedValueResolverAware、xxx；
//这些接口的实现类不能通过类型来自动注入
beanFactory.ignoreDependencyInterface(EnvironmentAware.class);
beanFactory.ignoreDependencyInterfhttp://www.cppcns.comace(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);
// 增加对 ASPectJ 的支持
if (beanFactory.containsBean(LOAD_TIME_WEAVER_BEAN_NAME)) {
 beanFactory.addBeanPostProcessor(new LoadTimeWeaverAwareProcessor(beanFactory));
 // Set a temporary ClassLoader for type matching.
 beanFactory.setTempClassLoader(new ContextTypeMatchClassLoader(beanFactory.getBeanClassLoader()));
}

1.4 postProcessBeanFactory(beanFactory)

这一步是空实现，留给子类扩展。
此时，所有的 beanDefinition 已经加载，但是还没有实例化允许在子类中对 beanFactory 进行扩展处理。

比如添加 ware 相关接口自动装配设置，添加后置处理器等,是子类扩展 prepareBeanFactory(beanFactory) 的方法。

1.5 invokeBeanFactoryPostProcessors(beanFactory)

这一步会调用 beanFactory 后处理器.beanFactory 后处理器，充当 beanFactory 的扩展点，可以用来补充或修改 BeanDefinition.
常见的 beanFactory 后处理器有:
ConfigurationClassPostProcessor – 解析 @Configuration、@Bean、@Import、@PropertySource 等
PropertySourcesPlaceHolderConfigurer – 替换 BeanDefinition 中的 ${ }
MapperScannerConfigurer – 补充 Mapper 接口对应的 BeanDefinition

// 执行BeanFactoryPostProcessor的方法
PostProcessorRegistrationDelegate.invokeBeanFactoryPostProcessors(beanFactory, getBeanFactoryPostProcessors());

在invokeBeanFactoryPostProcessors方法中，Spring 会先去找到所有的实现了BeanDefinitionRegistryPostProcessor的 BeanFactory 后置处理器，然后先执行实现PriorityOrdered的，再执行实现了Ordered的.该方法结束后，Spring 上下文中已经注册并执行了 BeanFactory 后置处理器，也将一部分 BeanDefinition 注册了进来。

1.6 registerBeanPostProcessors(beanFactory)

这一步是继续从 beanFactory 中找出 bean 后处理器，添加至 beanPostProcessors 集合中.
bean 后处理器，充当 bean 的扩展点，可以工作在 bean 的实例化、依赖注入、初始化阶段，常见的有：
AutowiredAnnotationBeanPostProcessor 功能有：解析 @Autowired，@Value 注解
CommonAnnotationBeanPostProcessor 功能有：解析 @Resource，@PostConstruct，@PreDestroy
AnnotationAwareAspectJAutoProxyCreator 功能有：为符合切点的目标 bean 自动创建代理

// 把这件事委托给 PostProcessorRegistrationDelegate 来处理
PostProcessorRegistrationDelegate.registerBeanPostProcessors(beanFactory, this);
// 1. 获取所有的 Bean 后置处理器的名字
String[] postProcessorNames = beanFactory.getBeanNamesForType(BeanPostProcessor.class, true, false);
// 2. 对 Bean 后置处理器分类
List<BeanPostProcessor> priorityOrderedPostProcessors = new ArrayList<>();
List<BeanPostProcessor> internalPostProcessors = new ArrayList<>();
List<String> orderedPostProcessorNames = new ArrayList<>();
List<String> nonOrderedPostProcessorNames = new ArrayList<>();
// 3. 注册 Bean 后置处理器
registerBeanPostProcessors(beanFactory, priorityOrderedPostProcessors);
registerBeanPostProcessors(beanFactory, orderedPostProcessors);
registerBeanPostProcessors(beanFactory, nonOrderedPostProcessors);
registerBeanPostProcessors(beanFactory, internalPostProcessors);
// 4. 注册 ApplicationListener 探测器
beanFactory.addBeanPostProcessor(new ApplicationListenerDetector(applicationContext)

1.7 initMessageSource()

为上下文初始化 Message 源，即对不同语言的消息体进行国际化处理。

1.8 initApplicationEventMulticaster()

初始化事件广播器，并放入 applicationEventMulticaster bean 中

1.9 onRefresh()

模板方法，在容器刷新的时候可以自定义逻辑，不同的Spring容器做不同的事情。

1.10 registerListeners()

注册监听器。

// 1. 添加指定的监听器
for (ApplicationListener<?> listener : getApplicationListeners()) {
 getApplicationEventMulticaster().addApplicationListener(listener);
}
// 2. 获取所有实现 ApplicationListener 的广播器,并添加
String[] listenerBeanNames = getBeanNamesForType(ApplicationListener.class, true, false);
for (String listenerBeanName : listenerBeanNames) {
 getApplicationEventMulticaster().addApplicationListenerBean(listenerBeanName);
}

1.11 finishBeanFactoryInitialization(beanFactory)

这一步会将 beanFactory 的成员补充完毕，并初始化所有非延迟单例 bean
conversionService 也是一套转换机制，作为对 PropertyEditor 的补充
embeddedValueResolvers 即内嵌值解析器，用来解析 @Value 中的 ${ }，借用的是 Environment 的功能
singletonObjects 即单例池，缓存所有单例对象
对象的创建都分三个阶段，每一阶段都有不同的 bean 后处理器参与进来，扩展功能

// 1. 冻结所有的 bean，已经注册的 bean 定义将不会被修改或任何进一步的处理
beanFactory.freezeConfiguration();
// 2. 实例化所有剩余的非懒加载的 bean
beanFactory.preInstantiateSingletons();
// 3.获取容器中所有 beanDefinition 的名称
List<String> beanNames = new ArrayList<>(this.beanDefinitionNames);
for (String beanName : beanNames) {
  // 根据 beanName 获取 BeanDefinition
 RootBeanDefinition bd = getMergedLocalBeanDefinition(beanName);
 // 不是抽象的 && 是单例的 && 不是懒加载的
 if (!bd.isAbstract() && bd.isSingleton() && !bd.isLazyInit()) {
  if (isFactoryBean(beanName)) {
    // 如果是 FactoryBean，就先获取 FactoryBean 实例
   Object bean = getBean(FACTORY_BEAN_PREFIX + beanName);
   if (bean instanceof FactoryBean) {
    …………
   }
  }
  else {
    // 如果不是 FactoryBean,就直接获取 Bean
   getBean(beanName);
  }
 }
}

1.12 finishRefresh()

refresh做完之后需要做的其他事情。
这一步会为 ApplicationContext 添加 lifecycleProcessor 成员，用来控制容器内需要生命周期管理的 bean
如果容器中有名称为 lifecycleProcessor 的 bean 就用它，否则创建默认的生命周期管理器,准备好生命周期管理器，就可以实现.
调用 context 的 start，即可触发所有实现 LifeCycle 接口 bean 的 start
调用 context 的 stop，即可触发所有实现 LifeCycle 接口 bean 的 stop
发布 ContextRefreshed 事件，整个 refresh 执行完成

// 清除上下文资源缓存（如扫描中的ASM元数据） scanning).
clearResourceCaches();
// 初始化上下文的生命周期处理器，并刷新（找出Spring容器中实现了Lifecycle接口的bean并执行start()方法）
initLifecycleProcessor();
getLifecycleProcessor().onRefresh();
// 发布ContextRefreshedEvent事件告知对应的ApplicationListener进行响应的操作
publishEvent(new ContextRefreshedEvent(this));