12 自动配置原理

1 自动配置原理：

1.1 SpringBoot启动的时候加载主配置类，开启了自动配置功能

package com.gp6.springboot12;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

@SpringBootApplication
public class Springboot12Application {

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

• @SpringBootApplication --> @EnableAutoConfiguration

1.2 @EnableAutoConfiguration 作用：

• @EnableAutoConfiguration --> @Import({AutoConfigurationImportSelector.class})

1.2.1 使用AutoConfigurationImportSelector给容器中导入组件

• selectImports() --> getAutoConfigurationEntry()

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);
		configurations = this.filter(configurations, autoConfigurationMetadata);
		this.fireAutoConfigurationImportEvents(configurations, exclusions);
		return new AutoConfigurationImportSelector.AutoConfigurationEntry(configurations, exclusions);
	}
}
	

• getCandidateConfigurations()–> SpringFactoriesLoader.loadFactoryNames(this.getSpringFactoriesLoaderFactoryClass(), this.getBeanClassLoader())

protected Class<?> getSpringFactoriesLoaderFactoryClass() {
	// EnableAutoConfiguration当做参数传递
	return EnableAutoConfiguration.class;
}

 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 {
				// 扫描所有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();

                while(urls.hasMoreElements()) {
                    URL url = (URL)urls.nextElement();
                    UrlResource resource = new UrlResource(url);
					
					//把扫描到的这些文件的内容包装成properties对象
                    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];
							
							// 从properties中获取到EnableAutoConfiguration.class类（类名）对应的值，然后添加在容器中
                            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);
            }
        }
    }

将 类路径下 META-INF/spring.factories 里面配置的所有EnableAutoConfiguration的值加入到了容器中；
​

每一个 xxxAutoConfiguration类都是容器中的一个组件，都加入到容器中；用他们来做自动配置

1.3 自动配置类进行自动配置功能

1.4 以HttpEncodingAutoConfiguration（Http编码自动配置）为例解释自动配置原理

@Configuration
@EnableConfigurationProperties({HttpProperties.class})
@ConditionalOnWebApplication(
    type = Type.SERVLET
)
@ConditionalOnClass({CharacterEncodingFilter.class})
@ConditionalOnProperty(
    prefix = "spring.http.encoding",
    value = {"enabled"},
    matchIfMissing = true
)
public class HttpEncodingAutoConfiguration {

1.4 以HttpEncodingAutoConfiguration（Http编码自动配置）为例解释自动配置原理

// 表示这是一个配置类，和以前编写的配置文件(xml)一样，给容器中添加组件
@Configuration

// 启动指定类的ConfigurationProperties功能；将配置文件中对应的值和HttpProperties绑定起来；并把HttpProperties加入到ioc容器中
@EnableConfigurationProperties({HttpProperties.class})

// Spring底层@Conditional注解（Spring注解版），根据不同条件，如果满足指定的条件，整个配置类里面的配置才会生效；    
// @ConditionalOnWebApplication : 判断当前应用是否是web应用，如果是，当前配置类生效
@ConditionalOnWebApplication(
    type = Type.SERVLET
)

// 判断当前项目中是否存在CharacterEncodingFilter(SpringMVC中进行乱码解决的过滤器);
@ConditionalOnClass({CharacterEncodingFilter.class})

// 判断配置文件中是否存在某个配置  spring.http.encoding.enabled;
// matchIfMissing = true: 如果不存在，判断也是成立的
// 即使配置文件中不配置pring.http.encoding.enabled=true，也是默认生效的；
@ConditionalOnProperty(
    prefix = "spring.http.encoding",
    value = {"enabled"},
    matchIfMissing = true
)
public class HttpEncodingAutoConfiguration {
	// 已和SpringBoot的配置文件映射
	private final Encoding properties;

	// 只有一个有参构造器的情况下,参数的值就会从容器中获取
    public HttpEncodingAutoConfiguration(HttpProperties properties) {
        this.properties = properties.getEncoding();
    }

	// 给容器中添加一个组件，组件的某些值需要从properties中获取
    @Bean
    @ConditionalOnMissingBean
    public CharacterEncodingFilter characterEncodingFilter() {
        CharacterEncodingFilter filter = new OrderedCharacterEncodingFilter();
        filter.setEncoding(this.properties.getCharset().name());
        filter.setForceRequestEncoding(this.properties.shouldForce(org.springframework.boot.autoconfigure.http.HttpProperties.Encoding.Type.REQUEST));
        filter.setForceResponseEncoding(this.properties.shouldForce(org.springframework.boot.autoconfigure.http.HttpProperties.Encoding.Type.RESPONSE));
        return filter;
    }
	
	......
}

• HttpProperties

// 从配置文件中获取指定的值和bean的属性进行绑定
@ConfigurationProperties(
    prefix = "spring.http"
)
public class HttpProperties {
    private boolean logRequestDetails;
	
	......
}

由此可知,可以在application.properties中配置HttpProperties 中对应的变量logRequestDetails
spring.http.log-request-details=false

根据当前不同的条件判断，决定这个配置类是否生效,一但配置类生效.配置类就会给容器中添加各种组件；这些组件的属性是从对应的properties类中获取的，这些类里面的每一个属性又是和配置文件绑定的；

作用：必须是@Conditional指定的条件成立，才给容器中添加组件，配置配里面的所有内容才生效；

@Conditional扩展注解	作用（判断是否满足当前指定条件）
@ConditionalOnJava	系统的java版本是否符合要求
@ConditionalOnBean	容器中存在指定Bean；
@ConditionalOnMissingBean	容器中不存在指定Bean；
@ConditionalOnExpression	满足SpEL表达式指定
@ConditionalOnClass	系统中有指定的类
@ConditionalOnMissingClass	系统中没有指定的类
@ConditionalOnSingleCandidate	容器中只有一个指定的Bean，或者这个Bean是首选Bean
@ConditionalOnProperty	系统中指定的属性是否有指定的值
@ConditionalOnResource	类路径下是否存在指定资源文件
@ConditionalOnWebApplication	当前是web环境
@ConditionalOnNotWebApplication	当前不是web环境
@ConditionalOnJndi	JNDI存在指定项

• 我们可以通过启用 debug=true属性；来让控制台打印自动配置报告
  

1.5 所有在配置文件中能配置的属性都是在xxxxProperties类中封装；配置文件能配置什么就可以参照某个功能对应的这个属性类

// 从配置文件中获取指定的值和bean的属性进行绑定
@ConfigurationProperties(
    prefix = "spring.http"
)
public class HttpProperties {...}

1.6 SpringBoot自动配置概括

​1 SpringBoot启动会加载大量的自动配置类
2 需要的功能有没有SpringBoot默认写好的自动配置类；
3 自动配置类中到底配置了哪些组件；（只要包含需要的组件，就无需配置）
4 给容器中自动配置类添加组件的时候，会从properties类中获取某些属性。就可以在配置文件中指定这些属性的值；

1.7 总结

• xxxxAutoConfigurartion：自动配置类,给容器中添加组件

• xxxxProperties:封装配置文件中相关属性；

1.7.1 常见的DataSourceProperties

public class DataSourceProperties implements BeanClassLoaderAware, InitializingBean {
    private ClassLoader classLoader;
    private String name;
    private boolean generateUniqueName;
    private Class<? extends DataSource> type;
    private String driverClassName;
    private String url;
    private String username;
    private String password;
    private String jndiName;
    private DataSourceInitializationMode initializationMode;
    private String platform;
    private List<String> schema;
    private String schemaUsername;
    private String schemaPassword;
    private List<String> data;
    private String dataUsername;
    private String dataPassword;
    private boolean continueOnError;
    private String separator;
    private Charset sqlScriptEncoding;
    private EmbeddedDatabaseConnection embeddedDatabaseConnection;
    private DataSourceProperties.Xa xa;
    private String uniqueName;

    public DataSourceProperties() {
        this.initializationMode = DataSourceInitializationMode.EMBEDDED;
        this.platform = "all";
        this.continueOnError = false;
        this.separator = ";";
        this.embeddedDatabaseConnection = EmbeddedDatabaseConnection.NONE;
        this.xa = new DataSourceProperties.Xa();
    }