Spring源码解读（8）---启动过程源码解析
Spring源码解读（8）—启动过程源码解析
Spring启动
Spring启动就是构造ApplicationContext对象及调⽤refresh⽅法的过程
Spring启动主要做了以下⼏件事情：
1. 构造⼀个BeanFactory对象
2. 解析配置类，得到BeanDefinition，并注册到BeanFactory中
1. 解析@CompanentScan注解，此时会完成扫描
2. 解析@Import注解
3. 解析@Bean注解。。。
3. 因为ApplicationContext还⽀持国持化，所以还需初始化MessageSource对象canno
4. ApplicationContext还⽀持事件机制，所以还需初始化ApplicationEventMulticaster对象
5. 把⽤户定义的ApplicationListener对象添加到ApplicationContext中，等Spring启动完了就要发布事件了
6. 创建⾮懒加载的单例Bean对象，并存在BeanFactory的单例池中
7. 调⽤Lifecycle Bean的start()⽅法
8. 发布ContextRefreshEvent事件
由于Spring启动过程中需要创建⾮懒加载的单例Bean对象，那么就需要⽤到PostProcessor，所以Spring在启动过程中需要做以下两件事：
1. ⽣成默认的BeanPostProcessor对象，并添加到BeanFactory中
1. AutowiredAnnotationBeanPostProcessor：处理@Autowired、@Value
2. CommonAnnotationBeanPostProcessor：处理@Resource、@PostConstruct、@PreDestroy
3. ApplicationContextAwareProcessor：处理ApplicationContextAware等回调
2. 找到外部⽤户所定义的BeanPostProcessor对象（类型为BeanPostProcessor的Bean对象），并添加到BeanFactory中BeanFactoryPostProcessor
BeanPostProcessor表⽰Bean的后置处理器，是⽤来对Bean进⾏加⼯的，类似的BeanFactoryPostProcessor为BeanFactory的后置处理器，⽤来对BeanFactory进⾏加⼯的。
Spring⽀持⽤户定义BeanFactoryPostProcessor的实现类Bean，来对BeanFactory进⾏加⼯
public class KingBeanFactoryPostProcessor implements BeanFactoryPostProcessor {
@Override
public void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) throws BeansException {
BeanDefinition beanDefinition = BeanDefinition("urService");
beanDefinition.tAutowireCandidate(fal);
}
}
以上代码就是利⽤BeanFactoryPostProcessor来拿到BeanFactory，然后获取BeanFactory内的某个BeanDefinition对象并进⾏修改，这⼀步是发⽣在Spring启动时，创建单例Bean之前的，所以此时对BeanDefiniton修改是会⽣效的。
注意：在ApplicationContext内部有⼀个核⼼的DefaultListableBeanFactory，它实现了ConfigurableListableBeanFactory和BeanDefinitionRegistry接⼝，所以ApplicationContext和DefaultListableBeanFactory是可以注册BeanDefinition的，但是ConfigurableListableBeanFactory是不能注册BeanDefinition的，只能获取BeanDefinition，然后做修改。emailverify
所以Spring还提供了⼀个BeanFactoryPostProcessor的⼦接⼝：BeanDefinitionRegistryPostProcessor
BeanDefinitionRegistryPostProcessor
BeanDefinitionRegistryPostProcessor继承了BeanFactoryPostProcessor接⼝，并新增了⼀个⽅法，⽅法参数为BeanDefinitionRegistry，如果换们提供⼀个类来实现BeanDefinitionRegistryPostProcesso
r，那么在postProcessBeanDefinitionRegistry()⽅法中就可以注册BeanDefinition了。
public class KingBeanDefinitionRegistryPostProcessor implements BeanDefinitionRegistryPostProcessor {
@Override
public void postProcessBeanDefinitionRegistry(BeanDefinitionRegistry registry) throws BeansException {
AbstractBeanDefinition beanDefinition = icBeanDefinition().getBeanDefinition();
beanDefinition.tBeanClass(Ur.class);
coldsteel}
@Override
public void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) throws BeansException {
BeanDefinition beanDefinition = BeanDefinition("urService");
beanDefinition.tAutowireCandidate(fal);
}
}
理解refresh()
这是ConfigurableApplicationContext接⼝上的refresh()⽅法的注解，意思是：加载或刷新持久化的配置，可能是xml⽂件，属性⽂件或关系数据库中存储的。由于这是⼀个启动⽅法，如果失败，它应该销毁已经创建的单例，以避免占⽤资源。也就是说在调⽤该⽅法之后，应该实例化所有的单例，或者根本不实例化单例。
在Spring设计中，也提供可以刷新的ApplicationContext和不可以刷新的ApplicationContext
// 可以刷新的ApplicationContext
AbstractRefreshableApplicationContext extends AbstractApplicationContext
//不可以刷新的ApplicationContext
GenericApplicationContext extends AbstractApplicationContext
AnnotationConfigApplicationContext继承的是GenericApplicationContext，所以它是不能刷新的。AnnotationConfigWebApplicationContext继承的是AbstractRefreshableWebApplicationContext，所以它是可以刷新的refresh()底层原理流程
以AnnotationConfigApplicationContext为例，来看看refresh的底层原理：
1. 在调⽤AnnotationConfigApplicationContext的构造⽅法之前，会调⽤⽗类GenericApplicationContext的⽆参构造⽅法，会构造
⼀个BeanFactory，为DefaultListableBeanFactory
2. 构造AnnotatedBeanDefinitionReader（增加⼀些基础的的PostProcessor），同时对BeanFactory进⾏设置和添加
PostProcessor（后置处理器）
3. 构造ClassPathBeanDefinitionScanner（主要是⽤来扫描得到注册BeanDefinition）
4. 利⽤reader注册AppConfig为BeanDefinition，类型为AnnotatedGenericBeanDefinition
5. 调⽤refresh⽅法
6. prepareRefresh()：记录启动时间，可以允许⼦容器设置⼀些内容到Environment中，验证Environment中是否包括了必须要有的
属性
7. obtainFreshBeanFactory()：进⾏BeanFactory的refresh，在这⾥会去调⽤⼦类的refreshBeanFactory⽅法，具体⼦类是怎么刷
新的得看⼦类，然后再调⽤⼦类的getBeanFactory⽅法，重新得到⼀个BeanFactory
8. prepareBeanFactory(beanFactory)：设置beanFactory的类加载器，设置表达式解析器，添加PropertyEditorRegistrar，添加
⼀个Bean的后置处理器，添加ignoredDependencyInterface，添加resolvableDependencies，添加⼀个Bean的后置处理器ApplicationListenerDetector，增加⼀个Bean的后置处理器LoadTimeWeaverAwareProcessor，增加⼀些单例bean到单例池
9. postProcessBeanFactory(beanFactory) ： 提供给AbstractApplicationContext的⼦类进⾏扩展
10. invokeBeanFactoryPostProcessors(beanFactory)：执⾏BeanFactoryPostProcessor
11. 得到BeanDefinition并注册到BeanFactory中
12. registerBeanPostProcessors(beanFactory)：这⼀步会把BeanFactory中所有的BeanPostProcessor找出来并实例化得到⼀个
对象，并添加到BeanFactory中去（属性 beanPostProcessors），最后再重新添加⼀个ApplicationListenerDetector对象（之前其实 就添加了过，这⾥是为了把ApplicationListenerDetector移动到最后）
collaboration>谈论的英文13. initMessageSource()：如果BeanFactory中存在⼀个叫做"messageSource"的 BeanDefinition，那么就会把这个Bean对象创建
出来并赋值给ApplicationContext的messageSource属性，让ApplicationContext拥有国际化的功能
14. initApplicationEventMulticaster()：如果BeanFactory中存在⼀个叫做"applicationEventMulticaster"的BeanDefinition，那么就
会把这个Bean对象创建出来并赋值给ApplicationContext的applicationEventMulticaster属性，让ApplicationContext拥有事件发布的功能
15. onRefresh()：提供给AbstractApplicationContext的⼦类进⾏扩展
16. registerListeners()：从BeanFactory中获取ApplicationListener类型的beanName，然后添加到ApplicationContext中的事件⼴
播器applicationEventMulticaster中去，到这⼀步因为FactoryBean还没有调⽤getObject()⽅法⽣成Bean对象，所以这⾥要在根据类型找⼀下ApplicationListener，记录⼀下对应的beanName
17. finishBeanFactoryInitialization(beanFactory)：完成BeanFactory的初始化，主要就是实例化⾮懒加载的单例Bean
18. finishRefresh()：BeanFactory的初始化完后，就到了Spring启动的最后⼀步了
19. 设置ApplicationContext的lifecycleProcessor，默认情况下设置的是DefaultLifecycleProcessor
20. 调⽤lifecycleProcessor的onRefresh()⽅法，如果是DefaultLifecycleProcessor，那么会获取所有类型为Lifecycle的Bean对issues是什么意思
象，然后调⽤它的start()⽅法，这就是ApplicationContext的⽣命周期扩展机制
21. 发布ContextRefreshedEvent事件
执⾏BeanFactoryPostProcessor
1. 执⾏通过ApplicationContext添加进来的BeanDefinitionRegistryPostProcessor的 postProcessBeanDefinitionRegistry()⽅法
2. 执⾏BeanFactory中实现了PriorityOrdered接⼝的BeanDefinitionRegistryPostProcessor的
postProcessBeanDefinitionRegistry()⽅法
3. 执⾏BeanFactory中实现了Ordered接⼝的BeanDefinitionRegistryPostProcessor的postProcessBea
nDefinitionRegistry()⽅
法
4. 执⾏BeanFactory中其他的BeanDefinitionRegistryPostProcessor的postProcessBeanDefinitionRegistry()⽅法
5. 执⾏上⾯所有的BeanDefinitionRegistryPostProcessor的postProcessBeanFactory()⽅法amaranth
6. 执⾏通过ApplicationContext添加进来的BeanFactoryPostProcessor的postProcessBeanFactory()⽅法
百度翻译下载
7. 执⾏BeanFactory中实现了PriorityOrdered接⼝的BeanFactoryPostProcessor的postProcessBeanFactory()⽅法
8. 执⾏BeanFactory中实现了Ordered接⼝的BeanFactoryPostProcessor的postProcessBeanFactory()⽅法
9. 执⾏BeanFactory中其他的BeanFactoryPostProcessor的postProcessBeanFactory()⽅法
Lifecycle的使⽤
Lifecycle表⽰的是ApplicationContext的⽣命周期，可以定义⼀个SmartLifecycle来监听ApplicationContext的启动和关闭：
import t.SmartLifecycle;
import org.springframework.stereotype.Component;
@Component
public class KingLifecycle implements SmartLifecycle {
private boolean isRunning = fal;
@Override
public void start() {cips
System.out.println("启动");
isRunning = true;
}
@Override
public void stop() {
//要触发stop()，要调⽤context.clo()，或注册关闭钩⼦（isterShutdownHook();）
System.out.println("停⽌");
isRunning = fal;
}
@Override
public boolean isRunning() {
return isRunning;
magic}
}
