SpringBoot 启动流程分析(寻找扩展点)
1、SpringBoot maven 依赖版本
<?xml version="1.0" encoding="UTF-8"?> <project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd"> <modelVersion>4.0.0</modelVersion> <groupId>org.example</groupId> <artifactId>SpringBootStudy</artifactId> <version>1.0-SNAPSHOT</version> <properties> <maven.compiler.source>8</maven.compiler.source> <maven.compiler.target>8</maven.compiler.target> <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding> </properties> <dependencies> <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-web</artifactId> <version>2.7.14</version> </dependency> </dependencies> </project>
2、启动代码
package com.springboot.study; import org.springframework.boot.SpringApplication; import org.springframework.boot.autoconfigure.SpringBootApplication; @SpringBootApplication public class Main { public static void main(String[] args) { SpringApplication springApplication = new SpringApplication(Main.class); springApplication.run(args); } }
3、启动流程分析
1、获取Spring工厂实例
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 List<String> loadFactoryNames(Class<?> factoryType, @Nullable ClassLoader classLoader) { ClassLoader classLoaderToUse = classLoader; if (classLoaderToUse == null) { classLoaderToUse = SpringFactoriesLoader.class.getClassLoader(); } String factoryTypeName = factoryType.getName(); return loadSpringFactories(classLoaderToUse).getOrDefault(factoryTypeName, Collections.emptyList()); }
private static Map<String, List<String>> loadSpringFactories(ClassLoader classLoader) { Map<String, List<String>> 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; }
这个地方会扫描项目中 resource 目录下的 META-INF/spring.factories 文件，默认如果不添加其他依赖，会扫描到如下项目：
- spring-boot-2.7.14.jar
- spring-boot-autoconfigure-2.7.14.jar
- spring-beans-5.3.29.jar
最终会扫描到如下对象：
2、run 方法分析
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, bootstrapContext, applicationArguments); configureIgnoreBeanInfo(environment); Banner printedBanner = printBanner(environment); context = createApplicationContext(); context.setApplicationStartup(this.applicationStartup); prepareContext(bootstrapContext, context, environment, listeners, applicationArguments, printedBanner); refreshContext(context); 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; }
1、首先是 createBootstrapContext 方法，该方法会调用第一个扩展点：BootstrapRegistryInitializer->initializer，但是项目中没有该接口的实现类。
2、其次就是 listeners.starting 方法， 该方法中会调用第二个扩展点 SpringApplicationRunListener->starting，这个 SpringApplicationRunListener 项目中只存在一个实现类：EventPublishingRunListener，它会触发所有的 ApplicationListener 监听 ApplicationStartingEvent 的事件，后文就不特别声明这个实现类了。
2.1、配置属性(prepareEnvironment->configureEnvironment)
protected void configurePropertySources(ConfigurableEnvironment environment, String[] args) { MutablePropertySources sources = environment.getPropertySources(); if (!CollectionUtils.isEmpty(this.defaultProperties)) { DefaultPropertiesPropertySource.addOrMerge(this.defaultProperties, sources); } if (this.addCommandLineProperties && args.length > 0) { String name = CommandLinePropertySource.COMMAND_LINE_PROPERTY_SOURCE_NAME; if (sources.contains(name)) { PropertySource<?> source = sources.get(name); CompositePropertySource composite = new CompositePropertySource(name); composite .addPropertySource(new SimpleCommandLinePropertySource("springApplicationCommandLineArgs", args)); composite.addPropertySource(source); sources.replace(name, composite); } else { sources.addFirst(new SimpleCommandLinePropertySource(args)); } } }
3、然后就是 prepareEnvironment 方法，该方法会调用第三个扩展点：SpringApplicationRunListener->environmentPrepared，它会触发所有的 ApplicationListener 监听 ApplicationEnvironmentPreparedEvent 的事件。
2.2、配置 Banner
private Banner getBanner(Environment environment) { Banners banners = new Banners(); banners.addIfNotNull(getImageBanner(environment)); banners.addIfNotNull(getTextBanner(environment)); if (banners.hasAtLeastOneBanner()) { return banners; } if (this.fallbackBanner != null) { return this.fallbackBanner; } return DEFAULT_BANNER; }
4、第四个扩展点在 prepareContext->applyInitializers 方法里，ApplicationContextInitializer->initialize。
5、第五个扩展点在 prepareContext->listeners.contextPrepared 方法里，SpringApplicationRunListeners->contextPrepared，它会触发所有的 ApplicationListener 监听 ApplicationContextInitializedEvent 的事件。
6、第六个扩展点在 prepareContext->bootstrapContext.close 方法里，它会触发所有的 ApplicationListener 监听 BootstrapContextClosedEvent 的事件。
2.3、加载 Source(prepareContext)
public Set<Object> getAllSources() { Set<Object> allSources = new LinkedHashSet<>(); if (!CollectionUtils.isEmpty(this.primarySources)) { allSources.addAll(this.primarySources); } if (!CollectionUtils.isEmpty(this.sources)) { allSources.addAll(this.sources); } return Collections.unmodifiableSet(allSources); }
private void load(Object source) { Assert.notNull(source, "Source must not be null"); if (source instanceof Class<?>) { load((Class<?>) source); return; } if (source instanceof Resource) { load((Resource) source); return; } if (source instanceof Package) { load((Package) source); return; } if (source instanceof CharSequence) { load((CharSequence) source); return; } throw new IllegalArgumentException("Invalid source type " + source.getClass()); }
这个地方会从 SpringApplication 中的 primarySources、sources 加载源，然后注册为 Bean。
7、第七个扩展点在 prepareContext->listeners.contextLoaded 方法里，SpringApplicationRunListeners->contextLoaded，会触发 ApplicationListener 监听 ApplicationPreparedEvent 的事件。
2.4、ServletWebServerApplicationContext->refresh
@Override public void refresh() throws BeansException, IllegalStateException { synchronized (this.startupShutdownMonitor) { StartupStep contextRefresh = this.applicationStartup.start("spring.context.refresh"); // Prepare this context for refreshing. prepareRefresh(); // Tell the subclass to refresh the internal bean factory. ConfigurableListableBeanFactory beanFactory = obtainFreshBeanFactory(); // Prepare the bean factory for use in this context. prepareBeanFactory(beanFactory); try { // Allows post-processing of the bean factory in context subclasses. postProcessBeanFactory(beanFactory); StartupStep beanPostProcess = this.applicationStartup.start("spring.context.beans.post-process"); // Invoke factory processors registered as beans in the context. invokeBeanFactoryPostProcessors(beanFactory); // Register bean processors that intercept bean creation. registerBeanPostProcessors(beanFactory); beanPostProcess.end(); // Initialize message source for this context. initMessageSource(); // Initialize event multicaster for this context. initApplicationEventMulticaster(); // Initialize other special beans in specific context subclasses. onRefresh(); // Check for listener beans and register them. registerListeners(); // Instantiate all remaining (non-lazy-init) singletons. finishBeanFactoryInitialization(beanFactory); // Last step: publish corresponding event. finishRefresh(); } catch (BeansException ex) { if (logger.isWarnEnabled()) { logger.warn("Exception encountered during context initialization - " + "cancelling refresh attempt: " + ex); } // Destroy already created singletons to avoid dangling resources. destroyBeans(); // Reset 'active' flag. cancelRefresh(ex); // Propagate exception to caller. throw ex; } finally { // Reset common introspection caches in Spring's core, since we // might not ever need metadata for singleton beans anymore... resetCommonCaches(); contextRefresh.end(); } } }
这里我们直接看到 invokeBeanFactoryPostProcessors 方法，不过这个方法蛮长的，就先看一部分：
for (BeanFactoryPostProcessor postProcessor : beanFactoryPostProcessors) { if (postProcessor instanceof BeanDefinitionRegistryPostProcessor) { BeanDefinitionRegistryPostProcessor registryProcessor = (BeanDefinitionRegistryPostProcessor) postProcessor; registryProcessor.postProcessBeanDefinitionRegistry(registry); registryProcessors.add(registryProcessor); } else { regularPostProcessors.add(postProcessor); } }
这个地方可以猜到这个 postProcessBeanDefinitionRegistry 也是一个扩展点，但是这个 beanFactoryPostProcessors 的值是从哪里来的呢?
打断点这里是有三个值的：
这里直接说答案，还记得这段代码吗：
context = createApplicationContext(); context.setApplicationStartup(this.applicationStartup); prepareContext(bootstrapContext, context, environment, listeners, applicationArguments, printedBanner);
这里获取了 context 之后，就调用了 prepareContext 方法，prepareContext 方法里曾提到过有第四、第五、第六、第七个扩展点。
举个例子，就拿第四个扩展点说：
ConfigurationWarningsApplicationContextInitializer 实现了 ApplicationContextInitializer 接口，然后添加了一个值：
@Override public void initialize(ConfigurableApplicationContext context) { context.addBeanFactoryPostProcessor(new ConfigurationWarningsPostProcessor(getChecks())); }
相同的还有 SharedMetadataReaderFactoryContextInitializer，至于第三个值则是直接在 prepareContext 方法里添加的。
8、第八个扩展点在 refresh->invokeBeanFactoryPostProcessors 方法里，会调用 invokeBeanDefinitionRegistryPostProcessors。
紧接着，就是如下代码：
String[] postProcessorNames = beanFactory.getBeanNamesForType(BeanDefinitionRegistryPostProcessor.class, true, false); for (String ppName : postProcessorNames) { if (beanFactory.isTypeMatch(ppName, PriorityOrdered.class)) { currentRegistryProcessors.add(beanFactory.getBean(ppName, BeanDefinitionRegistryPostProcessor.class)); processedBeans.add(ppName); } }
我们看看这个 postProcessorNames 是怎么来的，追踪到 beanFactory.getBeanNamesForType 方法，进去可以看到 doGetBeanNamesForType 方法，总而言之，是从 beanDefinitionNames 和 manualSingletonNames 的值来的，那这些值又是怎么来的呢，仍然是如下一段代码：
context = createApplicationContext(); context.setApplicationStartup(this.applicationStartup); prepareContext(bootstrapContext, context, environment, listeners, applicationArguments, printedBanner);
在创建 context 的时候，实际上是调用 AnnotationConfigApplicationContext 的构造方法，里面会调用 registerAnnotationConfigProcessors 方法，这个方法会初始化 5 个 beanDefinitionName。
然后就是 prepareContext 方法里，在第四个扩展点会初始化两个 manualSingletonName，prepareContext 方法里的 registerSingleton 方法也添加了两个 manualSingletonName，并且后面的 load 方法也添加了一个 main 的 beanDefinitionName，在最后的第七个扩展点里又添加了 3 个 manualSingletonName，总之在执行 refreshContext 之前，context 的 beanFactory 里包含 6 个 beanDefinitionName 7 个 manualSingletonName，后面的就不分析了，毕竟能扩展的就在这里。
9、第九个扩展点也在 refresh->invokeBeanFactoryPostProcessors 方法里，会调用 invokeBeanFactoryPostProcessors。
不过有一点要注意的是，虽说第八个、第九个也算是扩展点，但其只有在第四到第七个扩展点里面配置了才能进行扩展。
2.5、refresh->onRefresh
@Override protected void onRefresh() { super.onRefresh(); try { createWebServer(); } catch (Throwable ex) { throw new ApplicationContextException("Unable to start web server", ex); } }
该方法会调用 createWebServer 创建一个 webserver。
2.6、refresh->finishBeanFactoryInitialization
protected void finishBeanFactoryInitialization(ConfigurableListableBeanFactory beanFactory) { // Initialize conversion service for this context. if (beanFactory.containsBean(CONVERSION_SERVICE_BEAN_NAME) && beanFactory.isTypeMatch(CONVERSION_SERVICE_BEAN_NAME, ConversionService.class)) { beanFactory.setConversionService( beanFactory.getBean(CONVERSION_SERVICE_BEAN_NAME, ConversionService.class)); } // Register a default embedded value resolver if no BeanFactoryPostProcessor // (such as a PropertySourcesPlaceholderConfigurer bean) registered any before: // at this point, primarily for resolution in annotation attribute values. if (!beanFactory.hasEmbeddedValueResolver()) { beanFactory.addEmbeddedValueResolver(strVal -> getEnvironment().resolvePlaceholders(strVal)); } // Initialize LoadTimeWeaverAware beans early to allow for registering their transformers early. String[] weaverAwareNames = beanFactory.getBeanNamesForType(LoadTimeWeaverAware.class, false, false); for (String weaverAwareName : weaverAwareNames) { getBean(weaverAwareName); } // Stop using the temporary ClassLoader for type matching. beanFactory.setTempClassLoader(null); // Allow for caching all bean definition metadata, not expecting further changes. beanFactory.freezeConfiguration(); // Instantiate all remaining (non-lazy-init) singletons. beanFactory.preInstantiateSingletons(); }
这个方法会调用 beanFactory，实例化所有的 bean。
10、第十个扩展点在 refresh->finishRefresh 方法里，会调用 getLifecycleProcessor().onRefresh()，会调用 SmartLifecycle->start 方法。
11、第十一个扩展点也在 refresh->finishRefresh 方法里，会调用 publishEvent 然后触发 ApplicationListener 监听 ContextRefreshedEvent 的事件。
2.7、最后的三个扩展点-> run 方法
12、第十二个扩展点在 run 方法里，会调用 listeners.started 方法，SpringApplicationRunListener->started。
13、第十三个扩展点也在 run 方法里，会调用 callRunners 方法，ApplicationRunner 或 CommandLineRunner 的 run 方法。
14、第十四个扩展点也在 run 方法里，会调用 listeners.ready方法，SpringApplicationRunListener->ready。
3、结语
第一篇分析 SpringBoot 启动源码到这里就结束了，我们这次的目标是找到 SpringBoot 有哪些地方可以自己进行代码扩展的，其中不免有些遗漏的，欢迎各位补充。
目前看完还是有很多问题，比如 SpringBootApplication 注解的作用是什么、Bean 的实例化流程是什么、以及我们 Web 的 URL 请求是如何到方法上的...等等。
最后，这篇分析完的这些扩展点能干些什么呢？
