大白话教会你@SpringBootApplication中如何进行自动配置

最新推荐文章于 2024-02-29 14:25:25 发布

明天一定.

最新推荐文章于 2024-02-29 14:25:25 发布

阅读量609

点赞数 1

分类专栏： spring 文章标签： java spring spring boot

本文链接：https://blog.csdn.net/wai_58934/article/details/122049950

版权

spring 专栏收录该内容

14 篇文章 2 订阅

订阅专栏

我们首先点进@SpringBootApplication会看到以下代码，接下来我们逐一来解析重要的注解。

//作用目标
@Target({ElementType.TYPE})
//注解的生命周期
@Retention(RetentionPolicy.RUNTIME)
//生成文档时记录
@Documented
//实现类不会继承这个注解
@Inherited
//重要
@SpringBootConfiguration
//重要
@EnableAutoConfiguration
//重要
@ComponentScan(
    excludeFilters = {@Filter(
    type = FilterType.CUSTOM,
    classes = {TypeExcludeFilter.class}), 
    @Filter(type = FilterType.CUSTOM,
    classes = {AutoConfigurationExcludeFilter.class})}

@SpringBootConfiguration

这个注解点进去我们发现

@Target({ElementType.TYPE})
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Configuration
@Indexed

重要的注解只有@Configuration，我们大家再来复习想一下@Configuration的作用。

3............2.................1................，好了，想不到的不想了。

简单来说它就代表当前类是配置类，类比可以把它看做一个配置xml，看不懂的同学需要再去复习一下spring了。

@ComponentScan

spring的注解，指定扫描哪些包下，这个也没什么可说的。

重中之重@EnableAutoConfiguration

前置知识点：

@Import可以把类交给容器管理，给容器中导入组件

这里可是有自动配置的精华，敲黑板。我们点进来看

@Target({ElementType.TYPE})
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Inherited
@AutoConfigurationPackage
@Import({AutoConfigurationImportSelector.class})

我们可以很清晰的看出，重要的部分就是@AutoConfigurationPackage和@Import({AutoConfigurationImportSelector.class})。

@AutoConfigurationPackage

我们点进来看

@Target({ElementType.TYPE})
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Inherited
//重要
@Import({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));
        }
    }

在这里它开始在registerBeanDefinitions方法中批量注册一系列组件。我们来看它是如何实现的。首先是参数metadata，它代表的是注解元数据即作用到哪个类的元数据。很明显，我们这个注解最终融入到@SpringBootApplication，metadata即代表了启动类的元数据。我们来看

(String[])(new AutoConfigurationPackages.PackageImports(metadata)).getPackageNames().toArray(new String[0])

很明显就是拿到启动类所在的包路径。然后将其包下的所有组件导入。

总的来说这个注解指定了默认包规则。

@Import({AutoConfigurationImportSelector.class})

我们依旧点进来看，看他们所说的核心方法（为啥是核心方法，自己琢磨去吧）

    public String[] selectImports(AnnotationMetadata annotationMetadata) {
        if (!this.isEnabled(annotationMetadata)) {
            return NO_IMPORTS;
        } else {
            //核心方法
            AutoConfigurationImportSelector.AutoConfigurationEntry autoConfigurationEntry = this.getAutoConfigurationEntry(annotationMetadata);
            //拿到autoConfigurationEntry返回所有的配置
            return StringUtils.toStringArray(autoConfigurationEntry.getConfigurations());
        }
    }

ps：你是不是有selectImports方法什么时候会执行的疑惑？摘自网友

org.springframework.context.annotation.ConfigurationClassPostProcessor.postProcessBeanDefinitionRegistry方法,在解析@Configuration时,调用org.springframework.context.annotation.ConfigurationClassParser.parse方法，最终就走到了org.springframework.context.annotation.ConfigurationClassParser#processImports方法,

好，我们来点进去看一下核心方法。

    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做出操作，所以断定获取configurations方法是核心方法
            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);
        }
    }

点入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;
    }

继续点入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());
    }

点入return的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"位置的文件（核心是spring-boot-autoconfigure这个包），springboot默认将这些全部加载，但是最终会按需配置，如何按需配置，我们就要感谢以@Conditional开头的注解如：@ConditionalOnClass、@ConditionalOnMissingBean、@Conditional等

以上就是大致流程，如有错误请指出。