SpringBoot之SpringApplication初始化

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

@SuppressWarnings({ 
 "unchecked", "rawtypes" })
public SpringApplication(ResourceLoader resourceLoader, Class<?>... primarySources) { 

this.resourceLoader = resourceLoader;
Assert.notNull(primarySources, "PrimarySources must not be null");
//1.配置源
this.primarySources = new LinkedHashSet<>(Arrays.asList(primarySources));
//2.推断web应用类型
this.webApplicationType = WebApplicationType.deduceFromClasspath();
//3.应用上下文初始器和应用事件监听
setInitializers((Collection) getSpringFactoriesInstances(ApplicationContextInitializer.class));
setListeners((Collection) getSpringFactoriesInstances(ApplicationListener.class));
//4.推导引用主类
this.mainApplicationClass = deduceMainApplicationClass();
}

SpringApplication springApplication = new SpringApplication();
springApplication.setSources();
springApplication.run(args);

public Set<Object> getAllSources() { 

Set<Object> allSources = new LinkedHashSet<>();
if (!CollectionUtils.isEmpty(this.primarySources)) { 

allSources.addAll(this.primarySources); // java方式配置的源
}
if (!CollectionUtils.isEmpty(this.sources)) { 

allSources.addAll(this.sources);  //xml方式配置的源
}
return Collections.unmodifiableSet(allSources);
}
private void prepareContext(ConfigurableApplicationContext context, ConfigurableEnvironment environment,
//.....忽略代码
// 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);
}

protected void load(ApplicationContext context, Object[] sources) { 

if (logger.isDebugEnabled()) { 

logger.debug("Loading source " + StringUtils.arrayToCommaDelimitedString(sources));
}
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();
}

protected BeanDefinitionLoader createBeanDefinitionLoader(BeanDefinitionRegistry registry, Object[] sources) { 

return new BeanDefinitionLoader(registry, sources);
}

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

static WebApplicationType deduceFromClasspath() { 

//当类路径下存在Web Reactive 类路径并且不存在WebApplicationType.SERVLET类路径是才会启用
//WEB Reactive容器
if (ClassUtils.isPresent(WEBFLUX_INDICATOR_CLASS, null) && !ClassUtils.isPresent(WEBMVC_INDICATOR_CLASS, null)
&& !ClassUtils.isPresent(JERSEY_INDICATOR_CLASS, null)) { 

return WebApplicationType.REACTIVE;
}
//当类路径中都不存在时，会启用非WEB类型
for (String className : SERVLET_INDICATOR_CLASSES) { 

if (!ClassUtils.isPresent(className, null)) { 

return WebApplicationType.NONE;
}
}
//默认启用tomcat容器
return WebApplicationType.SERVLET;
}

setInitializers((Collection) getSpringFactoriesInstances(ApplicationContextInitializer.class));
setListeners((Collection) getSpringFactoriesInstances(ApplicationListener.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
Set<String> names = new LinkedHashSet<>(SpringFactoriesLoader.loadFactoryNames(type, classLoader));
List<T> instances = createSpringFactoriesInstances(type, parameterTypes, classLoader, args, names);
AnnotationAwareOrderComparator.sort(instances);
return instances;
}

/** * Load the fully qualified class names of factory implementations of the * given type from {@value #FACTORIES_RESOURCE_LOCATION}, using the given * class loader. * @param factoryType the interface or abstract class representing the factory * @param classLoader the ClassLoader to use for loading resources; can be * {@code null} to use the default * @throws IllegalArgumentException if an error occurs while loading factory names * @see #loadFactories */
public static List<String> loadFactoryNames(Class<?> factoryType, @Nullable ClassLoader classLoader) { 

String factoryTypeName = factoryType.getName();
return loadSpringFactories(classLoader).getOrDefault(factoryTypeName, Collections.emptyList());
}

# Initializers
org.springframework.context.ApplicationContextInitializer=\
org.springframework.boot.autoconfigure.SharedMetadataReaderFactoryContextInitializer,\
org.springframework.boot.autoconfigure.logging.ConditionEvaluationReportLoggingListener

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

@SpringBootApplication
public class MySpringBootApplication { 

public static void main(String[] args) { 

SpringApplication.run(MySpringBootApplication.class, args);
}
}

public class App { 

public static void main(String[] args) { 

SpringApplication
.run(MySpringBootApplication.class,args);
}
}

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