栏目分类:
子分类:
返回
名师互学网用户登录
快速导航关闭
当前搜索
当前分类
子分类
实用工具
热门搜索
名师互学网 > IT > 软件开发 > 后端开发 > Java

springboot自动配置原理详解(springboot的配置)

Java 更新时间: 发布时间: IT归档 最新发布 模块sitemap 名妆网 法律咨询 聚返吧 英语巴士网 伯小乐 网商动力

springboot自动配置原理详解(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 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 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 configurations = this.getCandidateConfigurations(annotationmetadata, attributes);
            configurations = this.removeDuplicates(configurations);
            Set 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 getCandidateConfigurations(Annotationmetadata metadata, AnnotationAttributes attributes) {
        List 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 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> loadSpringFactories(ClassLoader classLoader) {
        Map> 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的自动配置,并可以在配置文件中以指定的前缀修改自动配置的参数属性。

转载请注明:文章转载自 www.mshxw.com
我们一直用心在做
关于我们 文章归档 网站地图 联系我们

版权所有 (c)2021-2022 MSHXW.COM

ICP备案号:晋ICP备2021003244-6号