[Java知识库]【SpringBoot学习笔记 一】Spring基本概念和项目初始化

经过一段时间的学习，我们经历了JavaWeb系列、Spring系列、MyBatis系列、SpringMVC系列的学习，一路走来我们发现随着学习的深入需要配置的配置文件太多了，虽然学过一遍，但是很容易就忘记之前的详细配置还得回去翻笔记，那么今天终于进入SpringBoot的学习了，来将我们从 Spring的配置地狱中拯救出来，从这个角度而言，SpringBoot并不是什么新东西，不过是一个最佳实践或者一个开箱即用的最佳工具箱。那为啥还要学习呢，因为真正的生产工程开发还是趋向于使用这个最佳实践，毕竟我们不想在生产环境因为配置原因导致各种问题。

SpringBoot基本概念

SpringBoot是什么？要想回答这个问题，我们再回顾下Spring是什么？Spring是为了解决企业级应用开发的复杂性而创建的，简化开发为了降低Java开发的复杂性，Spring采用了以下4种关键策略：

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

但是随着功能的丰富，Spring需要维护的配置太多了，极易出错。这个时候SpringBoot横空出世。SpringBoot 具有 Spring 一切优秀特性，Spring 能做的事，Spring Boot 都可以做，而且使用更加简单，功能更加丰富，性能更加稳定而健壮。

SpringBoot本质

什么是SpringBoot呢，其实本质上就是一个JavaWeb的开发框架，和SpringMVC类似，对比其他JavaWeb框架的好处：简化开发，约定大于配置，能迅速的开发web应用，几行代码开发一个http接口。

所有的技术框架的发展似乎都遵循了一条主线规律：

1. 从一个复杂应用场景 衍生 一种规范框架，人们只需要进行各种配置而不需要自己去实现它，这时候强大的配置功能成了优点；
2. 发展到一定程度之后，人们根据实际生产应用情况，选取其中实用功能和设计精华，重构出一些轻量级的框架；
3. 之后为了提高开发效率，嫌弃原先的各类配置过于麻烦，于是开始提倡“约定大于配置”，进而衍生出一些一站式的解决方案

这就是Java企业级应用：J2EE->SSH->SSM->SpringBoot的发展历程，Spring Boot 以约定大于配置的核心思想，默认帮我们进行了很多设置，多数 Spring Boot 应用只需要很少的 Spring 配置。同时它集成了大量常用的第三方库配置（例如 Redis、MongoDB、Jpa、RabbitMQ、Quartz 等等），Spring Boot 应用中这些第三方库几乎可以零配置的开箱即用

简单来说就是SpringBoot其实不是什么新的框架，它默认配置了很多框架的使用方式，就像Maven整合了所有的JAR包，SpringBoot整合了所有的框架

SpringBoot优势

那么基于核心的约定大于配置这一核心思想，SpringBoot的主要优点有哪些呢？Spring Boot 具有以下特点：

1. 独立运行的 Spring 项目，Spring Boot 可以以 jar 包的形式独立运行，Spring Boot 项目只需通过命令“java–jar xx.jar 即可运行。
2. 内嵌 Servlet 容器，Spring Boot 使用嵌入式的 Servlet 容器（例如 Tomcat、Jetty 或者 Undertow 等），应用无需打成 WAR 包 。
3. 提供 starter 简化 Maven 配置，Spring Boot 提供了一系列的“starter”项目对象模型POMS来简化 Maven 配置。
4. 提供了大量的自动配置，Spring Boot 提供了大量的默认自动配置，来简化项目的开发，开发人员也通过配置文件修改默认配置。
5. 自带应用监控，Spring Boot 可以对正在运行的项目提供监控。
6. 无代码生成和 xml 配置，Spring Boot 不需要任何 xml 配置即可实现 Spring 的所有配置。

有了这些优势，我们开发Web程序的时候定可以事半功倍，用最小的配置完成最强大的功能。

构建第一个SpringBoot程序

创建SpringBoot项目的方式有很多，我们选择最为简便的方式，就是通过IDEA进行SpringBoot初始化构建。IntelliJ IDEA 支持用户使用 Spring 项目创建向导（Spring Initializr ）快速地创建一个 Spring Boot 项目，步骤如下。

1 初始化SpringBoot程序

在新建工程界面左侧，选择 Spring Initializr，选择项目的 SDK 为 1.8，选择 starter service URL 为 http://start.spring.io（默认）

IDEA 会连接网络，并根据 starter service URL 查询 Spring Boot 的当前可用版本和组件列表，查询出来后即可进行选择，选择 Spring Boot 的版本及所依赖的 Spring Boot 组件（例如 Spring Boot 的版本为 2.4.5， Spring Boot 组件为 Web和Lombok）

2 SpringBoot项目布局

初始化后打开项目，项目的分区布局如下：

项目初始化后整体包含如下四部分：

• 程序的主启动类：SpringbootApplication，是程序的启动入口
• 一个配置文件：application.properties ，管理相关配置信息
• 一个测试类：SpringbootApplicationTests，用来进行项目测试
• 一个Maven的坐标文件： pom.xml，项目的相关依赖坐标

这个时候我们可以创建controller文件进行请求测试。

2 创建Controller

在如下位置我们创建前端的中心控制器，在项目中的位置如下：

在控制器中我们写一个HelloSpringController进行启动测试；

package com.example.springboot.controller;

import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.ResponseBody;

/**
 * * @Name HelloSpringController
 * * @Description
 * * @author tianmaolin
 * * @Data 2021/9/22
 */
@Controller
public class HelloSpringController {
    @ResponseBody
    @RequestMapping("/hello")
    public String hello() {
        return "Hello TML First SpringBoot!";
    }
}

3 启动Tomcat进行测试

Spring Boot 内部集成了 Tomcat，不需要人为手动配置 Tomcat，开发者只需要关注具体的业务逻辑即可，我们可以看到相关的集成服务器：

我们之间启动项目即可，启动后控制台打印出如下信息：

项目启动后我们从浏览器进行请求测试，可以看到打印内容如下：

总体来看SpringBoot启动和运行相当简单，基本就是傻瓜式操作。

SpringBoot Starter

接下来我们分下为什么SpringBoot可以简化如此多的配置还能实现如此强的功能，这就需要分析下初始化项目时默认生产的这些文件了。首先我们来看下Maven的坐标配置文件，看看坐标配置文件中依靠哪些依赖SpringBoot实现功能。

<?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.4</version>
        <relativePath/> <!-- lookup parent from repository -->
    </parent>
    <groupId>com.example</groupId>
    <artifactId>springboot</artifactId>
    <version>0.0.1-SNAPSHOT</version>
    <name>springboot</name>
    <description>Demo project for Spring Boot</description>
    <properties>
        <java.version>1.8</java.version>
    </properties>
    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>

        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <optional>true</optional>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
        </dependency>
    </dependencies>

    <build>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
                <configuration>
                    <excludes>
                        <exclude>
                            <groupId>org.projectlombok</groupId>
                            <artifactId>lombok</artifactId>
                        </exclude>
                    </excludes>
                </configuration>
            </plugin>
        </plugins>
    </build>

</project>

首先了解一个概念：SpringBoot场景启动器。Spring Boot 将日常企业应用研发中的各种场景都抽取出来，做成一个个的 starter（启动器），starter 中整合了该场景下各种可能用到的依赖，用户只需要在 Maven 中引入 starter 依赖，SpringBoot 就能自动扫描到要加载的信息并启动相应的默认配置。starter 提供了大量的自动配置，让用户摆脱了处理各种依赖和配置的困扰。所有这些 starter 都遵循着约定成俗的默认配置，并允许用户调整这些配置，即遵循“约定大于配置”的原则。

SpringBoot场景启动器Starter

还记得我们在项目初建的时候选择了一个web模块，那么自然Spring会给我们开启一个Web的场景启动器Starter：

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

默认的SpringBoot中自带测试项目，所以依赖中也会引入测试相关的场景启动器Starter：

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

我们随机点进去web模块的artifactId，可以看到这个场景启动器实际包含的依赖列表如下：

 <dependencies>
    <dependency>
      <groupId>org.springframework.boot</groupId>
      <artifactId>spring-boot-starter</artifactId>
      <version>2.5.4</version>
      <scope>compile</scope>
    </dependency>
    <dependency>
      <groupId>org.springframework.boot</groupId>
      <artifactId>spring-boot-starter-json</artifactId>
      <version>2.5.4</version>
      <scope>compile</scope>
    </dependency>
    <dependency>
      <groupId>org.springframework.boot</groupId>
      <artifactId>spring-boot-starter-tomcat</artifactId>
      <version>2.5.4</version>
      <scope>compile</scope>
    </dependency>
    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-web</artifactId>
      <version>5.3.9</version>
      <scope>compile</scope>
    </dependency>
    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-webmvc</artifactId>
      <version>5.3.9</version>
      <scope>compile</scope>
    </dependency>
  </dependencies>

可以看的出这个场景启动器下还包含别的场景启动器，把我们SpringMVC用到的依赖，例如Jackson、spring-webmvc、spring-web甚至tomcat等web模块需要的依赖都引入了进来，也就是一个web模块的场景启动器即满足我们的所有需要。当然并不是所有的 starter 都是由 Spring Boot 官方提供的，也有部分 starter 是第三方技术厂商提供的，我们甚至也可以作为starter提供者，提供自定义的starter。

spring-boot-starter-parent

虽然在pom.xml中使用了场景启动器可以帮我们解决依赖汇总的问题，但是我们发现一个问题，即在以上 pom.xml 的配置中，引入依赖 spring-boot-starter-web 时，并没有指明其版本（version），但是实际查看其依赖信息却能看到一些依赖的版本信息，那么这些版本信息是在哪里控制的呢？这些版本信息是由 spring-boot-starter-parent（版本仲裁中心） 统一控制的spring-boot-starter-parent 是所有 Spring Boot 项目的父级依赖，它被称为 Spring Boot 的版本仲裁中心，可以对项目内的部分常用依赖进行统一管理

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

Spring Boot 项目可以通过继承 spring-boot-starter-parent 来获得一些合理的默认配置，它主要提供了以下特性：

• 默认 JDK 版本（Java 8）
• 默认字符集（UTF-8）
• 依赖管理功能
• 资源过滤
• 默认插件配置
• 识别 application.properties 和 application.yml 类型的配置文件

查看 spring-boot-starter- parent 的底层代码，可以发现其有一个父级依赖 spring-boot-dependencies

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

spring-boot-dependencies 的底层代码如下

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">

    <modelVersion>4.0.0</modelVersion>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-dependencies</artifactId>
    <version>2.4.5</version>
    <packaging>pom</packaging>
    ....
    <properties>
        <activemq.version>5.16.1</activemq.version>
        <antlr2.version>2.7.7</antlr2.version>
        <appengine-sdk.version>1.9.88</appengine-sdk.version>
        <artemis.version>2.15.0</artemis.version>
        <aspectj.version>1.9.6</aspectj.version>
        <assertj.version>3.18.1</assertj.version>
        <atomikos.version>4.0.6</atomikos.version>
        ....
    </properties>

    <dependencyManagement>
        <dependencies>
            <dependency>
                <groupId>org.apache.activemq</groupId>
                <artifactId>activemq-amqp</artifactId>
                <version>${activemq.version}</version>
            </dependency>
            <dependency>
                <groupId>org.apache.activemq</groupId>
                <artifactId>activemq-blueprint</artifactId>
                <version>${activemq.version}</version>
            </dependency>
            ...
        </dependencies>
    </dependencyManagement>

    <build>
        <pluginManagement>
            <plugins>
                <plugin>
                    <groupId>org.codehaus.mojo</groupId>
                    <artifactId>build-helper-maven-plugin</artifactId>
                    <version>${build-helper-maven-plugin.version}</version>
                </plugin>
                <plugin>
                    <groupId>org.flywaydb</groupId>
                    <artifactId>flyway-maven-plugin</artifactId>
                    <version>${flyway.version}</version>
                </plugin>
                ...
            </plugins>
        </pluginManagement>
    </build>
</project>

上面的配置节点中：dependencyManagement 负责管理依赖；pluginManagement负责管理插件；properties负责定义依赖或插件的版本号。spring-boot-dependencies 通过 dependencyManagement 、pluginManagement 和 properties 等元素对一些常用技术框架的依赖或插件进行了统一版本管理，例如在依赖里我们就能找到一些启动器的对应版本：

      <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-validation</artifactId>
        <version>2.5.4</version>
      </dependency>
      <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-web</artifactId>
        <version>2.5.4</version>
      </dependency>
      <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-webflux</artifactId>
        <version>2.5.4</version>
      </dependency>

总结一下

本篇Blog算是一个SpringBoot的入门吧，其实SpringBoot并不神秘，实际上可以看做一个最佳实践，这个最佳实践依据使用场景给我们整合了所有需要用到的依赖，并且经过依赖管理和验证，让我们在生产环境中通过最佳实践去写代码，大大简化了配置、减少了出错概率、能把我们从繁杂的ssm框架配置中解脱出来使我们专注于业务逻辑，想想之前要实现一个Web项目得一个依赖一个依赖加，用什么加什么那是相当麻烦，有了SpringBoot打包都给你，多方便啊，这个场景启动器Starter真是好东西啊，不过还是那句话，如果不知道历史沿革J2EE->SSH->SSM->SpringBoot，你就不知道为什么我们要这么用，需求是怎么产生的，理解起来也会容易不深刻不彻底，感受不到SpringBoot的美妙。