Spring Boot（二）--------运行原理探究

Spring Boot（二）--------探究运行原理

5、运行原理探究

5.1 父依赖pom.xml

• spring-boot-starter-parent：在pom.xml的parent中，其中资源过滤已经配置好，核心依赖在父工程spring-boot-dependencies中

• 它主要是依赖一个父项目，主要是管理项目的资源过滤、启动器及插件

• 点进去，发现还有一个父依赖spring-boot-dependencies

<parent>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-parent</artifactId>
    <version>2.5.5</version>
    <relativePath/> <!-- lookup parent from repository -->
</parent>

• spring-boot-dependencies：这里才是真正管理Spring Boot应用里面所有依赖版本的地方，Spring Boot的版本控制中心
• 我们在写或引入一些SpringBoot依赖的时候，不需要指定版本，是因为有这些仓库；如果导入的包没有在依赖中管理着就需要手动配置版本

<parent>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-dependencies</artifactId>
    <version>2.5.5</version>
</parent>

5.2 启动器 spring-boot-starter

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter</artifactId>
</dependency>

• 启动器：springboot-boot-starter-xxx，说白了就是Spring Boot的启动场景
• 比如spring-boot-starter-web，他就会帮我们自动导入web环境的所有依赖
• Spring Boot会将所有的功能场景，都变成一个个的启动器，我们要使用什么功能，只需找到对应的启动器即可
• 功能场景在spring-boot-dependencies中查看，其中没有mybatis的启动器

5.3 主程序

5.3.1 默认的主启动类

//@SpringBootApplication：标注这个类是一个springboot的应用
@SpringBootApplication
public class Springboot01HelloworldApplication {

    public static void main(String[] args) {
        //将SpringBoot应用启动
        SpringApplication.run(Springboot01HelloworldApplication.class, args);
    }
}

5.3.2 注解(@SpringBootApplication)

• 作用：标注这个类是一个SpringBoot应用，启动类下的所有资源被导入
• 点击进入这个注解，还可以看到很多注解

//四个元注解
@Target({ElementType.TYPE})
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Inherited
//SpringBoot的配置
@SpringBootConfiguration
//自动配置
@EnableAutoConfiguration
@ComponentScan(
    excludeFilters = {@Filter(
    type = FilterType.CUSTOM,
    classes = {TypeExcludeFilter.class}
), @Filter(
    type = FilterType.CUSTOM,
    classes = {AutoConfigurationExcludeFilter.class}
)}
)

@SpringBootConfiguration

• 作用：Spring Boot的配置类，标注在某个类上，表示这是一个SpringBoot的配置类

• 点击这个注解，可以看到其他注解

// 点击@SpringBootConfiguration，得到@Configuration
@Configuration
public @interface SpringBootConfiguration {}

//点击@Configuration，得到@Component
@Component
public @interface Configuration {}

• @Configuration：说明这是一个Spring的配置类 ，配置类就是对应Spring的xml 配置文件
• @Component：说明启动类本身也是Spring中的一个组件，负责启动应用

@EnableAutoConfiguration

• 作用：开启自动配置功能

//点击@EnableAutoConfiguration，得到@AutoConfigurationPackage，@Import
@AutoConfigurationPackage
@Import({AutoConfigurationImportSelector.class})
public @interface EnableAutoConfiguration {}

//点击AutoConfigurationImportSelector，得到public class AutoConfigurationImportSelector
//获取所有配置
List<String> configurations = this.getCandidateConfigurations(annotationMetadata, attributes);

//点击@AutoConfigurationPackage，得到@Import
//自动注册包
@Import(AutoConfigurationPackages.Registrar.class)
public @interface AutoConfigurationPackage {}

• @AutoConfigurationPackage：自动配置包

• @Import(AutoConfigurationPackages.Registrar.class)：导入选择器，自动配置包注册，将主启动类的所在包及包下面所有子包里面的所有组件扫描到Spring容器

• @Import({AutoConfigurationImportSelector.class})：导入组件

@Import(AutoConfigurationImportSelector.class)

• 自动导入包的核心
• 其中导入类 AutoConfigurationImportSelector：自动导入选择器（选择了什么东西？）
• 关注方法 getAutoConfigurationEntry()：获得自动配置实体，其中调用了方法 getCandidateConfigurations()：获取候选的配置

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

protected Class<?> getSpringFactoriesLoaderFactoryClass() {
		return EnableAutoConfiguration.class;
	}

• 方法 getSpringFactoriesLoaderFactoryClass()中，传入的参数为protected Class<?> getSpringFactoriesLoaderFactoryClass() { } ，标注了EnableAutoConfiguration注解的类

protected Class<?> getSpringFactoriesLoaderFactoryClass() {
		return EnableAutoConfiguration.class;
	}

• 其中，调用了loadFactoryNames()方法，获取了所有的加载配置名，在该方法调用了方法 loadSpringFactories() ：从什么地方获取资源，并且遍历了资源中所有的自动配置，遍历完成后封装为Properties供我们使用

public static List<String> 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());
    }

• 分为两种：从项目中获取资源、从系统中获取资源

• 项目中的资源来自spring-boot-autoconfigure-2.6.3.jar中的/META-INF/spring.factories

• spring.factories：包含所有的自动配置类

• 思考：为什么这些自动配置类没有全部生效，需要导入对应的start才能有作用？

• 解答：核心注解：@ConditionalOnXXX：如果其中的条件都满足，才会生效

@ComponentScan

• 这个注解在Spring中很重要，它对应XML配置中的元素
• 作用：自动扫描并加载符合条件的组件或bean，将这个bean定义加载到IOC容器中

5.3.3 结论

• Spring Boot在启动的时候，从类路径下/META-INF/spring.factories文件中获取指定的值

• 将这些自动配置的类导入容器，自动配置就会生效，帮我们进行自动配置

• 之前需要自动配置的东西，现在由Spring Boot帮助我们做

• 整合javaEE，解决方案和自动配置的东西都在spring-boot-autoconfigure-2.6.3.jar这个包下

• 它会把所有需要导入的组件，以类名的方式返回，这些组件就会被添加到容器中

• 容器中也会存在非常多的XXXAutoConfiguration的文件（@Bean），通过这些类给容器中导入了这个场景需要的所有组件，并自动配置（@Configuration）

• 有了自动配置类，免去了手动编写配置文件的工作

• SpringBoot中所有的自动配置，都是在启动的时候扫描并加载的，扫描了spring.factories文件，其中包含所有的自动配置类，根据条件是否成立来判断是否生效。导入对应start，就有了对应的启动器，有了启动器，自动装配就会生效，从而配置成功。

6、主启动类如何运行

6.1 run

• 最初以为只是运行了一个main()方法，没想到是开启了一个服务

@SpringBootApplication
public class Springboot01Application {

    public static void main(String[] args) {
        //该方法返回一个ConfigurableApplicationContext对象
        //参数一：应用入口的类  参数类：命令行参数
        SpringApplication.run(Springboot01Application.class, args);
    }

}

• SpringApplication.run()分析：一部分是SpringApplication的实例化，一部分是run()方法的执行

6.2 SpringApplication

6.2.1 这个类主要做了四件事

• 推断应用的类型是普通的项目还是Web项目
• 查找并加载所有可能的初始化器，设置到initializers属性中
• 找出所有的应用程序监听器，设置到listeners属性中
• 推断并设置main方法的定义类，找到运行的主类

6.2.2 构造器

public SpringApplication(ResourceLoader resourceLoader, Class<?>... primarySources) {
        this.sources = new LinkedHashSet();
        this.bannerMode = Mode.CONSOLE;
        this.logStartupInfo = true;
        this.addCommandLineProperties = true;
        this.addConversionService = true;
        this.headless = true;
        this.registerShutdownHook = true;
        this.additionalProfiles = Collections.emptySet();
        this.isCustomEnvironment = false;
        this.lazyInitialization = false;
        this.applicationContextFactory = ApplicationContextFactory.DEFAULT;
        this.applicationStartup = ApplicationStartup.DEFAULT;
        this.resourceLoader = resourceLoader;
        Assert.notNull(primarySources, "PrimarySources must not be null");
        this.primarySources = new LinkedHashSet(Arrays.asList(primarySources));
        this.webApplicationType = WebApplicationType.deduceFromClasspath();
        this.bootstrapRegistryInitializers = new ArrayList(this.getSpringFactoriesInstances(BootstrapRegistryInitializer.class));
        this.setInitializers(this.getSpringFactoriesInstances(ApplicationContextInitializer.class));
        this.setListeners(this.getSpringFactoriesInstances(ApplicationListener.class));
        this.mainApplicationClass = this.deduceMainApplicationClass();
    }

7、关于SpringBoot，谈谈你的理解

• 自动装配
• run()：判断是普通项目还是web项目；推断当前的主类；存在一些全局监听器，可以获取上下文处理所有的bean