1.1 Springboot启动:
@SpringBootApplication
public class ServerApplication {
public static void main(String[] args) {
SpringApplication.run(ServerApplication.class,args);
}
}
从上面代码看,调用了SpringApplication的静态方法run。这个run方法会构造一个SpringApplication的实例,然后再调用这里实例的run方法就表示启动SpringBoot。具体对象处理流程看下边时序图:
概述:
- 构造SpringApplication的实例(时序图步骤1-2)
- 调用SpringApplication.run()方法(时序图步骤3)
- 构造SpringApplicationRunListeners 实例(时序图步骤3.1.1)
- 发布ApplicationStartedEvent事件(时序图步骤3.1.2)
- SpringApplicationRunListeners 实例准备环境信息(时序图步骤3.1.3)
- 创建ApplicationContext对象(时序图步骤3.1.4)
- ApplicationContext实例准备环境信息(时序图步骤3.1.5)
- 刷新的上下文(时序图步骤3.1.6)
注:文章按照该顺序讲解【1.2 启动加载过程分析】
时序图:
1.2 启动加载过程分析
1.2.1 构造SpringApplication的实例(时序图步骤1-2)
代码
public static ConfigurableApplicationContext run(Object[] sources, String[] args) {
// 步骤1
return new SpringApplication(sources).run(args);
}
public SpringApplication(Object... sources) {
// 步骤1.1
initialize(sources);
}
@SuppressWarnings({ "unchecked", "rawtypes" })
private void initialize(Object[] sources) {
if (sources != null && sources.length > 0) {
this.sources.addAll(Arrays.asList(sources));
}
this.webEnvironment = deduceWebEnvironment();
//加载META-INF/spring.factories路径ApplicationContextInitializer.class
getSpringFactoriesInstances(
ApplicationContextInitializer.class));
setListeners((Collection)
//加载META-INF/spring.factories路径ApplicationListener.class
getSpringFactoriesInstances(ApplicationListener.class));
this.mainApplicationClass = deduceMainApplicationClass();
}
分析
⑴.通过ClassLoader.getResources加载META-INF/spring.factories路径下的
文件信息,从中找key为ApplicationContextInitializer.class,并实例化。
⑵.通过ClassLoader.getResources加载META-INF/spring.factories路径下的
文件信息ApplicationListener.class对应类,并实例化。
1.2.2 调用SpringApplication.run()方法(时序图步骤3)
代码:
public ConfigurableApplicationContext run(String... args) {
StopWatch stopWatch = new StopWatch();
stopWatch.start();
ConfigurableApplicationContext context = null;
FailureAnalyzers analyzers = null;
configureHeadlessProperty();
// 步骤3.1.1
SpringApplicationRunListeners listeners = getRunListeners(args);
// 步骤3.1.2
listeners.starting();
try {
ApplicationArguments applicationArguments = new DefaultApplicationArguments(
args);
// 步骤 3.1.3
ConfigurableEnvironment environment = prepareEnvironment(listeners,
applicationArguments);
Banner printedBanner = printBanner(environment);
// 步骤3.1.4
context = createApplicationContext();
analyzers = new FailureAnalyzers(context);
// 步骤3.1.5
prepareContext(context, environment, listeners, applicationArguments,
printedBanner);
// 步骤3.1.6
refreshContext(context);
// 步骤3.1.7
afterRefresh(context, applicationArguments);
// 步骤3.1.8
listeners.finished(context, null);
stopWatch.stop();
if (this.logStartupInfo) {
new StartupInfoLogger(this.mainApplicationClass)
.logStarted(getApplicationLog(), stopWatch);
}
return context;
}
catch (Throwable ex) {
handleRunFailure(context, listeners, analyzers, ex);
throw new IllegalStateException(ex);
}
}
1.2.2 步骤3.1.1:
代码
private SpringApplicationRunListeners getRunListeners(String[] args) {
Class<?>[] types = new Class<?>[] { SpringApplication.class, String[].class };
// (1)
return new SpringApplicationRunListeners(logger, getSpringFactoriesInstances(
SpringApplicationRunListener.class, types, this, args));
}
分析
(1). 通过ClassLoader.getResources加载META-INF/spring.factories路径下的
文件信息,从中找key为SpringApplicationRunListener对应类,并实例化。
1.2.3 步骤3.1.2:
代码
public void starting() {
for (SpringApplicationRunListener listener : this.listeners) {
listener.starting();
}
}
@Override
@SuppressWarnings("deprecation")
public void starting() {
this.initialMulticaster
.multicastEvent(new ApplicationStartedEvent(this.application, this.args));
}
分析
发布ApplicationStartedEvent事件。
1.2.4 步骤3.1.3:
代码
private ConfigurableEnvironment prepareEnvironment(
SpringApplicationRunListeners listeners,
ApplicationArguments applicationArguments) {
// Create and configure the environment
// ⑴. 得到环境对象ConfigurableEnvironment
ConfigurableEnvironment environment = getOrCreateEnvironment();
// ⑵. 并配置环境信息;对listeners初始化环境属性
configureEnvironment(environment, applicationArguments.getSourceArgs());
// ⑶. 发布ApplicationEnvironmentPreparedEvent事件。
listeners.environmentPrepared(environment);
if (isWebEnvironment(environment) && !this.webEnvironment) {
environment = convertToStandardEnvironment(environment);
}
return environment;
}
分析
⑴. 得到环境对象ConfigurableEnvironment
⑵. 并配置环境信息;对listeners初始化环境属性。
⑶. 发布ApplicationEnvironmentPreparedEvent事件。
步骤3.1.4:
分析
创建ApplicationContext对象 ,其中在实例化ApplicationContext子类
AnnotationConfigApplicationContext时,如代码:
public AnnotationConfigApplicationContext() {
this.reader = new AnnotatedBeanDefinitionReader(this);
this.scanner = new ClassPathBeanDefinitionScanner(this);
}
会创建AnnotatedBeanDefinitionReader对象检测是否需要将一下对象放到Spring上下文中
// 用户配置Configuration注解,实现了BeanDefinitionRegistryPostProcessor接口
ConfigurationClassPostProcessor
// 用于配置Autowired注解,实现了MergedBeanDefinitionPostProcessor接口
AutowiredAnnotationBeanPostProcessor
// 用于配置Required注解,实现了MergedBeanDefinitionPostProcessor接口
RequiredAnnotationBeanPostProcessor
// 用于配置JSR-250注解,实现了InstantiationAwareBeanPostProcessor接口
CommonAnnotationBeanPostProcessor
// 用于配置JPA注解
PersistenceAnnotationBeanPostProcessor
// 用于配置EventListener注解,实现了SmartInitializingSingleton接口
EventListenerMethodProcessor
// EventListener工厂
DefaultEventListenerFactory
步骤3.1.5:
代码
private void prepareContext(ConfigurableApplicationContext context,
ConfigurableEnvironment environment, SpringApplicationRunListeners listeners,
ApplicationArguments applicationArguments, Banner printedBanner) {
// ⑴.对ApplicationContext设置环境变量;
context.setEnvironment(environment);
// ⑵.配置属性ResourceLoader和ClassLoader属性;
postProcessApplicationContext(context);
// ⑶.循环初始化继承了
applyInitializers(context);
listeners.contextPrepared(context);
if (this.logStartupInfo) {
logStartupInfo(context.getParent() == null);
logStartupProfileInfo(context);
}
// Add boot specific singleton beans
context.getBeanFactory().registerSingleton("springApplicationArguments",
applicationArguments);
if (printedBanner != null) {
context.getBeanFactory().registerSingleton("springBootBanner", printedBanner);
}
// Load the sources
Set<Object> sources = getSources();
Assert.notEmpty(sources, "Sources must not be empty");
load(context, sources.toArray(new Object[sources.size()]));
listeners.contextLoaded(context);
}
分析:
⑴.对ApplicationContext设置环境变量;
⑵.配置属性ResourceLoader和ClassLoader属性;
⑶.调用步骤1查询出来ApplicationContextInitializer子类,循环调用initialize()方法。
@SuppressWarnings({ "rawtypes", "unchecked" })
protected void applyInitializers(ConfigurableApplicationContext context) {
for (ApplicationContextInitializer initializer : getInitializers()) {
Class<?> requiredType = GenericTypeResolver.resolveTypeArgument(
initializer.getClass(), ApplicationContextInitializer.class);
Assert.isInstanceOf(requiredType, context, "Unable to call initializer.");
initializer.initialize(context);
}
}
⑷.发布ApplicationPreparedEvent事件。
步骤3.1.6
代码:
@Override
public void refresh() throws BeansException, IllegalStateException {
synchronized (this.startupShutdownMonitor) {
// ⑴.准备刷新的上下文环境
prepareRefresh();
// ⑵.初始化BeanFactory
ConfigurableListableBeanFactory beanFactory = obtainFreshBeanFactory();
// ⑶.对BeanFactory进行各种功能填充
prepareBeanFactory(beanFactory);
try {
// ⑷.子类覆盖方法做额外的处理
postProcessBeanFactory(beanFactory);
// ⑸.激活各种BeanFactory处理器
invokeBeanFactoryPostProcessors(beanFactory);
// ⑹.注册拦截Bean创建的Bean处理,这里只是注册,真正调用是再拿去Bean的时候
registerBeanPostProcessors(beanFactory);
// ⑺.为上下文初始化Message源,即不同语言的消息体,国际化处理
initMessageSource();
// ⑻.初始化应用消息广播器,并放到applicationEventMulticaster bean中
initApplicationEventMulticaster();
// ⑼.留给子类来初始化其他bean
onRefresh();
// ⑽.在所有注册的bean中查找Listener bean,注册到消息广播中
registerListeners();
// ⑾.初始化剩下的单实例(非惰性)
finishBeanFactoryInitialization(beanFactory);
// ⑿.完成刷新过程,通知生命周期处理器lifecycleProcessor刷新过程,同时发出ContextRefreshEvent通知别人
finishRefresh();
}
catch (BeansException ex) {
if (logger.isWarnEnabled()) {
logger.warn("Exception encountered during context initialization - " +
"cancelling refresh attempt: " + ex);
}
// Destroy already created singletons to avoid dangling resources.
destroyBeans();
// Reset 'active' flag.
cancelRefresh(ex);
// Propagate exception to caller.
throw ex;
}
finally {
// Reset common introspection caches in Spring's core, since we
// might not ever need metadata for singleton beans anymore...
resetCommonCaches();
}
}
}
分析:
⑴.准备刷新的上下文环境
⑵.初始化BeanFactory
⑶.对BeanFactory进行各种功能填充
⑷.子类覆盖方法做额外的处理
⑸.激活各种BeanFactory处理器
⑹.注册拦截Bean创建的Bean处理,这里只是注册,真正调用是再拿去Bean的时候
⑺.为上下文初始化Message源,即不同语言的消息体,国际化处理
⑻.初始化应用消息广播器,并放到applicationEventMulticaster bean中
⑼.留给子类来初始化其他bean
⑽.在所有注册的bean中查找Listener bean,注册到消息广播中
⑾.初始化剩下的单实例(非惰性)
⑿.完成刷新过程,通知生命周期处理器lifecycleProcessor刷新过程,同时发出ContextRefreshEvent通知别人