浅谈spring boot原理

---

SpringBoot简介

1、什么是SpringBoot

1.1 概念

1. Spring Boot 基于 Spring 开发，Spirng Boot 本身并不提供 Spring 框架的核心特性以及扩展功能，只是用于快速、敏捷地开发新一代基于 Spring 框架的应用程序。
2. Spring Boot 以约定大于配置的核心思想，默认帮我们进行了很多设置，多数 Spring Boot 应用只需要很少的 Spring 配置。
3. Spring Boot基于快速构建理念，通过约定大于配置，开箱即用的方式。
4. 简单来说就是SpringBoot其实不是什么新的框架，它默认配置了很多框架的使用方式，就像maven整合了所有的jar包，spring boot整合了所有的框架 。

1.2 优点

• 为所有Spring开发者更快的入门
• 开箱即用，提供各种默认配置来简化项目配置
• 内嵌式容器简化Web项目
• 没有冗余代码生成和XML配置的要求

1.3 核心特性

SpringBoot 框架诞生后，之所以能得到软件开发行业的高度认可，自然离不开它提供给我们的一些关键特性，例如：

• 起步依赖(Starter Dependency)-创建项目时，会默认添加基础依赖，简化我们自己查找依赖的过程。
• 自动配置(Auto Configuration)-创建项目时，springboot工程添加的默认依赖中提供了很多默认的配置，简化了我们对资源的配置过程。
• 健康检查(Actator)-监控-springboot工程运行时，我们可以打开actuator特性，基于此特性监控spring中的bean，连接池，jvm内存等
• 嵌入式服务(Tomcat,Jetty)-springboot工程支持内嵌的web服务，可以将tomcat或jetty这样的服务直接嵌套到web依赖中，简化部署过程

2、第一个Spring Boot程序

创建基础项目的方式

2.1 spring boot项目的创建

项目创建方式一：使用Spring Initializr 的 Web页面创建项目

1、打开 https://start.spring.io/

2、填写项目信息

3、点击”Generate Project“按钮生成项目；下载此项目

4、解压项目包，并用IDEA以Maven项目导入，一路下一步即可，直到项目导入完毕。

项目创建方式二：使用 IDEA 直接创建项目

1、创建一个新项目

2、选择spring initalizr ， 可以看到默认就是去官网的快速构建工具那里实现

3、填写项目信息

4、选择初始化的组件（初学勾选 Web 即可）

5、填写项目路径

6、等待项目构建成功

2.2 pom.xml 分析

打开pom.xml，看看Spring Boot项目的依赖：

  <?xml version="1.0" encoding="UTF-8"?>
    <project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    	xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">
    	<modelVersion>4.0.0</modelVersion>
    <!--有一个父项目-->
        <parent>
    		<groupId>org.springframework.boot</groupId>
    		<artifactId>spring-boot-starter-parent</artifactId>
    		<version>2.5.3</version>
    		<relativePath/> 
    	</parent>
    	<groupId>com.zhu</groupId>
    	<artifactId>springboot-study</artifactId>
    	<version>0.0.1-SNAPSHOT</version>
    	<name>springboot-study</name>
    	<description>Demo project for Spring Boot</description>
    	<properties>
    		<java.version>1.8</java.version>
    	</properties>
    	<dependencies>
    	<!--web依赖 ：tomcat，dispatcherServlet,xml-->
    		<dependency>
    			<groupId>org.springframework.boot</groupId>
    			<artifactId>spring-boot-starter-web</artifactId>
    		</dependency>
    	<!--spring-boot-starter所有的spring boot依赖都是使用这个开头的-->
    	<!--单元测试-->
    		<dependency>
    			<groupId>org.springframework.boot</groupId>
    			<artifactId>spring-boot-starter-test</artifactId>
    			<scope>test</scope>
    		</dependency>
    	</dependencies>
    
    	<build>
    	<!--打jar包插件-->
    		<plugins>
    			<plugin>
    				<groupId>org.springframework.boot</groupId>
    				<artifactId>spring-boot-maven-plugin</artifactId>
    			</plugin>
    		</plugins>
    	</build>
    
    </project>
    

编写一个http接口

1、在主程序的同级目录下，新建一个controller包，一定要在同级目录下，否则识别不到

2、在包中新建一个HelloController类

  package com.zhu.springbootstudy.controller;
    
    import org.springframework.web.bind.annotation.RequestMapping;
    import org.springframework.web.bind.annotation.RestController;
    
    @RestController
    public class helloController {
        @RequestMapping("hello")
        public String hello(){
            return "Hello SpringBoot";
        }
    }

3、在主程序启动项目，浏览器发起请求，看页面返回。

将项目打成jar包，点击 maven的 package

配置打包时 跳过项目运行测试用例

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

如果打包成功，则会在target目录下生成一个 jar 包

2.3 更改启动时的字符图案

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

1. 只需一步：到项目下的 resources 目录下新建一个banner.txt 即可。

2. 图案可以到：https://www.bootschool.net/ascii 这个网站生成，然后拷贝到文件中即可！

3、原理初探

自动配置：

3.1 父依赖

pom.xml

• spring-boot-dependencies:核心依赖在父工程中
• 我们在写或者引入一些Springboot依赖的时候，不需要指定版本，就因为有这些版本仓库

3.2 启动器

启动器

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

• 启动器:说白了就是Springboot的启动场景;
• springboot-boot-starter-xxx：就是spring-boot的场景启动器
• 比如spring- boot-starter-web, 他就会帮我们自动导入web环境所有的依赖!
• springboot会将所有的功能场景，都变成一个个的启动器
• 我们要使用什么功能，就只需要找到对应的启动器就可以了starter

3.3 主启动类

主启动类

默认的主启动类

 //@SpringBootApplication 来标注一个主程序类
    //说明这是一个Spring Boot应用
    @SpringBootApplication
    public class SpringbootApplication {
       public static void main(String[] args) {
         //以为是启动了一个方法，没想到启动了一个服务
          SpringApplication.run(SpringbootApplication.class, args);
       }
    }

启动并运行项目
找到SpringBoot 工程中由@SpringBootApplication注解描述的类为然后启动运行，其启动过程如下

在启动过程中底层做了哪些事情，大致描述如下：
第一：基于配置加载类(通过ClassLoader将指定位置的类通过线程调用IO从磁盘读取到内存)。
第二：对类进行分析(创建字节码对象-Class类型,通过反射获取器配置信息)。
第三：对于指定配置(例如由spring特定注解描述)的对象存储其配置信息(借助BeanDefinition对象存储)。
第四：基于BeanDefinition对象中class的配置构建类的实例(Bean对象),并进行bean对象的管理(可能会存储到bean池)。

3.4 @SpringBootApplication

@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 {
    // ......
}

3.5 @ComponentScan

@ComponentScan

这个注解在Spring中很重要 ,它对应XML配置中的元素。

作用：自动扫描【当前主启动类同级的包】并加载符合条件的组件或者bean ， 将这个bean定义加载到IOC容器中

3.6 @SpringBootConfiguration

@SpringBootConfiguration

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

我们继续进去这个注解查看

	// 点进去得到下面的 @Component
	@Configuration
	public @interface SpringBootConfiguration {}
	@Component
	public @interface Configuration {}

1. @Component 注解描述的类，表示此类交给Spring框架管理。
2. 这里的@Configuration，说明这是一个配置类 ，配置类就是对应Spring的xml 配置文件；
3. 里面的 @Component 这就说明，启动类本身也是Spring中的一个组件而已，负责启动应用！

我们回到 SpringBootApplication 注解中继续看。

3.7 @EnableAutoConfiguration

@EnableAutoConfiguration ：开启自动配置功能

以前我们需要自己配置的东西，而现在SpringBoot可以自动帮我们配置 ；@EnableAutoConfiguration告诉SpringBoot开启自动配置功能，这样自动配置才能生效；

点进注解继续查看：

@AutoConfigurationPackage：自动配置包

   @Import({Registrar.class})
   public @interface AutoConfigurationPackage {}

@import ：Spring底层注解@import ， 给容器中导入一个组件

Registrar.class 作用：将主启动类的所在包及包下面所有子包里面的所有组件扫描到Spring容器 ；

这个分析完了，退到上一步，继续看

@Import({AutoConfigurationImportSelector.class}) ：给容器导入组件 ；

AutoConfigurationImportSelector ：自动配置导入选择器，那么它会导入哪些组件的选择器呢？我们点击去这个类看源码：

1、这个类中有一个这样的方法

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

2、这个方法又调用了 SpringFactoriesLoader类的静态方法！我们进入SpringFactoriesLoader类loadFactoryNames() 方法

  public static List<String> loadFactoryNames(Class<?> factoryClass, @Nullable ClassLoader classLoader) 
  {    
	  String factoryClassName = factoryClass.getName();    //这里它又调用了 loadSpringFactories 方法    
	  return (List)loadSpringFactories(classLoader).getOrDefault(factoryClassName, Collections.emptyList());
  }

3、我们继续点击查看 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 factoryClassName = ((String)entry.getKey()).trim();
                    String[] var9 = StringUtils.commaDelimitedListToStringArray((String)entry.getValue());
                    int var10 = var9.length;

                    for(int var11 = 0; var11 < var10; ++var11) {
                        String factoryName = var9[var11];
                        result.add(factoryClassName, factoryName.trim());
                    }
                }
            }
            cache.put(classLoader, result);
            return result;
        } catch (IOException var13) {
            throw new IllegalArgumentException("Unable to load factories from location [META-INF/spring.factories]", var13);
        }
    }
}

4、发现一个多次出现的文件：spring.factories，全局搜索它

3.8 spring.factories

我们根据源头打开spring.factories ， 看到了很多自动配置的文件；这就是自动配置根源所在！

WebMvcAutoConfiguration

我们在上面的自动配置类随便找一个打开看看，比如 ：WebMvcAutoConfiguration

可以看到这些一个个的都是JavaConfig配置类，而且都注入了一些Bean，可以找一些自己认识的类，看着熟悉一下！

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

3.9 结论

• SpringBoot 所有的自动配置都是在启动的时候扫描并加载的
• 自动配置真正实现
  • 从classpath中搜寻所有的META-INF/spring.factories配置文件
  • 并将其中对应的 org.springframework.boot.autoconfigure. 包下的配置项，通过反射实例化为对应标注了 @Configuration的JavaConfig形式的IOC容器配置类
  • 然后将这些都汇总成为一个实例并加载到IOC容器中
  • 不过有部分配置类不会一开始就自动加载，只有满足 @ConditionalOnXXX(xxxx) 中的条件才会生效—— 导入对应的 start 启动器

10、图解

3.10 SpringApplication

不简单的方法

   @SpringBootApplication
    public class SpringbootApplication {
        public static void main(String[] args) {
            SpringApplication.run(SpringbootApplication.class, args);
        }
    }

SpringApplication.run分析

分析该方法主要分两部分，一部分是SpringApplication的实例化，二是run方法的执行；

SpringApplication

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

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

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

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

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

查看构造器：

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

run方法流程分析