SpringBoot【一】入门程序及原理分析

入门程序

入门程序编写步骤

1、创建基础项目

Spring 官方提供了非常方便的工具（快速生成的网站）让我们快速构建应用，IDEA 中也集成了这个网站。

Spring Initializr：https://start.spring.io/

创建方式一：使用 Spring Initializr 的 Web 页面创建项目，下载并导入 IDEA 开发

1. 打开 https://start.spring.io，填写项目信息
2. 点击 ”Generate Project“ 按钮生成项目，下载此项目
3. 解压项目包，并用 IDEA 以 Maven 项目导入

创建方式二：使用 IDEA 直接创建项目【一般开发使用】

1. 创建一个新项目，选择 spring initalizr， 可以看到默认就是去官网的快速构建工具那里实现
2. 填写项目信息、项目路径
3. 选择初始化的组件（初学勾选 Web 即可）
4. 等待项目构建成功

项目结构分析：

基础项目的创建后会自动生成以下文件：

1. 程序的主启动类
2. 一个 application.properties 配置文件
3. 一个 测试类
4. 一个 pom.xml

pom.xml 分析：

<!-- 父依赖 -->
<parent>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-parent</artifactId>
    <version>2.3.1.RELEASE</version>
    <relativePath/> 
</parent>

<dependencies>
    <!-- web场景启动器 -->
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-web</artifactId>
    </dependency>
    <!-- springboot单元测试 -->
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-test</artifactId>
        <scope>test</scope>
        <!-- 剔除依赖 -->
        <exclusions>
            <exclusion>
                <groupId>org.junit.vintage</groupId>
                <artifactId>junit-vintage-engine</artifactId>
            </exclusion>
        </exclusions>
    </dependency>
</dependencies>

<build>
    <plugins>
        <!-- 打包插件 -->
        <plugin>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-maven-plugin</artifactId>
        </plugin>
    </plugins>
</build>

2、编写一个http接口

1. 在主程序【Springboot01HelloworldApplication.class】的同级目录下，新建一个 controller 包

   注意：一定要在同级目录下，否则识别不到

2. 在包中新建一个 HelloController 类

   @Controller
   @RequestMapping("/hello")
   public class HelloController {
   
       @RequestMapping("/hello")
       @ResponseBody
       public String hello(){
           return "hello";
       }
   }
   

3. 编写完毕后，从主程序启动项目，浏览器发起请求 localhost:8080/hello/hello

4. 结果：浏览器页面显示 hello

3、打成 jar 包

点击 maven 的 package 可以将项目打成 jar 包，打包成功会在 target 目录下生成一个 jar 包，可以在任何地方运行。

如果打包时出错，可以配置打包时跳过项目运行测试用例

<!--
    在工作中,很多情况下我们打包是不想执行测试用例的
    可能是测试用例不完事,或是测试用例会影响数据库数据
    跳过测试用例执行
-->
<plugin>
    <groupId>org.apache.maven.plugins</groupId>
    <artifactId>maven-surefire-plugin</artifactId>
    <configuration>
        <!--跳过项目运行测试用例-->
        <skipTests>true</skipTests>
    </configuration>
</plugin>

如何更改启动时显示的字符拼成的字母 SpringBoot，也就是 banner 图案？

在项目下的 resources 目录下新建一个 banner.txt 即可。图案可以到：https://www.bootschool.net/ascii 这个网站生成，然后拷贝到文件中。

程序运行原理

1、pom.xml

• 父依赖（核心依赖在父工程中）

  从文件中看到它主要是依赖一个父项目，主要是管理项目的资源过滤及插件。

  <parent>
     <groupId>org.springframework.boot</groupId>
     <artifactId>spring-boot-starter-parent</artifactId>
     <version>2.3.1.RELEASE</version>
     <relativePath/> 
  </parent>
  

  点进 spring-boot-starter-parent，发现还有一个父依赖 spring-boot-dependencies，这里是真正管理 SpringBoot 应用里面所有依赖版本的地方，即 SpringBoot 的版本控制中心（仓库），所以以后导入依赖默认是不需要写版本；但是如果导入的包没有在依赖中管理着就需要手动配置版本。

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

• 启动器

  spring-boot-starter-xxx：SpringBoot 的场景启动器，比如 spring-boot-starter-web 帮我们自动导入 web 模块正常运行所依赖的组件。

  SpringBoot 会将所有的功能场景都抽取出来，变成一个个的启动器（starter），如果要使用什么功能，只需要导入对应的启动器（starter）即可，所有相关的依赖都会导入进来。未来也可以自己自定义 starter。

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

2、主启动类

• 默认的主程序

  // @SpringBootApplication：来标注一个主程序类，说明这是一个springboot的应用，启动类下的所有资源被导入
  @SpringBootApplication
  public class Springboot01HelloworldApplication {
  
     public static void main(String[] args) {
        // 将 springboot 启动，启动了一个服务
        SpringApplication.run(Springboot01HelloworldApplication.class, args);
     }
  }
  

• 注解

  @SpringBootApplication：标注在某个类上说明这个类是 SpringBoot 的主配置类 ， SpringBoot 就应该运行这个类的 main 方法来启动 SpringBoot 应用。进入这个注解，可以看到上面还有很多其他注解：

  @SpringBootConfiguration
  @EnableAutoConfiguration
  @ComponentScan(
      excludeFilters = {@Filter(
      type = FilterType.CUSTOM,
      classes = {TypeExcludeFilter.class}
  ), @Filter(
      type = FilterType.CUSTOM,
      classes = {AutoConfigurationExcludeFilter.class}
  )}
  )
  public @interface SpringBootApplication {
      // ......
  }
  

  1. @ComponentScan(...)：扫描当前主启动类同级的包，自动扫描并加载符合条件的组件或者bean ， 将这个bean定义加载到IOC容器中

  2. @SpringBootConfiguration：SpringBoot 的配置类 ，标注在某个类上 ， 表示这是一个SpringBoot 的配置类，继续进入查看

     @SpringBootConfiguration：springboot的配置类
         
         @Configuration：spring 配置类，对应Spring的xml 配置文件
         public @interface SpringBootConfiguration {}
     
         	@Component：说明启动类本身也是 spring 的一个组件
             public @interface Configuration {}   
     

  3. @EnableAutoConfiguration：开启自动配置功能，该注解告诉SpringBoot开启自动配置功能，这样自动配置才能生效，继续进入查看

     @EnableAutoConfiguration：自动配置（导入）
     
     	@AutoConfigurationPackage：自动配置包（注册包）
         //AutoConfigurationImportSelector ：自动配置导入选择器
     	@Import(AutoConfigurationImportSelector.class)：自动导入选择【核心】
     	public @interface EnableAutoConfiguration {...}
     		
     		//Spring底层注解@import ，给容器中导入一个组件
             //Registrar.class 作用：将主启动类的所在包及包下面所有子包里面的所有组件扫描到Spring容器
     		@Import(AutoConfigurationPackages.Registrar.class)：自动配置 包注册
     		public @interface AutoConfigurationPackage {
     		
     

     • @Import(AutoConfigurationImportSelector.class)：自动配置导入选择器，会导入哪些组件的选择器呢？分析源码：

       类中 getAutoConfigurationEntry()//获得自动配置的实体 方法调用另一个方法：getCandidateConfigurations()

       //获取候选的配置
       protected List<String> getCandidateConfigurations(AnnotationMetadata metadata, AnnotationAttributes attributes) {
           //这里的getSpringFactoriesLoaderFactoryClass（）方法
           //返回的就是我们最开始的启动自动导入配置文件的注解类：EnableAutoConfiguration
       	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;
           //标注了EnableAutoConfiguration注解的类
       }
       

       该方法中又调用了 SpringFactoriesLoader 类的静态方法 loadFactoryNames()，进入这个静态方法 loadFactoryNames()

       // 获取所有的加载配置
       public static List<String> loadFactoryNames(Class<?> factoryType, @Nullable ClassLoader classLoader) {
           String factoryTypeName = factoryType.getName();
           //这里它又调用了 loadSpringFactories 方法
           return (List)loadSpringFactories(classLoader).getOrDefault(factoryTypeName, Collections.emptyList());
       }
       

       进入 loadSpringFactories() 方法

       private static Map<String, List<String>> loadSpringFactories(@Nullable ClassLoader classLoader) {
           //获得classLoader，我们返回可以看到这里得到的就是 EnableAutoConfiguration 标注的类本身
           ...
           //去获取一个资源 "META-INF/spring.factories"
           Enumeration<URL> urls = classLoader != null ? classLoader.getResources("META-INF/spring.factories") : ClassLoader.getSystemResources("META-INF/spring.factories");    
           ...
           URL url = (URL)urls.nextElement();
           UrlResource resource = new UrlResource(url);
           Properties properties = PropertiesLoaderUtils.loadProperties(resource);
           ...
       }
       /*
       项目资源：classLoader.getResources("META-INF/spring.factories")
       系统资源：ClassLoader.getSystemResources("META-INF/spring.factories")
           从这些资源中遍历了所有的 nextElement（自动配置），遍历完成之后，封装为properties供我们使用
       	Properties properties = PropertiesLoaderUtils.loadProperties(resource);
       	所有资源都加载到配置类中
       */
       

       发现一个多次出现的文件：spring.factories

• META-INF/spring.factories

  自动配置的核心文件，所有的自动配置类都在这里了，这就是自动配置根源所在。

  文件位置：spring-boot-autoconfigure-2.3.1.RELEASE.jar/META-INF/spring.factories

  这些自动配置类都是 JavaConfig 配置类，而且都注入了一些 Bean。

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

  问题：这么多自动配置为什么没有生效，需要导入对应的 start 才能有作用？

  原因：这些自动配置类上都有核心注解 @ConditionOnXXX ，如果这里的条件都满足，该类才会生效。

  总结：SpringBoot 所有的自动配置都是在启动的时候扫描并加载，spring.factories 所有的自动配置类都在这里，但是不一定生效，要判断条件是否成立，只要导入了对应的 start，就有对应的启动器了，有了启动器，自动装配就可以生效，然后就配置成功。

结论：

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

3、SpringApplication

不只是运行了一个 main 方法，而是开启了一个服务

@SpringBootApplication
public class Springboot01HelloworldApplication {

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

• SpringApplication 类

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

  1. 推断应用的类型是普通的项目还是 Web 项目

  2. 查找并加载所有可用初始化器 ， 设置到 initializers 属性中

  3. 找出所有的应用程序监听器，设置到 listeners 属性中

  4. 推断并设置 main 方法的定义类，找到运行的主类