目录
setInitializers((Collection) getSpringFactoriesInstances(ApplicationContextInitializer.class))
setListeners((Collection) getSpringFactoriesInstances(ApplicationListener.class)
run(args) SpringBoot启动流程的最关键方法
configureEnvironment(environment, applicationArguments.getSourceArgs());
第五步:刷新应用上下文(IOC容器的初始化过程----从这里开始就是spring的源码内容 会去处理@SpringBootApplication注解)
SpringBoot项目的mian函数
@SpringBootApplication//标注在类上说明这个类是`SpringBoot`的主配置类
public class SpringBootMytestApplication{
public static void main(String[] args) {
SpringApplication.run(SpringBootMytestApplication.class, args);
}
}
run方法
public static ConfigurableApplicationContext run(Class<?> primarySource, String... args){
// 调用重载方法
return run(new Class<?>[] { primarySource }, args);
}
public static ConfigurableApplicationContext run(Class<?>[] primarySources, String[] args) {
// 两件事:1.初始化SpringApplication 2.执行run方法
return new SpringApplication(primarySources).run(args);
}
SpringApplication() 构造方法
继续查看源码, SpringApplication 实例化过程,首先是进入带参数的构造方法,最终回来到两个参数 的构造方法。
public SpringApplication(Class<?>... primarySources) { this(null, primarySources); } public SpringApplication(ResourceLoader resourceLoader, Class<?>... primarySources) { //设置资源加载器为null this.resourceLoader = resourceLoader; //断言加载资源类不能为null Assert.notNull(primarySources, "PrimarySources must not be null"); //将primarySources数组转换为List,最后放到LinkedHashSet集合中 this.primarySources = new LinkedHashSet<>(Arrays.asList(primarySources)); //【1.1 推断应用类型,后面会根据类型初始化对应的环境。常用的一般都是servlet环境 】 this.webApplicationType = WebApplicationType.deduceFromClasspath(); //【1.2 初始化classpath下 META-INF/spring.factories中已配置的ApplicationContextInitializer 】 setInitializers((Collection) getSpringFactoriesInstances(ApplicationContextInitializer.class)); //【1.3 初始化classpath下所有已配置的 ApplicationListener 】 setListeners((Collection) getSpringFactoriesInstances(ApplicationListener.class)); //【1.4 根据调用栈,推断出 main 方法的类名 】 this.mainApplicationClass = deduceMainApplicationClass(); }
deduceFromClasspath 推断应用类型方法
private static final String[] WEB_ENVIRONMENT_CLASSES = {"javax.servlet.Servlet", "org.springframework.web.context.ConfigurableWebApplicationContext"}; private static final String REACTIVE_WEB_ENVIRONMENT_CLASS = "org.springframework." + "web.reactive.DispatcherHandler"; private static final String MVC_WEB_ENVIRONMENT_CLASS = "org.springframework." + "web.servlet.DispatcherServlet"; private static final String JERSEY_WEB_ENVIRONMENT_CLASS = "org.glassfish.jersey.server.ResourceConfig"; /** * 判断 应用的类型 * NONE: 应用程序不是web应用,也不应该用web服务器去启动 * SERVLET: 应用程序应作为基于servlet的web应用程序运行,并应启动嵌入式servlet web(tomcat)服务器。 * REACTIVE: 应用程序应作为 reactive web应用程序运行,并应启动嵌入式 reactive web服 务器。 * @return */ static WebApplicationType deduceFromClasspath() { //classpath下必须存在org.springframework.web.reactive.DispatcherHandler if (ClassUtils.isPresent(WEBFLUX_INDICATOR_CLASS, null) && !ClassUtils.isPresent(WEBMVC_INDICATOR_CLASS, null) && !ClassUtils.isPresent(JERSEY_INDICATOR_CLASS, null)) { return WebApplicationType.REACTIVE; } for (String className : SERVLET_INDICATOR_CLASSES) { //classpath环境下不存在javax.servlet.Servlet或者org.springframework.web.context.ConfigurableWebApplicationContext if (!ClassUtils.isPresent(className, null)) { return WebApplicationType.NONE; } } return WebApplicationType.SERVLET; }
返回类型是WebApplicationType的枚举类型, WebApplicationType 有三个枚举,三个枚举的解释如 其中注释 具体的判断逻辑如下:
WebApplicationType.REACTIVE classpath下存在 org.springframework.web.reactive.DispatcherHandler
WebApplicationType.SERVLET classpath下存在javax.servlet.Servlet或者 org.springframework.web.context.ConfigurableWebApplicationContext
WebApplicationType.NONE 不满足以上条件。
setInitializers((Collection) getSpringFactoriesInstances(ApplicationContextInitializer.class))
【1.2 初始化classpath下 META-INF/spring.factories中已配置的ApplicationContextInitializer 】
private <T> Collection<T> getSpringFactoriesInstances(Class<T> type) { return getSpringFactoriesInstances(type, new Class<?>[] {}); } private <T> Collection<T> getSpringFactoriesInstances(Class<T> type, Class<?>[] parameterTypes, Object... args) { ClassLoader classLoader = getClassLoader(); // Use names and ensure unique to protect against duplicates //通过指定的classLoader从 META-INF/spring.factories 的资源文件中, //读取 key 为 type.getName() 的 value Set<String> names = new LinkedHashSet<>(SpringFactoriesLoader.loadFactoryNames(type, classLoader)); //创建工厂实例 List<T> instances = createSpringFactoriesInstances(type, parameterTypes, classLoader, args, names); //对Spring工厂实例排序(org.springframework.core.annotation.Order注解指定的顺序) AnnotationAwareOrderComparator.sort(instances); return instances; }
发现在上图所示的两个工程中找到了debug中看到的结果。 ApplicationContextInitializer 是Spring框架的类, 这个类的主要目的就是在 ConfigurableApplicationContext 调用refresh()方法之前,回调这个类的initialize方法。 通过 ConfigurableApplicationContext 的实例获取容器的环境Environment,从而实现对配置文件的 修改完善等工作。
setListeners((Collection) getSpringFactoriesInstances(ApplicationListener.class)
初始化classpath下 META-INF/spring.factories中已配置的 ApplicationListener。
ApplicationListener 的加载过程和上面的 ApplicationContextInitializer 类的加载过程是一样的。 不多说了,至于 ApplicationListener 是spring的事件监听器,典型的观察者模式,通过 ApplicationEvent 类和 ApplicationListener 接口,可以实现对spring容器全生命周期的监听,当然也 可以自定义监听事件
SpringApplication() 总结
纵观 SpringApplication 类的实例化 过程,我们可以看到,合理的利用该类,我们能在spring容器创建之前做一些预备工作,和定制化的需 求。
比如,自定义SpringBoot的Banner,比如自定义事件监听器,再比如在容器refresh之前通过自定义 ApplicationContextInitializer 修改配置一些配置或者获取指定的bean都是可以的
run(args) SpringBoot启动流程的最关键方法
/** * Run the Spring application, creating and refreshing a new * {@link ApplicationContext}. * @param args the application arguments (usually passed from a Java main method) * @return a running {@link ApplicationContext} * 运行spring应用,并刷新一个新的 ApplicationContext(Spring的上下文) * ConfigurableApplicationContext 是 ApplicationContext 接口的子接口。在 ApplicationContext * 基础上增加了配置上下文的工具。 ConfigurableApplicationContext是容器的高级接口 */ public ConfigurableApplicationContext run(String... args) { //记录程序运行时间 StopWatch stopWatch = new StopWatch(); stopWatch.start(); // ConfigurableApplicationContext Spring 的上下文 ConfigurableApplicationContext context = null; Collection<SpringBootExceptionReporter> exceptionReporters = new ArrayList<>(); configureHeadlessProperty(); //【1、获取并启动监听器】 SpringApplicationRunListeners listeners = getRunListeners(args); listeners.starting(); try { ApplicationArguments applicationArguments = new DefaultApplicationArguments(args); //【2、构造应用上下文环境】 ConfigurableEnvironment environment = prepareEnvironment(listeners, applicationArguments); //处理需要忽略的Bean configureIgnoreBeanInfo(environment); //打印banner Banner printedBanner = printBanner(environment); ///【3、初始化应用上下文】 context = createApplicationContext(); //实例化SpringBootExceptionReporter.class,用来支持报告关于启动的错误 exceptionReporters = getSpringFactoriesInstances(SpringBootExceptionReporter.class, new Class[] { ConfigurableApplicationContext.class }, context); //【4、刷新应用上下文前的准备阶段】 prepareContext(context, environment, listeners, applicationArguments, printedBanner); //【5、刷新应用上下文----这里会去去处理@SpringBootApplication注解】 refreshContext(context); //【6、刷新应用上下文后的扩展接口】 afterRefresh(context, applicationArguments); //时间记录停止 stopWatch.stop(); if (this.logStartupInfo) { new StartupInfoLogger(this.mainApplicationClass).logStarted(getApplicationLog(), stopWatch); } //发布容器启动完成事件 listeners.started(context); callRunners(context, applicationArguments); } catch (Throwable ex) { handleRunFailure(context, ex, exceptionReporters, listeners); throw new IllegalStateException(ex); } try { listeners.running(context); } catch (Throwable ex) { handleRunFailure(context, ex, exceptionReporters, null); throw new IllegalStateException(ex); } return context; }
在以上的代码中,启动过程中的重要步骤共分为六步
第一步:获取并启动监听器
第二步:构造应用上下文环境
第三步:初始化应用上下文
第四步:刷新应用上下文前的准备阶段
第五步:刷新应用上下文(这里会去处理@SpringBootApplication注解)
第六步:刷新应用上下文后的扩展接口
第一步:获取并启动监听器
事件机制在Spring是很重要的一部分内容,通过事件机制我们可以监听Spring容器中正在发生的一些事 件,同样也可以自定义监听事件。Spring的事件为Bean和Bean之间的消息传递提供支持。当一个对象 处理完某种任务后,通知另外的对象进行某些处理,常用的场景有进行某些操作后发送通知,消息、邮 件等情况。
private SpringApplicationRunListeners getRunListeners(String[] args) { Class<?>[] types = new Class<?>[] { SpringApplication.class, String[].class }; // SpringApplicationRunListeners负责在SpringBoot启动的不同阶段, // 广播出不同的消息, 传递给ApplicationListener监听器实现类。 return new SpringApplicationRunListeners(logger, getSpringFactoriesInstances(SpringApplicationRunListener.class, types, this, args)); }
在这里面是不是看到一个熟悉的方法:getSpringFactoriesInstances(),可以看下面的注释,前面 的小节我们已经详细介绍过该方法是怎么一步步的获取到META-INF/spring.factories中的指定的key的 value,获取到以后怎么实例化类的。
从图中我们可以看出会从spring.factories中加载org.springframework.boot.SpringApplicationRunListener的需要自动装配的类 org.springframework.boot.context.event.EventPublishingRunListener
第二步:构造应用上下文环境
应用上下文环境包括什么呢?包括计算机的环境,Java环境,Spring的运行环境,Spring项目的配 置(在SpringBoot中就是那个熟悉的application.properties/yml)等等。
方法中主要完成的工作,首先是创建并按照相应的应用类型配置相应的环境,然后根 据用户的配置,配置系统环境,然后启动监听器,并加载系统配置文件。
private ConfigurableEnvironment prepareEnvironment(SpringApplicationRunListeners listeners, ApplicationArguments applicationArguments) { // Create and configure the environment //创建并配置相应的环境 ConfigurableEnvironment environment = getOrCreateEnvironment(); //根据用户配置,配置 environment系统环境 configureEnvironment(environment, applicationArguments.getSourceArgs()); ConfigurationPropertySources.attach(environment); // 启动相应的监听器,其中一个重要的监听器 ConfigFileApplicationListener 就是加载项目配置文件的监听器。 listeners.environmentPrepared(environment); bindToSpringApplication(environment); if (!this.isCustomEnvironment) { environment = new EnvironmentConverter(getClassLoader()).convertEnvironmentIfNecessary(environment, deduceEnvironmentClass()); } ConfigurationPropertySources.attach(environment); return environment; }
看看getOrCreateEnvironment()干了些什么。
private ConfigurableEnvironment getOrCreateEnvironment() { if (this.environment != null) { return this.environment; } //如果应用类型是 SERVLET 则实例化 StandardServletEnvironment switch (this.webApplicationType) { case SERVLET: return new StandardServletEnvironment(); case REACTIVE: return new StandardReactiveWebEnvironment(); default: return new StandardEnvironment(); } }
通过代码可以看到根据不同的应用类型初始化不同的系统环境实例。前面咱们已经说过应用类型是怎么 判断的了,这里就不在赘述了 所以在当前环境
从上面的继承关系可以看出,StandardServletEnvironment是StandardEnvironment的子类。
configureEnvironment(environment, applicationArguments.getSourceArgs());
protected void configureEnvironment(ConfigurableEnvironment environment, String[] args) { if (this.addConversionService) { ConversionService conversionService = ApplicationConversionService.getSharedInstance(); environment.setConversionService((ConfigurableConversionService) conversionService); } // 将main 函数的args封装成 SimpleCommandLinePropertySource 加入环境中。 configurePropertySources(environment, args); // 激活相应的配置文件 configureProfiles(environment, args); }
第三步:初始化应用上下文
在SpringBoot工程中,应用类型分为三种,如下代码所示。
public enum WebApplicationType { /** * 应用程序不是web应用,也不应该用web服务器去启动 */ NONE, /** * 应用程序应作为基于servlet的web应用程序运行,并应启动嵌入式servlet web(tomcat)服务器。 */ SERVLET, /** * 应用程序应作为 reactive web应用程序运行,并应启动嵌入式 reactive web服务器。 */ REACTIVE }
对应三种应用类型,SpringBoot项目有三种对应的应用上下文,我们以web工程为例,即其上下 文为AnnotationConfigServletWebServerApplicationContext。
public static final String DEFAULT_SERVLET_WEB_CONTEXT_CLASS = "org.springframework.boot." + "web.servlet.context.AnnotationConfigServletWebServerApplicationContext";
protected ConfigurableApplicationContext createApplicationContext() { Class<?> contextClass = this.applicationContextClass; if (contextClass == null) { try { switch (this.webApplicationType) { case SERVLET: contextClass = Class.forName(DEFAULT_SERVLET_WEB_CONTEXT_CLASS); break; case REACTIVE: contextClass = Class.forName(DEFAULT_REACTIVE_WEB_CONTEXT_CLASS); break; default: contextClass = Class.forName(DEFAULT_CONTEXT_CLASS); } } catch (ClassNotFoundException ex) { throw new IllegalStateException( "Unable create a default ApplicationContext, please specify an ApplicationContextClass", ex); } } return (ConfigurableApplicationContext) BeanUtils.instantiateClass(contextClass); }
应用上下文可以理解成IoC容器的高级表现形式,应用上下文确实是在IoC容器的基础上丰富了一 些高级功能。
应用上下文对IoC容器是持有的关系。他的一个属性beanFactory就是IoC容器 (DefaultListableBeanFactory)。所以他们之间是持有,和扩展的关系。
第四步:刷新应用上下文前的准备阶段
首先看prepareContext()方法。
private void prepareContext(ConfigurableApplicationContext context, ConfigurableEnvironment environment,
SpringApplicationRunListeners listeners, ApplicationArguments applicationArguments, Banner printedBanner) {
//设置容器环境
context.setEnvironment(environment);
//执行容器后置处理
postProcessApplicationContext(context);
applyInitializers(context);
//向各个监听器发送容器已经准备好的事件
listeners.contextPrepared(context);
if (this.logStartupInfo) {
logStartupInfo(context.getParent() == null);
logStartupProfileInfo(context);
}
// Add boot specific singleton beans
ConfigurableListableBeanFactory beanFactory = context.getBeanFactory();
//将main函数中的args参数封装成单例Bean,注册进容器
beanFactory.registerSingleton("springApplicationArguments", applicationArguments);
if (printedBanner != null) {
//将 printedBanner 也封装成单例,注册进容器
beanFactory.registerSingleton("springBootBanner", printedBanner);
}
if (beanFactory instanceof DefaultListableBeanFactory) {
((DefaultListableBeanFactory) beanFactory)
.setAllowBeanDefinitionOverriding(this.allowBeanDefinitionOverriding);
}
if (this.lazyInitialization) {
context.addBeanFactoryPostProcessor(new LazyInitializationBeanFactoryPostProcessor());
}
// Load the sources
Set<Object> sources = getAllSources();
Assert.notEmpty(sources, "Sources must not be empty");
//加载我们的启动类,将启动类注入容器
load(context, sources.toArray(new Object[0]));
//发布容器已加载事件
listeners.contextLoaded(context);
}
Set<Object> sources = getAllSources();; 在getAllSources()中拿到了我们的启动类。也就是标注了@SpringBootApplication的启动类 我们重点讲解这行 load(context, sources.toArray(new Object[0]));
protected void load(ApplicationContext context, Object[] sources) {
if (logger.isDebugEnabled()) {
logger.debug("Loading source " + StringUtils.arrayToCommaDelimitedString(sources));
}
//创建 BeanDefinitionLoader
BeanDefinitionLoader loader = createBeanDefinitionLoader(getBeanDefinitionRegistry(context), sources);
if (this.beanNameGenerator != null) {
loader.setBeanNameGenerator(this.beanNameGenerator);
}
if (this.resourceLoader != null) {
loader.setResourceLoader(this.resourceLoader);
}
if (this.environment != null) {
loader.setEnvironment(this.environment);
}
loader.load();
}
继续看getBeanDefinitionRegistry()方法的源码
private BeanDefinitionRegistry getBeanDefinitionRegistry(ApplicationContext context) { if (context instanceof BeanDefinitionRegistry) { return (BeanDefinitionRegistry) context; } if (context instanceof AbstractApplicationContext) { return (BeanDefinitionRegistry) ((AbstractApplicationContext) context).getBeanFactory(); } throw new IllegalStateException("Could not locate BeanDefinitionRegistry"); }
这里将我们前文创建的上下文强转为BeanDefinitionRegistry,他们之间是有继承关系的。 BeanDefinitionRegistry定义了很重要的方法registerBeanDefinition(),该方法将BeanDefinition 注册进DefaultListableBeanFactory容器的beanDefinitionMap中。
继续看createBeanDefinitionLoader()方法,最终进入了BeanDefinitionLoader类的构造方法,如 下
BeanDefinitionLoader(BeanDefinitionRegistry registry, Object... sources) { Assert.notNull(registry, "Registry must not be null"); Assert.notEmpty(sources, "Sources must not be empty"); this.sources = sources; //注解形式的Bean定义读取器 比如:@Configuration @Bean @Component @Controller @Service等等 this.annotatedReader = new AnnotatedBeanDefinitionReader(registry); //XML形式的Bean定义读取器 this.xmlReader = new XmlBeanDefinitionReader(registry); if (isGroovyPresent()) { this.groovyReader = new GroovyBeanDefinitionReader(registry); } //类路径扫描器 this.scanner = new ClassPathBeanDefinitionScanner(registry); //扫描器添加排除过滤器 this.scanner.addExcludeFilter(new ClassExcludeFilter(sources)); }
上面三个属性在,BeanDefinition的Resource定位,和BeanDefinition 的注册中起到了很重要的作用。
跟进load()方法
int load() { int count = 0; for (Object source : this.sources) { count += load(source); } return count; } private int load(Object source) { Assert.notNull(source, "Source must not be null"); // 从Class加载 if (source instanceof Class<?>) { return load((Class<?>) source); } // 从Resource加载 if (source instanceof Resource) { return load((Resource) source); } // 从Package加载 if (source instanceof Package) { return load((Package) source); } // 从 CharSequence 加载 if (source instanceof CharSequence) { return load((CharSequence) source); } throw new IllegalArgumentException("Invalid source type " + source.getClass()); }
当前我们的类会从class加载 跟进下一个load((Class<?>) source);
private int load(Class<?> source) { if (isGroovyPresent() && GroovyBeanDefinitionSource.class.isAssignableFrom(source)) { // Any GroovyLoaders added in beans{} DSL can contribute beans here GroovyBeanDefinitionSource loader = BeanUtils.instantiateClass(source, GroovyBeanDefinitionSource.class); load(loader); } if (isComponent(source)) { //将 启动类的 BeanDefinition注册进 beanDefinitionMap this.annotatedReader.register(source); return 1; } return 0; }
isComponent(source)判断主类是不是存在@Component注解,主类 @SpringBootApplication是一个组合注解,底层是@configuration,包含@Component。 this.annotatedReader.register(source);跟进register()方法,最终进到 AnnotatedBeanDefinitionReader类的doRegisterBean()方法。一直追到最后来到DefaultListableBeanFactory类中的registerBeanDefinition方法进行bean的注册 也就是放到该类的beanDefinitionMap中。
public void registerBeanDefinition(String beanName, BeanDefinition beanDefinition) throws BeanDefinitionStoreException { Assert.hasText(beanName, "Bean name must not be empty"); Assert.notNull(beanDefinition, "BeanDefinition must not be null"); if (beanDefinition instanceof AbstractBeanDefinition) { try { // 最后一次校验了 // 对bean的Overrides进行校验,还不知道会在哪处理这些overrides ((AbstractBeanDefinition) beanDefinition).validate(); } catch (BeanDefinitionValidationException ex) { throw new BeanDefinitionStoreException(beanDefinition.getResourceDescription(), beanName, "Validation of bean definition failed", ex); } } // 判断是否存在重复名字的bean,之后看允不允许override // 以前使用synchronized实现互斥访问,现在采用ConcurrentHashMap BeanDefinition existingDefinition = this.beanDefinitionMap.get(beanName); if (existingDefinition != null) { //如果该类不允许 Overriding 直接抛出异常 if (!isAllowBeanDefinitionOverriding()) { throw new BeanDefinitionStoreException(beanDefinition.getResourceDescription(), beanName, "Cannot register bean definition [" + beanDefinition + "] for bean '" + beanName + "': There is already [" + existingDefinition + "] bound."); } else if (existingDefinition.getRole() < beanDefinition.getRole()) { // e.g. was ROLE_APPLICATION, now overriding with ROLE_SUPPORT or ROLE_INFRASTRUCTURE if (logger.isWarnEnabled()) { logger.warn("Overriding user-defined bean definition for bean '" + beanName + "' with a framework-generated bean definition: replacing [" + existingDefinition + "] with [" + beanDefinition + "]"); 最终来到DefaultListableBeanFactory类的registerBeanDefinition()方法, DefaultListableBeanFactory类还熟悉吗?相信大家一定非常熟悉这个类了。 DefaultListableBeanFactory是IoC容器的具体产品。 } } else if (!beanDefinition.equals(existingDefinition)) { if (logger.isInfoEnabled()) { logger.info("Overriding bean definition for bean '" + beanName + "' with a different definition: replacing [" + existingDefinition + "] with [" + beanDefinition + "]"); } } else { if (logger.isDebugEnabled()) { logger.debug("Overriding bean definition for bean '" + beanName + "' with an equivalent definition: replacing [" + existingDefinition + "] with [" + beanDefinition + "]"); } } //注册进beanDefinitionMap this.beanDefinitionMap.put(beanName, beanDefinition); } else { if (hasBeanCreationStarted()) { // Cannot modify startup-time collection elements anymore (for stable iteration) synchronized (this.beanDefinitionMap) { this.beanDefinitionMap.put(beanName, beanDefinition); List<String> updatedDefinitions = new ArrayList<> (this.beanDefinitionNames.size() + 1); updatedDefinitions.addAll(this.beanDefinitionNames); updatedDefinitions.add(beanName); this.beanDefinitionNames = updatedDefinitions; if (this.manualSingletonNames.contains(beanName)) { Set<String> updatedSingletons = new LinkedHashSet<> (this.manualSingletonNames); updatedSingletons.remove(beanName); this.manualSingletonNames = updatedSingletons; } } } else { // Still in startup registration phase //如果仍处于启动注册阶段,注册进beanDefinitionMap this.beanDefinitionMap.put(beanName, beanDefinition); this.beanDefinitionNames.add(beanName); this.manualSingletonNames.remove(beanName); } this.frozenBeanDefinitionNames = null; } if (existingDefinition != null || containsSingleton(beanName)) { resetBeanDefinition(beanName); } }
第五步:刷新应用上下文(IOC容器的初始化过程----从这里开始就是spring的源码内容 会去处理@SpringBootApplication注解)
如果不明白@SpringBootApplication是什么?有什么用可以参考springboot源码剖析之自动配置
IoC容器的初始化过程,主要分下面三步:
1 BeanDefinition的Resource定位
2 BeanDefinition的载入
3 向IoC容器注册BeanDefinition
接下来我们主要从refresh()方法中总结IoC容器的初始化过程。 从run方法的,refreshContext()方法一路跟下去,最终来到AbstractApplicationContext类的 refresh()方法
public void refresh() throws BeansException, IllegalStateException { // 对象锁加锁 synchronized (this.startupShutdownMonitor) { // Prepare this context for refreshing. /*刷新之前的预处理 表示在真正做refresh操作之前需要准备的事情 设置Spring容器的启动时间 开启活跃状态 撤销关闭状态 验证环境信息里一些必须存在的属性等*/ prepareRefresh(); // Tell the subclass to refresh the internal bean factory. // 获取BeanFactory :默认实现是 DefaultListableBeanFactory // 加载BeanDefition 并注册到 BeanDefitionRegistry // 关键步骤 ConfigurableListableBeanFactory beanFactory = obtainFreshBeanFactory(); // Prepare the bean factory for use in this context. // BeanFactory的预准备工作(前置处理)(BeanFactory进行设置 比如context的类加载器等) prepareBeanFactory(beanFactory); try { // Allows post-processing of the bean factory in context subclasses. // BeanFactory的准备工作完成之后 进行的后置处理工作 postProcessBeanFactory(beanFactory); // Invoke factory processors registered as beans in the context. // 实例化实现了BeanFactoryPostProcessor接口的bean,并调用接口方法 invokeBeanFactoryPostProcessors(beanFactory); // Register bean processors that intercept bean creation. // 注册BeanPostProcessor(bean的后置处理),在创建bean的前后等执行 registerBeanPostProcessors(beanFactory); // Initialize message source for this context. // 初始化MessageSource组件(做国际化功能:消息绑定和消息解析) initMessageSource(); // Initialize event multicaster for this context. // 初始化事件派发器 initApplicationEventMulticaster(); // Initialize other special beans in specific context subclasses. // 子类重写这个方法,在容器刷新的时候可以自定义逻辑:如创建tomcat jetty等web服务器 onRefresh(); // Check for listener beans and register them. // 注册应用的监听器。就是注册实现了ApplicationListener接口的监听器bean registerListeners(); // Instantiate all remaining (non-lazy-init) singletons. // 初始化所有剩下的非懒加载的单例bean // 初始化创建非懒加载方式的单例bean的实例(属性未设置) // 填充属性 // 初始化方法调用(比如调用afterPropertiesSet方法,init-method方法) // 调用beanPostProcessor(后置处理器)对实例bean进行后置处理 finishBeanFactoryInitialization(beanFactory); // Last step: publish corresponding event. // 完成context的刷新。主要调用LifecycleProcessor的onRefresh()方法,并且发布事件(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(); } } }
从以上代码中我们可以看到,refresh()方法中所作的工作也挺多,具体详情可以 参考spring源码解析
第六步:刷新应用上下文后的扩展接口
protected void afterRefresh(ConfigurableApplicationContext context, ApplicationArguments args) { }
扩展接口,设计模式中的模板方法,默认为空实现。如果有自定义需求,可以重写该方法。比如打 印一些启动结束log,或者一些其它后置处理。
总结
启动过程中的重要步骤共分为六步
第一步:获取并启动监听器
第二步:构造应用上下文环境
第三步:初始化应用上下文
第四步:刷新应用上下文前的准备阶段
第五步:刷新应用上下文(这里会去处理@SpringBootApplication注解)
第六步:刷新应用上下文后的扩展接口