SpringBoot加载spring.factories的价值

SpringBoot加载spring.factories的价值

在springboot的各个依赖包下，我们经常看到META-INF/spring.factories这个文件。spring.factories文件的内容基本上都是这样的格式

# Initializers
org.springframework.context.ApplicationContextInitializer=
\org.springframework.boot.autoconfigure.SharedMetadataReaderFactoryContextInitializer,
\org.springframework.boot.autoconfigure.logging.ConditionEvaluationReportLoggingListener

通过spring.factories内容我们知道，这个里面其实就是应用上下文初始化。那么这个配置文件有什么作用呢？

通过源码我们可以看出来。

org.springframework.context.ApplicationContextInitializer是一个接口。而，
org.springframework.boot.autoconfigure.SharedMetadataReaderFactoryContextInitializer
org.springframework.boot.autoconfigure.logging.ConditionEvaluationReportLoggingListener
这两个就是接口的实现类。那么从这个逻辑看我们知道。spring.factories这个配置件，就是加载
ApplicationContextInitializer接口的实现类。实现初始化的作用、那么我们知道大部分封装的功能获取对象都是通过。
反射获取对应的实例对象。就像是简单工厂模式一样，也因此spring将这个文件定义为spring.factories这个名字

下面以ApplicationContextInitializer接口为示例，我们看看springboot是怎么使用spring.factories的。

首先会用classLoader加载类路径下的所有spring.factories的配置内容，SpringFactoriesLoader#loadSpringFactories方法将返回一个key=接口名，value=实现类集合的Map结构

private static Map<String, List<String>> loadSpringFactories(@Nullable ClassLoader classLoader) {
    // 先试着取缓存
    MultiValueMap<String, String> result = cache.get(classLoader);
    if (result != null) {
        return result;
    }

    try {
        // 获取所有spring.factories的URL
        Enumeration<URL> urls = (classLoader != null ? classLoader.getResources(FACTORIES_RESOURCE_LOCATION) : ClassLoader.getSystemResources(FACTORIES_RESOURCE_LOCATION));
        result = new LinkedMultiValueMap<>();
        // 遍历URL
        while (urls.hasMoreElements()) {
            URL url = urls.nextElement();
            UrlResource resource = new UrlResource(url);
            // 加载每个URL中的properties配置
            Properties properties = PropertiesLoaderUtils.loadProperties(resource);
            // 遍历每个配置
            for (Map.Entry<?, ?> entry : properties.entrySet()) {
                String factoryClassName = ((String) entry.getKey()).trim();
                // 将实现类的配置按照","符号分割开
                for (String factoryName : StringUtils.commaDelimitedListToStringArray((String) entry.getValue())) {
                    // 逐个添加到接口对应的集合当中
                    result.add(factoryClassName, factoryName.trim());
                }
            }
        }
        // 加入缓存
        cache.put(classLoader, result);
        return result;
    } catch (IOException ex) {
        // ...
    }
}

有了以上这个Map结构，就可以拿到对应接口的实现类集合

public static List<String> loadFactoryNames(Class<?> factoryClass, @Nullable ClassLoader classLoader) {
    String factoryClassName = factoryClass.getName();
     return loadSpringFactories(classLoader).getOrDefault(factoryClassName, Collections.emptyList());
 }

SpringApplication#getSpringFactoriesInstances首先会用classLoader加载类路径下的所有spring.factories的配置内容如上，然后通过反射实例化对象

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;
}

SpringApplication#createSpringFactoriesInstances这里的factoryClass是接口，通过getName()方法获取全限定名，然后根据该全限定名从Map结构中get出对应的实现类全限定名的集合。

到这里我们得到了一个实现类的集合，要获取实现类具体的实例对象只需要通过反射得到实例对象即可

private <T> List<T> createSpringFactoriesInstances(Class<T> type, Class<?>[] parameterTypes,
            ClassLoader classLoader, Object[] args, Set<String> names) {
    List<T> instances = new ArrayList<>(names.size());
    // 遍历实例对象的全限定名
    for (String name : names) {
        try {
            // 加载该类
            Class<?> instanceClass = ClassUtils.forName(name, classLoader);
            // 断言是否为该接口的实现类
            Assert.isAssignable(type, instanceClass);
            // 获取构造方法
            Constructor<?> constructor = instanceClass.getDeclaredConstructor(parameterTypes);
            // 实例化该类
            T instance = (T) BeanUtils.instantiateClass(constructor, args);
            // 添加到结果集当中
            instances.add(instance);
        }
        catch (Throwable ex) {
            throw new IllegalArgumentException("Cannot instantiate " + type + " : " + name, ex);
        }
    }
    return instances;
}

因此spring.factories就像是工厂一样配置了大量的接口对应的实现类，我们通过这些配置 + 反射处理就可以拿到相应的实现类。这种类似于插件式的设计方式，只要引入对应的jar包，那么对应的spring.factories就会被扫描到，对应的实现类也就会被实例化，如果不需要的时候，直接把jar包移除即可。

这也是我们说为什么要加上spring.factories配置文件的作用。实现的热插法