Spring Boot 源码分析-启动原理

ゞ浴缸里的玫瑰 2023-07-20 13:50 8阅读 0赞

# Spring Boot 源码分析（一） #

sschrodinger

2019/05/28

--------------------

### Spring boot 简介 ###

--------------------

Spring boot 采用约定大于配置的思想对应用程序进行默认配置，减少了大量的配置时间。

Spring Boot 包含的特性如下：

>  *  创建可以独立运行的 Spring 应用
>  *  直接嵌入 Tomcat 或 Jetty 服务器，不需要部署 WAR 文件
>  *  提供推荐的基础 POM 文件来简化 Apache Maven 配置
>  *  尽可能的根据项目依赖来自动配置 Spring 框架
>  *  提供可以直接在生产环境中使用的功能，如性能指标、应用信息和应用健康检查
>  *  没有代码生成，也没有 XML 配置文件

通过 Spring Boot，创建新的 Spring 应用变得非常容易，而且创建出的 Spring 应用符合通用的最佳实践。只需要简单的几个步骤就可以创建出一个 Web 应用。对于 spring boot 的创建，参见[ spring 官方启动器][spring]。

--------------------

### Spring boot 加载 ###

--------------------

因为 Spring boot 内置了 Tomcat 或 Jetty 服务器，不需要直接部署 War 文件，所以 spring boot 的程序起点为一个普通的主函数，主函数类如下：

package com.example.demo;
    
    import org.springframework.boot.SpringApplication;
    import org.springframework.boot.autoconfigure.SpringBootApplication;
    
    @SpringBootApplication
    public class DemoApplication {
    
        public static void main(String[] args) {
            SpringApplication.run(DemoApplication.class, args);
        }
    
    }

看似和普通的程序没有什么区别，其实他最主要的步骤都通过注解 **`@SpringBootApplication`** 和方法 **`SpringApplication.run()`** 完成了。

其实所有的依赖在这一步就可以完成注入，主要的步骤是 ==**spring 读取所有依赖中 `META-INF/spring.factories` 文件，该文件指明了哪些依赖可以被自动加载，然后根据 `ImportSelector` 类选择加载哪些依赖，使用 `ConditionOn` 系列注解排除掉不需要的配置文件，最后将剩余的配置文件所代表的 bean 加载到 IoC 容器中**==。

`META-INF/spring.factories` 文件的读取

spring 所有的配置文件都分布在 jar 包的 `META-INF/spring.factories` 中，如下：

![format_png][]

image.png

每一个 `META-INF/spring.factories` 为一个键值对列表，截取了部分 `spring-boot` jar 包下的 `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
    
    # Error Reporters
    org.springframework.boot.SpringBootExceptionReporter=\
    org.springframework.boot.diagnostics.FailureAnalyzers
    
    # 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.web.context.ServerPortInfoApplicationContextInitializer

在程序中，这段列表会被解析为 `Map<K, List<V>>` 的格式，即一个 `MultiValueMap`（一个键对应多个值的 map），**键和每一个值都是一个类的权限定名**。

主函数中，只有一个方法，即 `SpringApplication.run()`，如下：

@SpringBootApplication
    public class DemoApplication {
    
        public static void main(String[] args) {
            SpringApplication.run(DemoApplication.class, args);
        }
    
    }

我们来看一个读取 `META-INF/spring.factories` 的例子。

在程序初始化时，即运行 `new SpringApplication()` 时，就会读取一次配置文件，我们来分析是如何读取配置文件的。

`SpringApplication.run(DemoApplication.class, args)` 方法是 `SpringApplication` 类提供的一个静态方法，调用的是 `run(new Class<?>[] { primarySource }, args)` 方法。如下：

public static ConfigurableApplicationContext run(Class<?>[] primarySources,
                String[] args) {
        return new SpringApplication(primarySources).run(args);
    }

其中，读取配置文件的操作就发生在 `SpringApplication` 类的实例化过程中。实例化的代码如下：

public SpringApplication(ResourceLoader resourceLoader, Class<?>... primarySources) {
        this.resourceLoader = resourceLoader;
        this.primarySources = new LinkedHashSet<>(Arrays.asList(primarySources));
        this.webApplicationType = WebApplicationType.deduceFromClasspath();
        // 把初始化的初始化器存到数组中
        setInitializers((Collection) getSpringFactoriesInstances(
                ApplicationContextInitializer.class));
        // 把初始化的监听器加入到数组中
        setListeners((Collection) getSpringFactoriesInstances(ApplicationListener.class));
        // 获得主类
        this.mainApplicationClass = deduceMainApplicationClass();
    }

在 `getSpringFactoriesInstances(ApplicationContextInitializer.class))` 中 spring 读取了`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;
    }
    
    public static List<String> loadFactoryNames(Class<?> factoryClass, @Nullable ClassLoader classLoader) {
        String factoryClassName = factoryClass.getName();
        return loadSpringFactories(classLoader).getOrDefault(factoryClassName, Collections.emptyList());
    }

这里一定要记住 **`loadFactoryNames((Class<?> factoryClass, @Nullable ClassLoader classLoader)` 这个函数**，该函数是 `SpringFactoriesLoader` 类提供的一个静态方法，**用于读取 `factoryClass` 的类全限定名这个键在 `spring-factoies` 中的值列表。**

`loadSpringFactories` 读取所有的配置文件中的属性的键值对，并把缓存到一个 `cache` 中，在需要读取的时候进行读取。

在运行完 `loadSpringFactories(classLoader)` 执行语句后，在如上的 `spring.factories` 实例下，`cache` 可能变成如下形式：

cache : 
        key = classloader.toString()
        ->
        value = {
            "org.springframework.boot.env.PropertySourceLoader" 
                -> ["org.springframework.boot.env.PropertiesPropertySourceLoader", "
    org.springframework.boot.env.YamlPropertySourceLoader"],
            "org.springframework.boot.SpringApplicationRunListener" 
                -> ["org.springframework.boot.context.event.EventPublishingRunListener"],
            "org.springframework.boot.SpringBootExceptionReporter" 
                -> ["org.springframework.boot.diagnostics.FailureAnalyzers"],
            "org.springframework.context.ApplicationContextInitializer" 
                -> ["org.springframework.boot.context.ConfigurationWarningsApplicationContextInitializer", "org.springframework.boot.context.ContextIdApplicationContextInitializer", "org.springframework.boot.context.config.DelegatingApplicationContextInitializer", "org.springframework.boot.web.context.ServerPortInfoApplicationContextInitializer"],
            
        }
        // 以属性文件的 key 作为键，value 作为值，注意这个值用一个链表表示，因为可能一个键对应多个值

具体加载和读取配置文件如下所示：

**解析配置文**，如下：

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 ?
                // FACTORIES_RESOURCE_LOCATION = "META-INF/spring.factories"    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);
        }
        
        // output
        // like:
        // org.springframework.boot.autoconfigure.EnableAutoConfiguration -> {LinkedList@1446} size = 118
        //   |
        //   |- org.springframework.boot.autoconfigure.EnableAutoConfiguration
            
    }

**以指定的 `factoryClass` 的类全限定名为键，尝试从缓存中取出值**，对于 `ApplicationContextInitializer.class` 这个 `factoryClass` 来说，会取出所有键为 `org.springframework.context.ApplicationContextInitializer` 的值，对于以上的 `spring.factories`，就是取出了 \`

"org.springframework.boot.context.ConfigurationWarningsApplicationContextInitializer"
    "org.springframework.boot.context.ContextIdApplicationContextInitializer"
    "org.springframework.boot.context.config.DelegatingApplicationContextInitializer"
    "org.springframework.boot.web.context.ServerPortInfoApplicationContextInitializer"

> **总结**
> 
>  *  ==`SpringFactoriesLoader` 类的静态方法实现了依赖文件的读取，读取所有的配置类的全限定名名称==
>  *  ==整个 SpringApplication 在初始化时完成了最基本配置的读取和实例化==
>  *  ==我们需要记住这个时候的 `cache`，这个 `cache` 在上下文加载中非常有用==

文件上下文的加载

上一节展示了如何将配置文件所在的类加载到内存中，那么 spring boot 的自动配置如何办到？

如，在 spring mvc 中，我们需要手工配置如视图解析器等基本配置，需要如下的代码配置：

@Bean
    public ViewResolver viewResolver() {
        return new ThymeleafViewResolver();
    }

既然 spring boot 可以自动配置，那么在 spring boot 中，则一定有类似的语句加载默认的视图解析器等，我们来看看怎么加载的。

注解简介

首先介绍几个注解

**`@SpringBootApplication`**

`@SpringBootApplication` 是一个复合注解，如下：

@Target(ElementType.TYPE)
    @Retention(RetentionPolicy.RUNTIME)
    @Documented
    @Inherited
    @SpringBootConfiguration // 注解一
    @EnableAutoConfiguration // 注解二
    // 没有配置 basepackages，默认代表当前包及其子包
    @ComponentScan(excludeFilters = {
            @Filter(type = FilterType.CUSTOM, classes = TypeExcludeFilter.class),
            @Filter(type = FilterType.CUSTOM,
                    classes = AutoConfigurationExcludeFilter.class) }) // 注解三
    public @interface SpringBootApplication {
        // ...
    }

注解一代表配置注解，如下：

@Target(ElementType.TYPE)
    @Retention(RetentionPolicy.RUNTIME)
    @Documented
    @Configuration
    public @interface SpringBootConfiguration {}

有了这个注解，我们就可以把由 `@SpringBootApplication` 注解修饰的类作为配置类来使用，即在类 `DemoApplication` 中由 `@Bean` 注解修饰的代码都会被注入到 IoC 容器中由 Spring 统一管理。

注解三会自动扫描该类所在包，将各种组件注入到 IoC 容器中让其管理，所以我们也可以类 `DemoApplication` 上增加诸如 `@Controller` 的注解，将其作为一个 Controller。

**`@EnableAutoConfiguration`**

我们注意到 `SpringBootApplication` 注解同时由 `@EnableAutoConfiguration` 注解修饰，我们继续看 `@EnableAutoConfiguration`。

`@EnableAutoConfiguration` 的定义如下：

@Target(ElementType.TYPE)
    @Retention(RetentionPolicy.RUNTIME)
    @Documented
    @Inherited
    @AutoConfigurationPackage  // 注解一
    @Import(AutoConfigurationImportSelector.class) // 注解二
    public @interface EnableAutoConfiguration {
    
        // ...
    
    }

该注解的核心是注解二，用于导入自动配置类。

> note
> 
>  *  在 Spring 中，由 Enable 开头的注解的理念和做事方式其实一脉相承，简单概括一下就是，**借助@Import的支持，收集和注册特定场景相关的 bean 定义**。

**`@Import`**

`@Import` 注解可以导入三种类：

1.  `@Configuration` 注解修饰的类
2.  `ImportSelector` 或 `ImportBeanDefinitionRegistrar` 的实现类
3.  普通的组件类，即由 `@Component` 注解修饰的类。

> note
> 
>  *  在 spring boot 中，自动配置的加载使用的是 `AutoConfigurationImportSelector` 这个类。

**`ImportSelector`**

`ImportSelector` 接口定义如下：

public interface ImportSelector {
        // 返回哪些类需要被创建
        String[] selectImports(AnnotationMetadata importingClassMetadata);
    
    }

该接口的主要作用是根据给定的选择条件(通常是一个或多个注解属性)导入哪个 `@Configuration` 类。

> note
> 
>  *  如果该接口的子类实现了如下四个接口，会先执行如下四个接口的函数：
>  *  EnvironmentAware
>  *  BeanFactoryAware
>  *  BeanClassLoaderAware
>  *  ResourceLoaderAware
>  *  如果希望在所有的 `@Configuration` 类都导入后再导入该类，则使用其子接口 `DeferredImportSelector`

**filter**

在 spring 中，有过滤器注解，如下：

@ConditionalOnBean  // 在所有的 Bean 都加载好之后才能够加载
    @ConditionalOnMissingBean // 在没有该 bean 的时候才能够加载
    @ConditionalOnSingleCandidate // 仅当指定类的Bean已包含在BeanFactory中并且可以确定单个候选项时才匹配的条件
    
    @ConditionalOnClass // 所有的 class 都加载之后才能够加载
    @ConditionalOnMissingClass // 不存在 class 的时候才能够加载
    
    @ConditionalOnWebApplication // 在 web 环境下才能够加载
    @ConditionalOnNotWebApplication // 不在 web 环境下才能够加载

这些注解使用 `AutoConfigurationImportFilter` 接口处理，排除掉不需要的对象。在 spring 的实现中，分别是 `OnBeanCondition`、`OnClassCondition` 和 `OnWebApplicationCondition`。

加载过程

介绍完这些注解，我们回到加载过程。

`SpringApplication` 的实例方法 `run` 方法，在 `run` 方法中，会创建一个新的上下文实例 `context`，并调用 `context` 的 `refresh` 方法，**在 `refresh` 方法中，会自动配置我们需要的默认上下文**。

下面是我们非常熟悉的容器初始化的步骤：

@Override
    public void refresh() throws BeansException, IllegalStateException {
       synchronized (this.startupShutdownMonitor) {
           // Prepare this context for refreshing.
           prepareRefresh();
    
           // Tell the subclass to refresh the internal bean factory.
           ConfigurableListableBeanFactory beanFactory = obtainFreshBeanFactory();
    
           // Prepare the bean factory for use in this context.
           prepareBeanFactory(beanFactory);
    
           try {
               // Allows post-processing of the bean factory in context subclasses.
               postProcessBeanFactory(beanFactory);
    
               // Invoke factory processors registered as beans in the context.
               invokeBeanFactoryPostProcessors(beanFactory);
    
               // Register bean processors that intercept bean creation.
               registerBeanPostProcessors(beanFactory);
    
               // Initialize message source for this context.
               initMessageSource();
    
               // Initialize event multicaster for this context.
               initApplicationEventMulticaster();
    
               // Initialize other special beans in specific context subclasses.
               onRefresh();
    
               // Check for listener beans and register them.
               registerListeners();
    
               // Instantiate all remaining (non-lazy-init) singletons.
               finishBeanFactoryInitialization(beanFactory);
    
               // Last step: publish corresponding event.
               finishRefresh();
           }
           // ...
       }
    
       
    }

`invokeBeanFactoryPostProcessors` 会解析 `@Import` 注解，并根据 `@Import` 的属性进行下一步操作。

`invokeBeanFactoryPostProcessors` 的主要操作如下：

protected void invokeBeanFactoryPostProcessors(ConfigurableListableBeanFactory beanFactory) {
        PostProcessorRegistrationDelegate.invokeBeanFactoryPostProcessors(beanFactory, getBeanFactoryPostProcessors());
    
        // ...
    }

下面是 `PostProcessorRegistrationDelegate.invokeBeanFactoryPostProcessors()` 的方法代码，部分代码如下：

public static void invokeBeanFactoryPostProcessors(
                ConfigurableListableBeanFactory beanFactory, List<BeanFactoryPostProcessor> beanFactoryPostProcessors) {
    
        // Invoke BeanDefinitionRegistryPostProcessors first, if any.
        Set<String> processedBeans = new HashSet<>();
    
        if (beanFactory instanceof BeanDefinitionRegistry) {
            BeanDefinitionRegistry registry = (BeanDefinitionRegistry) beanFactory;
            List<BeanFactoryPostProcessor> regularPostProcessors = new ArrayList<>();
            List<BeanDefinitionRegistryPostProcessor> registryProcessors = new ArrayList<>();
    
            // 记录是否是定义类的 Processor 或者普通的 Processor
    
            // Do not initialize FactoryBeans here: We need to leave all regular beans
            // uninitialized to let the bean factory post-processors apply to them!
            // Separate between BeanDefinitionRegistryPostProcessors that implement
            // PriorityOrdered, Ordered, and the rest.
            List<BeanDefinitionRegistryPostProcessor> currentRegistryProcessors = new ArrayList<>();
    
            // ...
            // 应用 Bean 定义类的后置处理器
            invokeBeanDefinitionRegistryPostProcessors(currentRegistryProcessors, registry);
            // ...
    
    }
    
    private static void invokeBeanDefinitionRegistryPostProcessors(
                Collection<? extends BeanDefinitionRegistryPostProcessor> postProcessors, BeanDefinitionRegistry registry) {
    
        for (BeanDefinitionRegistryPostProcessor postProcessor : postProcessors) {
            postProcessor.postProcessBeanDefinitionRegistry(registry);
        }
    }

`invokeBeanDefinitionRegistryPostProcessors` 函数对每一个定义类的后置处理器分别进行应用， `@Configure` 的解析就在这个函数中。如下：

// 从注册表中的配置类派生更多的bean定义
    public void postProcessBeanDefinitionRegistry(BeanDefinitionRegistry registry) {
        // ...
        this.registriesPostProcessed.add(registryId);
        // Build and validate a configuration model based on the registry of Configuration classes.
        processConfigBeanDefinitions(registry);
    }

进入最关键的类 `ConfigurationClassPostProcessor`，这个类用户来注册所有的 `@Configure` 和 `@Bean`。他的 `processConfigBeanDefinitions` 函数如下：

public void processConfigBeanDefinitions(BeanDefinitionRegistry registry) {
        List<BeanDefinitionHolder> configCandidates = new ArrayList<>();
        String[] candidateNames = registry.getBeanDefinitionNames();
    
        // 记录所有候选的未加载的配置
    
        // Return immediately if no @Configuration classes were found
        if (configCandidates.isEmpty()) {
            return;
        }
    
        // 按照 Ordered 对配置进行排序
    
        // 加载自定义 bean 名命策略
    
        if (this.environment == null) {
            this.environment = new StandardEnvironment();
        }
    
            // Parse each @Configuration class
        ConfigurationClassParser parser = new ConfigurationClassParser(
                this.metadataReaderFactory, this.problemReporter, this.environment,
                this.resourceLoader, this.componentScanBeanNameGenerator, registry);
    
        Set<BeanDefinitionHolder> candidates = new LinkedHashSet<>(configCandidates);
        Set<ConfigurationClass> alreadyParsed = new HashSet<>(configCandidates.size());
        do {
            // 解译候选集
            parser.parse(candidates);
            parser.validate();
    
            Set<ConfigurationClass> configClasses = new LinkedHashSet<>(parser.getConfigurationClasses());
            configClasses.removeAll(alreadyParsed);
    
            // Read the model and create bean definitions based on its content
            this.reader.loadBeanDefinitions(configClasses);
            alreadyParsed.addAll(configClasses);
    
            // ...
        } while (!candidates.isEmpty());
    
        // Register the ImportRegistry as a bean in order to support ImportAware @Configuration classes
        if (sbr != null && !sbr.containsSingleton(IMPORT_REGISTRY_BEAN_NAME)) {
            sbr.registerSingleton(IMPORT_REGISTRY_BEAN_NAME, parser.getImportRegistry());
        }
    
        if (this.metadataReaderFactory instanceof CachingMetadataReaderFactory) {
            // Clear cache in externally provided MetadataReaderFactory; this is a no-op
            // for a shared cache since it'll be cleared by the ApplicationContext.
            ((CachingMetadataReaderFactory) this.metadataReaderFactory).clearCache();
        }
    }

在解释候选集 `parser.parse(candidates)` 中，会调用 `sourceClass = doProcessConfigurationClass(configClass, sourceClass)` 方法依次解析注解，得到所有的候选集。

> note
> 
>  *  `doProcessConfigurationClass` 顺次解析 `@PropertySource`、`@ComponentScan`、`@Import`、`@ImportResource`、`@Bean`、`父类`

注意 `process` 中的 `this.deferredImportSelectorHandler.process()` 方法：

public void parse(Set<BeanDefinitionHolder> configCandidates) {
        for (BeanDefinitionHolder holder : configCandidates) {
            BeanDefinition bd = holder.getBeanDefinition();
            try {
                if (bd instanceof AnnotatedBeanDefinition) {
                    parse(((AnnotatedBeanDefinition) bd).getMetadata(), holder.getBeanName());
                }
                else if (bd instanceof AbstractBeanDefinition && ((AbstractBeanDefinition) bd).hasBeanClass()) {
                    parse(((AbstractBeanDefinition) bd).getBeanClass(), holder.getBeanName());
                }
                else {
                    parse(bd.getBeanClassName(), holder.getBeanName());
                }
            }
            catch (BeanDefinitionStoreException ex) {
                throw ex;
            }
            catch (Throwable ex) {
                throw new BeanDefinitionStoreException(
                        "Failed to parse configuration class [" + bd.getBeanClassName() + "]", ex);
            }
        }
    
        this.deferredImportSelectorHandler.process();
    }

解析完成之后，会找到所有以 `@PropertySource`、`@ComponentScan`、`@Import`、`@ImportResource`、`@Bean` 注解的类及其对象，如果有 `DeferredImportSelector`，会将其加入到 `deferredImportSelectorHandler` 中，并调用 `this.deferredImportSelectorHandler.process()` 对这些 `DeferredImportSelector` 进行处理。

**`AutoConfigurationImportSelector`**

实际上，在 spring boot 中，容器初始化的时候，主要就是对 `AutoConfigurationImportSelector` 进行处理。

Spring 会将 `AutoConfigurationImportSelector` 封装成一个 `AutoConfigurationGroup`，用于处理。最终会调用 `AutoConfigurationGroup` 的 `process` 方法。

@Override
    public void process(AnnotationMetadata annotationMetadata, DeferredImportSelector deferredImportSelector) {
                // 主要通过该函数找到所有需要自动配置的类
                AutoConfigurationEntry autoConfigurationEntry = ((AutoConfigurationImportSelector) deferredImportSelector)
                        .getAutoConfigurationEntry(getAutoConfigurationMetadata(), annotationMetadata);
                this.autoConfigurationEntries.add(autoConfigurationEntry);
                for (String importClassName : autoConfigurationEntry.getConfigurations()) {
                    this.entries.putIfAbsent(importClassName, annotationMetadata);
                }
            }
            
    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);
    }
    
    protected List<String> getCandidateConfigurations(AnnotationMetadata metadata, AnnotationAttributes attributes) {
        List<String> configurations = SpringFactoriesLoader.loadFactoryNames(getSpringFactoriesLoaderFactoryClass(),
                getBeanClassLoader());
        return configurations;
    }

如上，我们可以看到 `process` 最终调用了我们非常熟悉的函数 `SpringFactoriesLoader.loadFactoryNames(getSpringFactoriesLoaderFactoryClass(), getBeanClassLoader());`，该方法以 `EnableAutoConfiguration` 类为键（`org.springframework.boot.autoconfigure.EnableAutoConfiguration`），取得所有的值。

在该函数中，还会调用 `configurations = filter(configurations, autoConfigurationMetadata)` 方法，将不需要的候选集全部排除。（该方法内部使用 `AutoConfigurationImportFilter` 的实现类排除）。

我们看一个常见的 `configuration`，即 `org.springframework.boot.autoconfigure.web.servlet.WebMvcAutoConfiguration`，这个类中有大量的 `@Bean` 注解的方法，用来产生 bean，如下：

@Bean
    @Override
    public RequestMappingHandlerAdapter requestMappingHandlerAdapter() {
        RequestMappingHandlerAdapter adapter = super.requestMappingHandlerAdapter();
        adapter.setIgnoreDefaultModelOnRedirect(
                this.mvcProperties == null || this.mvcProperties.isIgnoreDefaultModelOnRedirect());
        return adapter;
    }

==**spring 通过读取所有所需要的 `AutoConfiguration`，就可以加载默认的上下文容器，实现自动注入。**==

1人点赞

Spring 源码分析

作者：sschrodinger  
链接：https://www.jianshu.com/p/e7a33e9eec0e  
来源：简书  
著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。

[spring]: https://links.jianshu.com/go?to=https%3A%2F%2Fstart.spring.io%2F
[format_png]: /images/20230528/5e647fc0dc9b4e2889df8c26cde27ebe.png