springBoot-启动原理

阅读原文时间：2022年02月21日阅读：1

注：SpringBoot版本 2.6.2

SpringBoot的入口是从SpringApplication.run()传入我们的主启动类开始

@SpringBootApplication
public class LeeSpringbootApplication {

public static void main(String\[\] args) {  
    SpringApplication.run(LeeSpringbootApplication.class, args);  
}  复制

}

run()方法：

　　　　1、初始化SrpingApplication对象

　　　　2、执行run() 方法(primarySources：主启动类class)

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

1、初始化SrpingApplication对象

　　1、设置应用类型，后面会根据类型初始化对应的环境，常用的一般都是servlet环境

　　2、加载系统中引导器Bootstrapper（从META-INF/spring.factories中加载）

　　3、初始化classpath下 META-INF/spring.factories 中已配置的ApplicationContextInitalizer

　　4、初始化classpath下所以已配置的 ApplicationListener

　　5、根据调用栈，设置 main 方法的类名

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 加载系统中引导器Bootstrapper
this.bootstrapRegistryInitializers = new ArrayList<>(
getSpringFactoriesInstances(BootstrapRegistryInitializer.class));
// 1.3 初始化classpath下 META-INF/spring.factories 中已配置的ApplicationContextInitalizer
setInitializers((Collection) getSpringFactoriesInstances(ApplicationContextInitializer.class));
// 1.4 初始化classpath下所以已配置的 ApplicationListener
setListeners((Collection) getSpringFactoriesInstances(ApplicationListener.class));
// 1.5 根据调用栈，设置 main 方法的类名
this.mainApplicationClass = deduceMainApplicationClass();
}

在执行 getSpringFactoriesInstances(BootstrapRegistryInitializer.class) 中会调用 loadSpringFactories() 方法遍历所有jar包中classpath下 META-INF/spring.factories文件，并保存在缓存中

private static Map> loadSpringFactories(ClassLoader classLoader) {
Map> result = cache.get(classLoader);
if (result != null) {
return result;
}

result = new HashMap<>();  
try {  
    Enumeration<URL> urls = classLoader.getResources(FACTORIES\_RESOURCE\_LOCATION);  
    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();  
            String\[\] factoryImplementationNames =  
                    StringUtils.commaDelimitedListToStringArray((String) entry.getValue());  
            for (String factoryImplementationName : factoryImplementationNames) {  
                result.computeIfAbsent(factoryTypeName, key -> new ArrayList<>())  
                        .add(factoryImplementationName.trim());  
            }  
        }  
    }

    // Replace all lists with unmodifiable lists containing unique elements  
    result.replaceAll((factoryType, implementations) -> implementations.stream().distinct()  
            .collect(Collectors.collectingAndThen(Collectors.toList(), Collections::unmodifiableList)));  
    cache.put(classLoader, result);  
}  
catch (IOException ex) {  
    throw new IllegalArgumentException("Unable to load factories from location \[" +  
            FACTORIES\_RESOURCE\_LOCATION + "\]", ex);  
}  
return result;  复制

}

loadSpringFactories

2、执行run() 方法

　　1、获取并启动监听器

　　2、构造上下文环境

　　3、初始化应用上下文

　　4、刷新应用上下文前的准备阶段

　　5、刷新上下文

　　6、刷新应用上下文后的扩展接口

public ConfigurableApplicationContext run(String… args) {
//记录程序运行时间
long startTime = System.nanoTime();
// 创建 DefaultBootstrapContext 的一项
DefaultBootstrapContext bootstrapContext = createBootstrapContext();
// ConfigurableApplicationContext spring的上下文
ConfigurableApplicationContext context = null;
configureHeadlessProperty();
// 1、获取并启动监听器
SpringApplicationRunListeners listeners = getRunListeners(args);
listeners.starting(bootstrapContext, this.mainApplicationClass);
try {
ApplicationArguments applicationArguments = new DefaultApplicationArguments(args);
// 2、构造上下文环境
ConfigurableEnvironment environment = prepareEnvironment(listeners, bootstrapContext, applicationArguments);
// 处理需要忽略的Bean
configureIgnoreBeanInfo(environment);
// 打印banner （springboot图标）
Banner printedBanner = printBanner(environment);
// 3、初始化应用上下文
context = createApplicationContext();
context.setApplicationStartup(this.applicationStartup);
// 4、刷新应用上下文前的准备阶段
prepareContext(bootstrapContext, context, environment, listeners, applicationArguments, printedBanner);
// 5、刷新上下文
refreshContext(context);
// 6、刷新应用上下文后的扩展接口
afterRefresh(context, applicationArguments);
// 记录执行时间
Duration timeTakenToStartup = Duration.ofNanos(System.nanoTime() - startTime);
if (this.logStartupInfo) {
new StartupInfoLogger(this.mainApplicationClass).logStarted(getApplicationLog(), timeTakenToStartup);
}
listeners.started(context, timeTakenToStartup);
callRunners(context, applicationArguments);
}
catch (Throwable ex) {
handleRunFailure(context, ex, listeners);
throw new IllegalStateException(ex);
}
try {
Duration timeTakenToReady = Duration.ofNanos(System.nanoTime() - startTime);
listeners.ready(context, timeTakenToReady);
}
catch (Throwable ex) {
handleRunFailure(context, ex, null);
throw new IllegalStateException(ex);
}
return context;
}

　　2.1 加载监听器

　　　　加载META-INF/spring.factories 中的 SpringApplicationRunListener，SpringApplicationRunListeners负责在springBoot启动的不同阶段，广播出不同的消息，传递给ApplicationListener监听器实现类

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

　　　　在 getSpringFactoriesInstances 中加载构建监听器对象并根据order进行排序

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

　　2.2 构造上下文环境

　　　　根据之前标记的应用类型(SERVLET)创建相应的环境，并根据配置文件，配置相应的系统环境

private ConfigurableEnvironment prepareEnvironment(SpringApplicationRunListeners listeners,
DefaultBootstrapContext bootstrapContext, ApplicationArguments applicationArguments) {
// Create and configure the environment
// 创建并配置相应环境
ConfigurableEnvironment environment = getOrCreateEnvironment();
// 根据用户配置，配置系统环境
configureEnvironment(environment, applicationArguments.getSourceArgs());
ConfigurationPropertySources.attach(environment);
// 启动监听器，其中一个重要的监听器 ConfigFileApplicationListener 加载项目配置文件的监听器
listeners.environmentPrepared(bootstrapContext, environment);
DefaultPropertiesPropertySource.moveToEnd(environment);
Assert.state(!environment.containsProperty("spring.main.environment-prefix"),
"Environment prefix cannot be set via properties.");
bindToSpringApplication(environment);
if (!this.isCustomEnvironment) {
environment = convertEnvironment(environment);
}
ConfigurationPropertySources.attach(environment);
return environment;
}

　　2.3 初始化应用上下文

　　　　根据配置的应用类型(SERVLET)创建对应的context (AnnotationConfigServletWebServerApplicationContext) 并在父类 GenericApplicationContext 的构造方法中创建了DefaultListableBeanFactory（ioc容器）

protected ConfigurableApplicationContext createApplicationContext() {  
    return this.applicationContextFactory.create(this.webApplicationType);  
}复制

ApplicationContextFactory DEFAULT = (webApplicationType) -> {
try {
switch (webApplicationType) {
case SERVLET:
return new AnnotationConfigServletWebServerApplicationContext();
case REACTIVE:
return new AnnotationConfigReactiveWebServerApplicationContext();
default:
return new AnnotationConfigApplicationContext();
}
}
catch (Exception ex) {
throw new IllegalStateException("Unable create a default ApplicationContext instance, "
+ "you may need a custom ApplicationContextFactory", ex);
}
};