SpringFactoriesLoader源码解析

SpringFactoriesLoader

Spring工厂加载器,用于将META-INFO/spring.factories文件下的相关接口的实现按照K、V形式加载到内存中，一个接口的多个实现按照“,”分割。如下图所示，SpringFactoriesLoader会将spring.factories中的加载器、监听器、初始化器、后置处理器、配置类等进行加载。我们也可以自定义starter，在spring.factories文件中定义自己的内容。

# PropertySource Loaders
org.springframework.boot.env.PropertySourceLoader=\
org.springframework.boot.env.PropertiesPropertySourceLoader,\
org.springframework.boot.env.YamlPropertySourceLoader

# Run Listeners
org.springframework.boot.SpringApplicationRunListener=\
org.springframework.boot.context.event.EventPublishingRunListener

# Application Context Initializers
org.springframework.context.ApplicationContextInitializer=\
org.springframework.boot.context.ConfigurationWarningsApplicationContextInitializer,\
org.springframework.boot.context.ContextIdApplicationContextInitializer,\
org.springframework.boot.context.config.DelegatingApplicationContextInitializer,\
org.springframework.boot.context.embedded.ServerPortInfoApplicationContextInitializer

# 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.ConfigFileApplicationListener,\
org.springframework.boot.context.config.DelegatingApplicationListener,\
org.springframework.boot.liquibase.LiquibaseServiceLocatorApplicationListener,\
org.springframework.boot.logging.ClasspathLoggingApplicationListener,\
org.springframework.boot.logging.LoggingApplicationListener

# Environment Post Processors
org.springframework.boot.env.EnvironmentPostProcessor=\
org.springframework.boot.cloud.CloudFoundryVcapEnvironmentPostProcessor,\
org.springframework.boot.env.SpringApplicationJsonEnvironmentPostProcessor

# Failure Analyzers
org.springframework.boot.diagnostics.FailureAnalyzer=\
org.springframework.boot.diagnostics.analyzer.BeanCurrentlyInCreationFailureAnalyzer,\
org.springframework.boot.diagnostics.analyzer.BeanNotOfRequiredTypeFailureAnalyzer,\
org.springframework.boot.diagnostics.analyzer.BindFailureAnalyzer,\
org.springframework.boot.diagnostics.analyzer.ConnectorStartFailureAnalyzer,\
org.springframework.boot.diagnostics.analyzer.NoSuchMethodFailureAnalyzer,\
org.springframework.boot.diagnostics.analyzer.NoUniqueBeanDefinitionFailureAnalyzer,\
org.springframework.boot.diagnostics.analyzer.PortInUseFailureAnalyzer,\
org.springframework.boot.diagnostics.analyzer.ValidationExceptionFailureAnalyzer

# FailureAnalysisReporters
org.springframework.boot.diagnostics.FailureAnalysisReporter=\
org.springframework.boot.diagnostics.LoggingFailureAnalysisReporter

我们用SpringApplication的初始化过程来讲解SpringFactoriesLoader
SpringApplication(Object… sources)

SpringApplication的构造方法，创建一个Spring应用实例

public SpringApplication(Object... sources) {
   initialize(sources);
}

initialize()

在初始化方法中，设置初始化器时，获取SpringFactories实例

private void initialize(Object[] sources) {
   if (sources != null && sources.length > 0) {
      this.sources.addAll(Arrays.asList(sources));
   }
   this.webEnvironment = deduceWebEnvironment();
   // 设置初始化器
   setInitializers((Collection) getSpringFactoriesInstances(ApplicationContextInitializer.class));
   setListeners((Collection) getSpringFactoriesInstances(ApplicationListener.class));
   this.mainApplicationClass = deduceMainApplicationClass();
}

getSpringFactoriesInstances()

private <T> Collection<? extends T> getSpringFactoriesInstances(Class<T> type) {
   return getSpringFactoriesInstances(type, new Class<?>[] {});
}

getSpringFactoriesInstances()

获取类加载器–>加载工厂名称集合–>加载Spring工厂实例集合–>排序

private <T> Collection<? extends T> getSpringFactoriesInstances(Class<T> type, Class<?>[] parameterTypes,
      Object... args) {
   ClassLoader classLoader = Thread.currentThread().getContextClassLoader();
   // Use names and ensure unique to protect against duplicates
   Set<String> names = new LinkedHashSet<String>(SpringFactoriesLoader.loadFactoryNames(type, classLoader));
   List<T> instances = createSpringFactoriesInstances(type, parameterTypes, classLoader, args, names);
   AnnotationAwareOrderComparator.sort(instances);
   return instances;
}

loadFactoryNames()
去META-INFO/spring.factories中读取相关接口实现信息，并返回

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

public static List<String> loadFactoryNames(Class<?> factoryClass, ClassLoader classLoader) {
   String factoryClassName = factoryClass.getName();
   try {
      // 根据类加载器判断如何获取资源，若加载器不为null，则走getResources(),若为null，则走getSystemResources()
      Enumeration<URL> urls = (classLoader != null ? classLoader.getResources(FACTORIES_RESOURCE_LOCATION) :
            ClassLoader.getSystemResources(FACTORIES_RESOURCE_LOCATION));
      List<String> result = new ArrayList<String>();
      while (urls.hasMoreElements()) {
         URL url = urls.nextElement();
         // 根据资源路径加载资源
         Properties properties = PropertiesLoaderUtils.loadProperties(new UrlResource(url));
         // 获取KV中的值（接口的实现）
         String propertyValue = properties.getProperty(factoryClassName);
         for (String factoryName : StringUtils.commaDelimitedListToStringArray(propertyValue)) {
            result.add(factoryName.trim());
         }
      }
      return result;
   }
   catch (IOException ex) {
      throw new IllegalArgumentException("Unable to load factories from location [" +
            FACTORIES_RESOURCE_LOCATION + "]", ex);
   }
}

getResources()和getSystemResources()的区别

• ClassLoader.getResource()：这个方法会首先在相对于调用类的路径下查找资源。如果在类路径下没有找到，那么就会在系统类加载器路径下查找。这意味着如果你有一个特定的类加载器，并且你希望它只查找它自己的类路径，那么你应该使用getResource()。
• ClassLoader.getSystemResource()：这个方法会直接在系统类加载器路径下查找资源。这意味着它将查找所有类加载器都可以访问的资源，包括那些由Java运行时环境提供的资源。因此，如果你正在查找一个在所有类加载器路径下都存在的资源，你应该使用getSystemResource()。

createSpringFactoriesInstances()

创建SpringFactories实例，也就是创建监听器、初始化器、配置类等的实例。

private <T> List<T> createSpringFactoriesInstances(Class<T> type, Class<?>[] parameterTypes,
      ClassLoader classLoader, Object[] args, Set<String> names) {
   List<T> instances = new ArrayList<T>(names.size());
   for (String name : names) {
      try {
         // 使用全路径类名创建对应的类
         Class<?> instanceClass = ClassUtils.forName(name, classLoader);
         Assert.isAssignable(type, instanceClass);
         // 获取有参构造方法对象
         Constructor<?> constructor = instanceClass.getDeclaredConstructor(parameterTypes);
         // 返回一个instance
         T instance = (T) BeanUtils.instantiateClass(constructor, args);
         instances.add(instance);
      }
      catch (Throwable ex) {
         throw new IllegalArgumentException("Cannot instantiate " + type + " : " + name, ex);
      }
   }
   return instances;
}

总结：SpringFactoriesLoader会读取META-INFO/spring.factories文件下的接口实现类信息并将其进行实例化加载到内存中。这些类可能是监听器、初始化器、自动配置类以及后置处理器等。我们也可以自定义这些类，编写自己的META-INFO/spring.factories。