一：简介
SpringBoot 这款框架几乎是现在企业级开发的标配，使用SpringBoot进行开发，能够大量减少xml配置文件的编写，并且能为我们提供一站式服务。SpringBoot我们只需要导入相关模块的starter，就可以使用相关功能，但是我们几乎没有写配置，那么SpringBoot是如何帮我们配置的呢？
又比如说我们可以在application.properties或者application.yml 配置文件中进行一些配置，比如设置 server.port=8081，那么我们是如何知道可以设置哪些属性呢？我们往往是通过记忆，或者通过IDEA提示，或者是官方文档，但是这些都不太行，只有我们真正研究透原理，才能随心所欲的去应用。
下面就来谈谈SpringBoot的自动装配原理。
二：原理
一切的开始，都要从启动类上的@SpringBootApplication注解开始。
@SpringBootApplication
public class AutoconfigurationApplication {
public static void main(String[] args) {
SpringApplication.run(AutoconfigurationApplication.class, args);
}
}
这个注解又是一个合成注解，点进去看看。
@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 {}
SpringBoot启动时，加载主配置类，并且开启了自动配置功能。也就是这个注解： @EnableAutoConfiguration
那么这注解的作用是什么呢？点进去看看
@Target({ElementType.TYPE})
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Inherited
@AutoConfigurationPackage
@Import({AutoConfigurationImportSelector.class})
public @interface EnableAutoConfiguration {}
可以看到，主要利用到了一个底层的 @Import注解，导入一个选择器，根据选择器，给Spring的容器中导入一些组件。
那么导入哪些组件呢？点进这个 AutoConfigurationImportSelector 类看看。该类实现了 ImportSelect 接口，重写了这个方法：
String[] selectImports(AnnotationMetadata importingClassMetadata);
该方法返回的是一个String类型的数组，该数组其实就是一个全类名的数组，SpringBoot会将这些全类名对应的类加入到IOC容器中。重写如下：
@Override
public String[] selectImports(AnnotationMetadata annotationMetadata) {
if (!isEnabled(annotationMetadata)) {
return NO_IMPORTS;
}
AutoConfigurationEntry autoConfigurationEntry = getAutoConfigurationEntry(annotationMetadata);
return StringUtils.toStringArray(autoConfigurationEntry.getConfigurations());
}
// selectImports方法中调用了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);
}
可以看到，在 getAutoConfigurationEntry()，有这么一行代码
List configurations = getCandidateConfigurations(annotationMetadata, attributes);
通过getCandidateConfigurations方法，翻译过来是获取候选的配置，返回一个configurations对象。
那么这个getCandidateConfigurations方法的作用又是什么呢？点进去看看
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(getSpringFactoriesLoaderFactoryClass(),getBeanClassLoader()); 这个方法传入了EnableAutoConfiguration.class以及类加载器。点进这个方法看看。
public static List<String> loadFactoryNames(Class<?> factoryType, @Nullable ClassLoader classLoader) {
ClassLoader classLoaderToUse = classLoader;
if (classLoaderToUse == null) {
classLoaderToUse = SpringFactoriesLoader.class.getClassLoader();
}
String factoryTypeName = factoryType.getName();
return loadSpringFactories(classLoaderToUse).getOrDefault(factoryTypeName, Collections.emptyList());
}
private static Map<String, List<String>> loadSpringFactories(ClassLoader classLoader) {
Map<String, List<String>> result = cache.get(classLoader);
if (result != null) {
return result;
}
result = new HashMap<>();
try {
Enumeration<URL> urls = classLoader.getResources(FACTORIES_RESOURCE_LOCATION);
while (urls.hasMoreElements()) {
URL url = urls.nextElement();
UrlResource resource = new UrlResource(url);
Properties properties = PropertiesLoaderUtils.loadProperties(resource);
for (Map.Entry<?, ?> entry : properties.entrySet()) {
String factoryTypeName = ((String) entry.getKey()).trim();
String[] factoryImplementationNames =
StringUtils.commaDelimitedListToStringArray((String) entry.getValue());
for (String factoryImplementationName : factoryImplementationNames) {
result.computeIfAbsent(factoryTypeName, key -> new ArrayList<>())
.add(factoryImplementationName.trim());
}
}
}
// Replace all lists with unmodifiable lists containing unique elements
result.replaceAll((factoryType, implementations) -> implementations.stream().distinct()
.collect(Collectors.collectingAndThen(Collectors.toList(), Collections::unmodifiableList)));
cache.put(classLoader, result);
}
catch (IOException ex) {
throw new IllegalArgumentException("Unable to load factories from location [" +
FACTORIES_RESOURCE_LOCATION + "]", ex);
}
return result;
}
分析一下上述代码，在loadFactoryNames方法中，其实起作用的是loadSpringFactories方法，在loadSpringFactories方法中，先通过类加载器去获取资源：classLoader.getResources(FACTORIES_RESOURCE_LOCATION);这个FACTORIES_RESOURCE_LOCATION是一个常量，表示 META-INF/spring.factories 这个路径。
public static final String FACTORIES_RESOURCE_LOCATION = "META-INF/spring.factories";
所以说，当项目启动时，会去扫描所有jar包中的类路径下的META-INF/spring.factories 文件，获取文件对应的url。然后再遍历每一个url，最终将这些扫描到的文件的内容，包装成一个Properties对象。然后在从Properties中获取的值加入到返回的结果里面。这个结果就是要交给容器的所有组件的全类名。
这里的factoryType就是传过来的EnableAutoConfiguration.class。所以会从properties中获取这个类名对应的值，然后把他们添加到容器中。
一共131个。
这131给 xxxAutoConfiguration 都是容器中的一个组件，都会加入到容器中，这些自动配置类本质都是配置类，用他们来进行自动配置。
就拿HttpEncodingAutoConfiguration为例，来解释自动配置原理。
@Configuration(proxyBeanMethods = false) // 表示是一个配置类，可以给容器中添加组件
@EnableConfigurationProperties(ServerProperties.class) // 启动指定类的 @ConfigurationProperties 功能，让指定的类和 properties 文件进行属性映射，并将ServerProperties加入到容器中，给其他组件使用。
@ConditionalOnWebApplication(type = ConditionalOnWebApplication.Type.SERVLET)// @Condition，表示如果是web应用，才生效
@ConditionalOnClass(CharacterEncodingFilter.class) // 判断当前项目有没有这个类，这个类是MVC中进行乱码解决的过滤器
@ConditionalOnProperty(prefix = "server.servlet.encoding", value = "enabled", matchIfMissing = true) // 判断配置文件中是否存在 server.servlet.encoding 这个配置，即使不存在也判断成立。即使不配置，也默认生效。
public class HttpEncodingAutoConfiguration {
// 这个properties已经和配置文件映射了。
private final Encoding properties;
// 只有一个有参构造器，这个参数的值就会从容器中拿，
public HttpEncodingAutoConfiguration(ServerProperties properties) {
this.properties = properties.getServlet().getEncoding();
}
}
点进 ServerProperties 这个类看看，可以看到，标注了@ConfigurationProperties注解，该注解的作用就是从配置文件中获取指定的值和bean的属性进行绑定。
@ConfigurationProperties(prefix = "server", ignoreUnknownFields = true)
public class ServerProperties {
/**
* Server HTTP port.
*/
private Integer port;
所以说，我们想要知道配置文件中去配置什么，就可以看 @ConfigurationProperties 注解的prefix 前缀。 可以看到，我们常用的server.port就是这么来的。
也就是说，所有的在配置文件中配置的属性都是在xxxProperties中封装着。 配置文件能配什么，就可以参照某个功能对应的属性类。
HttpEncodingAutoConfiguration类上标注了很多的 @Condition 注解，如果这些条件都成立，配置类才会生效。如果生效，就会向容器中@Bean，添加组件，这些值的的某些属性，需要从properties中获取。
@Bean
@ConditionalOnMissingBean
public CharacterEncodingFilter characterEncodingFilter() {
CharacterEncodingFilter filter = new OrderedCharacterEncodingFilter();
filter.setEncoding(this.properties.getCharset().name());
filter.setForceRequestEncoding(this.properties.shouldForce(Encoding.Type.REQUEST));
filter.setForceResponseEncoding(this.properties.shouldForce(Encoding.Type.RESPONSE));
return filter;
}
我们在application.properteis 中直接点击我们配置的属性，也会跳转到绑定的properties文件中。