Spring Boot源码阅读——spring.factories的加载

提到 SpringBoot 的自动装配，不管是文章还是视频，都会提到 spring.factories 这个文件，这篇文章就来简单讲讲 spring.factories 的作用，以及它是怎么被加载的

简介

位置

以 SpringBoot 本体为例，spring.factories 在 jar 包的 META-INF 目录下

其他第三方库例如 mybatis-spring-boot-starter 等也都遵循这个规则

之所以要放在这个目录下，是 SpringBoot 提前约定好的，在 SpringFactoriesLoader 中有这样一个常量，项目启动时，扫描的就是这个路径：

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

类型

.factories 是 SpringBoot 专属的类型，但从文件的格式来看，其实就是一个 .properties 文件

实际上 SpringBoot 在读取解析 spring.factories 文件时，用的就是 properties 的解析器

内容

截取一部分如下

# Application Listeners
org.springframework.context.ApplicationListener=\
org.springframework.boot.ClearCachesApplicationListener,\
org.springframework.boot.builder.ParentContextCloserApplicationListener,\
org.springframework.boot.context.FileEncodingApplicationListener,\
org.springframework.boot.context.config.AnsiOutputApplicationListener,\
org.springframework.boot.context.config.DelegatingApplicationListener,\
org.springframework.boot.context.logging.LoggingApplicationListener,\
org.springframework.boot.env.EnvironmentPostProcessorApplicationListener

反斜杠 \ 可以换行，并且新的一行依旧属于上面那行

所以上面截取的这部分信息，实际只有两条数据

等号 = 左边的 key 是接口（也可以是注解）的全限定名，等号 = 右边的 value 是以逗号分隔的实现类的全限定名

作用

先讲讲 SpringBoot 自己的 spring.factories，其中定义了各种接口的实现类，在 SpringBoot 运行的某个过程中，会需要用到一些接口的功能，这时候就会从 spring.factories 中获取对应的实现类并实例化来进行调用

好处是极大地降低了耦合度

当版本升级的时候，只要修改 spring.factories 中的内容，而不用修改代码，就可以替换实现类

举个例子，SpringBoot 的生命周期中有监听器的参与，同一阶段，可能会触发好几个监听器的事件，而将来如果某个版本的 SpringBoot 要对“启动完成”这个阶段添加一个监听器，并作出一些处理，那么只需要写好这个新的监听器，然后加入 spring.factories 即可，不用修改 SpringBoot 原本的代码，并且原本的代码会从 spring.factories 读取到这个新的监听器并进行事件传播

当然，这是只针对 SpringBoot 自身而言的作用

对用户，或者第三方插件提供商，它的作用类似于 Java 的 SPI 机制

SPI 的全名是 Service Provider Interface，大概意思是，JDK 只提供某个模块的接口规范，而具体实现由厂商来完成

耳熟能详的有 JDBC 模块、日志模块等等

以 JDBC 为例，初学 JDBC 时肯定很熟悉一行代码：

Class.forName("com.mysql.cj.jdbc.Driver");

我们使用厂商提供的 JDBC 实现，都需要手动去注册并实例化

而 spring.factories 相比于 SPI，还提供了服务发现的机制，那就是我们只需要导入第三方库的 starter，SpringBoot 就能自动扫描并且帮助我们注册为 bean，相信只要熟悉 SpringBoot，就不用我多讲了

那么作为第三方库的开发者需要做些什么呢

除了在 META-INF 目录下留存一个 spring.factories 文件外，在文件内容中，还要加上其自身的自动配置类

以 mybatis 为例：

# Auto Configure
org.springframework.boot.autoconfigure.EnableAutoConfiguration=\
org.mybatis.spring.boot.autoconfigure.MybatisLanguageDriverAutoConfiguration,\
org.mybatis.spring.boot.autoconfigure.MybatisAutoConfiguration

key 是 SpringBoot 的 @EnableAutoConfiguration 注解，这个注解就是自动装配的关键，这篇文章的内容注重于 spring.factories 的加载，关于自动装配将写在下一篇文章

加载

从启动类的 run 方法进入，我们第一次见到与 factories 相关的代码是在 SpringApplication 的构造方法

public SpringApplication(ResourceLoader resourceLoader, Class<?>... primarySources) {
    this.resourceLoader = resourceLoader;
    Assert.notNull(primarySources, "PrimarySources must not be null");
    this.primarySources = new LinkedHashSet<>(Arrays.asList(primarySources));
    this.webApplicationType = WebApplicationType.deduceFromClasspath();
    // 下面三行都调用了 getSpringFactoriesInstances 方法，从方法名可以大致理解到作用是获取 factories 文件中某个接口的实现类
    this.bootstrapRegistryInitializers = new ArrayList<>(
        getSpringFactoriesInstances(BootstrapRegistryInitializer.class));
    setInitializers((Collection) getSpringFactoriesInstances(ApplicationContextInitializer.class));
    setListeners((Collection) getSpringFactoriesInstances(ApplicationListener.class));
    this.mainApplicationClass = deduceMainApplicationClass();
}

private <T> Collection<T> getSpringFactoriesInstances(Class<T> type, Class<?>[] parameterTypes, Object... args) {
    ClassLoader classLoader = getClassLoader();
    // loadFactoryNames 方法获取 spring.factories 定义的对应接口的所有实现类的全限定名
    Set<String> names = new LinkedHashSet<>(SpringFactoriesLoader.loadFactoryNames(type, classLoader));
    // 根据全限定名，和参数类型，实例化上面获取到的那些类
    List<T> instances = createSpringFactoriesInstances(type, parameterTypes, classLoader, args, names);
    // 根据 @Order 注解排序
    AnnotationAwareOrderComparator.sort(instances);
    return instances;
}

SpringFactoriesLoader#loadFactoryNames

public static List<String> loadFactoryNames(Class<?> factoryType, @Nullable ClassLoader classLoader) {
    ClassLoader classLoaderToUse = classLoader;
    if (classLoaderToUse == null) {
        classLoaderToUse = SpringFactoriesLoader.class.getClassLoader();
    }
    String factoryTypeName = factoryType.getName();
    // loadSpringFactories 是 spring.factories 加载的核心方法
    // 返回值是一个 Map，包含 spring.factories 所有的键值对，key 是接口名，value 是实现类的名字数组
    // 这里获取到所有键值对后，根据需要的接口名称，获取到相应的实现数组
    return loadSpringFactories(classLoaderToUse).getOrDefault(factoryTypeName, Collections.emptyList());
}

SpringFactoriesLoader#loadSpringFactories

private static Map<String, List<String>> loadSpringFactories(ClassLoader classLoader) {
    // cache 是这个类的静态变量，所以是唯一的
    Map<String, List<String>> result = cache.get(classLoader);
    // 如果缓存中已经有了，那么直接返回
    if (result != null) {
        return result;
    }

    result = new HashMap<>();
    try {
        // 使用 classLoader 从 classpath 读取文件
        // 这个地址常量在上面已经贴出来过了，也就是 META-INF/spring.factories
        // 如果引用了第三方库，那么就会获取到很多 url
        Enumeration<URL> urls = classLoader.getResources(FACTORIES_RESOURCE_LOCATION);
        // 所以要循环遍历每一个库里的 spring.factories 文件
        while (urls.hasMoreElements()) {
            URL url = urls.nextElement();
            UrlResource resource = new UrlResource(url);
            // 用 properties 解析器读取文件
            Properties properties = PropertiesLoaderUtils.loadProperties(resource);
            // 下面的内容就是把文件中的每一行数据，变成 result 数据，也就是 key(文件#String) 变成 key(Map#String)
            // value(文件#String) 变成 value(Map#List<String>)
            for (Map.Entry<?, ?> entry : properties.entrySet()) {
                String factoryTypeName = ((String) entry.getKey()).trim();
                // 这个 commaDelimitedListToStringArray 就是以逗号为分隔符，解析成字符串数组
                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;
}