【SpringBoot】spring-boot-自动配置原理

青旅半醒 2022-05-11 05:12 75阅读 0赞

**思考：配置文件到底能写什么？怎么写？自动配置原理；**

### **1.自动配置原理** ###

springboot自动配置主演通过**@EnableConfiguration**,**@Conditional,@EnableConfigurationProperties**或者**@ConfiguraionProperties**几个注解来进行自动配置。**@EnableConfiguraqtion**开启自动配置，主要作用就是调用core包里的**loadFactoryNames()**,将autoconfig包里已经写好的自动配置加载进来。

**@Conditional**条件注解，通过判断类路径下有没有相应配置的jar包来确定是否加载和自动配置这个类，

**@EnableConfigurationProperties**的作用就是，给自动配置提供具体的配置参数，只需要写在application.proerties中，就可以通过映射写入配置类 的Pojo属性中。

1）SpringBoot启动的时候加载主配置类，开启自动配置功能@EnableAutoConfiguration

2)@EnableAutoConfiguration,利用EnableAutoConfigurationImportSelector给容器中导入一些组件。

3）从启动类的@SpringBootApplication进入，在里面找到@EnableAutoConfiguration

@SpringBootApplication
    public class Application {
    
    	public static void main(String[] args) {
    		SpringApplication.run(Application.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 {

4)EnableAutoConfigutation里通过@Import导入了EnableAutoConfigurationImportSelector

@SuppressWarnings("deprecation")
    @Target(ElementType.TYPE)
    @Retention(RetentionPolicy.RUNTIME)
    @Documented
    @Inherited
    @AutoConfigurationPackage
    @Import(EnableAutoConfigurationImportSelector.class)
    public @interface EnableAutoConfiguration {
    
    	String ENABLED_OVERRIDE_PROPERTY = "spring.boot.enableautoconfiguration";
    
    	/**
    	 * Exclude specific auto-configuration classes such that they will never be applied.
    	 * @return the classes to exclude
    	 */
    	Class<?>[] exclude() default {};
    
    	/**
    	 * Exclude specific auto-configuration class names such that they will never be
    	 * applied.
    	 * @return the class names to exclude
    	 * @since 1.3.0
    	 */
    	String[] excludeName() default {};
    
    }

5）进入EnableAutoConfigurationImportSelector的父类AutoConfigurationImportSelector，找到了selectImports()方法,调用了getCandidateConfigurations（）方法，在这里又调用了Spring Core包中的loadFactoryNames()方法。这个方法的作用，扫描所有jar包类路径下 META-INF/spring.factories 把扫描到的这些文件的内容包装成properties对象，从properties中获取到EnableAutoConfig.class类（类名）对应的值，然后把他们添加到容器中

此方法找到getCandidateConfigurations（）方法

@Override
    	public String[] selectImports(AnnotationMetadata annotationMetadata) {
    		if (!isEnabled(annotationMetadata)) {
    			return NO_IMPORTS;
    		}
    		try {
    			AutoConfigurationMetadata autoConfigurationMetadata = AutoConfigurationMetadataLoader
    					.loadMetadata(this.beanClassLoader);
    			AnnotationAttributes attributes = getAttributes(annotationMetadata);
    			List<String> configurations = getCandidateConfigurations(annotationMetadata,
    					attributes);
    			configurations = removeDuplicates(configurations);
    			configurations = sort(configurations, autoConfigurationMetadata);
    			Set<String> exclusions = getExclusions(annotationMetadata, attributes);
    			checkExcludedClasses(configurations, exclusions);
    			configurations.removeAll(exclusions);
    			configurations = filter(configurations, autoConfigurationMetadata);
    			fireAutoConfigurationImportEvents(configurations, exclusions);
    			return configurations.toArray(new String[configurations.size()]);
    		}
    		catch (IOException ex) {
    			throw new IllegalStateException(ex);
    		}
    	}

此方法找到loadFactoryNames（）方法

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（）方法,里面有一个常量***FACTORIES\_RESOURCE\_LOCATION，***他的值就是"META-INF/spring.factories";

public static List<String> loadFactoryNames(Class<?> factoryClass, ClassLoader classLoader) {
    		String factoryClassName = factoryClass.getName();
    		try {
    			Enumeration<URL> urls = (classLoader != null ? classLoader.getResources(FACTORIES_RESOURCE_LOCATION) :
    					ClassLoader.getSystemResources(FACTORIES_RESOURCE_LOCATION));
    			List<String> result = new ArrayList<String>();
    			while (urls.hasMoreElements()) {
    				URL url = urls.nextElement();
    				Properties properties = PropertiesLoaderUtils.loadProperties(new UrlResource(url));
    				String factoryClassNames = properties.getProperty(factoryClassName);
    				result.addAll(Arrays.asList(StringUtils.commaDelimitedListToStringArray(factoryClassNames)));
    			}
    			return result;
    		}
    		catch (IOException ex) {
    			throw new IllegalArgumentException("Unable to load [" + factoryClass.getName() +
    					"] factories from location [" + FACTORIES_RESOURCE_LOCATION + "]", ex);
    		}
    	}

6）jar文件在org.springframework.boot.autoconfigure的spring.factories

![70][]

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

# Auto Configure
    org.springframework.boot.autoconfigure.EnableAutoConfiguration=\
    org.springframework.boot.autoconfigure.admin.SpringApplicationAdminJmxAutoConfiguration,\
    org.springframework.boot.autoconfigure.aop.AopAutoConfiguration,\
    org.springframework.boot.autoconfigure.amqp.RabbitAutoConfiguration,\
    org.springframework.boot.autoconfigure.batch.BatchAutoConfiguration,\
    org.springframework.boot.autoconfigure.cache.CacheAutoConfiguration,\
    org.springframework.boot.autoconfigure.cassandra.CassandraAutoConfiguration,\
    org.springframework.boot.autoconfigure.cloud.CloudAutoConfiguration,\
    org.springframework.boot.autoconfigure.context.ConfigurationPropertiesAutoConfiguration,\
    org.springframework.boot.autoconfigure.context.MessageSourceAutoConfiguration,\
    org.springframework.boot.autoconfigure.context.PropertyPlaceholderAutoConfiguration,\
    org.springframework.boot.autoconfigure.couchbase.CouchbaseAutoConfiguration,\

每一个这样的xxxAutoConfiguration类都是容器中的一个组件，都加入到容器中；用他们来做自动配置；每一个自动配置类进行自动配置功能。

### **2.以HttpEncodingAutoConfiguration(http编码)为例解释自动配置** ###

1）

@Configuration //表示这是一个配置类，以前编写的配置文件一样，也可以给容器中添加组件
    @EnableConfigurationProperties(HttpEncodingProperties.class)//启动指
    定类的ConfigurationProperties功能；将配置文件中对应的值和HttpEncodingProperties加入到ioc容器中
    @ConditionalOnWebApplication//Spring底层@Conditional注解（spring注解版),根据不同的条件，
    如果满足指定的条件，整个配置类里的配置就回生效；判断当前应用是否是web应用，如果是，当前配置类生效
    @ConditionalOnClass(CharacterEncodingFilter.class)//判断当前项目有没有
    这个类CharacterEncodingFilter，SpringMVC进行乱码解决的过滤器
    @ConditionalOnProperty(prefix = "spring.http.encoding", value = "enabled", matchIfMissing = true)//判断配置文件中是否存在某个配置 spring.http.encoding;如果不存在，
    判断也是成立的，即使我们配置文件中不配置spring.http.encoding.enable=true,也是默认生效的
    public class HttpEncodingAutoConfiguration {
        //他已经和SpringBoot的配置文件映射了
    	private final HttpEncodingProperties properties;
       //
    	public HttpEncodingAutoConfiguration(HttpEncodingProperties properties) {
    		this.properties = properties;
    	}
       //给容器中添加一个组件，这些组件的值需要从properties中获取
    	@Bean
    	@ConditionalOnMissingBean(CharacterEncodingFilter.class)
    	public CharacterEncodingFilter characterEncodingFilter() {
    		CharacterEncodingFilter filter = new OrderedCharacterEncodingFilter();
    		filter.setEncoding(this.properties.getCharset().name());
    		filter.setForceRequestEncoding(this.properties.shouldForce(Type.REQUEST));
    		filter.setForceResponseEncoding(this.properties.shouldForce(Type.RESPONSE));
    		return filter;
    	}

根据不同的条件判断，决定这个配置类是否生效？

一旦这个类配置生效；这个配置类就会给容器中添加各种组件；这些组件的属性是从对应的properties类中获取的，这些类里面的每一个属性又是配置文件绑定的；

2）所有在配置文件中能配置的属性都是在xxx.Properties类中封装着；配置文件能配置什么就可以参照某个功能对应的这个属性类

@ConfigurationProperties(prefix = "spring.http.encoding")//从配置文件中获取指定的值和      //bean的属性进行绑定
    public class HttpEncodingProperties {
    
    	public static final Charset DEFAULT_CHARSET = Charset.forName("UTF-8");
    }

### **3.总结** ###

**1）SpringBoot启动会加载大量的自动配置类；**

**2）我们看我们需要的功能有没有SpringBoot默认写好的自动配置类；**

**3）我们再来看这个配置类到底配置了哪些组件；（只要我们用的组件有，我们就不需要再来配置了）；**

**4）给容器中自动配置类添加组件的时候，会从 properties类中获取某些属性。我们就可以在配置文件中指定这些属性的值；**

**xxxConfiguration:自动配置类；给容器中添加组件**

**xxxProperties封装配置文件中相关属性**

[70]: /images/20220511/1978bb707ba04894bb61ab22f0754375.png