SpringBoot学习小结

喜欢ヅ旅行 2022-01-05 11:25 235阅读 0赞

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

转载于:https://www.cnblogs.com/mabaoqing/p/10691679.html