- 推测web应用类型。
- spi的方式获取BootstrapRegistryInitializer、ApplicationContextInitializer、ApplicationContextInitializer对象。
- 通过调用栈推测出main()方法所在的类。
- 调用启动方法:run(String... args)。后面的步骤在这个方法内部!
- 触发SpringApplicationRunListener的starting()。
- 创建Environment对象。
- 触发SpringApplicationRunListener的environmentPrepared()。
- 打印Banner。
- 创建Spring容器对象(ApplicationContext)。
- 利用ApplicationContextInitializer初始化Spring容器对象。
- 触发SpringApplicationRunListener的contextPrepared()。
- 调用DefaultBootstrapContext对象的close()。
- 将启动类作为配置类注册到Spring容器中(load()方法)。
- 触发SpringApplicationRunListener的contextLoaded()。
- 刷新Spring容器。
- 触发SpringApplicationRunListener的started()。
- 调用ApplicationRunner和CommandLineRunner。
- 触发SpringApplicationRunListener的ready()。
- 上述过程抛异常了就触发SpringApplicationRunListener的failed()。
入口位置
- 第一步构造对象:new SpringApplication(primarySources)
- 第二步调用SpringApplication.run(String... args)
// 我们自己写的main方法
@SpringBootApplication
public class ZfcqApp {
public static void main(String[] args) {
SpringApplication.run(ZfcqApp.class, args);
}
}
/**
* 他会调用SpringApplication的run方法
* primarySource:我们传入的类的class
* args:我们传入的参数,一般是启动的时候-D制定的参数
*/
public static ConfigurableApplicationContext run(Class<?> primarySource, String... args) {
return run(new Class<?>[] { primarySource }, args);
}
/**
* 继续看内部调用的run方法
*/
public static ConfigurableApplicationContext run(Class<?>[] primarySources, String[] args) {
// 俩步,第一步构造对象:new SpringApplication(primarySources)
// 第二步调用SpringApplication.run(String... args)
// 这里我们可以在main方法中分开俩步去写,从而可以在中间设置SpringApplication对象的信息
return new SpringApplication(primarySources).run(args);
}
构造SpringApplication源码分析
/**
* 调用俩个参数的构造方法
* primarySources:我们主类的class
*/
public SpringApplication(Class<?>... primarySources) {
this(null, primarySources);
}
/**
* 俩个产生的构造方法
*/
public SpringApplication(ResourceLoader resourceLoader, Class<?>... primarySources) {
// 赋值到全局,这里第一次传入的是null
this.resourceLoader = resourceLoader;
// 主类存在的判断
Assert.notNull(primarySources, "PrimarySources must not be null");
// 赋值到全局,这里一般传入的是我们的main方法的类
this.primarySources = new LinkedHashSet<>(Arrays.asList(primarySources));
// 推测WEB应用的类型(NONE、SERVLET、REACTIVE)
this.webApplicationType = WebApplicationType.deduceFromClasspath();
// 从spring.factories中获取BootstrapRegistryInitializer对象的值
this.bootstrapRegistryInitializers = new ArrayList<>(getSpringFactoriesInstances(BootstrapRegistryInitializer.class));
// 从spring.factories中获取ApplicationContextInitializer对象的值
setInitializers((Collection) getSpringFactoriesInstances(ApplicationContextInitializer.class));
// 从spring.factories中获取ApplicationListener对象的值。非常重要的有一个是EnvironmentPostProcessorApplicationListener
setListeners((Collection) getSpringFactoriesInstances(ApplicationListener.class));
// 推测出main方法所在的类!SpringApplication.run(ZfcqApp.class, args);可以传任意的类!
this.mainApplicationClass = deduceMainApplicationClass();
}
推测web应用类型
-
REACTIVE:web应用。
-
NONE:无Servlet,不是web应用。
-
SERVLET:除去上面俩种的其他应用。
static WebApplicationType deduceFromClasspath() {
// 如果项目依赖中存在org.springframework.web.reactive.DispatcherHandler,并且不存在org.springframework.web.servlet.DispatcherServlet,那么应用类型为WebApplicationType.REACTIVE
if (ClassUtils.isPresent(WEBFLUX_INDICATOR_CLASS, null) && !ClassUtils.isPresent(WEBMVC_INDICATOR_CLASS, null) && !ClassUtils.isPresent(JERSEY_INDICATOR_CLASS, null)) {
return WebApplicationType.REACTIVE;
}
// 如果项目依赖中不存在org.springframework.web.reactive.Dispatche#rHandler,也不存在org.springframework.web.servlet.DispatcherServlet,那么应用类型为WebApplicationType.NONE
for (String className : SERVLET_INDICATOR_CLASSES) {
if (!ClassUtils.isPresent(className, null)) {
return WebApplicationType.NONE;
}
}
// 否则,应用类型为WebApplicationType.SERVLET
return WebApplicationType.SERVLET;
}
推测出Main类(main()方法所在的类)
private Class<?> deduceMainApplicationClass() {
try {
// 获取调用栈数组
StackTraceElement[] stackTrace = new RuntimeException().getStackTrace();
// 找到调用栈中的main方法!
for (StackTraceElement stackTraceElement : stackTrace) {
if ("main".equals(stackTraceElement.getMethodName())) {
return Class.forName(stackTraceElement.getClassName());
}
}
}
catch (ClassNotFoundException ex) {
// Swallow and continue
}
return null;
}
核心的启动方法:run(String... args)
public ConfigurableApplicationContext run(String... args) {
// 开始时间
long startTime = System.nanoTime();
// 创建引导启动器,类似一个ApplicationContext,可以往里面添加一些对象。
DefaultBootstrapContext bootstrapContext = createBootstrapContext();
// spring容器对象,开始的时候为空
ConfigurableApplicationContext context = null;
// 与awt有关,一般用不上
configureHeadlessProperty();
// spring boot的启动监听器
// 从spring.factories中获取SpringApplicationRunListener对象的值
// 默认会拿到EventPublishingRunListener,他会启动各个地方的ApplicationEvent事件。
SpringApplicationRunListeners listeners = getRunListeners(args);
// 发布开始启动的事件:ApplicationstartingEvent
listeners.starting(bootstrapContext, this.mainApplicationClass);
try {
// 把run方法的参数进行封装
ApplicationArguments applicationArguments = new DefaultApplicationArguments(args);
// 准备environment对象:包括操作系统、jvm、ymal、properties....配置
// 发布一个ApplicationEnvironmentPreparedEvent事件。
ConfigurableEnvironment environment = prepareEnvironment(listeners, bootstrapContext, applicationArguments);
// 默认spring.beaninfo.ignore为true,表示不需要jdk去缓存BeanInfo信息,spring自己缓存。
// 这里是spring在创建bean的时候会利用jdk的一些工具来解析一个类的相关信息,jdk在解析一个类的信息的时候会进行缓存,这里就是禁止了jdk的缓存。
configureIgnoreBeanInfo(environment);
// 打印Banner
Banner printedBanner = printBanner(environment);
// 根据应用类型,创建spring容器
context = createApplicationContext();
// jdk9的一个机制,默认没做任何操作
context.setApplicationStartup(this.applicationStartup);
// 准备容器的操作
// 利用ApplicationContextInitializer初始化spring容器
// 发布ApplicationContextInitializedEvent(容器初始化完成)事件
// 发布BootstrapContextClosedEvent(关闭引导容器)事件
// 注册primarySources类(run方法存进来的配置类)
// 发布ApplicationPreparedEvent事件
prepareContext(bootstrapContext, context, environment, listeners, applicationArguments, printedBanner);
// refresh容器:解析配置类、扫描、启动webServer。spring相关的逻辑!
refreshContext(context);
// 空方法,类似spring的onRefresh方法,可以由子类实现。
afterRefresh(context, applicationArguments);
// 启动的事件
Duration timeTakenToStartup = Duration.ofNanos(System.nanoTime() - startTime);
if (this.logStartupInfo) {
new StartupInfoLogger(this.mainApplicationClass).logStarted(getApplicationLog(), timeTakenToStartup);
}
// 发布一个ApplicationStartedEvent事件,表示spring已经启动完成
listeners.started(context, timeTakenToStartup);
// 从spring容器中获取ApplicationRunner和CommandLineRunner,并执行他的run方法。
// 这俩个可以自己定义Bean
callRunners(context, applicationArguments);
}
catch (Throwable ex) {
// 失败之后,发布一个失败的事件:ApplicationFailedEvent
handleRunFailure(context, ex, listeners);
throw new IllegalStateException(ex);
}
try {
// 计算下事件
Duration timeTakenToReady = Duration.ofNanos(System.nanoTime() - startTime);
// 一切都成功,发布ApplicationStartedEvent事件
listeners.ready(context, timeTakenToReady);
}
catch (Throwable ex) {
// 失败之后,发布一个失败的事件:ApplicationFailedEvent
handleRunFailure(context, ex, null);
throw new IllegalStateException(ex);
}
return context;
}
创建引导启动器
private DefaultBootstrapContext createBootstrapContext() {
// 构建一个DefaultBootstrapContext对象,这个对象是2.4.0之后才会有!
DefaultBootstrapContext bootstrapContext = new DefaultBootstrapContext();
// 利用bootstrapRegistryInitializers初始化bootstrapContext。可以在spring.factories中设置bootstrapRegistryInitializers
this.bootstrapRegistryInitializers.forEach((initializer) -> initializer.initialize(bootstrapContext));
return bootstrapContext;
}
准备environment
private ConfigurableEnvironment prepareEnvironment(SpringApplicationRunListeners listeners, DefaultBootstrapContext bootstrapContext, ApplicationArguments applicationArguments) {
// Create and configure the environment 这句话是源码中本身的注释!
// 创建ApplicationServletEnvironment。
ConfigurableEnvironment environment = getOrCreateEnvironment();
// 添加SimpleCommandLinePropertySource放在首位
configureEnvironment(environment, applicationArguments.getSourceArgs());
// 把所有的PropertySource封装为ConfigurationPropertySourcesPropertySource,然后添加到environment中,放在首位!
ConfigurationPropertySources.attach(environment);
// 发布ApplicationEnvironmentPreparedEvent(应用Environment准备完成)事件,表示环境已经准备好了。默认EnvironmentPostProcessorApplicationListener去处理这个事件!
listeners.environmentPrepared(bootstrapContext, environment);
// 把DefaultProperties放到最后
DefaultPropertiesPropertySource.moveToEnd(environment);
// 环境中spring.main.environment-prefix参数校验
Assert.state(!environment.containsProperty("spring.main.environment-prefix"), "Environment prefix cannot be set via properties.");
// 环境中spring.main参数校验
bindToSpringApplication(environment);
if (!this.isCustomEnvironment) {
environment = convertEnvironment(environment);
}
ConfigurationPropertySources.attach(environment);
return environment;
}
准备spring容器的操作
private void prepareContext(DefaultBootstrapContext bootstrapContext, ConfigurableApplicationContext context, ConfigurableEnvironment environment, SpringApplicationRunListeners listeners, ApplicationArguments applicationArguments, Banner printedBanner) {
// 设置环境变量到spring容器
context.setEnvironment(environment);
// 设置在SpringApplication上的BeanNameGenerator、resourceLoader设置到spring容器中
postProcessApplicationContext(context);
// 使用ApplicationContextInitializer初始化spring容器
applyInitializers(context);
// 容器初始化完成,发布ApplicationContextInitializedEvent事件
listeners.contextPrepared(context);
// 关闭引导的容器
bootstrapContext.close(context);
if (this.logStartupInfo) {
logStartupInfo(context.getParent() == null);
logStartupProfileInfo(context);
}
// 注册一些单例Bean
// Add boot specific singleton beans
ConfigurableListableBeanFactory beanFactory = context.getBeanFactory();
beanFactory.registerSingleton("springApplicationArguments", applicationArguments);
if (printedBanner != null) {
beanFactory.registerSingleton("springBootBanner", printedBanner);
}
// spring容器设置AllowCircularReferences和allowBeanDefinitionOverriding
if (beanFactory instanceof AbstractAutowireCapableBeanFactory) {
((AbstractAutowireCapableBeanFactory) beanFactory).setAllowCircularReferences(this.allowCircularReferences);
if (beanFactory instanceof DefaultListableBeanFactory) {
((DefaultListableBeanFactory) beanFactory) .setAllowBeanDefinitionOverriding(this.allowBeanDefinitionOverriding);
}
}
if (this.lazyInitialization) {
context.addBeanFactoryPostProcessor(new LazyInitializationBeanFactoryPostProcessor());
}
// Load the sources
// 拿到启动配置(run方法传递进来的)
Set<Object> sources = getAllSources();
Assert.notEmpty(sources, "Sources must not be empty");
// 将启动配置类解析为BeanDefinition注册到spring容器
load(context, sources.toArray(new Object[0]));
// 发布ApplicationPreparedEvent事件,表示已经启动好spring容器
listeners.contextLoaded(context);
}
结束语
- 你的点赞是我提高文章质量最大的动力!!!
- 获取更多本文的前置知识文章,以及新的有价值的文章,让我们一起成为架构师!
- 目前已经完成了并发编程、MySQL、spring源码、Mybatis的源码。可以在公众号下方菜单点击查看之前的文章!
- 这个公众号的所有技术点,会分析的很深入!
- 这个公众号,无广告!!!