一、SpringFactoriesLoader 介紹

1.1 SpringFactoriesLoader 簡介

SpringFactoriesLoader 工廠載入機制是 Spring 內部提供的一個約定俗成的載入方式，與 java spi 類似，只需要在模組的 META-INF/spring.factories 檔案中，以 Properties 型別(即 key-value 形式)配置，就可以將相應的實現類注入 Spirng 容器中。

Properties 型別格式：

key：是全限定名(抽象類|介面)

value：是實現，多個實現通過 **逗號** 進行分隔

1.2 SpringFactoriesLoader 常用方法

loadFactoryNames

讀取 classpath上 所有的 jar 包中的所有 META-INF/spring.factories屬 性檔案，找出其中定義的匹配型別 factoryClass 的工廠類，然後並返回這些工廠類的名字列表，注意是包含包名的全限定名。
loadFactories

讀取 classpath 上所有的jar包中的所有 META-INF/spring.factories 屬性檔案，找出其中定義的匹配型別 factoryClass 的工廠類，然後建立每個工廠類的物件/例項，並返回這些工廠類物件/例項的列表。

1.3 loadFactories 流程圖

二、SpringFactoriesLoader 原始碼解析

2.1 loadFactoryNames 解析

public static List<String> loadFactoryNames(Class<?> factoryType,@Nullable ClassLoader classLoader) {
  // 獲取包含包名的工廠類名稱
  String factoryTypeName = factoryType.getName();
  // 獲取所有配置在 META-INF/spring.factories 檔案的值
  // 然後獲取指定類的實現類名列表
  return loadSpringFactories(classLoader).getOrDefault(factoryTypeName,Collections.emptyList());
}

// 預設的工廠配置路徑地址，可以存放在多個 JAR 包下
public static final String FACTORIES_RESOURCE_LOCATION = "META-INF/spring.factories";

private static Map<String,List<String>> loadSpringFactories(@Nullable ClassLoader classLoader) {
  // 判斷是否有快取結果，如果有直接返回
  MultiValueMap<String,String> result = cache.get(classLoader);
  if (result != null) {
    return result;
  }

  try {
    // 掃描 classpath 上所有 JAR 中的檔案 META-INF/spring.factories
    Enumeration<URL> urls = (classLoader != null ?
        classLoader.getResources(FACTORIES_RESOURCE_LOCATION) :
        ClassLoader.getSystemResources(FACTORIES_RESOURCE_LOCATION));
    result = new LinkedMultiValueMap<>();
    while (urls.hasMoreElements()) {
      // 找到的每個 META-INF/spring.factories 檔案都是一個 Properties 檔案，將其內容載入到一個 Properties 物件然後處理其中的每個屬性
      URL url = urls.nextElement();
      UrlResource resource = new UrlResource(url);
      Properties properties = PropertiesLoaderUtils.loadProperties(resource);
      for (Map.Entry<?,?> entry : properties.entrySet()) {
        // 獲取工廠類名稱（介面或者抽象類的全限定名）
        String factoryTypeName = ((String) entry.getKey()).trim();
        // 將逗號分割的屬性值逐個取出，然後放到 結果result 中去
        for (String factoryImplementationName : StringUtils.commaDelimitedListToStringArray((String) entry.getValue())) {
          result.add(factoryTypeName,factoryImplementationName.trim());
        }
      }
    }
    // 將結果存放到快取中
    cache.put(classLoader,result);
    return result;
  }
  catch (IOException ex) {
    throw new IllegalArgumentException("Unable to load factories from location [" +
        FACTORIES_RESOURCE_LOCATION + "]",ex);
  }
}

default V getOrDefault(Object key,V defaultValue) {
  V v;
  return (((v = get(key)) != null) || containsKey(key))
    ? v
    : defaultValue;
}

2.2 loadFactories 解析

public static <T> List<T> loadFactories(Class<T> factoryType,@Nullable ClassLoader classLoader) {
  Assert.notNull(factoryType,"'factoryType' must not be null");
  // 如果未指定類載入器，則使用預設的
  ClassLoader classLoaderToUse = classLoader;
  if (classLoaderToUse == null) {
    classLoaderToUse = SpringFactoriesLoader.class.getClassLoader();
  }
  // 獲取指定工廠名稱列表
  List<String> factoryImplementationNames = loadFactoryNames(factoryType,classLoaderToUse);
  // 如果記錄器Trace跟蹤啟用的話,將工廠名稱列表輸出
  if (logger.isTraceEnabled()) {
    logger.trace("Loaded [" + factoryType.getName() + "] names: " + factoryImplementationNames);
  }
  // 建立結果集
  List<T> result = new ArrayList<>(factoryImplementationNames.size());
  for (String factoryImplementationName : factoryImplementationNames) {
    // 例項化工廠類,並新增到結果集中
    result.add(instantiateFactory(factoryImplementationName,factoryType,classLoaderToUse));
  }
  // 對結果集列表進行排序
  AnnotationAwareOrderComparator.sort(result);
  return result;
}

private static <T> T instantiateFactory(String factoryImplementationName,Class<T> factoryType,ClassLoader classLoader) {
  try {
    Class<?> factoryImplementationClass = ClassUtils.forName(factoryImplementationName,classLoader);
    if (!factoryType.isAssignableFrom(factoryImplementationClass)) {
      throw new IllegalArgumentException(
          "Class [" + factoryImplementationName + "] is not assignable to factory type [" + factoryType.getName() + "]");
    }
    return (T) ReflectionUtils.accessibleConstructor(factoryImplementationClass).newInstance();
  }
  catch (Throwable ex) {
    throw new IllegalArgumentException(
      "Unable to instantiate factory class [" + factoryImplementationName + "] for factory type [" + factoryType.getName() + "]",ex);
  }
}

以上就是本文的全部內容，希望對大家的學習有所幫助，也希望大家多多支援我們。