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

public static ConfigurableApplicationContext run(Object source, String... args) {
 return run(new Object[] { source }, args);
}

public static ConfigurableApplicationContext run(Object[] sources, String[] args) {
 return new SpringApplication(sources).run(args);
}

public SpringApplication(Object... sources) {
 initialize(sources);
}

private void initialize(Object[] sources) {
 if (sources != null && sources.length > 0) {
 this.sources.addAll(Arrays.asList(sources));
 }
 this.webEnvironment = deduceWebEnvironment();
 setInitializers((Collection) getSpringFactoriesInstances(
 ApplicationContextInitializer.class));
 setListeners((Collection) getSpringFactoriesInstances(ApplicationListener.class));
 this.mainApplicationClass = deduceMainApplicationClass();
}

private static final String[] WEB_ENVIRONMENT_CLASSES = { "javax.servlet.Servlet",
 "org.springframework.web.context.ConfigurableWebApplicationContext" };
private boolean deduceWebEnvironment() {
 for (String className : WEB_ENVIRONMENT_CLASSES) {
 if (!ClassUtils.isPresent(className, null)) {
 return false;
 }
 }
 return true;
}

private <T> Collection<? extends T> getSpringFactoriesInstances(Class<T> type) {
 return getSpringFactoriesInstances(type, new Class<?>[] {});
}

private <T> Collection<? extends T> getSpringFactoriesInstances(Class<T> type,
 Class<?>[] parameterTypes, Object... args) {
 ClassLoader classLoader = Thread.currentThread().getContextClassLoader();
 // Use names and ensure unique to protect against duplicates
 // 使⽤Set保存names来避免重复元素
 Set<String> names = new LinkedHashSet<String>(
 SpringFactoriesLoader.loadFactoryNames(type, classLoader));
 // 根据names来进⾏实例化
 List<T> instances = createSpringFactoriesInstances(type, parameterTypes,
 classLoader, args, names);
 // 对实例进⾏排序
 AnnotationAwareOrderComparator.sort(instances);
 return instances;
}

public static List<String> loadFactoryNames(Class<?> factoryClass, ClassLoader classLoader) {
 String factoryClassName = factoryClass.getName();
 try {
 Enumeration<URL> urls = (classLoader != null ? classLoader.getResources(FACTORIES_RESOURC
E_LOCATION) :
 ClassLoader.getSystemResources(FACTORIES_RESOURCE_LOCATION));
 List<String> result = new ArrayList<String>();
 while (urls.hasMoreElements()) {
 URL url = urls.nextElement();
 Properties properties = PropertiesLoaderUtils.loadProperties(new UrlResource(url));
 String factoryClassNames = properties.getProperty(factoryClassName);
 result.addAll(Arrays.asList(StringUtils.commaDelimitedListToStringArray(factoryClassN
ames)));
 }
 return result;
 }
 catch (IOException ex) {
 throw new IllegalArgumentException("Unable to load [" + factoryClass.getName() +
 "] factories from location [" + FACTORIES_RESOURCE_LOCATION + "]", ex);
 }
}

org.springframework.context.ApplicationContextInitializer=\
org.springframework.boot.context.ConfigurationWarningsApplicationContextInitializer,\
org.springframework.boot.context.ContextIdApplicationContextInitializer,\
org.springframework.boot.context.config.DelegatingApplicationContextInitializer,\
org.springframework.boot.context.embedded.ServerPortInfoApplicationContextInitializer

org.springframework.context.ApplicationContextInitializer=\
org.springframework.boot.autoconfigure.SharedMetadataReaderFactoryContextInitializer,\
org.springframework.boot.autoconfigure.logging.AutoConfigurationReportLoggingInitializer

private <T> List<T> createSpringFactoriesInstances(Class<T> type,
 Class<?>[] parameterTypes, ClassLoader classLoader, Object[] args,
 Set<String> names) {
 List<T> instances = new ArrayList<T>(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;
}

private static final String NAME_PATTERN = "${spring.application.name:${vcap.application.name:${s
pring.config.name:application}}}";
public ContextIdApplicationContextInitializer() {
 this(NAME_PATTERN);
}
public ContextIdApplicationContextInitializer(String name) {
 this.name = name;
}

org.springframework.context.ApplicationListener=\
org.springframework.boot.ClearCachesApplicationListener,\
org.springframework.boot.builder.ParentContextCloserApplicationListener,\
org.springframework.boot.context.FileEncodingApplicationListener,\
org.springframework.boot.context.config.AnsiOutputApplicationListener,\
org.springframework.boot.context.config.ConfigFileApplicationListener,\
org.springframework.boot.context.config.DelegatingApplicationListener,\
org.springframework.boot.liquibase.LiquibaseServiceLocatorApplicationListener,\
org.springframework.boot.logging.ClasspathLoggingApplicationListener,\
org.springframework.boot.logging.LoggingApplicationListener

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