SpringBoot学习小结

基于Spring，简化Spring应用开发的框架，整个Spring技术栈的大整合，J2EE开发的一站式解决方案

优点：

• 快速创建独立运行的Spring项目以及集成主流框架
• 使用嵌入式的Servlet容器，无需war包
• starters自动依赖与版本控制
• 无需XML，无代码生成，简化配置，自动配置
• 准生产环境的运行时应用监控
• 与云计算的天然集成

微服务

• 2014，重构一书作者Martin Fowler在他的个人博客中提出的
• 是一种架构风格
• 每个应用都该是一组小型服务，可以通过HTTP进行沟通

场景启动器

SpringBoot自动配置原理

• 项目启动时，会去寻找自动配置类的导入选择器，在选择器的 selectImports 方法中查找所有包下 META-INF/spring.factories文件，将文件内容解析成Properties，然后读取其中key为org.springframework.boot.autoconfigure.EnableAutoConfiguration的value值，然后对这些值进行过滤（重复的、被排除的），返回最后的自动配置类全路径的字符串集合。
• 每个自动配置类（AutoConfiguration）都会关联一个或多个属性类（Properties），这些Properties类都是与配置文件进行绑定的，在自动配置类中存在Properties的引用，且只包含一个参数为Properties的构造器，说明Properties引用的值来自于配置文件或者默认值，并存在向spring容器注入bean的方法，方法里面使用Properties对象的属性。
• 同时每个配置类可以包含一个或多个条件判断，只有在满足了所有条件时这个配置类才会生效。

@EnableAutoConfiguration    //允许自动配置
@Import({EnableAutoConfigurationImportSelector.class})    //导入允许自动配置导入选择器，高版本以及废弃，使用ImportAuto...

public class EnableAutoConfigurationImportSelector extends AutoConfigurationImportSelector{} //自动配置导入选择器

public class AutoConfigurationImportSelector {
    public String[] selectImports(AnnotationMetadata annotationMetadata) {
    if (!this.isEnabled(annotationMetadata)) {
        return NO_IMPORTS;
    } else {
        try {
            //自动配置元数据
            AutoConfigurationMetadata autoConfigurationMetadata = AutoConfigurationMetadataLoader.loadMetadata(this.beanClassLoader);
            //从元数据读取注解属性
            AnnotationAttributes attributes = this.getAttributes(annotationMetadata);
            //从元数据和属性获取所有配置类的字符串集合
            List<String> configurations = this.getCandidateConfigurations(annotationMetadata, attributes);

            //处理自动配置类：去除重复的、被排除掉的等
            configurations = this.removeDuplicates(configurations);
            configurations = this.sort(configurations, autoConfigurationMetadata);
            Set<String> exclusions = this.getExclusions(annotationMetadata, attributes);
            this.checkExcludedClasses(configurations, exclusions);
            configurations.removeAll(exclusions);
            configurations = this.filter(configurations, autoConfigurationMetadata);
            this.fireAutoConfigurationImportEvents(configurations, exclusions);
            return (String[])configurations.toArray(new String[configurations.size()]);
        } catch (IOException var6) {
            throw new IllegalStateException(var6);
        }
    }
}
}

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

public static List<String> loadFactoryNames(Class<?> factoryClass, ClassLoader classLoader) {
    //EnableAutoConfiguration的全路径：org.springframework.boot.autoconfigure.EnableAutoConfiguration
    String factoryClassName = factoryClass.getName();

    try {
        //读取所有META-INF/spring.factories文件，解析成URL
        Enumeration<URL> urls = classLoader != null ? classLoader.getResources("META-INF/spring.factories") : ClassLoader.getSystemResources("META-INF/spring.factories");
        ArrayList result = new ArrayList();

        while(urls.hasMoreElements()) {
            URL url = (URL)urls.nextElement();
            //将URL解析成Properties文件
            Properties properties = PropertiesLoaderUtils.loadProperties(new UrlResource(url));
            //查找properties中属性名称为org.springframework.boot.autoconfigure.EnableAutoConfiguration的值
            String propertyValue = properties.getProperty(factoryClassName);
            String[] var8 = StringUtils.commaDelimitedListToStringArray(propertyValue);
            int var9 = var8.length;

            //遍历所有的value，放入结果list中
            for(int var10 = 0; var10 < var9; ++var10) {
                String factoryName = var8[var10];
                result.add(factoryName.trim());
            }
        }
        //返回所有的自动配置类的路径list
        return result;
    } catch (IOException var12) {
        throw new IllegalArgumentException("Unable to load factories from location [META-INF/spring.factories]", var12);
    }
}

如HttpEncodingAutoConfiguration
// 是一个配置类，可以往spring容器添加bean对象
@Configuration
// 开启HttpEncodingProperties类的可配置属性功能，即该类的属性与配置文件进行绑定，并将该类添加到ioc容器中，这个类需要使用@ConfigurationProperties声明。
@EnableConfigurationProperties({HttpEncodingProperties.class})
//条件判断：必须是web应用，必须存在CharacterEncodingFilter，即引入了依赖包，需要有spring.http.encoding.enabled的属性，如果没有则默认为true
@ConditionalOnWebApplication
@ConditionalOnClass({CharacterEncodingFilter.class})
@ConditionalOnProperty(
    prefix = "spring.http.encoding",
    value = {"enabled"},
    matchIfMissing = true
)
public class HttpEncodingAutoConfiguration {
    //持有一个HttpEncodingProperties类的引用对象
    private final HttpEncodingProperties properties;

    //只有一个参数为HttpEncodingProperties对象的构造方法，说明此参数是由spring容器确定的，这里一般是由配置文件编写
    public HttpEncodingAutoConfiguration(HttpEncodingProperties properties) {
        this.properties = properties;
    }

    //将方法返回结果注入到spring容器里，id为方法名。只有在容器中不存在这个bean时才进行注入，说明是单例的
    @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;
    }
}

@ConfigurationProperties(prefix = "spring.http.encoding")
public class HttpEncodingProperties {
    public static final Charset DEFAULT_CHARSET = Charset.forName("UTF-8");
    private Charset charset;
    private Boolean force;
    private Boolean forceRequest;
    private Boolean forceResponse;
    private Map<Locale, Charset> mapping;
}