SpringBoot 启动类 SpringApplication 三 设置IOC容器

设置IOC容器

1. public ConfigurableApplicationContext run(String... args) {
2.         // -- snip
3.                 try {
4.                         // context的类型是AnnotationConfigServletWebServerApplicationContext
5.                         context = createApplicationContext();
6.                         context.setApplicationStartup(this.applicationStartup);
7.                         // 1. 准备容器
8.                         prepareContext(bootstrapContext, context, environment, listeners, applicationArguments, printedBanner);
9.                         // 2. 刷新容器
10.                         refreshContext(context);
11.                         afterRefresh(context, applicationArguments);
12.                         startup.started();
13.                         if (this.logStartupInfo) {
14.                                 new StartupInfoLogger(this.mainApplicationClass).logStarted(getApplicationLog(), startup);
15.                         }
16.                         listeners.started(context, startup.timeTakenToStarted());
17.                         callRunners(context, applicationArguments);
18.                 }
19.                 catch (Throwable ex) {
20.                         throw handleRunFailure(context, ex, listeners);
21.                 }
22.                 try {
23.                         if (context.isRunning()) {
24.                                 listeners.ready(context, startup.ready());
25.                         }
26.                 }
27.                 catch (Throwable ex) {
28.                         throw handleRunFailure(context, ex, null);
29.                 }
30.                 return context;
31.         }

复制代码

1. 准备容器

1. private void prepareContext(DefaultBootstrapContext bootstrapContext, ConfigurableApplicationContext context,
2.                 ConfigurableEnvironment environment, SpringApplicationRunListeners listeners,
3.                 ApplicationArguments applicationArguments, Banner printedBanner) {
4.         context.setEnvironment(environment);
5.         // 配置容器的类加载器、资源加载器、类型转换器
6.         postProcessApplicationContext(context);
7.         // 如果JVM允许AOT，则配置AOT相关的ApplicationContextInitializer
8.         // AOT(ahead of time)是在程序运行前将字节码编译成机器码，JIT(just in time)是程序边运行边将字节码编译成机器码。普通SpringBoot用的是JIT
9.         addAotGeneratedInitializerIfNecessary(this.initializers);
10.         // 1. 执行初始化器
11.         applyInitializers(context);
12.         listeners.contextPrepared(context);
13.         // 关闭引导上下文
14.         bootstrapContext.close(context);
15.         if (this.logStartupInfo) {
16.                 logStartupInfo(context.getParent() == null);
17.                 logStartupProfileInfo(context);
18.         }
19.         // Add boot specific singleton beans
20.         // beanFactory的类型是DefaultListableBeanFactory
21.         ConfigurableListableBeanFactory beanFactory = context.getBeanFactory();
22.         // 向bean工厂注册单例applicationArguments
23.         beanFactory.registerSingleton("springApplicationArguments", applicationArguments);
24.         if (printedBanner != null) {
25.                 beanFactory.registerSingleton("springBootBanner", printedBanner);
26.         }
27.         if (beanFactory instanceof AbstractAutowireCapableBeanFactory autowireCapableBeanFactory) {
28.                 // 配置是否允许循环依赖
29.                 autowireCapableBeanFactory.setAllowCircularReferences(this.allowCircularReferences);
30.                 if (beanFactory instanceof DefaultListableBeanFactory listableBeanFactory) {
31.                         listableBeanFactory.setAllowBeanDefinitionOverriding(this.allowBeanDefinitionOverriding);
32.                 }
33.         }
34.         if (this.lazyInitialization) {
35.                 // 设置延迟加载
36.                 context.addBeanFactoryPostProcessor(new LazyInitializationBeanFactoryPostProcessor());
37.         }
38.         if (this.keepAlive) {
39.                 // KeepAlive()对象额外启动一个非守护线程，避免`SpringBoot`因为非守护线程结束而关闭JVM
40.                 context.addApplicationListener(new KeepAlive());
41.         }
42.         // PropertySourceOrderingBeanFactoryPostProcessor是对@PropertySource注解修饰的类进行排序
43.         context.addBeanFactoryPostProcessor(new PropertySourceOrderingBeanFactoryPostProcessor(context));
44.         if (!AotDetector.useGeneratedArtifacts()) {
45.                 // Load the sources
46.                 Set<Object> sources = getAllSources();
47.                 Assert.notEmpty(sources, "Sources must not be empty");
48.                 load(context, sources.toArray(new Object[0]));
49.         }
50.         listeners.contextLoaded(context);
51. }

复制代码

1. 实行初始化器

1. protected void applyInitializers(ConfigurableApplicationContext context) {
2.         for (ApplicationContextInitializer initializer : getInitializers()) {
3.                 Class<?> requiredType = GenericTypeResolver.resolveTypeArgument(initializer.getClass(),
4.                                 ApplicationContextInitializer.class);
5.                 Assert.isInstanceOf(requiredType, context, "Unable to call initializer.");
6.                 initializer.initialize(context);
7.         }
8. }

复制代码

SpringBoot默认的初始化器有7个。从上到下它们的功能分别是
0. 实行情况属性context.initializer.classes指定的初始化器。它的优先级最高。

• 向容器添加一个CachingMetadataReaderFactoryPostProcessor。
  
• 初始化容器的ID。
  
• 向容器增长一个处理处罚错误告警的BeanFactoryPostProcessor。
  
• RSocket是基于Reactive Streams的通讯协议。
  
• 向容器设置server.port端口属性。
  
• 向容器中设置ConditionEvaluationReportListener。
  
  
  
  

2.革新容器

终极调用的是AbstractApplicationContext#refresh()方法。

1. private final Lock startupShutdownLock = new ReentrantLock();
3. public void refresh() throws BeansException, IllegalStateException {
4.         // startupShutdownLock锁是防止当前线程刷新容器，别的线程关闭容器。
5.         this.startupShutdownLock.lock();
6.         try {
7.                 this.startupShutdownThread = Thread.currentThread();
9.                 StartupStep contextRefresh = this.applicationStartup.start("spring.context.refresh");
11.                 // Prepare this context for refreshing.
12.                 // 1. 准备刷新
13.                 prepareRefresh();
15.                 // Tell the subclass to refresh the internal bean factory.
16.                 // 2. 重获容器
17.                 ConfigurableListableBeanFactory beanFactory = obtainFreshBeanFactory();
19.                 // Prepare the bean factory for use in this context.
20.                 // 3. 配置容器
21.                 prepareBeanFactory(beanFactory);
23.                 try {
24.                         // Allows post-processing of the bean factory in context subclasses.
25.                         // 4. 容器子类添加后处理器
26.                         postProcessBeanFactory(beanFactory);
27.                        
28.                         // 标记阶段
29.                         StartupStep beanPostProcess = this.applicationStartup.start("spring.context.beans.post-process");
30.                         // Invoke factory processors registered as beans in the context.
31.                        
32.                         // 5. 调用BeanFactory后处理器
33.                         invokeBeanFactoryPostProcessors(beanFactory);
34.                         // Register bean processors that intercept bean creation.
35.                         // 6. 注册bean后处理器
36.                         registerBeanPostProcessors(beanFactory);
37.                         beanPostProcess.end();
39.                         // Initialize message source for this context.
40.                         // 向bean工厂注册一个名为`messageSource`的单例bean
41.                         initMessageSource();
43.                         // Initialize event multicaster for this context.
44.                         // 向bean工厂注册一个名为`applicationEventMulticaster`的SimpleApplicationEventMulticaster对象
45.                         initApplicationEventMulticaster();
47.                         // Initialize other special beans in specific context subclasses.
48.                         // 7. tomcat初始化
49.                         onRefresh();
51.                         // Check for listener beans and register them.
52.                         registerListeners();
54.                         // Instantiate all remaining (non-lazy-init) singletons.
55.                         finishBeanFactoryInitialization(beanFactory);
57.                         // Last step: publish corresponding event.
58.                         finishRefresh();
59.                 }
61.                 catch (RuntimeException | Error ex ) {
62.                         if (logger.isWarnEnabled()) {
63.                                 logger.warn("Exception encountered during context initialization - " +
64.                                                 "cancelling refresh attempt: " + ex);
65.                         }
67.                         // Destroy already created singletons to avoid dangling resources.
68.                         destroyBeans();
70.                         // Reset 'active' flag.
71.                         cancelRefresh(ex);
73.                         // Propagate exception to caller.
74.                         throw ex;
75.                 }
77.                 finally {
78.                         contextRefresh.end();
79.                 }
80.         }
81.         finally {
82.                 this.startupShutdownThread = null;
83.                 this.startupShutdownLock.unlock();
84.         }
85. }

复制代码

1. 准备革新

1. protected void prepareRefresh() {
2.         // Switch to active.
3.         this.startupDate = System.currentTimeMillis(); // startupDate的类型是`long`，标记容器启动时刻
4.         this.closed.set(false); // close的类型是`AtomicBoolean`，标记当前容器是否已就绪
5.         this.active.set(true); // active的类型是`AtomicBoolean`，标记当前容器是否活跃
6.         // 源码此处有log
7.         // Initialize any placeholder property sources in the context environment.
8.         // 初始化名称为`servletContextInitParams`的ServletContextPropertySource`，即初始化Servlet相关属性
9.         initPropertySources();
11.         // Validate that all properties marked as required are resolvable:
12.         // see ConfigurablePropertyResolver#setRequiredProperties
13.         getEnvironment().validateRequiredProperties();
15.         // Store pre-refresh ApplicationListeners...
16.         // earlyApplicationListeners 刷新容器之前已存在的监听器
17.         if (this.earlyApplicationListeners == null) {
18.                 this.earlyApplicationListeners = new LinkedHashSet<>(this.applicationListeners);
19.         }
20.         else {
21.                 // Reset local application listeners to pre-refresh state.
22.                 this.applicationListeners.clear();
23.                 this.applicationListeners.addAll(this.earlyApplicationListeners);
24.         }
26.         // Allow for the collection of early ApplicationEvents,
27.         // to be published once the multicaster is available...
28.         this.earlyApplicationEvents = new LinkedHashSet<>();
29. }

复制代码

2. 重获容器

1. protected ConfigurableListableBeanFactory obtainFreshBeanFactory() {
2.         refreshBeanFactory();
3.         // 当前applicationContext是容器对象，但是包含了环境配置，事件发布器等等。而`getBeanFactory`返回的容器仅仅处理对象
4.         return getBeanFactory();
5. }

复制代码

1. // GenericApplicationContext#refreshBeanFactory
2. protected final void refreshBeanFactory() throws IllegalStateException {
3.         // refreshed的类型是`AtomicBoolean`,代表容器正在刷新，cas表示容器只能刷新一次
4.         if (!this.refreshed.compareAndSet(false, true)) {
5.                 throw new IllegalStateException(
6.                                 "GenericApplicationContext does not support multiple refresh attempts: just call 'refresh' once");
7.         }
8.         // 容器的id是`application`
9.         this.beanFactory.setSerializationId(getId());
10. }

复制代码

3. 设置容器

1. protected void prepareBeanFactory(ConfigurableListableBeanFactory beanFactory) {
2.         // Tell the internal bean factory to use the context's class loader etc.
3.         // 设置bean的类加载器，是`AppClassLoader`
4.         beanFactory.setBeanClassLoader(getClassLoader());
5.         // 设置SPEL解析器
6.         beanFactory.setBeanExpressionResolver(new StandardBeanExpressionResolver(beanFactory.getBeanClassLoader()));
7.         // 设置属性编辑器，将字符串属性转为java对象，比如将"false"字符串转为Boolean.False。
8.         beanFactory.addPropertyEditorRegistrar(new ResourceEditorRegistrar(this, getEnvironment()));
10.         // Configure the bean factory with context callbacks.
11.         // 配置bean后处理器。`ignoreDependencyInterface`表示容器不解析这些接口，不将接口的实现放入容器。
12.         //源码里是将这些接口放入`Set<Class<?>> ignoredDependencyInterfaces`。
13.         // 这些接口统一由`ApplicationContextAwareProcessor`处理。
14.         beanFactory.addBeanPostProcessor(new ApplicationContextAwareProcessor(this));
15.         beanFactory.ignoreDependencyInterface(EnvironmentAware.class);
16.         beanFactory.ignoreDependencyInterface(EmbeddedValueResolverAware.class);
17.         beanFactory.ignoreDependencyInterface(ResourceLoaderAware.class);
18.         beanFactory.ignoreDependencyInterface(ApplicationEventPublisherAware.class);
19.         beanFactory.ignoreDependencyInterface(MessageSourceAware.class);
20.         beanFactory.ignoreDependencyInterface(ApplicationContextAware.class);
21.         beanFactory.ignoreDependencyInterface(ApplicationStartupAware.class);
23.         // BeanFactory interface not registered as resolvable type in a plain factory.
24.         // MessageSource registered (and found for autowiring) as a bean.
25.         // 指定BeanFactory.class接口的容器对象是beanfactory
26.         // 源码里就是将`BeanFactory.class`和`beanFactory`放入`Map<Class<?>, Object> resolvableDependencies`。
27.         beanFactory.registerResolvableDependency(BeanFactory.class, beanFactory);
28.         beanFactory.registerResolvableDependency(ResourceLoader.class, this);
29.         beanFactory.registerResolvableDependency(ApplicationEventPublisher.class, this);
30.         beanFactory.registerResolvableDependency(ApplicationContext.class, this);
32.         // Register early post-processor for detecting inner beans as ApplicationListeners.
33.         // 添加bean后处理器，ApplicationListenerDetector监听实现ApplicationListener接口的bean
34.         beanFactory.addBeanPostProcessor(new ApplicationListenerDetector(this));
36.         // Detect a LoadTimeWeaver and prepare for weaving, if found.
37.         // NativeDetector检测当前环境是否是GraalVM native镜像。
38.         if (!NativeDetector.inNativeImage() && beanFactory.containsBean(LOAD_TIME_WEAVER_BEAN_NAME)) {
39.                 beanFactory.addBeanPostProcessor(new LoadTimeWeaverAwareProcessor(beanFactory));
40.                 // Set a temporary ClassLoader for type matching.
41.                 beanFactory.setTempClassLoader(new ContextTypeMatchClassLoader(beanFactory.getBeanClassLoader()));
42.         }
44.         // Register default environment beans.
45.         // 向容器注册名为"environment"的单例ApplicationServletEnvironment对象
46.         if (!beanFactory.containsLocalBean(ENVIRONMENT_BEAN_NAME)) {
47.                 beanFactory.registerSingleton(ENVIRONMENT_BEAN_NAME, getEnvironment());
48.         }
49.         // 向容器注册名为"systemProperties"的单例Properties对象
50.         if (!beanFactory.containsLocalBean(SYSTEM_PROPERTIES_BEAN_NAME)) {
51.                 beanFactory.registerSingleton(SYSTEM_PROPERTIES_BEAN_NAME, getEnvironment().getSystemProperties());
52.         }
53.         // 向容器注册名为"systemEnvironment"的`UnmodifiableMap`对象
54.         if (!beanFactory.containsLocalBean(SYSTEM_ENVIRONMENT_BEAN_NAME)) {
55.                 beanFactory.registerSingleton(SYSTEM_ENVIRONMENT_BEAN_NAME, getEnvironment().getSystemEnvironment());
56.         }
57.         // 向容器注册名为"applicationStartup"的单例DefaultApplicationStartup对象
58.         if (!beanFactory.containsLocalBean(APPLICATION_STARTUP_BEAN_NAME)) {
59.                 beanFactory.registerSingleton(APPLICATION_STARTUP_BEAN_NAME, getApplicationStartup());
60.         }
61. }

复制代码

4. 容器子类添加后处理处罚器

ServletWebServerApplicationContext是容器实现类，它添加bean后处理处罚器。WebApplicationContextServletContextAwareProcessor是向容器添加servletContext。

1. // org.springframework.boot.web.servlet.context.ServletWebServerApplicationContext
2. protected void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) {
3.         beanFactory.addBeanPostProcessor(new WebApplicationContextServletContextAwareProcessor(this));
4.         beanFactory.ignoreDependencyInterface(ServletContextAware.class);
5.         registerWebApplicationScopes();
6. }

复制代码

5. 调用BeanFactory后处理处罚器

终极调用的是PostProcessorRegistrationDelegate#invokeBeanFactoryPostProcessors()方法。后处理处罚器分2种，一种是BeanDefinitionRegistryPostProcessors，处理处罚BeanDefinitionRegistry中登记的BeanDefinition。BeanDefinition是bean的界说类，是对差别泉源(Annotation注解，xml文件)的容器界说(scope, beanName)的抽象。容器根据界说类创建容器。一种是BeanFactoryPostProcessors，处理处罚容器。

先看BeanDefinitionRegistryPostProcessors。起首处理处罚PriorityOrdered接口，之后处理处罚Ordered接口，别的的末了处理处罚。

invokeBeanDefinitionRegistryPostProcessors方法让每个后处理处罚器postProcessor调用本身的postProcessBeanDefinitionRegistry方法。此中有个org.springframework.context.annotation.ConfigurationClassPostProcessor将全部@Confuguration注解类剖析成BeanDefinitionHolder。

1. private static void invokeBeanDefinitionRegistryPostProcessors(
2.                         Collection<? extends BeanDefinitionRegistryPostProcessor> postProcessors, BeanDefinitionRegistry registry, ApplicationStartup applicationStartup) {
4.                 for (BeanDefinitionRegistryPostProcessor postProcessor : postProcessors) {
5.                         StartupStep postProcessBeanDefRegistry = applicationStartup.start("spring.context.beandef-registry.post-process")
6.                                         .tag("postProcessor", postProcessor::toString);
7.                         postProcessor.postProcessBeanDefinitionRegistry(registry);
8.                         postProcessBeanDefRegistry.end();
9.                 }
10.         }

复制代码

BeanFactoryPostProcessors也是按照优先级举行处理处罚。

处理处罚竣过后，删除缓存。

1. @Override
2. public void clearMetadataCache() {
3.         super.clearMetadataCache();
4.         this.mergedBeanDefinitionHolders.clear();
5.         clearByTypeCache();
6. }

复制代码

6. 注册bean后处理处罚器

registerBeanPostProcessors方法也是按照优先级注册bean后处理处罚方法。这里的注册指的是将BeanPostProcessors放入容器，即abstractBeanFactory.addBeanPostProcessors(postProcessors)。而不是实行BeanPostProcessors，由于此时还没有创建bean。

末了将后处理处罚器重新注册一遍。而且添加ApplicationListenerDetector容器后处理处罚器。

7. tomcat初始化

onfresh()是交给容器子类自界说初始化，web容器在此设置web情况而且启动tomcat。