springboot sessionfactory_【修炼内功】[springboot] [1] SpringBoot是如何实现自动装配的...

最新推荐文章于 2024-05-06 18:04:26 发布
最新推荐文章于 2024-05-06 18:04:26 发布
阅读量247 收藏 1
点赞数
文章标签： springboot sessionfactory springboot 自动装配 springboot自动装配

林中通幽径，深山藏小舍

e46ac9c5a0b1c9f035f7aa77d0cee6a5.png

上篇文章 Spring Framework中的注解是如何运作的 介绍了Spring Framework中各种注解的运作方式，(在SpringBoot推出之前)对于组件的使用还需要手动进行配置(无论xml/groovy文件方式还是注解方式)，如DataSource、SessionFactory、TransactionManager、DispatcherServlet等等

SpringBoot提供了一种新的方式用于简化Spring应用的搭建及开发过程，通过各种starter实现组件的自动装配(autoconfig)，将约定优于配置表现的淋漓尽致，在此基础上还提供了众多扩展点用以修改约定的配置及默认的组件功能

那，SpringBoot是如何实现自动装配的？(SpringBoot提供的starter列表见 https://docs.spring.io/spring-boot/docs/current/reference/html/using-spring-boot.html#using-boot-starter)

快速生成Boot应用

  • SpringBoot脚手架：https://start.spring.io/

  • PandoraBoot脚手架(阿里内部)：http://mw.alibaba-inc.com/bootstrap.html

1. SpringBoot的启动

SpringBoot应用一般会将 SpringApplication 及 @SpringBootApplication 放一起配合使用

@SpringBootApplicationpublic class Application {    public static void main(String[] args) {        SpringApplication app = new SpringApplication(Application.class);        app.setWebApplicationType(WebApplicationType.NONE);        app.run(args);        // 或者        // SpringApplication.run(Application.class, args);        // 或者        // new SpringApplicationBuilder(Application.class)        //        .profiles("dev")        //        .properties("spring.application.name=spring-boot-demo")        //        .run(args);    }}

这里，不一定非要使用@SpringBootApplication注解，SpringApplication也不一定非要放在main入口中

在此，将SpringApplication及@SpringBootApplication的作用分两个小节详解

上例中展示了三种SpringApplication的编码方式，但不论何种方式都离不开两个步骤：创建(SpringApplication#new)；运行(SpringApplication#run)

1.1 SpringApplication创建

在SpringApplication创建过程中初始化了一些参数，各参数的作用/使用会在下文中得以解释

public SpringApplication(ResourceLoader resourceLoader, Class>... primarySources) {    // ResourceLoader    this.resourceLoader = resourceLoader;    // 主入口类    this.primarySources = new LinkedHashSet<>(Arrays.asList(primarySources));    // web类型 NONE | SERVLET | REACTIVE    this.webApplicationType = WebApplicationType.deduceFromClasspath();    // 设置initializers(org.springframework.context.ApplicationContextInitializer)    setInitializers((Collection) getSpringFactoriesInstances(ApplicationContextInitializer.class));    // 设置listeners(org.springframework.context.ApplicationListener)    setListeners((Collection) getSpringFactoriesInstances(ApplicationListener.class));    // main函数所处的类    this.mainApplicationClass = deduceMainApplicationClass();}

这里需要着重介绍的是在初始化某些参数时使用的一些逻辑

1.1.1 web类型的探测

web类型的探测用到了WebApplicationType#deduceFromClasspath，其逻辑如下

c9a8936769768afef6f5cdd86f6972ff.png

或许你也遇到过类似的情况，本身并不是一个web工程，却因为某些原因(如引入第三方包的不规范)导致探测到了REACTIVE/SERVLET从而进入了web启动流程(ReactiveWebServerApplicationContext / ServletWebServerApplicationContext)进而引发其他的问题

1.1.2 spring.factories文件初探

Java中SPI(Service Provider Interface)的概念或许各位都不陌生，其提供了一套用来被第三方实现或者扩展的API，用以启用框架扩展、替换组件，将装配的控制权移到程序之外(如最为典型的 jdbc dirver)

Spring中大量使用了该思想，spring.factories是其一种实现形式，spring.factories核心加载逻辑在SpringFactoriesLoader#loadFactoryNames / SpringFactoriesLoader#loadSpringFactories

181649a599558b73c404fe519adc1e78.png

以spring-boot中spring.factories片段为例

# PropertySource Loadersorg.springframework.boot.env.PropertySourceLoader=\org.springframework.boot.env.PropertiesPropertySourceLoader,\org.springframework.boot.env.YamlPropertySourceLoader# Run Listenersorg.springframework.boot.SpringApplicationRunListener=\org.springframework.boot.context.event.EventPublishingRunListener

SpringFactoriesLoader#loadSpringFactories加载后的Map，key为等号前的接口类，value为等号后的实现类列表

再次回到SpringApplication创建过程中对initializers及listeners的初始化，其分别加载并初始化了spring.factories文件中的org.springframework.context.ApplicationContextInitializer及org.springframework.context.ApplicationListener

Java SPI及Spring Factories的几点对比如下

 Java SPISpring Factories
文件位置META-INF/services/{interface full class name}META-INF/spring.factories
文件内容每行一个接口实现类，可以多行properties文件格式，key为接口类全路径，value为实现类全路径(多个间使用逗号分隔)
加载方法ServiceLoader#loadSpringFactoriesLoader#loadFactoryNames/#loadFactories

Q&A

  • 是否可以自定义META-INF/spring.factories，用以扩展Spring中用到的组件？

    可以，事实上Spring也鼓励这样做

  • 是否可以使用META-INF/spring.factories实现自己的逻辑？

    可以，SpringFactoriesLoader中的方法为公开的，并且SpringFactoriesLoader的实现在spring-core中，其使用并不局限于spring-boot

注：使用SpringFactorieLoader加载并初始化的实例通常并没有被IOC管理，通常也没有实现依赖注入的能力

参考 SpringFactoriesLoader#loadFactories / SpringApplication#createSpringFactoriesInstances

1.1.3 主main函数入口类探测

mainApplicationClass用以记录main函数所在类，其探测实现在SpringApplication#deduceMainApplicationClass，逻辑则略显“奇巧”，通过构造RuntimeException获取其stackTrace，分析每一个StackTraceElement找到调用链上的main函数，并返回该函数所在类

关于mainApplicationClass的作用会在下文介绍

1.2 SpringApplication启动

SpringApplication的启动过程要比创建过程实在的多

ed81d3bb767a8c43a921cfe12baf9c5d.png

SpringApplicationRunListener配置在spring.factories中，其可以针对SpringBoot启动过程中的各事件进行监听(详见SpringApplicationRunListener中的方法定义)

Spring错综复杂的逻辑关系难以在一张流程图中理清所有，惯例，将其拆分并各个击破

1.2.1 ApplicationArguments

在启动jvm时通常可以添加一些启动参数，诸如-jar、-XX:CMSTriggerRatio、-Dproperty以及自定义参数等

通常有两种参数可以被Spring使用，-Dproperty=value 及--property=value

前者为jvm的能力，其将具体的参数值设置到系统参数中，以便任意的框架均可通过System#getProperty获取

-Dproperty=value

Sets a system property value. The property variable is a string with no spaces that represents the name of the property. The value variable is a string that represents the value of the property. If value is a string with spaces, then enclose it in quotation marks (for example -Dfoo="foo bar").

https://docs.oracle.com/javase/8/docs/technotes/tools/windows/java.html

后者为spring的能力，其底层使用SimpleCommandLinePropertySource来解析，在SpringBoot应用中还可以通过bean-type或bean-name(“springApplicationArguments”)来注入ApplicationArguments，以便在自己的逻辑中获取--property=value类型的启动参数

1.2.2 构造Environment

org.springframework.boot.SpringApplication#prepareEnvironment

98a0c259e014718c80dad010d86b4242.png

流程图中ConversionService的作用可以参考org.springframework.beans.TypeConverter的使用(Bean是如何被创建的)

同时Spring会将启动参数中的-Dproperty=value 及--property=value一并合并到Environment中

Environment创建过程中会将SystemProperties及SystemEnvironment一并合并到Environment中

见AbstractEnvironment#new及StandardEnvironment#customizePropertySources

注意到，application配置文件中spring.main.*下的配置可以修改SpringApplication中的参数，如

spring.main.log-startup-info=falsespring.main.lazy-initialization=truespring.main.banner-mode=LOG# 见SpringApplication中支持的参数设置# https://docs.spring.io/spring-boot/docs/current/reference/html/spring-boot-features.html#boot-features

Binder的使用见 https://spring.io/blog/2018/03/28/property-binding-in-spring-boot-2-0

1.2.3 输出Banner

org.springframework.boot.SpringApplication#printBanner

通常在Spring启动时会看到诸如下图的banner，其实spring是提供了强大定制能力的，具体使用可以参考 https://docs.spring.io/spring-boot/docs/current/reference/html/spring-boot-features.html#boot-features-banner

94598225d88116c4f812296d9a2ca32b.png

Spring同时支持文本(直接输出文本内容)及图片(将图片解析为文本进行绘制)两种banner能力，其分别通过ResourceBanner及ImageBanner实现，具体见SpringApplicationBannerPrinter#getBanner

1.2.4 构造ApplicationContext

org.springframework.boot.SpringApplication#createApplicationContext

这里并没有太多需要介绍的，spring会根据webApplicationType生成不同的ApplicationContext

webApplicationTypeApplicationContext
WebApplicationType.SERVLETAnnotationConfigServletWebServerApplicationContext
WebApplicationType.REACTIVEAnnotationConfigReactiveWebServerApplicationContext
默认AnnotationConfigApplicationContext

1.2.5 ApplicationContext初始化前

org.springframework.boot.SpringApplication#prepareContext

12fce439e873a39c4b0ccee9ca12ac78.png

这里需要重点介绍几个逻辑

(1)ApplicationContextInitializer#initialize

文章开始初介绍了Spring会从spring.factories中加载ApplicationContextInitializer，在这里则会用到它们的initialize方法，通常可以通过该方法注册一些额外的bean或者BeanFactoryPostProcessor，甚至对ApplicationContext做一些修改

如spring-boot-autoconfiguration中注册的SharedMetadataReaderFactoryContextInitializer

class SharedMetadataReaderFactoryContextInitializer    implements ApplicationContextInitializer<ConfigurableApplicationContext> {  @Override  public void initialize(ConfigurableApplicationContext applicationContext) {    applicationContext.addBeanFactoryPostProcessor(new CachingMetadataReaderFactoryPostProcessor());  }}

再如spring-boot-devtools中注册的RestartScopeInitializer

public class RestartScopeInitializer implements ApplicationContextInitializer<ConfigurableApplicationContext> {  @Override  public void initialize(ConfigurableApplicationContext applicationContext) {    applicationContext.getBeanFactory().registerScope("restart", new RestartScope());  }}
(2)lazyInitialization

如果该属性被设置为true，spring则会向ApplicationContext中添加LazyInitializationBeanFactoryPostProcessor，其会将所有bean的lazyInit属性设置为true，以延迟bean的加载并加快SpringBoot的启动速度，其弊端则是将一些隐性的错误延迟到了首次加载阶段(如注入问题)

A downside of lazy initialization is that it can delay the discovery of a problem with the application.

当然也有例外情况，可通过注册LazyInitializationExcludeFilter进行排除实现

(3)primarySources及sources的加载

primarySources可通过SpringApplication的构造传入，sources可通过spring.main.sources设置

通常我们需要将@SpringBootApplication注解添加到primarySource或source类上，其目的就是在加载primarySources或sources时一并解析

SpringApplication的启动逻辑(run函数)并不是SpringBoot的全部，其大部分功能由@SpringBootApplication注解代入

至此还没有执行ApplicationContext的refresh动作，也就是说primarySources及sources(如果存在则包括@SpringBootApplication)的解析是优先于ApplicationContext#refresh的

当然，理论上可以将@SpringBootApplication注解放到其他类上，但请保证该类可以被Spring扫描到

1.2.6 ApplicationContext的初始化

org.springframework.boot.SpringApplication#refreshContext

该部分没有十分特别的逻辑，执行ApplicationContext的refresh方法并注册shutdown hook(registerShutdownHook)

ApplicationContext的refresh逻辑参考ApplicationContext给开发者提供了哪些(默认)扩展

1.2.7 ApplicationContext初始化后

org.springframework.boot.SpringApplication#afterRefresh

该部分并没有实际的实现，由子类实现

1.2.8 异常处理

org.springframework.boot.SpringApplication#handleRunFailure

在SpringApplication启动过程中发生异常则有此部分处理，这里需要关注的是，具体的异常可由SpringBootExceptionReporter#reportException接收并处理

而SpringBootExceptionReporter则由spring.factories中的org.springframework.boot.SpringBootExceptionReporter进行注册(通常为org.springframework.boot.diagnostics.FailureAnalyzers)

至此完成了SpringApplication的初始化及执行过程的介绍，但对于众多SpringBoot的能力貌似都没有体现，正如上文所述，SpringBoot大部分功能由@SpringBootApplication注解代入

2. @SpringBootApplication注解的威力

如上文介绍，通常需要将@SpringBootApplication注解添加到primarySource或source类上，其目的是在加载primarySources或sources时一并解析，并且此过程一般在ApplicationContext refresh之前

对于注解的解析逻辑见 Spring Framework中的注解是如何运作的

首先看一下@SpringBootApplication注解的层级结构我们对其进行拆分并依次介绍其作用

e522700ff4866b8945675b93c4c82a1e.png

2.1 ComponentScan

在Spring Framework中的注解是如何运作的一文中有介绍，如果@ComponentScan中没有指定任何扫描packages，Spring则会使用目标class所在的package进行扫描，这也是为什么我们在@SpringBootApplication上没有指定scanBasePackages时，总是会扫描@SpringBootApplication修饰类所在package的原因

此外，@SpringBootApplication中默认为@ComponentScan添加了两个excludeFilter，TypeExcludeFilter及AutoConfigurationExcludeFilter

前者的排除规则由TypeExcludeFilter类型的bean实现，可自行实现并注册

后者则为了防止primarySource与spring.factories中org.springframework.boot.autoconfigure.EnableAutoConfiguration同时指定一个类时的重复注册

2.2 SpringBootConfiguration

该注解仅是简单继承了@Configuration，@Configuration介绍详见 Spring Framework中的注解是如何运作的

2.3 EnableAutoConfiguration

@EnableAutoConfiguration注解主要用来发现需要装配的配置类，并进行自动装配

该注解使用@Import直接导入了AutoConfigurationImportSelector，同时继承了@AutoConfigurationPackage，而@AutoConfigurationPackage也简单地使用@Import导入了AutoConfigurationPackages.Registrar

这里我们对导入的两个类进行分析(@Import的介绍详见 Spring Framework中的注解是如何运作的)

2.4 AutoConfigurationImportSelector

AutoConfigurationImportSelector#selectImports

该注册器的逻辑其实非常简单

  • spring.factories中org.springframework.boot.autoconfigure.EnableAutoConfiguration记录了所有需要注册的配置类

  • @EnableAutoConfiguration中的exclude及excludeName参数，及spring.autoconfigure.exclude，配置了不需要注册的配置类信息

  • spring-autoconfigure-metadata.properties中记录了各种配置类的注册条件

根据以上信息，可以筛选出最终需要注册的配置类，并对其进行配置

5e5cb279f82503c9f2360ef2435cb187.png

spring.factories中org.springframework.boot.autoconfigure.EnableAutoConfiguration，示例如

org.springframework.boot.autoconfigure.EnableAutoConfiguration=\org.springframework.boot.autoconfigure.aop.AopAutoConfiguration,\org.springframework.boot.autoconfigure.batch.BatchAutoConfiguration,\org.springframework.boot.autoconfigure.cache.CacheAutoConfiguration,\org.springframework.boot.autoconfigure.context.PropertyPlaceholderAutoConfiguration

spring-boot-autoconfigure工程中的spring.factories文件中定义了大量的XxxAutoConfiguration，用以在引入不同starter时对相关Bean的自动装配(SpringBoot提供的starter列表见 https://docs.spring.io/spring-boot/docs/current/reference/html/using-spring-boot.html#using-boot-starter)

spring-boot-autoconfigure工程中的spring.factories文件定义了spring-boot绝大部分starter自动装配的XxxAutoConfiguration，但通常来讲并不是所有的XxxAutoConfiguration都需要装配

决定一个XxxAutoConfiguration是否需要进行装配，由以下几方面控制

  • @EnableAutoConfiguration参数控制

  • spring.autoconfigure.exclude参数控制

  • spring-autoconfigure-metadata.properties文件中指定的规则控制

  • XxxAutoConfiguration本身的条件控制，如硬编码的@ConditionalOn

spring-autoconfigure-metadata.properties文件，示例如

org.springframework.boot.autoconfigure.web.client.RestTemplateAutoConfiguration.AutoConfigureAfter=org.springframework.boot.autoconfigure.http.HttpMessageConvertersAutoConfigurationorg.springframework.boot.autoconfigure.data.cassandra.CassandraReactiveDataAutoConfiguration.ConditionalOnClass=com.datastax.driver.core.Cluster,reactor.core.publisher.Flux,org.springframework.data.cassandra.core.ReactiveCassandraTemplateorg.springframework.boot.autoconfigure.security.oauth2.client.servlet.OAuth2ClientAutoConfiguration.ConditionalOnWebApplication=SERVLETorg.springframework.boot.autoconfigure.jersey.JerseyAutoConfiguration.AutoConfigureOrder=-2147483648

该文件定义了各种配置类自动装配的条件，properties文件的格式为${配置类全路径}.${条件类型}=${条件值}

条件类型可以为ConditionalOnClass、AutoConfigureAfter、AutoConfigureOrder等，其逻辑由org.springframework.boot.autoconfigure.AutoConfigurationImportFilter定义解析，AutoConfigurationImportFilter同样在spring.factories中指定

Q: 如何借助spring.factories在SpringBoot启动时自动装配自定义的Bean(s)? 如何使用该特性自定义starter?

Q&A:

SpringBoot是如何通过@AutoConfigureBefore、@AutoConfigureAfter、AutoConfigureOrder控制配置类加载顺序的？

AutoConfigurationImportSelector实现了DeferredImportSelector(DeferredImportSelector的原理参考Spring Framework中的注解是如何运作的)，其在ConfigurationClassParser#deferredImportSelectorHandler.process()阶段，使用AutoConfigurationSorter针对以上注解对配置类进行了加载的排序

  • AutoConfigurationImportSelector.AutoConfigurationGroup#selectImports

  • AutoConfigurationImportSelector.AutoConfigurationGroup#sortAutoConfigurations

2.3.2 AutoConfigurationPackages.Registrar

AutoConfigurationPackages.Registrar#registerBeanDefinitions

该注册器的逻辑则略显单薄，其注册了一个名为org.springframework.boot.autoconfigure.AutoConfigurationPackages类型为BasePackages的bean，该bean中记录了被@EnableAutoConfiguration修饰的类所在的package

2.4 ConfigurationPropertiesScan

@ConfigurationPropertiesScan主要用来发现@ConfigurationProperties，并对其进行解析、注册

同样的，该注解使用@Import直接导入了ConfigurationPropertiesScanRegistrar，同时继承了@EnableConfigurationProperties，而@EnableConfigurationProperties也简单地使用@Import导入了@EnableConfigurationPropertiesRegistrar

这里我们对导入的两个类进行分析

2.4.1 ConfigurationPropertiesScanRegistrar

ConfigurationPropertiesScanRegistrar#registerBeanDefinitions

该部分逻辑比较简单，不再附以流程图

@Overridepublic void registerBeanDefinitions(AnnotationMetadata importingClassMetadata, BeanDefinitionRegistry registry) {    // 从@ConfigurationPropertiesScan中获取需要扫描packages    Set<String> packagesToScan = getPackagesToScan(importingClassMetadata);    // 在指定packages中扫描被@ConfigurationProperties修饰的类并注册    scan(registry, packagesToScan);}

所以整体逻辑

  1. 从@ConfigurationPropertiesScan中(basePackages/basePackageClasses)获取需要扫描的packages，如果均为指定则默认@ConfigurationPropertiesScan修饰类所在package

  2. 在以上package中扫描被@ConfigurationProperties修饰的类并注册，扫描器由ClassPathScanningCandidateComponentProvider创建

以上具体逻辑可阅读源码，扫描逻辑可参考Spring Framework中的注解是如何运作的 - ClassPathBeanDefinitionScanner

2.4.2 EnableConfigurationPropertiesRegistrar

EnableConfigurationPropertiesRegistrar#registerBeanDefinitions

@ConfigurationPropertiesScanRegistrar只是用来在指定packages中发现@ConfigurationProperties并注册，那@ConfigurationProperties的具体解析在哪里？

@Overridepublic void registerBeanDefinitions(AnnotationMetadata metadata, BeanDefinitionRegistry registry) {    // 注册处理器    registerInfrastructureBeans(registry);    // 对@EnableConfigurationProperties中指定的类进行注册    ConfigurationPropertiesBeanRegistrar beanRegistrar = new ConfigurationPropertiesBeanRegistrar(registry);    getTypes(metadata).forEach(beanRegistrar::register);}

EnableConfigurationPropertiesRegistrar做了两件事

  1. @EnableConfigurationProperties#value可以直接指定被@ConfigurationProperties修饰的类，EnableConfigurationPropertiesRegistrar对其进行注册(注册逻辑可参考Spring Framework中的注解是如何运作的 - AnnotatedBeanDefinitionReader)

  2. 注册一些处理器(以下仅列出其中比较关键的几个处理器)

  • ConfigurationPropertiesBindingPostProcessor

  • ConfigurationPropertiesBinder

(1)ConfigurationPropertiesBinder

ConfigurationPropertiesBinder是一个通用能力，底层采用Binder(见https://spring.io/blog/2018/03/28/property-binding-in-spring-boot-2-0)将@ConfigurationProperties中指定的规则属性绑定到修饰的Bean实例中

(2)ConfigurationPropertiesBindingPostProcessor

ConfigurationPropertiesBindingPostProcessor实现了BeanPostProcessor，在其postProcessBeforeInitialization函数中借助ConfigurationPropertiesBinder对@ConfigurationProperties修饰的Bean做属性绑定动作(BeanPostPocessor原理参考Bean是如何被创建的)

通常@ConfigurationProperties与@NestedConfigurationProperty配合使用，解决复杂对象属性绑定

参考 https://docs.spring.io/spring-boot/docs/current/reference/html/appendix-configuration-metadata.html#configuration-metadata-nested-properties

starter中使用@ConfigurationProperties绑定属性时，为了快速让使用者了解starter可以进行配置的选项，以及辅助IDE在配置时进行提示、校验、自动补全等，会使用spring-boot-configuration-processor将@ConfigurationProperties所在类的信息映射为元数据文件(META-INF/spring-configuration-metadata.json)

其中描述信息来自标准的javadoc(参考 https://docs.spring.io/spring-boot/docs/current/reference/html/appendix-configuration-metadata.html#configuration-metadata-annotation-processor)

2.5 回顾

回顾一下@SpringBootApplication注解的层级结构

e522700ff4866b8945675b93c4c82a1e.png

Spring Framework中的注解是如何运作的中有介绍Spring中的注解编程模型，@SpringBootApplication由很多注解组合而成，并且在其中重写了@EnableAutoConfiguration及@ComponentScan的参数，以便在@SpringBootApplication中直接控制后者的参数

是否有曾考虑过，@SpringBootApplication所包含的注解只能以@SpringBootApplication的方式使用么？是否可以单独使用？@SpringBootApplication并没有重写@ConfigurationPropertiesScan及@EnableConfigurationProperties注解参数，那后者的参数如何控制？

凡事不用太过死板，@SpringBootApplication仅仅整合了多个注解的能力，至于组合使用还是单独使用完全由开发者决定，这也是Spring比较友好的地方

对于Bean属性绑定而言，反而比较常用的是@ConfigurationProperties与@EnableConfigurationProperties的组合，而不是@SpringBootApplication，尤其在starter的实现中

@ConfigurationProperties(prefix = "spring.my", ignoreInvalidFields = true)public class MyProperties { ... }@Configuration@EnableConfigurationProperties(MyProperties.class)public class MyConfiguration { ... }

Q: 是否还有其他发现？

3. spring.factories浅解

SpringBoot中spring.factories内容非常丰富，这里挑选几个有代表性的进行梳理，更多的内容还需要读者自行探索

3.1 spring-boot

3.1.1 SpringApplicationRunListener

org.springframework.boot.SpringApplicationRunListener (on spring.factories)

上文有介绍，SpringApplicationRunListener可以针对SpringBoot启动过程中的各事件进行监听，其中比较有代表性的EventPublishingRunListener，其在contextLoaded阶段(EventPublishingRunListener#contextLoaded)将spring.factories中配置的ApplicationListener添加到创建的ApplicationContext中

3.1.2 ApplicationListener

org.springframework.context.ApplicationListener (on spring.factories)

ApplicationListener的使用在ApplicationContext给开发者提供了哪些(默认)扩展中有介绍，ApplicationListener的注册也可以在spring.factories中，这里要介绍的一个ApplicationListener是ConfigFileApplicationListener，其在ApplicationEnvironmentPreparedEvent事件(ConfigFileApplicationListener#onApplicationEnvironmentPreparedEvent)下加载了spring.factories中所有的EnvironmentPostProcessor，执行其postProcessEnvironment方法对Environment进行增强

3.1.3 EnvironmentPostProcessor

org.springframework.boot.env.EnvironmentPostProcessor (on spring.factories)

从命名上可以看出，EnvironmentPostProcessor是在Environment准备好后对Environment做一些处理

ConfigFileApplicationListener除了实现ApplicationListener之外同时还实现了EnvironmentPostProcessor，在其postProcessEnvironment方法中加载了spring.factories中所有的PropertySourceLoader，将classpath:/,classpath:/config/,file:./,file:./config/下的 application.* 类似的文件加载到Environment中

3.1.4 PropertySourceLoader

org.springframework.boot.env.PropertySourceLoader

PropertySourceLoader则是用来加载配置文件的具体实现，SpringBoot spring.factories中提供了两种实现 PropertiesPropertySourceLoader及YamlPropertySourceLoader，前者用来加载properties及xml文件，后者用来加载yml文件

从这里可以看出，通过 (on spring.factories)

  1. EventPublishingRunListener(SpringApplicationRunListener)->

  2. ConfigFileApplicationListener(ApplicationListener)->

  3. ConfigFileApplicationListener(EnvironmentPostProcessor)->

  4. Properties/YamlPropertySourceLoader(PropertySourceLoader)

才实现了application.properties / application.yml配置文件的加载

spring.factories所提供服务的体系比较庞大，其在SpringBoot自动装配中起到了至关重要的作用

Q: 如何实现自己的PropertySourceLoader，实现自定义application.*文件的加载

Q: 了解SpringBoot提供的spring.factories内的功能，并对其进行扩展

3.2 spring-autoconfigure

3.2.1 EnableAutoConfiguration

org.springframework.boot.autoconfigure.EnableAutoConfiguration

用来定义需要导入的配置类，SpringBoot starter使用该方式实现配置类的自动导入

3.2.2 AutoConfigurationImportFilter

org.springframework.boot.autoconfigure.AutoConfigurationImportFilter

用来实现类似@Conditional的功能，判断目标配置类是否满足导入条件

SpringBoot提供了OnBeanCondition、OnClassCondition、OnWebApplicationCondition三种Condition，分别处理

  • OnBeanCondition

    @ConditionalOnBean、@ConditionalOnMissingBean、@ConditionalOnSingleCandidate

  • OnClassCondition

    @ConditionalOnClass、@ConditionalOnMissingClass

  • OnWebApplicationCondition

    @ConditionalOnWebApplication、@ConditionalOnNotWebApplication

等注解的处理

4. 后记

SpringBoot的内容远不止这些，SpringBoot所能实现的功能也远超我目前对它的认识，Spring很强大，但也有它自身的缺点，当下不乏一些优秀的竞争对手

语言与框架只是你迈上下一级台阶的工具和手段，匠人精神不能少，但也要正确看待当今快速变化的世界

e46ac9c5a0b1c9f035f7aa77d0cee6a5.png

weixin_39842918
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
FTP-springboot.zip
02-26
总之，"FTP-springboot.zip"项目展示了如何在SpringBoot应用中集成FTP服务，实现文件的上传和下载功能。开发者可以根据自己的需求调整配置和业务逻辑，以适应不同场景下的文件传输需求。通过这种方式，我们可以利用...
springboot-spring-data-jpa.zip
02-04
首先，SpringBoot的核心是自动配置。在项目中引入Spring Boot Starter JPA依赖后，它会自动配置数据源、JPA供应商（如Hibernate）、事务管理器等组件，大大减少了手动配置的工作量。开发者只需要在`application....
【仿牛客网笔记】初识Spring Boot，开发社区首页-MyBatis入门
xue_hua_c的博客
10-20 535
插入的时候需要声明需要添加的元素的类型，如果参数是一个简单的比如String username或者 String email时候不需要声明添加的类型，但是如果参数是User user这样一个Bean的时候就需要。还需要ResultType是说明经过select操作之后返回的类型是什么，按理说应该是报名和全限定名，但是因为下面中application.properties中有声明，所以前面的包名省略了。即便Mybatis自动配置，但是Mybatis不知道数据库的自动配置的路径什么，启动的最大连接。
给你的项目启动提提速：Lazy Initialization
BASK2311的博客
05-11 648
在一个名为种花家的小镇上，生活着一群热爱编程的人。他们致力于构建出高效、可维护的软件系统，而 Spring Boot 框架成为了他们的不二之选。这个小镇上的人们每天都在用 Spring Boot 框架创造着令人瞩目的应用程序。然而，随着时间的推移，他们的应用程序变得越来越庞大，包含了许多不同的模块和组件。在应用程序启动的时候，所有的 bean 都会被一次性初始化，这导致了一个令人头疼的问题：启动时间变得越来越长了。小镇的居民们开始感到困扰。
正确解决org.springframework.boot.context.properties.ConfigurationPropertiesBindException配置属性绑定异常的有效解决方法
最新发布
wbajsjhhhhh的博客
05-06 2331
正确解决org.springframework.boot.context.properties.ConfigurationPropertiesBindException配置属性绑定异常的有效解决方法
『Spring Boot 2.2新特性』全局懒加载机制
〆、风神的博客
06-04 979
关于延迟加载 在 Spring 中，Spring IoC （ApplicationContext） 容器一般都会在启动的时候实例化所有单实例 bean 。测试代码如下： @Slf4j @Configuration public class DemoConfig { public DemoConfig() { log.warn(" > > > demoConfig 被初始化 > > >"); } } "D:\Program Files\Ja
Spring Boot 2.2版本变化[翻译]
烤鸭的世界我们不懂的博客
01-29 1131
大家好，我是烤鸭： ​ 最近在把低版本的springboot项目升级，正好翻译了下springboot 2.1-2.3 版本的更新日志。 ​ Github 原文：https://github.com/spring-projects/spring-boot/wiki/Spring-Boot-2.2-Release-Notes ​ 2.1 版本变化： ​ 2.3 版本变化： 推荐版本： 2.2.12.RELEASE 从Spring Boot 2.1升级 Spring Framework 5.2 此版本升级到Sp
15hibernate_day04_pm_v1.zip_K.
09-19
1）如何根据DB生成实体类和映射文件 =========利用Myeclipse追加Hibernate框架======== a.先在DB Browser窗口建立一个与数据库的连接 b.新建一个工程，点工程名右键-->Myeclipse-->Add Hibernate.... c....
springboot-hibernate-strruts2_springboot_struts2_hibernate_整合_源码
10-04
这个名为"springboot-hibernate-strruts2_springboot_struts2_hibernate_整合_源码"的压缩包文件，显然包含了将Spring Boot与Struts2和Hibernate整合的示例代码或项目模板。下面我们将详细讨论如何进行这种整合以及...
springboot+mybatis通过实体类自动生成数据库表的方法
08-18
1. 使用 Spring Boot 和 MyBatis 自动生成数据库表 2. 配置 MyBatis 的自动建表模式 3. 使用@Entity 和@Table 注解标注实体类 4. 使用 @Column 注解标注字段名 5. 配置数据源和 MyBatis 的会话工厂 6. 使用 Druid ...
深度解析Spring Boot自动装配原理
MaoTongBin的专栏
03-08 1474
源码解析 1 @SpringBootApplication 1 @SpringBootConfiguration 2 @EnableAutoConfiguration 3 @ComponentScan 20 自定义starter 23 命名规范 24 工程结构 24 实战示例 24 创建工程 24 修改pom 26 编写业务逻辑 31 添加spring.factories 35 测试 35
springboot sessionfactory_搭建SpringBoot环境（Mock）
weixin_39926016的博客
11-26 549
一、什么是mock，mock作用 mock是一种测试手段，通过用来模拟不可控或者比较复杂的的请求结果（比如第三方的请求），通过请求参数控制，来达到自己期望的结果。通俗得讲就是通过参数控制接口返回的是自己想要的“伪数据”二、mock服务设计 网上大都是通过js,jQuery实现的mock,这里重点说明后端服务的mock-模拟第三方服务。1、设计前的分析考虑（1）mock...
Spring配置SessionFactory
柳波 五期信息技术提高班
04-30 3331
Spring的核心模块之一为依赖注入，普遍使用的为Set方式注入，那么下面将借助该方式配置数据源和SessionFactory。           直接引用hibernate.cfg.xml配置文件         这种方式需要提供hibernate.cfg.xml配置文件，在其中构造sessionFactory，并且持久层类的映射也在改文件配置，这步操作和Spring没有任何关系。产生关
springboot @ConfigurationProperties注入属性流程
lipengyao2010的专栏
07-27 1485
一、编写实例，只要加上ConfigurationProperties注解，就会从当前springboot的Environment中读取配置属笥。Environment包括bootStrap,application,application_dev等。 @Data @Configuration @ConfigurationProperties(prefix = "redisson") public class RedissonProperties { private int timeout = 3
Spring BeanPostProcessor : ConfigurationPropertiesBindingPostProcessor
Details Inside Spring
03-06 4685
概述 ConfigurationPropertiesBindingPostProcessor是一个BeanPostProcessor,它通常被框架添加到容器,用于解析bean组件上的注解@ConfigurationProperties，将属性源中的属性设置到bean组件。 源代码解析 1 被引入到容器 在不同的应用中,ConfigurationPropertiesBindingPostProces...
Spring boot中Session Factory的使用
huoji555的博客
11-07 4937
最近在搭建Spring Boot项目的时候，因为项目较大的原因，由于直接继承spring boot自带的jpa会在Dao层写很多sql语句，且不能通用，于是抽象了一个底层方法，方便各层的继承。下面是抽象的底层类具体实现方法的部分代码。 BaseDaoImpl.java@Transactional public class BaseDaoImpl implements IBaseDao { p
聊聊springboot的ConfigurationProperties的绑定
go4it
09-07 561
本文主要研究一下springboot的ConfigurationProperties的绑定。
springboot启动报错：org.springframework.boot.context.properties.ConfigurationPropertiesBean
m0_67393827的博客
04-26 1011
springboot启动报错：org.springframework.boot.context.properties.ConfigurationPropertiesBean springboot版本和springcloud版本不兼容，换一个版本试试 原本报错时，spring-cloud版本为Hoxston-SR9 修改为格林威治-sr6 错误解决 ...
springboot 实现 org.apache.ibatis.cache.Cache接口
05-05
sessionFactory.setConfiguration(configuration); return sessionFactory.getObject(); } } ``` 上面的代码中，我们创建了一个 `SqlSessionFactoryBean` 对象，并将其配置为使用我们的 `MybatisCache` 缓存实现...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值