一,Spring启动流程概述
Spring的IoC容器在实现控制反转和依赖注入的过程中,可以划分为两个阶段:
-
容器启动阶段
-
Bean实例化阶段
容器初始化
-
加载配置
-
分析配置信息
-
将Bean信息装配到BeanDefinition
-
将Bean信息注册到相应的BeanDefinitionRegistry
-
其他后续处理
容器实例化
-
根据策略实例化对象
-
装配依赖
-
Bean初始化前处理
-
对象初始化
-
对象其他处理
-
注册回调接口
二,Spring启动流程详解
完成刷新
protected void finishRefresh() {
// 为上下文初始化生命周期处理器
initLifecycleProcessor();
// 将刷新事件传播到生命周期处理器
getLifecycleProcessor().onRefresh();
// 发布刷新完毕事件到对应的监听器
publishEvent(new ContextRefreshedEvent(this));
// 注册Mbean
LiveBeansView.registerApplicationContext(this);
}
Spring使用BeanPostProcessor来处理可以找到的任何接口实现并调用具体的方法。如果需要自定义功能或其他生命周期行为,Spring并不提供现成的功能,需要自己实现BeanPostProcessor。
除了初始化和销毁回调外,Bean对象还可以实现Lifecycle接口,以便这些Bean可以在容器自身的生命周期驱动下进行start和stop过程。Lifecycle接口为具有生命周期要求的对象定义了基本方法。
当ApplicationContext接收到开始和停止信号时,它会调用那些关联到在该上下文中的所有Lifecycle实现类(如:启动和停止某些后台进程)。
解码解读
org.springframework.context.support.AbstractApplicationContext
// 初始化生命周期处理器
protected void initLifecycleProcessor() {
// 获取BeanFactory
ConfigurableListableBeanFactory beanFactory = getBeanFactory();
// 判断BeanFactory中是否已经定义过lifecycleProcessor
if (beanFactory.containsLocalBean(LIFECYCLE_PROCESSOR_BEAN_NAME)) {
// 如果定义过lifecycleProcessor,则使用beanFactory中的定义给lifecycleProcessor赋值
this.lifecycleProcessor =
beanFactory.getBean(LIFECYCLE_PROCESSOR_BEAN_NAME, LifecycleProcessor.class);
if (logger.isDebugEnabled()) {
// 日志打印
}
}
else {
// 如果BeanFactory中没有定义lifecycleProcessor,则构造一个DefaultLifecycleProcessor
DefaultLifecycleProcessor defaultProcessor = new DefaultLifecycleProcessor();
// 设置defaultProcessor的BeanFactory
defaultProcessor.setBeanFactory(beanFactory);
this.lifecycleProcessor = defaultProcessor;
// 将defaultProcessor以单例的形式注册到BeanFactory的生命周期管理器
beanFactory.registerSingleton(LIFECYCLE_PROCESSOR_BEAN_NAME, this.lifecycleProcessor);
if (logger.isDebugEnabled()) {
logger.debug("Unable to locate LifecycleProcessor with name '" +
LIFECYCLE_PROCESSOR_BEAN_NAME +
"': using default [" + this.lifecycleProcessor + "]");
}
}
}
org.springframework.context.support.DefaultLifecycleProcessor
private void startBeans(boolean autoStartupOnly) {
// 获取所有的Lifecycle接口实现类
Map<String, Lifecycle> lifecycleBeans = getLifecycleBeans();
// 按phase进行分组存储
Map<Integer, LifecycleGroup> phases = new HashMap<Integer, LifecycleGroup>();
for (Map.Entry<String, ? extends Lifecycle> entry : lifecycleBeans.entrySet()) {
Lifecycle bean = entry.getValue();
// 如果参数autoStartupOnly不等于true,或者bean是SmartLifecycle实现类并且autoStartup=true
// autoStartupOnly=true 代表本次刷新为自动启动,触发所有自动启动的SmartLifecycle实现类
// autoStartupOnly=false 代表本次刷新为显式调用,触发所有的Lifecycle实现类启动
if (!autoStartupOnly || (bean instanceof SmartLifecycle && ((SmartLifecycle) bean).isAutoStartup())) {
// 获取Lifecycle Bean的phase,phase默认为0
int phase = getPhase(bean);
// 根据phase获取对应的分组
LifecycleGroup group = phases.get(phase);
if (group == null) {
// 如果没有分组,则新建一个分组
group = new LifecycleGroup(phase, this.timeoutPerShutdownPhase, lifecycleBeans, autoStartupOnly);
// 把phase和对应的group放入到集合
phases.put(phase, group);
}
// 把对应的Lifecycle Bean放到对应的分组中
group.add(entry.getKey(), bean);
}
}
// 遍历分组后的集合
if (!phases.isEmpty()) {
List<Integer> keys = new ArrayList<Integer>(phases.keySet());
// 根据分组phase进行排序
Collections.sort(keys);
for (Integer key : keys) {
// 根据分组顺序依次启动Lifecycle Bean
phases.get(key).start();
}
}
}
// 遍历集合成员,执行Lifecycle实现类的start()函数回调
public void start() {
if (this.members.isEmpty()) {
return;
}
if (logger.isInfoEnabled()) {
logger.info("Starting beans in phase " + this.phase);
}
// 对分组内的member进行排序
Collections.sort(this.members);
for (LifecycleGroupMember member : this.members) {
if (this.lifecycleBeans.containsKey(member.name)) {
// 启动Lifecycle Bean
doStart(this.lifecycleBeans, member.name, this.autoStartupOnly);
}
}
}
private void doStart(Map<String, ? extends Lifecycle> lifecycleBeans, String beanName, boolean autoStartupOnly) {
Lifecycle bean = lifecycleBeans.remove(beanName);
if (bean != null && bean != this) {
// 根据beanName获取相应的依赖Bean
String[] dependenciesForBean = this.beanFactory.getDependenciesForBean(beanName);
// 遍历依赖Bean
for (String dependency : dependenciesForBean) {
// 递归。先回调依赖Bean的start函数(如果依赖Bean是Lifecycle实现类)
doStart(lifecycleBeans, dependency, autoStartupOnly);
}
if (!bean.isRunning() &&
(!autoStartupOnly || !(bean instanceof SmartLifecycle) || ((SmartLifecycle) bean).isAutoStartup())) {
if (logger.isDebugEnabled()) {
// 打印日志
}
try {
// 执行Lifecycle实现类的start()函数回调
bean.start();
}
catch (Throwable ex) {
throw new ApplicationContextException("Failed to start bean '" + beanName + "'", ex);
}
if (logger.isDebugEnabled()) {
logger.debug("Successfully started bean '" + beanName + "'");
}
}
}
}