SpringBoot02：运行原理初探-优快云博客

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

点进去还有一个父依赖：

  <parent>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-dependencies</artifactId>
    <version>2.2.5.RELEASE</version>
    <relativePath>../../spring-boot-dependencies</relativePath>
  </parent>

注意：这里才是真正管理SpringBoot应用里面所有依赖版本的地方，SpringBoot的版本控制中心
以后我们导入依赖默认是不需要写版本；但是如果导入的包没有在依赖中管理着就需要手动配置版本了。

1.2、启动器Spring-boot-starter

        <!--web场景启动器-->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>

spring-boot-starter-xxx:就是spring-boot的场景启动器；
spring-boot-starter-web:帮我们导入了web模块正常运行所依赖的组件；

SpringBoot将所有的功能场景都抽取出来，做成一个个的starter（启动器），只需要在项目种引入这些starter即可，所有相关的依赖都会导入进来，我们要用什么功能就导入什么样的场景启动器即可；我们未来也可以自己自定义starter。

2、主启动类

2.1、默认的主启动类：

//@SpringBootApplication 来标注一个主程序类
@SpringBootApplication
public class Springboot03WebApplication {
    public static void main(String[] args) {
        SpringApplication.run(Springboot03WebApplication.class, args);
    }
}

2.2、分析主启动类注解：@SpringBootApplication

作用：标注在某个类上说明这个类是SpringBoot的主配置类，SpringBoot就应该运行这个类的main方法来启动SpringBoot应用；进入@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 {
     /....省略......../
}

1、@Target(ElementType.TYPE)

作用：注释类型的上下文（即注解的作用目标），这里是接口、类、枚举、注解等；

2、@Retention(RetentionPolicy.RUNTIME)

作用：具有注释类型的注释要保留多长时间，这里注解是将被JVM保留，所以在运行时被JVM或其他使用了反射机制的代码所读取和使用；

3、@Documented

作用：默认情况下，带有类型的注释将由javadoc和类似工具记录；

4、@Inherited

作用：自动继承注释类型（即子类可以继承父类）。

5、@SpringBootConfiguration

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

@Configuration:说明这是一个配置类，配置类就是对应Spring的XML配置文件；
- @Component:说明启动类本身也是Spring中的一个组件而已，负责启动应用。

6、@EnableAutoConfiguration

作用：开启自动配置功能，这样自动配置才生效；以前我们需要手动配置的东西，现在SpringBoot可以自动帮我们配置；

@AutoConfigurationPackage：自动配置包
```
@Import(AutoConfigurationPackages.Registrar.class)
public @interface AutoConfigurationPackage {

}
```
1. @Import：Spring底层注解@import，给容器中导入一个组件；
2. Register.class作用：将主启动类的所在包及包下面所有子包里面的所有组件扫描到Spring容器；
@Import({AutoConfigurationImportSelector.class}) ：给容器导入组件
1. AutoConfigurationImportSelector：自动配置导入选择器，它会导入哪些组件的选择器呢？

①这个类中有一个获取候选配置的方法：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;
}

//返回的是启动自动导入配置文件的注解类：EnableAutoConfiguration
protected Class<?> getSpringFactoriesLoaderFactoryClass() {
		return EnableAutoConfiguration.class;
	}

②这个方法又调用了SpringFactoriesLoader类的静态方法：loadFactoryNames

public static List<String> loadFactoryNames(Class<?> factoryType, @Nullable ClassLoader classLoader) {
        String factoryTypeName = factoryType.getName();
        return (List)loadSpringFactories(classLoader).getOrDefault(factoryTypeName, Collections.emptyList());
}

③继续查看loadSpringFactories方法

private static Map<String, List<String>> loadSpringFactories(@Nullable ClassLoader classLoader) {
    //获得classloader，我们返回可以看到这里得到的就是EnableAutoConfiguration标注的类本身
        MultiValueMap<String, String> result = (MultiValueMap)cache.get(classLoader);
        if (result != null) {
            return result;
        } else {
            try {
                //去获取一个资源："META-INF/spring.factories"
                Enumeration<URL> urls = classLoader != null ? classLoader.getResources("META-INF/spring.factories") : ClassLoader.getSystemResources("META-INF/spring.factories");
                LinkedMultiValueMap result = new LinkedMultiValueMap();
                //将读取到的资源遍历，封装成为一个Properties
                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[] 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);
            }
        }
 }

④发现一个多次出现的文件：spring.factories,从源头打开该配置文件
发现很多自动配置的文件，这就是自动配置根源所在

⑤WebMvcAutoConfiguration

以org.springframework.boot.autoconfigure.web.servlet.WebMvcAutoConfiguration,\配置为例：

可以看到这些一个个都是JavaConfig配置类，而且都注入了一些Bean。所以自动配置真正实现的是从classpath中搜寻所有的META-INF/spring.factories配置文件，并将其中对应的org.springframework.boot.autoconfigure包下的配置项，通过反射实例化为对应标注了@Configuration注解的JavaConfig形式的IOC容器配置类，然后将这些都汇总成为一个实例并加载到IOC容器中。

7、结论：

SpringBoot在启动的时候从类路径下的META-INF/spring.factories中获取EnableAutoConfiguration指定的值；
将这些值作为自动配置类导入容器，自动配置类就生效，帮我们进行自动配置工作；
整个J2EE的整体解决方案和自动配置都在springboot-autoconfigure的jar包中；
它会给容器中导入非常多的自动配置类（xxxAutoconfiguration），就是给容器中导入这个场景需要的所有组件，并配置好这些组件。
有了自动配置类，免去了我们手动编写配置注入功能组件等的工作。

2.3、分析主启动类：SpringApplication

2.3.1、主启动类开启一个服务

//@SpringBootApplication 来标注一个主程序类
@SpringBootApplication
public class Springboot03WebApplication {
    public static void main(String[] args) {
        SpringApplication.run(Springboot03WebApplication.class, args);
    }
}

2.3.2、SpringApplication.run分析：

分析该方法主要分为两部分：

一是SpringApplication的实例化；

二是run方法的执行。

2.3.3、SpringApplication

这个类主要做了一下四件事情：

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

查看构造器：

public SpringApplication(ResourceLoader resourceLoader, Class<?>... primarySources) {
        //.....
        this.webApplicationType = WebApplicationType.deduceFromClasspath();
        this.setInitializers(
this.getSpringFactoriesInstances(ApplicationContextInitializer.class));
        this.setListeners(this.getSpringFactoriesInstances(ApplicationListener.class));
        this.mainApplicationClass = this.deduceMainApplicationClass();
    }

run方法流程分析: