Java-SpringBoot-配置原理_spring java配置原理-优快云博客

本文链接：https://blog.youkuaiyun.com/codfishXY/article/details/108859658

1. 配置文件

SpringBoot 使用的是一个全局配置文件，文件名固定，有两种类型

application.properties
application.yml

prefix:
	child-key: value #！注意：冒号后的空格不可省略
	maps: {k1: v1,k2: v2,k3: v3} 
	lists:
		- a
		- b
		- c

使用注解对指定类加载配置文件中的信息

//加载yml文件，并注入属性值
@Component
@ConfigurationProperties(prefix = "person") //使用prefix来指定文件中需要加载的属性块
public class Person{}

//加载指定properties文件
@Component
@PropertySource("classpath:person.properties")
public class Person{}

//加载xml配置文件
@ImportResource(locations = "classpath:beans.xml")
@SpringBootApplication
public class SlidepageApplication {
    public static void main(String[] args) {SpringApplication.run(SlidepageApplication.class, args);}
}

Profile多环境支持

配置文件命名规则：application-{profile}.properties/yml

application.yml：公共配置文件，并指定激活环境
application-dev.yml：开发环境配置文件
application-pro.yml：生产环境配置文件
application-test.yml：测试环境配置文件

按文件名的加载优先级
bootstrap.properties→application.properties→application-dev.properties

spring:
	profiles:
		active: pro  #激活生产环境

SpringBoot加载配置文件的默认扫描路径及优先级

外置，应用程序所在目录的/config目录里
外置，应用程序所在目录里
内置，classpath:/config
内置，classpath:/

在全局配置文件中指定扫描路径（一般是在打包好后，用命令行加入新的配置文件）

spring.config.location=D:/application.properties

可在application.properties中配置的所有属性，参见SpringBoot官方文档

2. 自动配置原理

应用程序启动类注解@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 {
	
				...
				
}

其中 @EnableAutoConfiguration 注解开启了自动配置，其源码如下

@Target({ElementType.TYPE})
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Inherited
@AutoConfigurationPackage
@Import({AutoConfigurationImportSelector.class}) //加载选择器导入组件
public @interface EnableAutoConfiguration {
    String ENABLED_OVERRIDE_PROPERTY = "spring.boot.enableautoconfiguration";

    Class<?>[] exclude() default {};

    String[] excludeName() default {};
}

该注解通过导入AutoConfigurationImportSelector选择器加载了很多组件

该选择器内部通过调用其他方法最终调用到一个loadSpringFactories方法，源码如下

   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"); //扫描spring.factories
                LinkedMultiValueMap result = new LinkedMultiValueMap();

                while(urls.hasMoreElements()) {
                    URL url = (URL)urls.nextElement();
                    UrlResource resource = new UrlResource(url);
                    Properties properties = PropertiesLoaderUtils.loadProperties(resource); //封装成Properties对象
                    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);
            }
        }
    }

该方法会扫描jar包类路径下的"META-INF/spring.factories"，并包装成properties，从properties中获取信息，将返回结果作为参数由loadFactoryNames获取工厂名，被SpringFactoriesLoader调用后获取configurations返回给选择器

	protected List<String> getCandidateConfigurations(AnnotationMetadata metadata, AnnotationAttributes attributes) {
        List<String> configurations = SpringFactoriesLoader.loadFactoryNames(this.getSpringFactoriesLoaderFactoryClass(), this.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;
    }

在依赖的jar包sping-boot-autoconfigure中扫描到spring.factories
在这里插入图片描述
该spring.factories中包含了EnableAutoConfiguration下的所有自动配置相关组件类
这些组件类都由 @EnableAutoConfiguration 注解注入到了spring容器中

# 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,\
...

所有的组件类都以*AutoConfiguration命名，以HttpEncodingAutoConfiguration为例

@Configuration(proxyBeanMethods = false) //表示这是一个配置类
@EnableConfigurationProperties({ServerProperties.class}) //把指定类中的属性和配置文件里的信息绑定起来
@ConditionalOnWebApplication(type = Type.SERVLET) //判断是否是web应用，判断条件为true时，配置才会生效
@ConditionalOnClass({CharacterEncodingFilter.class}) //判断当前项目是否存在指定类，有的话配置才会生效
@ConditionalOnProperty(	//判断是否存在配置server.servlet.encoding.enabled
    prefix = "server.servlet.encoding", //根据这个前缀，就可以在application.properties配置文件中自己指定属性了
    value = {"enabled"},
    matchIfMissing = true //表示即使不存在上面的配置属性，该配置也会生效
)
public class HttpEncodingAutoConfiguration {...}

根据自动配置组件类，就可以在application.properties配置一些需要自己指定的属性

server.servlet.encoding.charset=UTF-8
server.servlet.encoding.force=true
...

这就是SpringBoot的自动配置原理，以后就可以根据自己的需求配置相关属性了