SpringBoot是如何启动的？

public static void main(String[] args) {  
    SpringApplication.run(Application.class, args);  
}

public static ConfigurableApplicationContext run(Class<?>[] primarySources, String[] args) {  
   return new SpringApplication(primarySources).run(args);  
}

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();  
   setInitializers((Collection) getSpringFactoriesInstances(ApplicationContextInitializer.class));  
   setListeners((Collection) getSpringFactoriesInstances(ApplicationListener.class));  
   this.mainApplicationClass = deduceMainApplicationClass();  
}

private <T> Collection<T> getSpringFactoriesInstances(Class<T> type, Class<?>[] parameterTypes, Object... args) {  
   ClassLoader classLoader = getClassLoader();  
   // Use names and ensure unique to protect against duplicates  
 Set<String> names = new LinkedHashSet<>(SpringFactoriesLoader.loadFactoryNames(type, classLoader));  
   List<T> instances = createSpringFactoriesInstances(type, parameterTypes, classLoader, args, names);  
   AnnotationAwareOrderComparator.sort(instances);  
   return instances;  
}

public static final String FACTORIES_RESOURCE_LOCATION = "META-INF/spring.factories";

private static Map<String, List<String>> loadSpringFactories(@Nullable ClassLoader classLoader) {  
   MultiValueMap<String, String> result = cache.get(classLoader);  
   if (result != null) {  
      return result;  
   }  
  
   try {  
      Enumeration<URL> urls = (classLoader != null ?  
            classLoader.getResources(FACTORIES_RESOURCE_LOCATION) :  
            ClassLoader.getSystemResources(FACTORIES_RESOURCE_LOCATION));  
      result = new LinkedMultiValueMap<>();  
      while (urls.hasMoreElements()) {  
         URL url = urls.nextElement();  
         UrlResource resource = new UrlResource(url);  
         Properties properties = PropertiesLoaderUtils.loadProperties(resource);  
         for (Map.Entry<?, ?> entry : properties.entrySet()) {  
            String factoryTypeName = ((String) entry.getKey()).trim();  
            for (String factoryImplementationName : StringUtils.commaDelimitedListToStringArray((String) entry.getValue())) {  
               result.add(factoryTypeName, factoryImplementationName.trim());  
            }  
         }  
      }  
      cache.put(classLoader, result);  
      return result;  
   }  
   catch (IOException ex) {  
      throw new IllegalArgumentException("Unable to load factories from location [" +  
            FACTORIES_RESOURCE_LOCATION + "]", ex);  
   }  
}

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;
	}

public ConfigurableApplicationContext run(String... args) {
	long startTime = System.nanoTime();  
	DefaultBootstrapContext bootstrapContext = createBootstrapContext();  
	ConfigurableApplicationContext context = null;  
	configureHeadlessProperty();  
	SpringApplicationRunListeners listeners = getRunListeners(args);  
	listeners.starting(bootstrapContext, this.mainApplicationClass);

	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);
	}
	return context;
}

private ConfigurableEnvironment prepareEnvironment(SpringApplicationRunListeners listeners,  
      ApplicationArguments applicationArguments) {  
   // Create and configure the environment  
 ConfigurableEnvironment environment = getOrCreateEnvironment();  
   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;  
}

private ConfigurableEnvironment getOrCreateEnvironment() {  
   if (this.environment != null) {  
      return this.environment;  
   }  
   switch (this.webApplicationType) {  
   case SERVLET:  
      return new StandardServletEnvironment();  
   case REACTIVE:  
      return new StandardReactiveWebEnvironment();  
   default:  
      return new StandardEnvironment();  
   }  
}

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);
}

BeanDefinitionLoader(BeanDefinitionRegistry registry, Object... sources) {  
   Assert.notNull(registry, "Registry must not be null");  
   Assert.notEmpty(sources, "Sources must not be empty");  
   this.sources = sources;  
   this.annotatedReader = new AnnotatedBeanDefinitionReader(registry);  
   this.xmlReader = new XmlBeanDefinitionReader(registry);  
   if (isGroovyPresent()) {  
      this.groovyReader = new GroovyBeanDefinitionReader(registry);  
   }  
   this.scanner = new ClassPathBeanDefinitionScanner(registry);  
   this.scanner.addExcludeFilter(new ClassExcludeFilter(sources));  
}