石一歌的SpringBoot笔记

运行原理探究（2.6.2）

基于狂神的springboot运行原理探究，自己操作一下 2.6.2版本

	org.springframework.boot
	spring-boot-starter-parent
	2.6.2
	 

前置知识

java元注解

• @Target 表示该注解用于什么地方。
• @Retention 表示在什么级别保存该注解信息。
• @Documented 将此注解包含在 javadoc 中 ，它代表着此注解会被javadoc工具提取成文档。
• @Inherited 允许子类继承父类中的注解。

@SpringBootApplication

主启动类，主要目的是开启自动配置

@Target({ElementType.TYPE})// 元注解，该注解可修饰类，接口（包括注解类型）或enum声明 
@Retention(RetentionPolicy.RUNTIME)// 元注解，注解保留级别 VM将在运行期保留注释，可通过反射读取注解的信息
@Documented// 元注解 注解会被javadoc工具提取成文档
@Inherited// 元注解 允许子类继承父类中的注解
@SpringBootConfiguration// springboot配置注解
@EnableAutoConfiguration// 自动配置注解 核心
@ComponentScan(// 组件扫描注解
    excludeFilters = {@Filter(
    type = FilterType.CUSTOM,
    classes = {TypeExcludeFilter.class}
), @Filter(
    type = FilterType.CUSTOM,
    classes = {AutoConfigurationExcludeFilter.class}
)}
)
public @interface SpringBootApplication {
  	...
}

@SpringBootConfiguration

SpringBoot的配置类，继承了@Configuration，功能类似

@Target({ElementType.TYPE})// 元注解，该注解可修饰类，接口（包括注解类型）或enum声明 
@Retention(RetentionPolicy.RUNTIME)// 元注解，注解保留级别 VM将在运行期保留注释，可通过反射读取注解的信息
@Documented// 元注解 注解会被javadoc工具提取成文档
@Configuration// 配置注解 将当前类标注为配置类，配合@bean使用
@Indexed// 索引注解，为Spring的模式注解添加索引，以提升应用启动性能。
public @interface SpringBootConfiguration {
    ...
}

@EnableAutoConfiguration

开启自动配置

@Target({ElementType.TYPE})// 元注解，该注解可修饰类，接口（包括注解类型）或enum声明 
@Retention(RetentionPolicy.RUNTIME)// 元注解，注解保留级别 VM将在运行期保留注释，可通过反射读取注解的信息
@Documented// 元注解 注解会被javadoc工具提取成文档
@Inherited// 元注解 允许子类继承父类中的注解
@AutoConfigurationPackage// 自动配置包注解，启动类注解所在包的自包
@Import({AutoConfigurationImportSelector.class})// 导入自动配置导入选择器组件
public @interface EnableAutoConfiguration {
    ...
}

AutoConfigurationImportSelector

自动配置导入选择器

 protected List getCandidateConfigurations(AnnotationMetadata metadata, AnnotationAttributes attributes) {
        List 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;
    }

调用SpringFactoriesLoader.loadFactoryNames()方法

public static List loadFactoryNames(Class<?> factoryType, @Nullable ClassLoader classLoader) {
        ClassLoader classLoaderToUse = classLoader;
        if (classLoader == null) {
            classLoaderToUse = SpringFactoriesLoader.class.getClassLoader();
        }

        String factoryTypeName = factoryType.getName();
        return (List)loadSpringFactories(classLoaderToUse).getOrDefault(factoryTypeName, Collections.emptyList());
    }

调用SpringFactoriesLoader.loadSpringFactories()方法

 private static Map> loadSpringFactories(ClassLoader classLoader) {
        Map> result = (Map)cache.get(classLoader);
        if (result != null) {
            return result;
        } else {
            HashMap result = new HashMap();

            try {
                Enumeration urls = classLoader.getResources("META-INF/spring.factories");

                while(urls.hasMoreElements()) {
                    URL url = (URL)urls.nextElement();
                    UrlResource resource = new UrlResource(url);
                    Properties properties = PropertiesLoaderUtils.loadProperties(resource);
                    Iterator var6 = properties.entrySet().iterator();

                    while(var6.hasNext()) {
                        Entry<?, ?> entry = (Entry)var6.next();
                        String factoryTypeName = ((String)entry.getKey()).trim();
                        String[] factoryImplementationNames = StringUtils.commaDelimitedListToStringArray((String)entry.getValue());
                        String[] var10 = factoryImplementationNames;
                        int var11 = factoryImplementationNames.length;

                        for(int var12 = 0; var12 < var11; ++var12) {
                            String factoryImplementationName = var10[var12];
                            ((List)result.computeIfAbsent(factoryTypeName, (key) -> {
                                return new ArrayList();
                            })).add(factoryImplementationName.trim());
                        }
                    }
                }

                result.replaceAll((factoryType, implementations) -> {
                    return (List)implementations.stream().distinct().collect(Collectors.collectingAndThen(Collectors.toList(), Collections::unmodifiableList));
                });
                cache.put(classLoader, result);
                return result;
            } catch (IOException var14) {
                throw new IllegalArgumentException("Unable to load factories from location [META-INF/spring.factories]", var14);
            }
        }
    }

源头

@AutoConfigurationPackage

@Target({ElementType.TYPE})// 元注解，该注解可修饰类，接口（包括注解类型）或enum声明 
@Retention(RetentionPolicy.RUNTIME)// 元注解，注解保留级别 VM将在运行期保留注释，可通过反射读取注解的信息
@Documented// 元注解 注解会被javadoc工具提取成文档
@Inherited// 元注解 允许子类继承父类中的注解
@Import({Registrar.class})// 导入注册组件，将主启动类的所在包及包下面所有子包里面的所有组件扫描到Spring容器
public @interface AutoConfigurationPackage {
    ...
}

@ComponentScan

自动扫描并加载符合条件的组件或bean

总结

• @SpringBootApplication 主配置类

  • @SpringBootConfiguration SpringBoot的配置类

    • Configuration 配置类对应spring的xml

• @EnableAutoConfiguration springboot自动配置

  • @AutoConfigurationPackage 自动配置包

    • @import(Registrar.class) 将主启动类的所在包及包下面所有子包里面的所有组件扫描到Spring容器

  • @Import({AutoConfigurationImportSelector.class}) ：自动配置导入选择器

    • AutoConfigurationImportSelector.getCandidateConfigurations 调用
      • SpringFactoriesLoader.loadFactoryNames 调用
        • SpringFactoriesLoader.loadSpringFactories 调用
          • META-INF/spring.factories 配置源文件

• @ComponentScan 自动扫描并加载符合条件的组件或bean

结论：

1. SpringBoot在启动的时候从类路径下的META-INF/spring.factories中获取EnableAutoConfiguration指定的值
2. 将这些值作为自动配置类导入容器 ， 自动配置类生效 ，进行自动配置工作
3. 整个J2EE的整体解决方案和自动配置都在springboot-autoconfigure的jar包中
4. 它会给容器中导入非常多的自动配置类 （xxxAutoConfiguration）, 就是给容器中导入这个场景需要的所有组件 ， 并配置好这些组件

自动装配原理

//表明为配置类
@Configuration(
    proxyBeanMethods = false
)
//判断 有DataSource.class, EmbeddedDatabaseType.class，实例化
@ConditionalOnClass({DataSource.class, EmbeddedDatabaseType.class})
//判断 无io.r2dbc.spi.ConnectionFactory，实例化
@ConditionalOnMissingBean(
    type = {"io.r2dbc.spi.ConnectionFactory"}
)
//自动配置之前加载SqlInitializationAutoConfiguration.class
@AutoConfigureBefore({SqlInitializationAutoConfiguration.class})
//将配置文件中对应的值和DataSourceProperties绑定起来；并把DataSourceProperties加入到ioc容器中
@EnableConfigurationProperties({DataSourceProperties.class})
//导入DataSourcePoolMetadataProvidersConfiguration.class, InitializationSpecificCredentialsDataSourceInitializationConfiguration.class, SharedCredentialsDataSourceInitializationConfiguration.class
@Import({DataSourcePoolMetadataProvidersConfiguration.class, InitializationSpecificCredentialsDataSourceInitializationConfiguration.class, SharedCredentialsDataSourceInitializationConfiguration.class})
public class DataSourceAutoConfiguration {
    public DataSourceAutoConfiguration() {
    }
    ...
}

总结

• 一但这个配置类生效；这个配置类就会给容器中添加各种组件；
• 这些组件的属性是从对应的properties类中获取的，这些类里面的每一个属性又是和配置文件绑定的；
• 所有在配置文件中能配置的属性都是在xxxxProperties类中封装着；
• 配置文件能配置什么就可以参照某个功能对应的这个属性类

Springboot启动流程

1. SpringBoot启动加载大量的自动配置类(spring.factories)

2. SpringBoot默认写好的自动配置类

3. 自动配置类中配置组件

4. 给容器中自动配置类添加组件的时候，会从properties类中获取某些属性(用配置文件可修改)。

Yaml注入配置文件

用@ConfigurationProperties(prefix = "person")代替@Value

此注解需要导入配置文件处理器

  org.springframework.boot
  spring-boot-configuration-processor
  true

配置javabean Person

@PropertySource(value = "classpath:person.yaml")//指定配置文件
@Component //注册bean
@ConfigurationProperties(prefix = "person")//与配置文件下person属性对应
public class Person {
    private String name;
    private Integer age;
    private Boolean happy;
    private Date birth;
    private Map maps;
    private List