SpringBoot启动引导-自动动装配

发表于 | 更新于

[toc]

6. SpringBoot的自动装配

SpringBoot的自动配置完全由 @EnableAutoConfiguration 开启。

@EnableAutoConfiguration 的内容：

1
2
3
4
5
6
7
@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Inherited
@AutoConfigurationPackage
@Import(AutoConfigurationImportSelector.class)
public @interface EnableAutoConfiguration

文档注释原文翻译：

Enable auto-configuration of the Spring Application Context, attempting to guess and configure beans that you are likely to need. Auto-configuration classes are usually applied based on your classpath and what beans you have defined. For example, if you have tomcat-embedded.jar on your classpath you are likely to want a TomcatServletWebServerFactory (unless you have defined your own ServletWebServerFactory bean).

启用Spring-ApplicationContext的自动配置，并且会尝试猜测和配置您可能需要的Bean。通常根据您的类路径和定义的Bean来应用自动配置类。例如，如果您的类路径上有 tomcat-embedded.jar，则可能需要 TomcatServletWebServerFactory （除非自己已经定义了 ServletWebServerFactory 的Bean）。

When using SpringBootApplication, the auto-configuration of the context is automatically enabled and adding this annotation has therefore no additional effect.

使用 @SpringBootApplication 时，将自动启用上下文的自动配置，因此再添加该注解不会产生任何其他影响。

Auto-configuration tries to be as intelligent as possible and will back-away as you define more of your own configuration. You can always manually exclude() any configuration that you never want to apply (use excludeName() if you don’t have access to them). You can also exclude them via the spring.autoconfigure.exclude property. Auto-configuration is always applied after user-defined beans have been registered.

自动配置会尝试尽可能地智能化，并且在您定义更多自定义配置时会自动退出（被覆盖）。您始终可以手动排除掉任何您不想应用的配置（如果您无法访问它们，请使用 excludeName() 方法），您也可以通过 spring.autoconfigure.exclude 属性排除它们。自动配置始终在注册用户自定义的Bean之后应用。

The package of the class that is annotated with @EnableAutoConfiguration, usually via @SpringBootApplication, has specific significance and is often used as a ‘default’. For example, it will be used when scanning for @Entity classes. It is generally recommended that you place @EnableAutoConfiguration (if you’re not using @SpringBootApplication) in a root package so that all sub-packages and classes can be searched.

通常被 @EnableAutoConfiguration 标注的类（如 @SpringBootApplication）的包具有特定的意义，通常被用作“默认值”。例如，在扫描@Entity类时将使用它。通常建议您将 @EnableAutoConfiguration（如果您未使用 @SpringBootApplication）放在根包中，以便可以搜索所有包及子包下的类。

Auto-configuration classes are regular Spring Configuration beans. They are located using the SpringFactoriesLoader mechanism (keyed against this class). Generally auto-configuration beans are @Conditional beans (most often using @ConditionalOnClass and @ConditionalOnMissingBean annotations).

自动配置类也是常规的Spring配置类。它们使用 SpringFactoriesLoader 机制定位（针对此类）。通常自动配置类也是 @Conditional Bean（最经常的情况下是使用 @ConditionalOnClass 和 @ConditionalOnMissingBean 标注）。

@EnableAutoConfiguration 也是一个组合注解,分开来看

6.1 @AutoConfigurationPackage

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
/**
 * Indicates that the package containing the annotated class should be registered with
 * {@link AutoConfigurationPackages}.
 *
 表示包含该注解的类所在的包应该在 AutoConfigurationPackages 中注册。
 * @author Phillip Webb
 * @since 1.3.0
 * @see AutoConfigurationPackages
 */
@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Inherited
@Import(AutoConfigurationPackages.Registrar.class)
public @interface AutoConfigurationPackage

它的实现原理是在注解上标注了 @Import，导入了一个 AutoConfigurationPackages.Registrar 。

6.1.1 AutoConfigurationPackages.Registrar

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
/**
 * {@link ImportBeanDefinitionRegistrar} to store the base package from the importing
 ImportBeanDefinitionRegistrar 用于保存导入的配置类所在的根包
 * configuration.
 */
static class Registrar implements ImportBeanDefinitionRegistrar, DeterminableImports {
	@Override
	public void registerBeanDefinitions(AnnotationMetadata metadata, BeanDefinitionRegistry registry) {
		register(registry, new PackageImport(metadata).getPackageName());
	}
	@Override
	public Set<Object> determineImports(AnnotationMetadata metadata) {
		return Collections.singleton(new PackageImport(metadata));
	}
}

它就是实现把主配置所在根包保存起来以便后期扫描用的。分析源码：

Registrar 实现了 ImportBeanDefinitionRegistrar 接口，它向IOC容器中要手动注册组件。

在重写的 registerBeanDefinitions 方法中，它要调用外部类 AutoConfigurationPackages 的register方法。

看传入的参数：new PackageImport(metadata).getPackageName(),它实例化的 PackageImport 对象的构造方法：

1
2
3
PackageImport(AnnotationMetadata metadata) {
    this.packageName = ClassUtils.getPackageName(metadata.getClassName());
}

它取了一个 metadata 的所在包名。那 metadata 又是什么呢？

翻看 ImportBeanDefinitionRegistrar的文档注释：

1
2
3
4
5
6
7
8
public interface ImportBeanDefinitionRegistrar {
    /**
     * ......
     * @param importingClassMetadata annotation metadata of the importing class
     * @param registry current bean definition registry
     */
    void registerBeanDefinitions(AnnotationMetadata importingClassMetadata, BeanDefinitionRegistry registry);
}

注意 importingClassMetadata 的参数说明：导入类的注解元数据。

它实际代表的是被 @Import 标记的类的信息。

那在 SpringBoot 的主启动类中，被标记的肯定就是最开始案例里的 DemoApplication。

也就是说它是 DemoApplication 的类信息，那获取它的包名就是获取主启动类的所在包。

拿到这个包有什么意义呢？不清楚，那就回到那个 Registrar 中，看它调用的 register 方法都干了什么：

6.1.2 register方法

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
private static final String BEAN = AutoConfigurationPackages.class.getName();

public static void register(BeanDefinitionRegistry registry, String... packageNames) {
    // 判断 BeanFactory 中是否包含 AutoConfigurationPackages
    if (registry.containsBeanDefinition(BEAN)) {
        BeanDefinition beanDefinition = registry.getBeanDefinition(BEAN);
        ConstructorArgumentValues constructorArguments = beanDefinition.getConstructorArgumentValues();
        // addBasePackages：添加根包扫描包
        constructorArguments.addIndexedArgumentValue(0, addBasePackages(constructorArguments, packageNames));
    }
    else {
        GenericBeanDefinition beanDefinition = new GenericBeanDefinition();
        beanDefinition.setBeanClass(BasePackages.class);
        beanDefinition.getConstructorArgumentValues().addIndexedArgumentValue(0, packageNames);
        beanDefinition.setRole(BeanDefinition.ROLE_INFRASTRUCTURE);
        registry.registerBeanDefinition(BEAN, beanDefinition);
    }
}

划重点：它要判断当前IOC容器中是否包含 AutoConfigurationPackages 。如果有，就会拿到刚才传入的包名，设置到一个 basePackage 里面！basePackage 的意义很明显是根包。

换句话说，它要取主启动类所在包及子包下的组件。

到这里，就呼应了文档注释中的描述，也解释了为什么 SpringBoot 的启动器一定要在所有类的最外层。

6.2 @Import(AutoConfigurationImportSelector.class)

根据上一章节的基础，看到这个也不难理解，它导入了一个 ImportSelector，来向容器中导入组件。

导入的组件是：AutoConfigurationImportSelector

6.2.1 AutoConfigurationImportSelector

1
2
public class AutoConfigurationImportSelector implements DeferredImportSelector, BeanClassLoaderAware,
		ResourceLoaderAware, BeanFactoryAware, EnvironmentAware, Ordered

文档注释原文翻译：

DeferredImportSelector to handle auto-configuration. This class can also be subclassed if a custom variant of @EnableAutoConfiguration is needed.

DeferredImportSelector 处理自动配置。如果需要自定义扩展 @EnableAutoConfiguration，则也可以编写该类的子类。

咱能看出来它是 ImportSelector , 可它又特别提到了 DeferredImportSelector，它又是什么呢？

6.2.2 DeferredImportSelector

1
public interface DeferredImportSelector extends ImportSelector

它是 ImportSelector 的子接口，它的文档注释原文和翻译：

A variation of ImportSelector that runs after all @Configuration beans have been processed. This type of selector can be particularly useful when the selected imports are @Conditional . Implementations can also extend the org.springframework.core.Ordered interface or use the org.springframework.core.annotation.Order annotation to indicate a precedence against other DeferredImportSelectors . Implementations may also provide an import group which can provide additional sorting and filtering logic across different selectors.

ImportSelector 的一种扩展，在处理完所有 @Configuration 类型的Bean之后运行。当所选导入为 @Conditional 时，这种类型的选择器特别有用。

实现类还可以扩展 Ordered 接口，或使用 @Order 注解来指示相对于其他 DeferredImportSelector 的优先级。

实现类也可以提供导入组，该导入组可以提供跨不同选择器的其他排序和筛选逻辑。

由此我们可以知道，DeferredImportSelector 的执行时机，是在 @Configuration 注解中的其他逻辑被处理完毕之后（包括对 @ImportResource、@Bean 这些注解的处理）再执行，换句话说，DeferredImportSelector 的执行时机比 ImportSelector 更晚。

回到 AutoConfigurationImportSelector，它的核心部分，就是 ImportSelector 的 selectImport 方法：

1
2
3
4
5
6
7
8
9
10
11
12
13
@Override
public String[] selectImports(AnnotationMetadata annotationMetadata) {
    if (!isEnabled(annotationMetadata)) {
        return NO_IMPORTS;
    }
    
    AutoConfigurationMetadata autoConfigurationMetadata = AutoConfigurationMetadataLoader
            .loadMetadata(this.beanClassLoader);
    // 加载自动配置类
    AutoConfigurationEntry autoConfigurationEntry = getAutoConfigurationEntry(autoConfigurationMetadata, 
            annotationMetadata);
    return StringUtils.toStringArray(autoConfigurationEntry.getConfigurations());
}

关键的源码在 getAutoConfigurationEntry(autoConfigurationMetadata, annotationMetadata) ：

6.2.3 getAutoConfigurationEntry(autoConfigurationMetadata, annotationMetadata)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
/**
 * Return the {@link AutoConfigurationEntry} based on the {@link AnnotationMetadata}
 * of the importing {@link Configuration @Configuration} class.
 * 
 * 根据导入的@Configuration类的AnnotationMetadata返回AutoConfigurationImportSelector.AutoConfigurationEntry。
 */
protected AutoConfigurationEntry getAutoConfigurationEntry(AutoConfigurationMetadata autoConfigurationMetadata,
         AnnotationMetadata annotationMetadata) {
    if (!isEnabled(annotationMetadata)) {
        return EMPTY_ENTRY;
    }
    AnnotationAttributes attributes = getAttributes(annotationMetadata);
    // 【核心】加载候选的自动配置类
    List<String> configurations = getCandidateConfigurations(annotationMetadata, attributes);
    configurations = removeDuplicates(configurations);
    Set<String> exclusions = getExclusions(annotationMetadata, attributes);
    checkExcludedClasses(configurations, exclusions);
    configurations.removeAll(exclusions);
    configurations = filter(configurations, autoConfigurationMetadata);
    fireAutoConfigurationImportEvents(configurations, exclusions);
    return new AutoConfigurationEntry(configurations, exclusions);
}

这个方法里有一个非常关键的集合：configurations（最后直接拿他来返回出去了，给 selectImports 方法转成 String[]）。

既然最后拿它返回出去，必然它是导入其他组件的核心。

这个 configurations 集合的数据，都是通过 getCandidateConfigurations 方法来获取：

1
2
3
4
5
6
7
8
9
10
11
12
protected Class<?> getSpringFactoriesLoaderFactoryClass() {
    return EnableAutoConfiguration.class;
}

protected List<String> getCandidateConfigurations(AnnotationMetadata metadata, AnnotationAttributes attributes) {
    // SPI机制加载自动配置类
    List<String> configurations = SpringFactoriesLoader.loadFactoryNames(getSpringFactoriesLoaderFactoryClass(),
             getBeanClassLoader());
    Assert.notEmpty(configurations, "No auto configuration classes found in META-INF/spring.factories. If you "
             + "are using a custom packaging, make sure that file is correct.");
    return configurations;
}

这个方法又调用了 SpringFactoriesLoader.loadFactoryNames 方法，传入的Class就是 @EnableAutoConfiguration：

6.2.4 SpringFactoriesLoader.loadFactoryNames

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
public static final String FACTORIES_RESOURCE_LOCATION = "META-INF/spring.factories";

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

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

    try {
        // ↓ ↓ ↓ ↓ ↓ ↓ ↓ ↓ ↓ ↓ ↓ ↓ ↓ ↓ ↓ ↓ ↓ ↓ ↓ ↓ ↓ ↓
        Enumeration<URL> urls = (classLoader != null ?
                 classLoader.getResources(FACTORIES_RESOURCE_LOCATION) :
                 ClassLoader.getSystemResources(FACTORIES_RESOURCE_LOCATION));
        result = new LinkedMultiValueMap<>();
        while (urls.hasMoreElements()) {
            URL url = urls.nextElement();
            UrlResource resource = new UrlResource(url);
            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) {
        throw new IllegalArgumentException("Unable to load factories from location [" +
                                       FACTORIES_RESOURCE_LOCATION + "]", ex);
    }
}

源码中使用 classLoader 去加载了指定常量路径下的资源： FACTORIES_RESOURCE_LOCATION ，而这个常量指定的路径实际是：META-INF/spring.factories 。

这个文件在 spring-boot-autoconfiguration 包下可以找到。

spring-boot-autoconfiguration 包下 META-INF/spring.factories 节选：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
# Initializers
org.springframework.context.ApplicationContextInitializer=\
org.springframework.boot.autoconfigure.SharedMetadataReaderFactoryContextInitializer,\
org.springframework.boot.autoconfigure.logging.ConditionEvaluationReportLoggingListener

# Application Listeners
org.springframework.context.ApplicationListener=\
org.springframework.boot.autoconfigure.BackgroundPreinitializer

# Auto Configuration Import Listeners
org.springframework.boot.autoconfigure.AutoConfigurationImportListener=\
org.springframework.boot.autoconfigure.condition.ConditionEvaluationReportAutoConfigurationImportListener

# Auto Configuration Import Filters
org.springframework.boot.autoconfigure.AutoConfigurationImportFilter=\
org.springframework.boot.autoconfigure.condition.OnBeanCondition,\
org.springframework.boot.autoconfigure.condition.OnClassCondition,\
org.springframework.boot.autoconfigure.condition.OnWebApplicationCondition

# Auto Configure
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,\
......

之后拿到这个资源文件，以 Properties 的形式加载，并取出 org.springframework.boot.autoconfigure.EnableAutoConfiguration 指定的所有自动配置类（是一个很大的字符串，里面都是自动配置类的全限定类名），装配到IOC容器中，之后自动配置类就会通过 ImportSelector 和 @Import 的机制被创建出来，之后就生效了。

这也就解释了为什么 即便没有任何配置文件，SpringBoot的Web应用都能正常运行。

6.2.5 【总结规律】

从上面的 Properties 中发现，所有配置的 EnableAutoConfiguration 的自动配置类，都以 AutoConfiguration 结尾！由此规律，以后我们要了解一个 SpringBoot 的模块或者第三方集成的模块时，就可以大胆猜测基本上一定会有 XXXAutoConfiguration 类出现！

6.3 【扩展】SpringBoot使用的工厂机制

SpringBoot 在非常多的位置都利用类似于上面 “通过读取 spring.factories 加载一组预先配置的类” 的机制，而这个机制的核心源码来自 SpringFactoriesLoader 。这一章节我们来详细了解一下这个类，对于后续 SpringBoot 的应用启动过程的源码阅读和原理的理解都有所帮助。

1
2
3
4
5
6
7
8
package org.springframework.core.io.support;

/**
 * ......
 *
 * @since 3.2
 */
public final class SpringFactoriesLoader

我们发现它不是来自 SpringBoot，而是在 SpringFramework3.2 就已经有了的类。它的文档注释原文翻译：

General purpose factory loading mechanism for internal use within the framework. SpringFactoriesLoader loads and instantiates factories of a given type from "META-INF/spring.factories" files which may be present in multiple JAR files in the classpath. The spring.factories file must be in Properties format, where the key is the fully qualified name of the interface or abstract class, and the value is a comma-separated list of implementation class names. For example: example.MyService=example.MyServiceImpl1,example.MyServiceImpl2 where example.MyService is the name of the interface, and MyServiceImpl1 and MyServiceImpl2 are two implementations.

它是一个框架内部内部使用的通用工厂加载机制。

SpringFactoriesLoader 从 META-INF/spring.factories 文件中加载并实例化给定类型的工厂，这些文件可能存在于类路径中的多个jar包中。spring.factories 文件必须采用 properties 格式，其中key是接口或抽象类的全限定名，而value是用逗号分隔的实现类的全限定类名列表。

例如：example.MyService=example.MyServiceImpl1,example.MyServiceImpl2

其中 example.MyService 是接口的名称，而 MyServiceImpl1 和 MyServiceImpl2 是两个该接口的实现类。

到这里已经能够发现，这个思路跟Java原生的SPI非常类似。

6.3.1 【扩展】Java的SPI

SPI全称为 Service Provider Interface，是jdk内置的一种服务提供发现机制。简单来说，它就是一种动态替换发现的机制。

SPI规定，所有要预先声明的类都应该放在 META-INF/services 中。配置的文件名是接口/抽象类的全限定名，文件内容是抽象类的子类或接口的实现类的全限定类名，如果有多个，借助换行符，一行一个。

具体使用时，使用jdk内置的 ServiceLoader 类来加载预先配置好的实现类。

举个例子：

在 META-INF/services 中声明一个文件名为 com.linkedbear.boot.demo.SpiDemoInterface 的文件，文件内容为：

1
com.linkedbear.boot.demo.SpiDemoInterfaceImpl

在 com.linkedbear.boot.demo 包下新建一个接口，类名必须跟上面配置的文件名一样：SpiDemoInterface。

在接口中声明一个 test() 方法：

1
2
3
public interface SpiDemoInterface {
    void test();
}

接下来再新建一个类 SpiDemoInterfaceImpl，并实现 SpiDemoInterface：

1
2
3
4
5
6
public class SpiDemoInterfaceImpl implements SpiDemoInterface {
    @Override
    public void test() {
        System.out.println("SpiDemoInterfaceImpl#test() run...");
    }
}

编写主运行类，测试效果：

1
2
3
4
5
6
public class App {
    public static void main(String[] args) {
        ServiceLoader<SpiDemoInterface> loaders = ServiceLoader.load(SpiDemoInterface.class);
        loaders.foreach(SpiDemoInterface::test);
    }
}

运行结果：

1
SpiDemoInterfaceImpl#test() run...

6.3.2 SpringFramework的SpringFactoriesLoader

SpringFramework 利用 SpringFactoriesLoader 都是调用 loadFactoryNames 方法：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
/**
 * Load the fully qualified class names of factory implementations of the
 * given type from {@value #FACTORIES_RESOURCE_LOCATION}, using the given
 * class loader.
 * @param factoryClass the interface or abstract class representing the factory
 * @param classLoader the ClassLoader to use for loading resources; can be
 * {@code null} to use the default
 * @throws IllegalArgumentException if an error occurs while loading factory names
 * @see #loadFactories
 */
public static List<String> loadFactoryNames(Class<?> factoryClass, @Nullable ClassLoader classLoader) {
    String factoryClassName = factoryClass.getName();
    return loadSpringFactories(classLoader).getOrDefault(factoryClassName, Collections.emptyList());
}

文档注释原文翻译：

Load the fully qualified class names of factory implementations of the given type from “META-INF/spring.factories”, using the given class loader.

使用给定的类加载器从 META-INF/spring.factories 中加载给定类型的工厂实现的全限定类名。

文档注释中没有提到接口、抽象类、实现类的概念，结合之前看到过的 spring.factories 文件，应该能意识到它只是key-value的关系！

这么设计的好处：不再局限于接口-实现类的模式，key可以随意定义！ （如上面的 org.springframework.boot.autoconfigure.EnableAutoConfiguration 是一个注解）

来看方法实现，第一行代码获取的是要被加载的接口/抽象类的全限定名，下面的 return 分为两部分：loadSpringFactories 和 getOrDefault。getOrDefault 方法很明显是Map中的方法，不再解释，主要来详细看 loadSpringFactories 方法。

6.3.3 loadSpringFactories

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
public static final String FACTORIES_RESOURCE_LOCATION = "META-INF/spring.factories";

private static final Map<ClassLoader, MultiValueMap<String, String>> cache = new ConcurrentReferenceHashMap<>();

// 这个方法仅接收了一个类加载器
private static Map<String, List<String>> loadSpringFactories(@Nullable ClassLoader classLoader) {
    MultiValueMap<String, String> result = cache.get(classLoader);
    if (result != null) {
        return result;
    }

    try {
        Enumeration<URL> urls = (classLoader != null ?
                 classLoader.getResources(FACTORIES_RESOURCE_LOCATION) :
                 ClassLoader.getSystemResources(FACTORIES_RESOURCE_LOCATION));
        result = new LinkedMultiValueMap<>();
        while (urls.hasMoreElements()) {
            URL url = urls.nextElement();
            UrlResource resource = new UrlResource(url);
            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) {
        throw new IllegalArgumentException("Unable to load factories from location [" +
                                       FACTORIES_RESOURCE_LOCATION + "]", ex);
    }
}

我们分段来看。

6.3.3.1 获取本地缓存
1
2
3
4
MultiValueMap<String, String> result = cache.get(classLoader);
if (result != null) {
    return result;
}

进入方法后先从本地缓存中根据当前的类加载器获取是否有一个类型为 MultiValueMap 的值，这个类型有些陌生，我们先看看这是个什么东西：

1
2
3
4
5
6
7
8
9
10
package org.springframework.util;

/**
 * Extension of the {@code Map} interface that stores multiple values.
 *
 * @since 3.0
 * @param <K> the key type
 * @param <V> the value element type
 */
public interface MultiValueMap<K, V> extends Map<K, List<V>>

发现它实际上就是一个 Map>。

那第一次从cache中肯定获取不到值，故下面的if结构肯定不进入，进入下面的try块。

6.3.3.2 加载spring.factories
1
2
3
4
Enumeration<URL> urls = (classLoader != null ?
         classLoader.getResources(FACTORIES_RESOURCE_LOCATION) :
         ClassLoader.getSystemResources(FACTORIES_RESOURCE_LOCATION));
result = new LinkedMultiValueMap<>();

这部分动作就是获取当前 classpath 下所有jar包中有的 spring.factories 文件，并将它们加载到内存中。

6.3.3.3 缓存到本地
1
2
3
4
5
6
7
8
9
10
11
12
while (urls.hasMoreElements()) {
    URL url = urls.nextElement();
    UrlResource resource = new UrlResource(url);
    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);

它拿到每一个文件，并用 Properties 方式加载文件，之后把这个文件中每一组键值对都加载出来，放入 MultiValueMap 中。

如果一个接口/抽象类有多个对应的目标类，则使用英文逗号隔开。StringUtils.commaDelimitedListToStringArray会将大字符串拆成一个一个的全限定类名。

整理完后，整个result放入cache中。下一次再加载时就无需再次加载 spring.factories 文件了。