五、Spring Boot（1）

一、回顾 Spring

1.1 什么是 Spring

• Spring是一个开源框架，2003 年兴起的一个轻量级的Java 开发框架，作者：Rod Johnson 。
• Spring是为了解决企业级应用开发的复杂性而创建的，简化开发。

1.2 Spring 是如何简化 Java 开发的

为了降低 Java 开发的复杂性，Spring 采用了以下4种关键策略：

1. 基于POJO的轻量级和最小侵入性编程，所有东西都是bean；
2. 通过IOC，依赖注入（DI）和面向接口实现松耦合
3. 基于切面（AOP）和惯例进行声明式编程；
4. 通过切面和模版减少样式代码，RedisTemplate，xxxTemplate；

二、 SpringBoot 概述

SpringBoot 官网

2.1 什么是SpringBoot

• 学过javaweb的同学就知道，开发一个web应用，从最初开始接触Servlet结合Tomcat, 跑出一个Hello Wolrld程序，是要经历特别多的步骤；后来就用了框架Struts，再后来是SpringMVC，到了现在的SpringBoot，过一两年又会有其他web框架出现；你们有经历过框架不断的演进，然后自己开发项目所有的技术也在不断的变化、改造吗？建议都可以去经历一遍；

• 言归正传，什么是SpringBoot呢，就是一个javaweb的开发框架，和SpringMVC类似，对比其他javaweb框架的好处，官方说是简化开发，约定大于配置， you can "just run"，能迅速的开发web应用，几行代码开发一个http接口。

• 所有的技术框架的发展似乎都遵循了一条主线规律：从一个复杂应用场景 衍生 一种规范框架，人们只需要进行各种配置而不需要自己去实现它，这时候强大的配置功能成了优点；发展到一定程度之后，人们根据实际生产应用情况，选取其中实用功能和设计精华，重构出一些轻量级的框架；之后为了提高开发效率，嫌弃原先的各类配置过于麻烦，于是开始提倡“约定大于配置”，进而衍生出一些一站式的解决方案。
• 是的这就是Java企业级应用->J2EE->spring->springboot的过程。
• 随着 Spring 不断的发展，涉及的领域越来越多，项目整合开发需要配合各种各样的文件，慢慢变得不那么易用简单，违背了最初的理念，甚至人称配置地狱。Spring Boot 正是在这样的一个背景下被抽象出来的开发框架，目的为了让大家更容易的使用 Spring 、更容易的集成各种常用的中间件、开源软件；
• Spring Boot 基于 Spring 开发，Spirng Boot 本身并不提供 Spring 框架的核心特性以及扩展功能，只是用于快速、敏捷地开发新一代基于 Spring 框架的应用程序。也就是说，它并不是用来替代 Spring 的解决方案，而是和 Spring 框架紧密结合用于提升 Spring 开发者体验的工具。Spring Boot 以约定大于配置的核心思想，默认帮我们进行了很多设置，多数 Spring Boot 应用只需要很少的 Spring 配置。同时它集成了大量常用的第三方库配置（例如 Redis、MongoDB、Jpa、RabbitMQ、Quartz 等等），Spring Boot 应用中这些第三方库几乎可以零配置的开箱即用。
• 简单来说就是SpringBoot其实不是什么新的框架，它默认配置了很多框架的使用方式，就像maven整合了所有的jar包，spring boot整合了所有的框架 。
• Spring Boot 出生名门，从一开始就站在一个比较高的起点，又经过这几年的发展，生态足够完善，Spring Boot 已经当之无愧成为 Java 领域最热门的技术。

2.2 SpringBoot 主要的优点

1. 为所有的开发者入门
2. 开箱即用，提供各种默认配置来简化项目配置
3. 内嵌式容器化web项目
4. 没有冗余代码生成和XML配置的要求

真的很爽，我们快速去体验开发个接口的感觉吧！

三、 SpringBoot 入门体验

3.1 准备工作

现在学习将如何快速的创建一个Spring Boot应用，并且实现一个简单的Http请求处理。通过这个例子对Spring Boot有一个初步的了解，并体验其结构简单、开发快速的特性。

1. 现在的环境准备：

• java version “1.8.0_181”
• Maven-3.6.1
• SpringBoot 2.x 最新版

2. 开发工具：

• IDEA

3.2 创建基础项目说明

• Spring官方提供了非常方便的工具让我们快速应用
• Spring Initializr：

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

1. 打开👉🏾👉🏾 官网 Spring Initializr
2. 填写项目信息
3. 点击 “Generate Project” 按钮生成项目；下载此项目
4. 解压项目包，并用 IDEA以Maven项目导入，一路下一步即可，直到项目导入完毕。
5. 如果是第一次使用，可能速度会比较慢，包比较多、需要耐心等待一切就绪。

上面⑦的选择可以参考下面 👇🏾

注：配好 maven

构建导入成功，删除一些初始化生成的，如下：

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

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

构建导入成功，删除一些初始化生成的，如下：

随便启动上面两项目任意一项目：

浏览器访问：http://localhost:8080/error

3. 项目结构分析

通过上面步骤完成了基础项目的创建。就会自动生成一下文件。

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

3.3 pom.xml 分析

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

<parent>
    <groupId>org.springframework.bootgroupId>
    <artifactId>spring-boot-starter-parentartifactId>
    <version>2.2.5.RELEASEversion>
    <relativePath/>
parent>

<dependencies>
    
    <dependency>
        <groupId>org.springframework.bootgroupId>
        <artifactId>spring-boot-starter-webartifactId>
    dependency>
    
    <dependency>
        <groupId>org.springframework.bootgroupId>
        <artifactId>spring-boot-starter-testartifactId>
        <scope>testscope>
        
        <exclusions>
            <exclusion>
                <groupId>org.junit.vintagegroupId>
                <artifactId>junit-vintage-engineartifactId>
            exclusion>
        exclusions>
    dependency>
dependencies>

<build>
    <plugins>
        
        <plugin>
            <groupId>org.springframework.bootgroupId>
            <artifactId>spring-boot-maven-pluginartifactId>
        plugin>
    plugins>
build>
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39

3.4 编写一个http接口

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

创建一个测试：

package com.zql.hello_world.controller;

import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

/**
 * @Author:Daniel
 * @Version 1.0
 */

@RestController //为了返回一个字符串
public class HelloController {

    @RequestMapping("/hello")
    public String helloWorld(){

        return "My English name is Daniel!";
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

3. 编写完毕后，从主程序启动项目，浏览器发起请求，看页面返回；控制台输出了 Tomcat 访问的端口号！浏览器访问：http://localhost:8080/hello

简单几步，就完成了一个web接口的开发，SpringBoot就是这么简单。所以我们常用它来建立我们的微服务项目！

更改项目端口号：

#更改项目端口号
server.port=8081
1
2

访问就变成了：http://localhost:8081/hello

3.5 彩蛋

• 如何更改启动时显示的字符拼成的字母，SpringBoot呢？也就是 banner 图案；
• 只需一步：到项目下的 resources 目录下新建一个banner.txt 即可。

图案可以到：👉🏾👉🏾 banner 这个网站生成，然后拷贝到文件中即可！

将下载好的banner.txt 拷贝到 IDEA中SpringBoot项目中的resources下面，效果如下

四、运行原理探究

创建一个 springboot-01-helloworld 项目（不选web），无法访问，看下面的解决

解决：

只需要在 pom.xml 中加下面：即可正常访问

<dependency>
    <groupId>org.springframework.bootgroupId>
    <artifactId>spring-boot-starter-webartifactId>
dependency>
1
2
3
4

我们之前写的HelloCotroller到底是怎么运行的呢，Maven项目，我们一般从pom.xml文件探究起；

4.1 pom.xml

4.1.1 父依赖

• 其中它主要依赖一个父项目，主要是管理项目的资源过滤及插件！
• spring-boot-dependencies: 核心依赖在父工程中！
• 我们在写或者引入一些Springboot依赖的时候，不需要指定版本，就因为这些版本仓库

启动器

<dependency>
   <groupId>org.springframework.bootgroupId>
   <artifactId>spring-boot-starterartifactId>
dependency>
1
2
3
4

• 启动器：说白了就是springboot的启动场景；
  比如spring-boot-start-web,就会帮我们自动导入web环境所有的依赖1
  springboot会将所有的功能场景，都会变成一个个启动器。

<parent>
    <groupId>org.springframework.bootgroupId>
    <artifactId>spring-boot-starter-parentartifactId>
    <version>2.7.3version>
    <relativePath/> 
parent>
1
2
3
4
5
6

点击进去，发现还有一个父依赖：

<parent>
  <groupId>org.springframework.bootgroupId>
  <artifactId>spring-boot-dependenciesartifactId>
  <version>2.7.3version>
parent>
1
2
3
4
5

继续点击去👇🏾👇🏾

继续点击去👇🏾👇🏾发现这里管理的是jar 包版本

SpringBoot官网版本

这里才是真正管理SpringBoot应用里面所以依赖版本的地方，SpringBoot的版本控制中心；

以后我们导入依赖默认是不需要写版本；但是如果导入的包没有在依赖中管理着就要手动配置版本了；

4.1.2 Spring-boot-starter

<dependency>
    <groupId>org.springframework.bootgroupId>
    <artifactId>spring-boot-starter-webartifactId>
dependency>
1
2
3
4

• spring-boot-starter-xxx:就是spring-boot的场景启动器
• spring-boot-starter-web:帮我们导入了web模块正常运行所依赖的组件；
• SpringBoot将所有的功能场景都抽取出来，做成一个个的starter(启动器)，只需要在项目中引入这些starter 即可，所有相关依赖都会导入进来，我们要用什么功能就导入什么样的场景启动器即可；我们未来也可以自己自定义starter;

4.2 主启动类

分析完了pom.xml来看看这个启动类

4.2.1 默认的主启动类

package com.zql;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

//@SpringBootApplication 来标注一个主程序类
//说明这是一个Spring Boot应用
@SpringBootApplication
public class SpringbootApplication {

    public static void main(String[] args) {
        //以为是启动了一个方法，没想到启动了一个服务
        SpringApplication.run(SpringbootApplication.class, args);
    }

}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

但是**一个简单的启动类并不简单！**我们来分析一下这些注解都干了什么

4.2.2 @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
2
3
4
5
6
7
8
9
10
11
12
13
14

4.2.3 @ComponentScan

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

4.2.4 @SpringBootConfiguration

• 作用：SpringBoot的配置类，标注在某个类上，表示这是一个SpringBoot的配置类；
• 我么继续进去这个注解查看

// 点进去得到下面的 @Component
@Configuration
public @interface SpringBootConfiguration {}
//点击@Configuration进去又得到下面
@Component
public @interface Configuration {}
1
2
3
4
5
6

• 这里的 `@Configuration，说明这是一个配置类，配置类就是对应Spring的xml配置文件；
• 里面的 @Component 这就说明，启动类本身也是Spring中的一个组件而已，负责启动应用！
• 我们回到SpringBootApplication注解中继续查看。

4.2.5 @SpringBootConfiguration

• @EnableAutoConfiguration:开启自动配置功能
• 以前我们需要自己配置的东西，而现在SpringBoot可以自动帮我们配置；
• @EnableAutoConfiguration 告诉SpringBoot 开启自动配置功能，这样自动配置才能生效；
• 点进去注解继续查看：

@AutoConfigurationPackage：自动配置包

@Target({ElementType.TYPE})
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Inherited
@Import({Registrar.class})
public @interface AutoConfigurationPackage {
    String[] basePackages() default {};

    Class<?>[] basePackageClasses() default {};
}
1
2
3
4
5
6
7
8
9
10

@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;
}
1
2
3
4
5
6
7
8

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());
}
1
2
3
4
5

3. 我们继续点击查看

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);
        }
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38

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

4.2.6 spring.factories

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

WebMvcAutoConfiguration

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

WebMvcAutoConfiguration

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

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

4.2.7 自动配置原理图分析

结论：

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

1. SpringBoot在启动的时候从类路径下的META-INF/spring.factories中获取EnableAutoConfiguration指定的值;
2. 将这些值作为自动配置类导入容器 ， 自动配置类就生效 ， 帮我们进行自动配置工作；
3. 以前我们需要自己配置的东西，现在springboot帮我们做了！
4. 整合J2EE的整体解决方案和自动配置都在spring-boot-autoconfigure-2.7.3.jar这个包下；
5. 它会把所有需要导入的组件，以类名的方式返回，这些组件就会被添加到容器中；
   它会给容器中导入非常多的自动配置类 （xxxAutoConfiguration）, 就是给容器中导入这个场景需要的所有组件 ， 并配置好这些组件 ；
6. 容器中也会存在非常多的xxxAutoConfiguration的文件（@bean）,就是这些类给容器中导入了这个场景需要的所有组件，并自动配置，@Configuration,JavaConfig!
7. 有了自动配置类 ， 免去了我们手动编写配置注入功能组件等的工作；

现在大家应该大概的了解了下，SpringBoot的运行原理，后面我们还会深化一次！

4.3 SpringApplication

4.3.1 不简单的方法

我最初以为就是运行了一个main方法，没想到却开启了一个服务；

@SpringBootApplication
public class SpringbootApplication {
    public static void main(String[] args) {
        SpringApplication.run(SpringbootApplication.class, args);
    }
}
1
2
3
4
5
6

SpringApplication.run分析

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

4.3.2 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();
}
1
2
3
4
5
6
7

4.4 run方法流程分析