经验首页 前端设计 程序设计 Java相关 移动开发 数据库/运维 软件/图像 大数据/云计算 其他经验
当前位置:技术经验 » Java相关 » Spring » 查看文章
springboot自动配置原理以及spring.factories文件的作用详解
来源:jb51  时间:2021/10/8 11:07:46  对本文有异议

一、springboot 自动配置原理

先说说我们自己的应用程序中Bean加入容器的办法:

  1. package com.ynunicom.dc.dingdingcontractapp;
  2. import com.alibaba.druid.spring.boot.autoconfigure.DruidDataSourceAutoConfigure;
  3. import org.springframework.boot.SpringApplication;
  4. import org.springframework.boot.autoconfigure.SpringBootApplication;
  5. /**
  6. * @author jinye.Bai
  7. */
  8. @SpringBootApplication(
  9. scanBasePackages ={"com.ynunicom.dc.dingdingcontractapp"}
  10. )
  11. public class DingdingContractAppApplication {
  12. public static void main(String[] args) {
  13. SpringApplication.run(DingdingContractAppApplication.class, args);
  14. }
  15. }

我们在应用程序的入口设置了 @SpringBootApplication标签,默认情况下他会扫描所有次级目录。

如果增加了 scanBasePackages属性,就会扫描所有被指定的路径及其次级目录。

那么它在扫描的是什么东西呢?

是这个:@Component

所有被扫描到的 @Component,都会成为一个默认的singleton(单例,即一个容器里只有一个对象实体)加入到容器中。

认识到以上这点,便于我们理解springboot自动配置的机制。

接下来让我们看看在自己的应用程序中实现配置的方法。

如图:

  1. package com.ynunicom.dc.dingdingcontractapp.configuration;
  2. import org.springframework.context.annotation.Bean;
  3. import org.springframework.context.annotation.Configuration;
  4. import org.springframework.web.client.RestTemplate;
  5. /**
  6. * @author: jinye.Bai
  7. * @date: 2020/5/22 15:51
  8. */
  9. @Configuration
  10. public class RestTemplateConfig {
  11. @Bean
  12. public RestTemplate restTemplate(){
  13. return new RestTemplate();
  14. }
  15. }

这里我们设置了一个配置,往容器中加入了一个RestTemplate。

首先说 @Configuration,这个标签继承了 @Component标签,我们可以在标签内容看到:

  1. //
  2. // Source code recreated from a .class file by IntelliJ IDEA
  3. // (powered by Fernflower decompiler)
  4. //
  5. package org.springframework.context.annotation;
  6. import java.lang.annotation.Documented;
  7. import java.lang.annotation.ElementType;
  8. import java.lang.annotation.Retention;
  9. import java.lang.annotation.RetentionPolicy;
  10. import java.lang.annotation.Target;
  11. import org.springframework.core.annotation.AliasFor;
  12. import org.springframework.stereotype.Component;
  13. @Target({ElementType.TYPE})
  14. @Retention(RetentionPolicy.RUNTIME)
  15. @Documented
  16. @Component
  17. public @interface Configuration {
  18. @AliasFor(
  19. annotation = Component.class
  20. )
  21. String value() default "";
  22. }

可以看到其中是有 @Component标签的,所以,@Configuration会被 @SpringBootApplication扫描到,进而把它和它下面的 @Bean加入容器,于是我们 RestTemplate的内容就配置完成了,在后续的使用中,我们就可以直接从容器中拿出RestTemplate使用它。

对于在maven中引用的其他外部包加入容器的过程,需要用到spring.factories。

二、spring.factories文件的作用

在springboot运行时,SpringFactoriesLoader 类会去寻找

  1. public static final String FACTORIES_RESOURCE_LOCATION = "META-INF/spring.factories";

我们以mybatis-plus为例。

首先我们引入:

  1. <dependency>
  2. <groupId>com.baomidou</groupId>
  3. <artifactId>mybatis-plus-boot-starter</artifactId>
  4. <version>3.3.2</version>
  5. </dependency>

然后去maven的依赖里看它的自动配置类MybatisPlusAutoConfiguration

  1. @Configuration
  2. @ConditionalOnClass({SqlSessionFactory.class, SqlSessionFactoryBean.class})
  3. @ConditionalOnSingleCandidate(DataSource.class)
  4. @EnableConfigurationProperties({MybatisPlusProperties.class})
  5. @AutoConfigureAfter({DataSourceAutoConfiguration.class, MybatisPlusLanguageDriverAutoConfiguration.class})
  6. public class MybatisPlusAutoConfiguration implements InitializingBean {

可以看到有上文提到的 @Configuration,还有从application.yml载入自动配置的 @EnableConfigurationProperties({MybatisPlusProperties.class})

这个注解的具体内容请查看我另一篇博文,对其进行了解释:

迅速学会@ConfigurationProperties的使用

也就是说,springboot只要能扫描到MybatisPlusAutoConfiguration类的 @Configuration注解,其中的所有配置就能自动加入到容器中,这一过程由上面提到的SpringFactoriesLoader 起作用,它会去寻找 “META-INF/spring.factories” 文件,我们可以在 mybatis-plus的依赖中找到它:

spring.factories被SpringFactoriesLoader找到

SpringFactoriesLoader为什么要读取它呢?因为它内部是这样的

  1. org.springframework.boot.autoconfigure.EnableAutoConfiguration= com.baomidou.mybatisplus.autoconfigure.MybatisPlusLanguageDriverAutoConfiguration, com.baomidou.mybatisplus.autoconfigure.MybatisPlusAutoConfiguration

spring.factories用键值对的方式记录了所有需要加入容器的类,EnableAutoConfigurationImportSelector的selectImports方法返回的类名,来自spring.factories文件内的配置信息,这些配置信息的key等于EnableAutoConfiguration,因为spring boot应用启动时使用了EnableAutoConfiguration注解,所以EnableAutoConfiguration注解通过import注解将EnableAutoConfigurationImportSelector类实例化,并且将其selectImports方法返回的类名实例化后注册到spring容器。

以上内容是springboot获得这些类的方式,如果你想要实现自己的自动配置,就将你的类通过键值对的方式写在你的spring.factories即可,注意,值是你的自动配置类,键必须是org.springframework.boot.autoconfigure.EnableAutoConfiguration

spring.factories 的妙用

现象

在阅读 Spring-Boot 相关源码时,常常见到 spring.factories 文件,里面写了自动配置(AutoConfiguration)相关的类名,因此产生了一个疑问:“明明自动配置的类已经打上了 @Configuration 的注解,为什么还要写 spring.factories 文件?

用过 Spring Boot 的都知道

@ComponentScan 注解的作用是扫描 @SpringBootApplication 所在的 Application 类所在的包(basepackage)下所有的 @component 注解(或拓展了 @component 的注解)标记的 bean,并注册到 spring 容器中。

那么问题来了

在 Spring Boot 项目中,如果你想要被 Spring 容器管理的 bean 不在 Spring Boot 包扫描路径下,怎么办?

解决 Spring Boot 中不能被默认路径扫描的配置类的方式,有 2 种:

(1)在 Spring Boot 主类上使用 @Import 注解

(2)使用 spring.factories 文件

以下是对 使用 spring.factories 文件的简单理解

Spring Boot 的扩展机制之 Spring Factories

Spring Boot 中有一种非常解耦的扩展机制:Spring Factories。这种扩展机制实际上是仿照Java中的SPI扩展机制来实现的。

什么是 SPI 机制?

SPI 的全名为 Service Provider Interface.大多数开发人员可能不熟悉,因为这个是针对厂商或者插件的。在java.util.ServiceLoader的文档里有比较详细的介绍。

简单的总结下 java SPI 机制的思想。我们系统里抽象的各个模块,往往有很多不同的实现方案,比如日志模块的方案,xml解析模块、jdbc模块的方案等。面向的对象的设计里,我们一般推荐模块之间基于接口编程,模块之间不对实现类进行硬编码。一旦代码里涉及具体的实现类,就违反了可拔插的原则,如果需要替换一种实现,就需要修改代码。为了实现在模块装配的时候能不在程序里动态指明,这就需要一种服务发现机制。

java SPI 就是提供这样的一个机制:为某个接口寻找服务实现的机制。有点类似IOC的思想,就是将装配的控制权移到程序之外,在模块化设计中这个机制尤其重要。

Spring Boot 中的 SPI 机制

在 Spring 中也有一种类似与 Java SPI 的加载机制。它在 resources/META-INF/spring.factories 文件中配置接口的实现类名称,然后在程序中读取这些配置文件并实例化。

在 Spring 中也有一种类似与 Java SPI 的加载机制。它在 resources/META-INF/spring.factories 文件中配置接口的实现类名称,然后在程序中读取这些配置文件并实例化。

这种自定义的SPI机制是 Spring Boot Starter 实现的基础。

在这里插入图片描述

Spring Factories 实现原理是什么?

spring-core 包里定义了 SpringFactoriesLoader 类,这个类实现了检索 META-INF/spring.factories 文件,并获取指定接口的配置的功能。在这个类中定义了两个对外的方法:

loadFactories 根据接口类获取其实现类的实例,这个方法返回的是对象列表。 loadFactoryNames 根据接口获取其接口类的名称,这个方法返回的是类名的列表。

上面的两个方法的关键都是从指定的 ClassLoader 中获取 spring.factories 文件,并解析得到类名列表,具体代码如下

  1. public final class SpringFactoriesLoader {
  2. public static final String FACTORIES_RESOURCE_LOCATION = "META-INF/spring.factories";
  3. private static final Log logger = LogFactory.getLog(SpringFactoriesLoader.class);
  4. private static final Map<ClassLoader, MultiValueMap<String, String>> cache = new ConcurrentReferenceHashMap();
  5. private SpringFactoriesLoader() {}
  6. public static <T> List<T> loadFactories(Class<T> factoryClass, @Nullable ClassLoader classLoader) {
  7. Assert.notNull(factoryClass, "'factoryClass' must not be null");
  8. ClassLoader classLoaderToUse = classLoader;
  9. if (classLoader == null) {
  10. classLoaderToUse = SpringFactoriesLoader.class.getClassLoader();
  11. }
  12. List<String> factoryNames = loadFactoryNames(factoryClass, classLoaderToUse);
  13. if (logger.isTraceEnabled()) {
  14. logger.trace("Loaded [" + factoryClass.getName() + "] names: " + factoryNames);
  15. }
  16. List<T> result = new ArrayList(factoryNames.size());
  17. Iterator var5 = factoryNames.iterator();
  18. while(var5.hasNext()) {
  19. String factoryName = (String)var5.next();
  20. result.add(instantiateFactory(factoryName, factoryClass, classLoaderToUse));
  21. }
  22. AnnotationAwareOrderComparator.sort(result);
  23. return result;
  24. }
  25. public static List<String> loadFactoryNames(Class<?> factoryClass, @Nullable ClassLoader classLoader) {
  26. String factoryClassName = factoryClass.getName();
  27. return (List)loadSpringFactories(classLoader).getOrDefault(factoryClassName, Collections.emptyList());
  28. }
  29. private static Map<String, List<String>> loadSpringFactories(@Nullable ClassLoader classLoader) {
  30. MultiValueMap<String, String> result = (MultiValueMap)cache.get(classLoader);
  31. if (result != null) {
  32. return result;
  33. } else {
  34. try {
  35. Enumeration<URL> urls = classLoader != null ? classLoader.getResources("META-INF/spring.factories") : ClassLoader.getSystemResources("META-INF/spring.factories");
  36. LinkedMultiValueMap result = new LinkedMultiValueMap();
  37. while(urls.hasMoreElements()) {
  38. URL url = (URL)urls.nextElement();
  39. UrlResource resource = new UrlResource(url);
  40. Properties properties = PropertiesLoaderUtils.loadProperties(resource);
  41. Iterator var6 = properties.entrySet().iterator();
  42. while(var6.hasNext()) {
  43. Entry<?, ?> entry = (Entry)var6.next();
  44. String factoryClassName = ((String)entry.getKey()).trim();
  45. String[] var9 = StringUtils.commaDelimitedListToStringArray((String)entry.getValue());
  46. int var10 = var9.length;
  47. for(int var11 = 0; var11 < var10; ++var11) {
  48. String factoryName = var9[var11];
  49. result.add(factoryClassName, factoryName.trim());
  50. }
  51. }
  52. }
  53. cache.put(classLoader, result);
  54. return result;
  55. } catch (IOException var13) {
  56. throw new IllegalArgumentException("Unable to load factories from location [META-INF/spring.factories]", var13);
  57. }
  58. }
  59. }
  60. private static <T> T instantiateFactory(String instanceClassName, Class<T> factoryClass, ClassLoader classLoader) {
  61. try {
  62. Class<?> instanceClass = ClassUtils.forName(instanceClassName, classLoader);
  63. if (!factoryClass.isAssignableFrom(instanceClass)) {
  64. throw new IllegalArgumentException("Class [" + instanceClassName + "] is not assignable to [" + factoryClass.getName() + "]");
  65. } else {
  66. return ReflectionUtils.accessibleConstructor(instanceClass, new Class[0]).newInstance();
  67. }
  68. } catch (Throwable var4) {
  69. throw new IllegalArgumentException("Unable to instantiate factory class: " + factoryClass.getName(), var4);
  70. }
  71. }
  72. }

从代码中我们可以知道,在这个方法中会遍历整个 spring-boot 项目的 classpath 下 ClassLoader 中所有 jar 包下的 spring.factories文件。也就是说我们可以在自己的 jar 中配置 spring.factories 文件,不会影响到其它地方的配置,也不会被别人的配置覆盖。

Spring Factories 在 Spring Boot 中的应用

在 Spring Boot 的很多包中都能够找到 spring.factories 文件,接下来我们以 spring-boot-autoconfigure 包为例进行介绍

  1. # Initializers
  2. org.springframework.context.ApplicationContextInitializer=org.springframework.boot.autoconfigure.SharedMetadataReaderFactoryContextInitializer,org.springframework.boot.autoconfigure.logging.ConditionEvaluationReportLoggingListener
  3. # Application Listeners
  4. org.springframework.context.ApplicationListener=org.springframework.boot.autoconfigure.BackgroundPreinitializer
  5. # Auto Configuration Import Listeners
  6. org.springframework.boot.autoconfigure.AutoConfigurationImportListener=org.springframework.boot.autoconfigure.condition.ConditionEvaluationReportAutoConfigurationImportListener
  7. # Auto Configuration Import Filters
  8. org.springframework.boot.autoconfigure.AutoConfigurationImportFilter=org.springframework.boot.autoconfigure.condition.OnBeanCondition,org.springframework.boot.autoconfigure.condition.OnClassCondition,org.springframework.boot.autoconfigure.condition.OnWebApplicationCondition
  9. # Auto Configure
  10. org.springframework.boot.autoconfigure.EnableAutoConfiguration=org.springframework.boot.autoconfigure.admin.SpringApplicationAdminJmxAutoConfiguration,org.springframework.boot.autoconfigure.aop.AopAutoConfiguration,org.springframework.boot.autoconfigure.amqp.RabbitAutoConfiguration,org.springframework.boot.autoconfigure.batch.BatchAutoConfiguration,org.springframework.boot.autoconfigure.cache.CacheAutoConfiguration

结合前面的内容,可以看出 spring.factories 文件可以将 spring-boot 项目包以外的 bean(即在 pom 文件中添加依赖中的 bean)注册到 spring-boot 项目的 spring 容器。

由于@ComponentScan 注解只能扫描 spring-boot 项目包内的 bean 并注册到 spring 容器中,因此需要 @EnableAutoConfiguration 注解来注册项目包外的bean。

而 spring.factories 文件,则是用来记录项目包外需要注册的bean类名。

以上为个人经验,希望能给大家一个参考,也希望大家多多支持w3xue。

 友情链接:直通硅谷  点职佳  北美留学生论坛

本站QQ群:前端 618073944 | Java 606181507 | Python 626812652 | C/C++ 612253063 | 微信 634508462 | 苹果 692586424 | C#/.net 182808419 | PHP 305140648 | 运维 608723728

W3xue 的所有内容仅供测试,对任何法律问题及风险不承担任何责任。通过使用本站内容随之而来的风险与本站无关。
关于我们  |  意见建议  |  捐助我们  |  报错有奖  |  广告合作、友情链接(目前9元/月)请联系QQ:27243702 沸活量
皖ICP备17017327号-2 皖公网安备34020702000426号