1.第一个步骤进入SpringApplication构造函数

public SpringApplication(ResourceLoader resourceLoader, Class… primarySources) {
this.resourceLoader = resourceLoader;
Assert.notNull(primarySources, "PrimarySources must not be null");
this.primarySources = new LinkedHashSet<>(Arrays.asList(primarySources));
this.webApplicationType = WebApplicationType.deduceFromClasspath();//这个type是SERVLET
setInitializers((Collection) getSpringFactoriesInstances(ApplicationContextInitializer.class));//设置初始化
setListeners((Collection) getSpringFactoriesInstances(ApplicationListener.class));//设置监听器
this.mainApplicationClass = deduceMainApplicationClass();
}

1.1 看一下 setInitializers 方法做了些什么事情

// type 是 ApplicationContextInitializer.class
private Collection getSpringFactoriesInstances(Class type, Class[] parameterTypes, Object… args) {
ClassLoader classLoader = getClassLoader();//
// Use names and ensure unique to protect against duplicates
Set names = new LinkedHashSet<>(SpringFactoriesLoader.loadFactoryNames(type, classLoader));//返回ApplicationContextInitializer对应的类路径
List instances = createSpringFactoriesInstances(type, parameterTypes, classLoader, args, names);//
AnnotationAwareOrderComparator.sort(instances);
return instances;
}

返回ApplicationContextInitializer对应的类路径

public static List loadFactoryNames(Class factoryType, @Nullable ClassLoader classLoader) {
String factoryTypeName = factoryType.getName();//ApplicationContextInitializer
//加载/META-INF/spring.factories下面的文件，并获取ApplicationContextInitializer为key对应的值
return (List)loadSpringFactories(classLoader).getOrDefault(factoryTypeName, Collections.emptyList());
}

根据类路径反射生成类的实例

private <T> List<T> createSpringFactoriesInstances(Class<T> type, Class<?>\[\] parameterTypes,  
        ClassLoader classLoader, Object\[\] args, Set<String> names) {  
    List<T> instances = new ArrayList<>(names.size());  
    for (String name : names) {  
        try {  
            Class<?> instanceClass = ClassUtils.forName(name, classLoader);  
            Assert.isAssignable(type, instanceClass);  
            Constructor<?> constructor = instanceClass.getDeclaredConstructor(parameterTypes);  
            T instance = (T) BeanUtils.instantiateClass(constructor, args);  
            instances.add(instance);  
        }  
        catch (Throwable ex) {  
            throw new IllegalArgumentException("Cannot instantiate " + type + " : " + name, ex);  
        }  
    }  
    return instances;  
}

1.2 setListeners做了什么

//type = ApplicationListener.class 和上面一样获取ApplicationListener的类实例
private Collection getSpringFactoriesInstances(Class type, Class[] parameterTypes, Object… args) {
ClassLoader classLoader = getClassLoader();
// Use names and ensure unique to protect against duplicates
Set names = new LinkedHashSet<>(SpringFactoriesLoader.loadFactoryNames(type, classLoader));
List instances = createSpringFactoriesInstances(type, parameterTypes, classLoader, args, names);
AnnotationAwareOrderComparator.sort(instances);
return instances;
}

1.3 获取主类

private Class deduceMainApplicationClass() {
try {
StackTraceElement[] stackTrace = new RuntimeException().getStackTrace();
for (StackTraceElement stackTraceElement : stackTrace) {
if ("main".equals(stackTraceElement.getMethodName())) {
return Class.forName(stackTraceElement.getClassName());
}
}
}
catch (ClassNotFoundException ex) {
// Swallow and continue
}
return null;
}

2.第二个步骤调用run方法　　

public ConfigurableApplicationContext run(String… args) {
StopWatch stopWatch = new StopWatch();
stopWatch.start();
ConfigurableApplicationContext context = null;
Collection exceptionReporters = new ArrayList<>();
configureHeadlessProperty();//配置handless参数
SpringApplicationRunListeners listeners = getRunListeners(args);
listeners.starting();
try {
ApplicationArguments applicationArguments = new DefaultApplicationArguments(args);
ConfigurableEnvironment environment = prepareEnvironment(listeners, applicationArguments);
configureIgnoreBeanInfo(environment);
Banner printedBanner = printBanner(environment);
context = createApplicationContext();//
exceptionReporters = getSpringFactoriesInstances(SpringBootExceptionReporter.class,
new Class[] { ConfigurableApplicationContext.class }, context);
prepareContext(context, environment, listeners, applicationArguments, printedBanner);
refreshContext(context);
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;  
}

　　2.1 设置系统handless参数

private static final String SYSTEM\_PROPERTY\_JAVA\_AWT\_HEADLESS = "java.awt.headless";

private void configureHeadlessProperty() {
System.setProperty(SYSTEM_PROPERTY_JAVA_AWT_HEADLESS,
System.getProperty(SYSTEM_PROPERTY_JAVA_AWT_HEADLESS, Boolean.toString(this.headless)));
}

　 2.2 获取SpringApplicationRunListeners的实例

private SpringApplicationRunListeners getRunListeners(String\[\] args) {  
    Class<?>\[\] types = new Class<?>\[\] { SpringApplication.class, String\[\].class };  
    return new SpringApplicationRunListeners(logger,  
            getSpringFactoriesInstances(SpringApplicationRunListener.class, types, this, args));  
}

2.3 准备环境

private ConfigurableEnvironment prepareEnvironment(SpringApplicationRunListeners listeners,  
        ApplicationArguments applicationArguments) {  
    // Create and configure the environment  
    ConfigurableEnvironment environment = getOrCreateEnvironment();// new StandardServletEnvironment()  创建Servlet环境  
    configureEnvironment(environment, applicationArguments.getSourceArgs());  
    ConfigurationPropertySources.attach(environment);  
    listeners.environmentPrepared(environment);  
    bindToSpringApplication(environment);  
    if (!this.isCustomEnvironment) {  
        environment = new EnvironmentConverter(getClassLoader()).convertEnvironmentIfNecessary(environment,  
                deduceEnvironmentClass());  
    }  
    ConfigurationPropertySources.attach(environment);  
    return environment;  
}

　2.4 console开启banner

图片配置路径：spring.banner.image.location
图片配置名称：banner.{ "gif", "jpg", "png" }
文本配置路径：spring.banner.location
默认数据resource下的：banner.txt

2.5 创建上下文类

public static final String DEFAULT\_SERVLET\_WEB\_CONTEXT\_CLASS = "org.springframework.boot."  
        + "web.servlet.context.AnnotationConfigServletWebServerApplicationContext";  
   protected ConfigurableApplicationContext createApplicationContext() {  
    contextClass = Class.forName(DEFAULT\_SERVLET\_WEB\_CONTEXT\_CLASS);  
    return (ConfigurableApplicationContext) BeanUtils.instantiateClass(contextClass);  
}

2.6 准备上下文

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();
beanFactory.registerSingleton("springApplicationArguments", applicationArguments);
if (printedBanner != null) {
beanFactory.registerSingleton("springBootBanner", printedBanner);
}
if (beanFactory instanceof DefaultListableBeanFactory) {
((DefaultListableBeanFactory) beanFactory)
.setAllowBeanDefinitionOverriding(this.allowBeanDefinitionOverriding);
}
if (this.lazyInitialization) {
context.addBeanFactoryPostProcessor(new LazyInitializationBeanFactoryPostProcessor());
}
// Load the sources
Set