springboot源码剖析-Run方法执行流程

目录

SpringBoot项目的mian函数

run方法

SpringApplication() 构造方法

deduceFromClasspath 推断应用类型方法

setInitializers((Collection) getSpringFactoriesInstances(ApplicationContextInitializer.class))

setListeners((Collection) getSpringFactoriesInstances(ApplicationListener.class)

SpringApplication() 总结

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注解)

                  第六步：刷新应用上下文后的扩展接口