详述springboot自动配置原理

springboot自动配置原理

一、pom.xml

1.父工程

<parent>
	<groupId>org.springframework.boot</groupId>
	<artifactId>spring‐boot‐starter‐parent</artifactId>
	<version>2.2.2.RELEASE</version>
</parent>
他的父项目是
<parent>
	<groupId>org.springframework.boot</groupId>
	<artifactId>spring‐boot‐dependencies</artifactId>
	<version>2.2.2.RELEASE</version>
	<relativePath>../../spring‐boot‐dependencies</relativePath>
</parent>
他来真正管理Spring Boot应用里面的所有依赖版本

2.启动器

SpringBoot将所有的功能场景都抽取出来，做成一个个的starter，只需要在项目里面引入这些starter,相关场景的所有依赖都会导入进来
<dependency>
	<groupId>org.springframework.boot</groupId>
	<artifactId>spring‐boot‐starter‐web</artifactId>
</dependency>
spring‐boot‐starter‐web帮我们导入了web模块正常运行所依赖的组件

二、程序入口类（启动类）

/**
* @SpringBootApplication 来标注一个主程序类，说明这是一个Spring Boot应用
*/
@SpringBootApplication
public class Application {
	public static void main(String[] args) {
		// Spring应用启动起来
		SpringApplication.run(Application.class,args);
	}
}

@SpringBootApplication注解是一个组合注解，源码如下：

@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注解表示这个类是一个springBoot的配置类，底层是spring的@Configuration注解。
@EnableAutoConfiguration的源码如下：

@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Inherited
@AutoConfigurationPackage
@Import(AutoConfigurationImportSelector.class)
public @interface EnableAutoConfiguration {
	....
}

其中@AutoConfigurationPackage注解表示自动配置包，源码如下：

@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Inherited
@Import(AutoConfigurationPackages.Registrar.class)
public @interface AutoConfigurationPackage {

}

@Import(AutoConfigurationPackages.Registrar.class)会将主配置类（@SpringBootApplication标注的类）所在包的及下面所有子包里面的所有组件扫描到Spring容器。
@Import(AutoConfigurationImportSelector.class)注解中，跟踪AutoConfigurationImportSelector.class的源码，会执行到如下代码：

继续跟踪getAutoConfigurationEntry(autoConfigurationMetadata,annotationMetadata)方法，执行到如下代码：

	protected AutoConfigurationEntry getAutoConfigurationEntry(AutoConfigurationMetadata autoConfigurationMetadata,
			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 = filter(configurations, autoConfigurationMetadata);
		fireAutoConfigurationImportEvents(configurations, exclusions);
		return new AutoConfigurationEntry(configurations, exclusions);
	}

跟踪getCandidateConfigurations(annotationMetadata, attributes)方法，代码如下：

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

执行loadFactoryNames(getSpringFactoriesLoaderFactoryClass(),getBeanClassLoader())方法，代码如下：

  public static List<String> loadFactoryNames(Class<?> factoryType, @Nullable ClassLoader classLoader) {
        String factoryTypeName = factoryType.getName();
        return (List)loadSpringFactories(classLoader).getOrDefault(factoryTypeName, 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 {
                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 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);
            }
        }
    }

在loadSpringFactories方法中，从类加载器中加载一个资源，资源路径为：META-INF/spring.factories，将获取到的一个资源赋值给 Enumeration类型的变量urls， 如果该变量中有下一个元素，说明这里面又包含资源，那就将这个资源加载成 properties 配置文件，并转换成为键值对即 Map类型的数据 进行返回。
spring.factories文件如下：

这个@EnableAutoConfiguration注解通过@SpringBootApplication被间接的标记在了Spring Boot的启动类上。在SpringApplication.run(…)的内部就会执行selectImports()方法，找到所有JavaConfig自动配置类的全限定名对应的class，然后将所有自动配置类加载到Spring容器中。
以org.springframework.boot.autoconfigure.data.redis.RedisAutoConfiguration,\配置为例：

@Configuration(proxyBeanMethods = false)
@ConditionalOnClass(RedisOperations.class)
@EnableConfigurationProperties(RedisProperties.class)
@Import({ LettuceConnectionConfiguration.class, JedisConnectionConfiguration.class })
public class RedisAutoConfiguration {

	@Bean
	@ConditionalOnMissingBean(name = "redisTemplate")
	public RedisTemplate<Object, Object> redisTemplate(RedisConnectionFactory redisConnectionFactory)
			throws UnknownHostException {
		RedisTemplate<Object, Object> template = new RedisTemplate<>();
		template.setConnectionFactory(redisConnectionFactory);
		return template;
	}

	@Bean
	@ConditionalOnMissingBean
	public StringRedisTemplate stringRedisTemplate(RedisConnectionFactory redisConnectionFactory)
			throws UnknownHostException {
		StringRedisTemplate template = new StringRedisTemplate();
		template.setConnectionFactory(redisConnectionFactory);
		return template;
	}

}

在RedisAutoConfiguration 类上有一个@EnableConfigurationProperties(RedisProperties.class)注解，参数是RedisProperties.class，进入RedisProperties类可以看到一个@ConfigurationProperties(prefix = “spring.redis”)注解。@ConfigurationProperties注解的作用就是告诉SpringBoot将本类中的所有属性和配置文件中相关的配置进行绑定。最后通过@EnableConfigurationProperties注解导入到spring容器中，@EnableConfigurationProperties注解底层是@Import注解，了解@Import注解可以参考：https://blog.csdn.net/panchao888888/article/details/82882279

@ConfigurationProperties(prefix = "spring.redis")
public class RedisProperties {

	/**
	 * Database index used by the connection factory.
	 */
	private int database = 0;

	/**
	 * Connection URL. Overrides host, port, and password. User is ignored. Example:
	 * redis://user:password@example.com:6379
	 */
	private String url;

	/**
	 * Redis server host.
	 */
	private String host = "localhost";