springboot自动配置原理--学习版

Springboot自动配置主启动类

@SpringBootApplication
public class SpringstudyApplication {

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

@springbootApplication为自动配置的核心注解，如下图是该注解下面的继承的注解

@SpringBootApplication

@SpringBootAppliacation下面的两个主要的注解为：
1.@SpringBootConfiguration
2.@EnableAutoConfiguration

@SpringBootConfiguration

@SpringBootConfiguration注解下的一个注解是@Configuration,
这个就是标注@SpringBootConfiguration的类本质上面就是一个配置类
也标注了@SpringBootAppliacation的主启动类本质上也是一个配置类

@EnableAutoConfiguration

@EnableAutoConfiguration这是一个自动配置的注解，这下面有两个主要的注解分别是：
1.@AutoConfigurationPackage
2.@Import(AutoConfigurationImportSelector.class)

@AutoConfigurationPackage

这个注解下面包含一个注解@Import(AutoConfigurationPackages.Registrar.class)
这个注解导入了Registrar这个类，这个类是自动配置包下面的一个注册类
贴源码：

    static class Registrar implements ImportBeanDefinitionRegistrar, DeterminableImports {
        Registrar() {
        }

        public void registerBeanDefinitions(AnnotationMetadata metadata, BeanDefinitionRegistry registry) {
            AutoConfigurationPackages.register(registry, (String[])(new AutoConfigurationPackages.PackageImports(metadata)).getPackageNames().toArray(new String[0]));
        }

        public Set<Object> determineImports(AnnotationMetadata metadata) {
            return Collections.singleton(new AutoConfigurationPackages.PackageImports(metadata));
        }
    }

这个类主要实现了接口的两个方法：
1.通过元数据获得一个PackageImports，并且对其进行注册
2.通过PackageImports返回一个Set集合
这个是PackageImports的构造方法：

       PackageImports(AnnotationMetadata metadata) {
            AnnotationAttributes attributes = AnnotationAttributes.fromMap(metadata.getAnnotationAttributes(AutoConfigurationPackage.class.getName(), false));
            List<String> packageNames = new ArrayList(Arrays.asList(attributes.getStringArray("basePackages")));
            Class[] var4 = attributes.getClassArray("basePackageClasses");
            int var5 = var4.length;

            for(int var6 = 0; var6 < var5; ++var6) {
                Class<?> basePackageClass = var4[var6];
                packageNames.add(basePackageClass.getPackage().getName());
            }

            if (packageNames.isEmpty()) {
                packageNames.add(ClassUtils.getPackageName(metadata.getClassName()));
            }

            this.packageNames = Collections.unmodifiableList(packageNames);
        }

packageNames 保存了通过元数据得到的类名，这也就说明PackageImports这个类保存了元数据类名

@Import({AutoConfigurationImportSelector.class})

1、AutoConfigurationImportSelector.selectImports

这个类是一个导入自动配置的选择器
第一个方法：selectImports

  public String[] selectImports(AnnotationMetadata annotationMetadata) {
        if (!this.isEnabled(annotationMetadata)) {
            return NO_IMPORTS;
        } else {
            AutoConfigurationImportSelector.AutoConfigurationEntry autoConfigurationEntry = this.getAutoConfigurationEntry(annotationMetadata);
            return StringUtils.toStringArray(autoConfigurationEntry.getConfigurations());
        }
    }

第一行if的判断是：ENABLED_OVERRIDE_PROPERTY属性，就是是否可以重写配置属性，如果为true，继续走接下来的代码，否则就会返回一个空数组。
接着就是加载元数据，通过getAutoConfigurationEntry来获得自动配置实体autoConfigurationEntry 。
最后返回的是autoConfigurationEntry.getConfigurations()也就是自动配置实体的配置。

2.AutoConfigurationImportSelector.getAutoConfigurationEntry

我们接下来看第二个方法：getAutoConfigurationEntry
上面那个selectImports方法中调用了这个方法

    protected AutoConfigurationImportSelector.AutoConfigurationEntry getAutoConfigurationEntry(AnnotationMetadata annotationMetadata) {
        if (!this.isEnabled(annotationMetadata)) {
            return EMPTY_ENTRY;
        } else {
            AnnotationAttributes attributes = this.getAttributes(annotationMetadata);
            List<String> configurations = this.getCandidateConfigurations(annotationMetadata, attributes);
            configurations = this.removeDuplicates(configurations);
            Set<String> exclusions = this.getExclusions(annotationMetadata, attributes);
            this.checkExcludedClasses(configurations, exclusions);
            configurations.removeAll(exclusions);
            configurations = this.getConfigurationClassFilter().filter(configurations);
            this.fireAutoConfigurationImportEvents(configurations, exclusions);
            return new AutoConfigurationImportSelector.AutoConfigurationEntry(configurations, exclusions);
        }
    }

①if判断跟上面讲的一样
②用了getAttributes来获取元数据的属性attributes
③通过getCandidateConfigurations这个方法来获取候选配置（这个是个重要的地方）
④对获取的候选配置进行一些操作（检查配置，排除一些配置）并通过这些配置来返回自动配置实体

上面的第四步只是对一些配置做过滤以及检查，所以我们对getCandidateConfigurations这个方法继续进行分析

3.AutoConfigurationImportSelector.getCandidateConfigurations

    protected List<String> getCandidateConfigurations(AnnotationMetadata metadata, AnnotationAttributes attributes) {
        List<String> configurations = SpringFactoriesLoader.loadFactoryNames(this.getSpringFactoriesLoaderFactoryClass(), this.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方法来获取配置并把这个配置返回
loadFactoryNames方法：

4.SpringFactoriesLoader.loadFactoryNames

    public static List<String> loadFactoryNames(Class<?> factoryType, @Nullable ClassLoader classLoader) {
        ClassLoader classLoaderToUse = classLoader;
        if (classLoader == null) {
            classLoaderToUse = SpringFactoriesLoader.class.getClassLoader();
        }

        String factoryTypeName = factoryType.getName();
        return (List)loadSpringFactories(classLoaderToUse).getOrDefault(factoryTypeName, Collections.emptyList());
    }

这个方法首先获取工厂类的类名又调用了loadSpringFactories方法，继续分析：
loadSpringFactories

5.SpringFactoriesLoader.loadSpringFactories

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

            try {
                Enumeration urls = classLoader.getResources("META-INF/spring.factories");

                while(urls.hasMoreElements()) {
                    URL url = (URL)urls.nextElement();
                    UrlResource resource = new UrlResource(url);
                    Properties properties = PropertiesLoaderUtils.loadProperties(resource);
                    Iterator var6 = properties.entrySet().iterator();

                    while(var6.hasNext()) {
                        Entry<?, ?> entry = (Entry)var6.next();
                        String factoryTypeName = ((String)entry.getKey()).trim();
                        String[] factoryImplementationNames = StringUtils.commaDelimitedListToStringArray((String)entry.getValue());
                        String[] var10 = factoryImplementationNames;
                        int var11 = factoryImplementationNames.length;

                        for(int var12 = 0; var12 < var11; ++var12) {
                            String factoryImplementationName = var10[var12];
                            ((List)result.computeIfAbsent(factoryTypeName, (key) -> {
                                return new ArrayList();
                            })).add(factoryImplementationName.trim());
                        }
                    }
                }

                result.replaceAll((factoryType, implementations) -> {
                    return (List)implementations.stream().distinct().collect(Collectors.collectingAndThen(Collectors.toList(), Collections::unmodifiableList));
                });
                cache.put(classLoader, result);
                return result;
            } catch (IOException var14) {
                throw new IllegalArgumentException("Unable to load factories from location [META-INF/spring.factories]", var14);
            }
        }
    }

这个方法大概就是从META-INF/spring.factories里获得url，然后对url进行遍历，并把遍历出的内容放在缓存中进行返回。
我们继续分析spring.factories文件

6.spring.factories

springfactories在spring-boot-autoconfiguration:2.5.0jar包下的META-INF，自动配置就是回到了springboot自动配置的jar包
这里面有初始化，监听器，过滤器等等，最最最重要的就是里面包含了大量XXAutoConfiguration的自动配置类
重点！！！
随便进入一个包里面看比如WebMvcAutoConfiguration可以看到如下注解：

@ConditionalOnXxxx：在达成该注解的要求后，该自动配置类才会生效，比如：
@ConditionalOnClass：在指定的类存在(即有被导入)后生效 @ConditionalOnMissingBean：spring
IoC容器中不存在指定的bean时生效 …
@EnableConfigurationProperties：与一个XxxxProperties的配置类绑定。基本每一个XxxxAutoConfiguration都会与一个或多个XxxxProperties所绑定，该注解不仅会在XxxxAutoConfiguration上，也可能在其的静态内部类上标注

@ConditionalOnWebApplication(
    type = Type.SERVLET
)
@ConditionalOnClass({Servlet.class, DispatcherServlet.class, WebMvcConfigurer.class})
@ConditionalOnMissingBean({WebMvcConfigurationSupport.class})
@EnableConfigurationProperties({WebProperties.class})

8.XxxxProperties

与XxxxAutoConfiguration绑定的配置类，通常标有@ConfigurationProperties注解

@ConfigurationProperties：可传入参数prefix前缀，表示可以把springboot配置文件中以指定前缀开头的属性加载到本配置文件中
XxxxProperties中的属性与springboot配置文件中以prefix前缀开头的属性一一对应，因此在配置文件中配置的内容，会通过XxxxProperties传入XxxxAutoConfiguration中，从而达到自定义配置的效果

末尾总结：

自动配置最最最核心的是@EnableAutoConfiguration所导入的AutoConfigurationImportSelector.class

这个类： ①用getCandidateConfigurations方法来加载候选配置
②上面的方法是用SpringFactoriesLoader.loadFactoryNames方法来获取配置
③上述方法调用的是loadSpringFactories方法
④loadSpringFactories的方法里面加载了spring.factories文件的内容
⑤spring.factories文件里面又有大量的XXXAutoConfiguration类
⑥XXXAutoConfiguration类中通过@ConditionalOnXXX来决定自动配置是否生效，然后通过@EnableConfigurationProperties来绑定XXXProperties配置类
⑦XXXProperties配置类中通过@ConfigurationProperties导入springboot配置文件中的自定义配置

XXXAutoConfiguration中已经写好了大量配置以及bean，因此，我们可以通过导入指定的类或达成指定的条件，使我们需要的XXXAutoConfiguration自动配置类生效，即可完成springboot的自动配置，并可以在配置文件中以指定的前缀修改自动配置的参数属性。