SpringBoot自动配置原理实现

SpringBoot的自动配置实现原理

我们在启动SpringBoot项目的时候，SpringBoot是怎么启动的？还有SpringBoot是怎么实现自动配置的？

• 开始看主配置类，每次启动SpringBoot项目的时候，都是从这个main方法启动的，这个配置类上有一个 @SpringBootApplication 注解，这个注解有什么用？标注在某个类上说明这个类是SpringBoot的主配置类 ， SpringBoot就应该运行这个类的main方法来启动SpringBoot应用，点进这个注解看看。

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

• 点进@SpringBootApplication这个注解里面还有其他的注解前面4个是java的元注解在javaSE学过，就不解释了，先从@SpringBootConfiguration这个开始看。

@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})})
public @interface SpringBootApplication {
     ......
}

@SpringBootConfiguration这个注解里面只有一个@Configuration,说明这是一个配置类 ，配置类就是对应Spring的xml 配置文件；
里面的 @Component 这就说明，启动类本身也是Spring中的一个组件而已，负责启动应用，再回头看其他注解。

@Configuration
public @interface SpringBootConfiguration {
  ...
}

@ComponentScan作用是扫描当前主配置类同级的包，继续看下一个

@ComponentScan(excludeFilters = { @Filter(type = FilterType.CUSTOM, classes = TypeExcludeFilter.class),
		@Filter(type = FilterType.CUSTOM, classes = AutoConfigurationExcludeFilter.class) })
public @interface SpringBootConfiguration {
  ...
}

@EnableAutoConfiguration 最主要的一个，这个注解是告诉SpringBoot开启自动配置，之前我们需要手动配置的东西，SpringBoot帮我们自动配置，那自动配置是怎么实现的？先点进@AutoConfigurationPackage

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

• @AutoConfigurationPackage这里使用Spring底层注解@import ， 给容器中导入一个组件，Registrar.class的作用将主配置类（@SpringBootApplication标注的类）的所在包及下面所有子包里面的所有组件扫描到Spring容器。退回上一步，还有一个@Import(AutoConfigurationImportSelector.class)

@Import(AutoConfigurationPackages.Registrar.class)
public @interface AutoConfigurationPackage {
	...
}

• @Import(AutoConfigurationImportSelector.class) 这里又给容器导了一个组件AutoConfigurationImportSelector这个类是自动配置导入选择器，那么他会导入什么选择器？点进这个类看一下。

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

点进AutoConfigurationImportSelector.class之后看第一个方法selectImports() ,这里调用了 getAutoConfigurationEntry(); 获得自动配置入口，看一下这个方法。

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());
			}
			
			...
		}

getAutoConfigurationEntry() 这里最后有一个 configurations 被返回，看一下这个configurations是什么？继续看getCandidateConfigurations()（这个方法是获取候选的配置）

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);
	}

这里就调用了SpringFactoriesLoader.loadFactoryNames(getSpringFactoriesLoaderFactoryClass(),getBeanClassLoader()) 看这个参数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;
	}

SpringFactoriesLoader.loadFactoryNames(); 继续点进查看 loadSpringFactories 方法

 public static List<String> loadFactoryNames(Class<?> factoryType, @Nullable ClassLoader classLoader) {
        String factoryTypeName = factoryType.getName();
        return (List)loadSpringFactories(classLoader).getOrDefault(factoryTypeName, Collections.emptyList());
    }

那么META-INF/spring.factories是什么东西，下面说到这是从所有jar包下的类路径找资源，那么就去一个SpringBootAutoConfigure自动配置包下的类路径下找这个东西。

 private static Map<String, List<String>> loadSpringFactories(@Nullable ClassLoader classLoader) {
		 //获得classLoader ， 我们返回可以看到这里得到的就是EnableAutoConfiguration标注的类本身
        MultiValueMap<String, String> result = (MultiValueMap)cache.get(classLoader);
        if (result != null) {
            return result;
        } else {
            try {
            
             //在这里扫描所有jar包类路径下的 "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();
                //对"META-INF/spring.factories"那下的资源进行遍历，并且封装成一个Properties
                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[] var9 = StringUtils.commaDelimitedListToStringArray((String)entry.getValue());
                        int var10 = var9.length;

                        for(int var11 = 0; var11 < var10; ++var11) {
                            String factoryImplementationName = var9[var11];
                            result.add(factoryTypeName, factoryImplementationName.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.factories之后可以看到有很多自动配置文件，这就是SpringBoot自动配置的根源。

随便点击一个自动配置类WebMvcAutoConfiguration，可以看到里面是一个@Configuration配置类，并且还注入了一些Bean

所以就是自动配置的实现就是从classpath:下搜索所有的META-INF/spring.factories配置文件，并将org.springframework.boot.autoconfigure. 包下的配置项，给并且有标注 @Configuration的JavaConfig形式的IOC容器配置类 通过反射实例化对象，然后将这些都汇总成为一个实例并加载到IOC容器中。(注意：但并不是说只要是spring.factories下的全部都会被注入) 例如:

@ConditionalOnXXX()，意思是当在什么环境下才会生效(不生效)，或者当容器里有哪个类或没有哪个类时生效(不生效)，当全部条件成立时才会被注入到ioc容器里。

结论：SpringBoot在启动的时会扫描主配置类同级的包及子包下所有的资源并导入和从所有类路径下的META-INF/spring.factories中获取EnableAutoConfiguration指定的值。将这些值作为自动配置类导入容器，帮我们进行自动配置。SpringBoot所有自动配置类都在org.springframework.boot.autoconfigure。