springboot自动配置原理加载主流程

springboot自动配置原理加载主流程

1. @SpringBootApplication
   

2. @Target(ElementType.TYPE) //注解可以标在哪里
   @Retention(RetentionPolicy.RUNTIME) // 注解的有效范围
   @Documented // 生成doc
   @Inherited // 可以被继承
   @SpringBootConfiguration // SpringBoot的配置类
   @EnableAutoConfiguration // 自动配置的配置类
   @ComponentScan(excludeFilters = { @Filter(type = FilterType.CUSTOM, classes = TypeExcludeFilter.class),      @Filter(type = FilterType.CUSTOM, classes = AutoConfigurationExcludeFilter.class) }) // 扫描包
   

3. @Target(ElementType.TYPE)
   @Retention(RetentionPolicy.RUNTIME)
   @Documented
   @Inherited
   @AutoConfigurationPackage
   @Import(AutoConfigurationImportSelector.class) // 将AutoConfigurationImportSelector注册为bean
   public @interface EnableAutoConfiguration {}
   

4. // Import注入的bean,看它有没有重写getImportGroup()方法,如果有则会优先调用getImportGroup()方法
   // 如果没有会调用selectImports方法
   // 这里时重写了getImportGroup()方法,所以优先调用getImportGroup()方法,
   // 返回了AutoConfigurationGroup.class
   public class AutoConfigurationImportSelector implements DeferredImportSelector, BeanClassLoaderAware,
   		ResourceLoaderAware, BeanFactoryAware, EnvironmentAware, Ordered {
       @Override
   	public String[] selectImports(AnnotationMetadata annotationMetadata) {
   		if (!isEnabled(annotationMetadata)) {
   			return NO_IMPORTS;
   		}
   		AutoConfigurationEntry autoConfigurationEntry = getAutoConfigurationEntry(annotationMetadata);
   		return StringUtils.toStringArray(autoConfigurationEntry.getConfigurations());
   	}
       @Override
   	public Class<? extends Group> getImportGroup() {
   		return AutoConfigurationGroup.class;
   	}
   }
   

5. // 先调用process 找出所有的自动配置类
   // 再调用 selectImports(),主要是将自动配置类进行排序,根据@Order,@ConfigurationBefore,@ConfigurationAfter进行排序
   private static class AutoConfigurationGroup
   			implements DeferredImportSelector.Group, BeanClassLoaderAware, BeanFactoryAware, ResourceLoaderAware {
   	@Override
   	public void process(AnnotationMetadata annotationMetadata, DeferredImportSelector deferredImportSelector) {
   	Assert.state(deferredImportSelector instanceof AutoConfigurationImportSelector,
   () -> String.format("Only %s implementations are supported, got %s",AutoConfigurationImportSelector.class.getSimpleName(),deferredImportSelector.getClass().getName()));
   	AutoConfigurationEntry autoConfigurationEntry = ((AutoConfigurationImportSelector) deferredImportSelector)
   					.getAutoConfigurationEntry(annotationMetadata);
   	this.autoConfigurationEntries.add(autoConfigurationEntry);
   	for (String importClassName : autoConfigurationEntry.getConfigurations()) {
           this.entries.putIfAbsent(importClassName, annotationMetadata);
       }
       }
       @Override
   		public Iterable<Entry> selectImports() {
   			if (this.autoConfigurationEntries.isEmpty()) {
   				return Collections.emptyList();
   			}
   			Set<String> allExclusions = this.autoConfigurationEntries.stream()
   					.map(AutoConfigurationEntry::getExclusions).flatMap(Collection::stream).collect(Collectors.toSet());
   			Set<String> processedConfigurations = this.autoConfigurationEntries.stream()
   					.map(AutoConfigurationEntry::getConfigurations).flatMap(Collection::stream)
   					.collect(Collectors.toCollection(LinkedHashSet::new));
   			processedConfigurations.removeAll(allExclusions);
   
   			return sortAutoConfigurations(processedConfigurations, getAutoConfigurationMetadata()).stream()
   					.map((importClassName) -> new Entry(this.entries.get(importClassName), importClassName))
   					.collect(Collectors.toList());
   		}
   }
   

6. /** process里的getAutoConfigurationEntry方法 获取所有有效的配置类
   **/
   protected AutoConfigurationEntry getAutoConfigurationEntry(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 = getConfigurationClassFilter().filter(configurations);
       fireAutoConfigurationImportEvents(configurations, exclusions);
       return new AutoConfigurationEntry(configurations, exclusions);
   }
   

7. // getCandidateConfigurations() 获取所有的配置类
   // getSpringFactoriesLoaderFactoryClass() 返回 EnableAutoConfiguration.class;
   protected List<String> getCandidateConfigurations(AnnotationMetadata metadata, AnnotationAttributes attributes) {
       List<String> configurations = SpringFactoriesLoader.loadFactoryNames(getSpringFactoriesLoaderFactoryClass(),
   				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;
   }
   

8. /** loadFactoryNames() 以EnableAutoConfiguration.class做过滤,获取所有的自动配置类
   
   */
   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());
   }
   

9. // loadSpringFactories() 会去所有jar包中和类路径中读取"META-INF/spring.factories"这个文件
   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);
           }
       }
   }
   

10. // getOrDefault(factoryTypeName, Collections.emptyList())
    // 根据EnableAutoConfiguration.class做过滤获取所有的配置文件
    

11. // getAutoConfigurationEntry() 里
    // configurations = getConfigurationClassFilter().filter(configurations);
    // 根据pom件里依赖的starter,过滤出所有的有效配置类
    

原文：https://www.cnblogs.com/jqccan/p/14675253.html