spring boot自动装配原理介绍

简介：springboot是spring快速启动的脚手架，通过自动装配减少spring、及spring与其他功能整合中涉及到的大量配置，为程序人员的开发提供了较大的便利，能够通过较为简单导包的方式和少量配置，引入其他功能，本文主要介绍springboot自动配置的原理。

springboot怎么启动，通过运行带有注解@SpringBootApplication类中的main()，注解@SpringBootApplication是一个组合注解，有@Configuration、@EnableAutoConfiguration、@ComponentScan注解组成

@Configuration 表示配置类，会解析类中带有@Bean的方法，将返回的类生成Bean保存在容器中
@ComponentScan 扫描指定包下，带有注解@Component(@Service、@Controller、@Repository)的类，生成Bean托管在容器中
@EnableAutoConfiguration 开启自动装配的注解
从注解@EnableAutoConfiguration入手，查看自动装配的过程

@AutoConfigurationPackage
@Import({AutoConfigurationImportSelector.class})
public @interface EnableAutoConfiguration {...}

注解@Import的作用，判断value值的类型，如果实现了ImportSelector接口，就会将类中selectImports()返回的集合中所有的权限名注入到容器中，所以我们来看这个类中selectImports()方法的实现

public String[] selectImports(AnnotationMetadata annotationMetadata) {
       if (!this.isEnabled(annotationMetadata)) {
           return NO_IMPORTS;
       } else {
           AutoConfigurationMetadata autoConfigurationMetadata = AutoConfigurationMetadataLoader.loadMetadata(this.beanClassLoader);
           //加载需要类的权限定名信息
           AutoConfigurationImportSelector.AutoConfigurationEntry autoConfigurationEntry = this.getAutoConfigurationEntry(autoConfigurationMetadata, annotationMetadata);
           return StringUtils.toStringArray(autoConfigurationEntry.getConfigurations());
       }
 }
 //具体加载的方法
 protected AutoConfigurationImportSelector.AutoConfigurationEntry getAutoConfigurationEntry(AutoConfigurationMetadata autoConfigurationMetadata, 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);
            //过滤掉不符合条件的类，例如@ConditionalOnXXX的注解条件不满足 
            configurations = this.filter(configurations, autoConfigurationMetadata);
            this.fireAutoConfigurationImportEvents(configurations, exclusions);
            return new AutoConfigurationImportSelector.AutoConfigurationEntry(configurations, exclusions);
        }
    }
//加载的过程
 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;
    }
public static List<String> loadFactoryNames(Class<?> factoryClass, @Nullable ClassLoader classLoader) {
        String factoryClassName = factoryClass.getName();
        return (List)loadSpringFactories(classLoader).getOrDefault(factoryClassName, Collections.emptyList());
    }

   private static Map<String, List<String>> loadSpringFactories(@Nullable ClassLoader classLoader) {
       MultiValueMap<String, String> result = (MultiValueMap)cache.get(classLoader);
       if (result != null) {
           return result;
       } else {
           try {
           		//加载路径，所有依赖包下 路径中META-INF/spring.factories的信息
               Enumeration<URL> urls = classLoader != null ? classLoader.getResources("META-INF/spring.factories") : ClassLoader.getSystemResources("META-INF/spring.factories");
               LinkedMultiValueMap result = new LinkedMultiValueMap();

               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 factoryClassName = ((String)entry.getKey()).trim();
                       String[] var9 = StringUtils.commaDelimitedListToStringArray((String)entry.getValue());
                       int var10 = var9.length;

                       for(int var11 = 0; var11 < var10; ++var11) {
                           String factoryName = var9[var11];
                           result.add(factoryClassName, factoryName.trim());
                       }
                   }
               }

               cache.put(classLoader, result);
               return result;
           } catch (IOException var13) {
               throw new IllegalArgumentException("Unable to load factories from location [META-INF/spring.factories]", var13);
           }
       }
 }

spring boot 自动装配原理的总结

1. spring boot 启动时会解析带有@Configuration注解的配置类，将类中带有@Bean方法中返回的类或者属性参数注入到IOC容器中
2. 如果是第三方依赖的jar包，会利用spring的SPI机制，使用springFactoriesLoader加载器加载约定路径下META-INF/spring.factories配置信息
3. 根据SPI加载的信息，调用ImportSelector动态加载