史上最全-SpringBoot基础入门-重学SpringBoot吧！！！

1.SpringBoot基本介绍

1.1自动化配置

        为什么我们要抛弃SSM，SSH原始的方式，使用SpringBoot替代掉他们呢？

        最主要的原因就是SpringBoot是一个自动化配置框架，主要是可以自动化配置集成的框架，无需自己再去手动配置这些框架的依赖了，大幅度增加了开发的效率。

1.2核心思想：约定>配置

        SpringBoot的核心思想就是：约定大于配置。

        约定是什么呢？

        约定就是SpringBoot已经准备好了很多技术相关的依赖的配置了，无需程序员再去自主配置。

        即SpringBoot中已经准备好了相关依赖的默认配置了，程序员只需要配置这些依赖以外的配置即可，程序员如果对SpringBoot的约定不满意，感觉SpringBoot当前约定的依赖版本不满足于开发的要求，可以自行去配置SpringBoot的版本依赖，如果对于SpringBoot约定的依赖配置不满意，也可以自己定义依赖的配置。

1.3组件关系

        搭建一个简单的SpringBoot空壳子系统，可以通过Maven的依赖体系查看工具查看SpringBoot整体的依赖的关系。

        SpringBoot项目中最重要的依赖：

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

        查看spring-boot-starter-web依赖中的继承关系：

        可以看到spring-boot中集成了spring-mvc的依赖，spring-mvc中集成了spring的依赖。

        并且其实在spring-clond中也集成了spring-boot的依赖，没有spring-boot的依赖，spring-clond是肯定无法运行的。

        所以整体组件关系是：

2.SpringBoot基本特性        

2.1独立运行

        SpringBoot的诞生改变了整个Java项目部署的格局。

        原始Java项目部署需要将编写的JavaEE项目打包为War包，部署在实现了Servlet标准的Web容器中（例如Tomcat，Jetty），才可以正常运行。

        但是SpringBoot将大局转变了，SpringBoot将常见的Web容器集成到了框架中（例如：Tomcat，Jetty等）

        只需要将SpringBoot打包为一个jar包，调用java -jar指令就可以将SpringBoot项目启动。

        要点：SpringBoot开发的项目无需打包部署在Web容器中，直接打成jar包就能使用。

2.2简化配置

        SSM框架体系的开发模式，需要自己配置大量的信息，如果不是经验比较多的工程师或者架构师，可能就无法将这些配置合理的配置好。

        但是SpringBoot提供了开箱即用的Starter一站式启动器，只要将对应技术的Starter引入，就可以大大简化相关技术的配置，直接做到开箱即用，并且SpringBoot也给我们提供了技术组件的默认底层依赖，默认配置参数等，这些都不需要我们进行配置了，直接上手使用就可以了。

        以Web开发为例，直接将spring-boot-starter-web引入之后，就可以很简单的完成WEB层的开发，快速集成Spring和SpringMVC，无需进行任何多余配置。

        要点：SpringBoot中starter的出现，将配置极简化处理，无需操作繁杂的配置，直接开箱即用。

2.3自动配置

        传统的Spring项目需要开发人员去配置很多相关的技术组件，比如我们引入一个技术组件到项目中，需要我们自己去配置这个技术组件的相关配置。

        但是SpringBoot中的Starter可以帮我们自动配置，只要引入这个技术组件对应的Starter，就可以自动化配置技术组件。

        比如在项目中引入了Druid的依赖，并且也引入了Druid组件对应的Starter，如果项目中没有数据库连接池的配置，SpringBoot就会自动帮助我们引入默认配置。

        要点：对于SpringBoot提供Starter的技术组件，如果自己没有配置，SpringBoot就会使用默认的配置进行自动配置。对于SpringBoot没有提供Starter的技术组件，第三方也会提供自己编写的starter进行使用。

2.4无代码生成和无需XML配置

        SpringBoot的自动化配置并不是依赖的代码生成，也不需要XML配置，而是SpringBoot内部核心代码的扫描检测配置的。

2.5各种生产级特性

        SpringBoot提供对项目的监控能力，可以做到生产级别的监控处理。

3.SpringBoot核心模块

        与Spring框架一样，SpringBoot也是由多个子模块一起组成的，每个子模块负责不同的功能，由这些子模块·一起组成了整个SpringBoot系统。

        一般来说，SpringBoot中模块一般有下面的十大子模块：

3.1spring-boot

        spring-boot是SpringBoot框架的主模块，也是支撑起整个SpringBoot框架的核心部分。

        spring-boot子模块提供的支持：

        1.提供启动Spring项目的主类，并提供了启动方法，这个启动方法就是负责创建和刷新IOC容器上下文。

        2.提供内嵌的Servlet标准Web容器，比如：Tomcat/Jetty/Undertow等。

        3.提供一流的配置外部化支持。

        4.提供一个非常方便的Spring容器上下文初始化器，包括合理记录日志默认参数的支持。

        要点：spring-boot模块是最基础的底层模块，是基建。

3.2spring-boot-autoconfigure

        这个模块提供了常用的Java主流技术的自动配置组件，即spring-boot-autoconfigure模块可以提供自动配置化功能。

        使用其提供的@EnableAutoConfiguration注解就可以开启自动化配置功能，会根据类路径下的文件进行自动化配置。

        要点：spring-boot-autoconfigure可以提供自动化配置的能力。

3.3spring-boot-starters

        这个子模块是所有Starters启动器的基础依赖，为所有的starter提供基础的依赖，从而使得starter让基础的技术组件拥有默认配置，自动配置的能力。

        要点：spring-boot-starters为所有技术组件的starter提供基础依赖，实现自动化配置的能力。

3.4spring-boot-cli

        这个子模块提供命令行工具，是一种创建Spring应用的方式，可以借助这个模块很简单的编写并运行一个应用程序。

        要点：spring-boot-cli可以帮助很简单的编写并运行一个程序。

3.5spring-boot-actuator

        这个子模块提供了监控的能力，比如提供了健康端点，环境端点，SpringBean端点等端点，可以很好的帮助监控程序与应用程序交流。

        要点：这个子模块提供强大的监控能力。

3.6spring-boot-actuator-autoconfigure

        这个子模块可以为spring-boot-actuator监控模块提供自动化配置的能力。

        要点：自动化配置监控模块，辅助实现监控功能。

3.7spring-test

        这个模块是SpringBoot的测试模块，为应用程序提供了强大的单元测试功能，包含了单元测试需要的核心模块和注解。

        要点：为应用提供强大的单元测试能力。

3.8spring-test-autoconfigure

        这个模块可以为spring-boot-test测试模块提供自动化配置的能力。

        要点：自动化配置测试模块，辅助实现单元测试功能。

3.9spring-boot-loader

        这个模块可以将SpringBoot工程打包为一个jar包，但是一般不使用这个模块进行打包，都是使用Maven中的SpringBoot插件。

        要点：提供了将SpringBoot工程打包的功能。

3.10spring-boot-devtools

        这个模块提供了开发者工具，是一个可选的模块，且只在开发阶段生效，提供的代码修改自动重启的能力。

        要点：提供了大量的开发者工具。

4.SpringBoot版本选择

4.1版本周期

        SpringBoot官方将SpringBoot的版本定义为GA，CURRENT，SNAPSHOT，PRE。

4.1.1GA(正式版本)

        GA就是代表正式可用的版本，是面向大众的版本，是一个正式发布的版本，这种版本一旦发布之后，就不会再次修改了，即使发现了BUG，也只会在下一个版本进行更改。GA的版本是没有后缀的，但是在SpringBoot2.4及之前的版本都会有一个RELEASE的版本后缀。

        在生产环境中必须使用GA版本，从Maven中央仓库获取到的依赖都是GA版本。

4.1.2CURRENT(最新正式版本)

        CURRENT是最新正式版本，每一次最新的GA正式版本发布时，都会携带CURRENT的标识，表示是最新的正式版本。

        生产环境中不建议使用最新的正式版本，因为可能还有很多潜在的BUG没有被发现，当然，可以作为研究学习时使用。

        在生产环境中还是建议使用早几个版本的GA正式版本。

4.1.3SNAPSHOT(快照版本)

        SNAPSHOT是快照版本，一般每天晚上都会更新，一般每个版本都会只有一个快照版本，比如2.7.3-SNAPSHOT快照版本，一般正式版本的BUG都会在快照版本中修复。

        SNAPSHOT快照版本可能存在大量的BUG，强烈不建议在生产环境中使用，只建议用于学习研究。

4.1.4PRE(预览版本)

        PRE代表的是 pre release版本，即预览版本，然后预览版本又分为两个不同的阶段：

        1.里程碑版本：比如3.0.0-M3，这里的M指的是milestone，即里程碑，里程碑版本是从M1版本开始累计的。

        2.候选发行版本：比如3.0.0-RC2，这里的RC值得是Release Candiate，即候选发行版本，正式版本发行之前的候选版本，和里程碑版本一样，会从RC1开始累计。

        预览版本发布之后也是不会进行任何修改的，如果发现BUG，修复之后会在SNAPSHOT快照版本中更新，并在发布下一个版本。

        当里程碑版本逐渐稳定之后，会发布候选发布版本，当候选发布版本逐渐稳定之后，才会发布GA正式版本。

        与快照版本一样，PRE版本也不建议在生产环境中使用，只建议在研究学习的时候使用。

4.1.5版本周期分析总览

4.2版本支持

        目前来看2.x版本已经全面停止社区支持了，只有企业支持还在继续，现在是SpringBoot3.x的时代，尽快更新版本，跟上时代的步伐。

5.SpringBoot环境要求

        不同的SpringBoot版本对Java开发环境的要求是不一样的，对Servlet版本的支持也是不一样的，需要对版本对应关系进行把握。

        以下是SpringBoot和JDK，Spring，Maven，Gradle之间的版本对应关系。

        SpringBoot3.0最低要求JDK17，并向上兼容支持JDK19，虽然Oracle宣布当前JDK17的是免费使用的，但是不确定当免费期过去之后，是否还能正常使用，所以还是建议使用社区免费开源的OpenJDK，或者是其他开源的JDK。

        并且在SpringBoot3.x版本开始，SpringBoot依赖的Spring版本就全面变为了6.x版本，在SpringBoot3.x发布之前，Spring6就对底层进行了大量升级。

        对Servlet容器的要求：

        SpringBoot3.x最低支持Servlet5.0，并且底层的支持由JavaEE更换为JakartaEE，因为几年之前JavaEE就已经升级为JakartaEE，很多底层细节发生了改变，如果需要迁移升级，需要格外注意这一点。

        环境迁移：

6.安装集成SpringBoot

6.1集成方式

        1.使用Maven/Grade插件

        2.使用SpringBootCLI工具

        一般来说，现在都更推荐使用Maven去构建SpringBoot项目，Maven也是Java开发最主流的项目构建工具，所以更加建议使用Maven去构建项目。

6.2Maven集成SpringBoot

        使用Maven集成SpringBoot有两种方式：1集成spring-boot-starter-parent工程。2.导入spring-boot-dependencies依赖。

        1.继承spring-boot-starter-parent项目：

        在项目中直接使用parent标签继承spring-boot-starter-parent项目即可。

<parent>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-parent</artifactId>
    <version>3.2.2</version>
</parent>

        2.导入spring-boot-denpendencies依赖：

        在项目中使用这种导入依赖的方式也可以轻松搭建SpringBoot项目。

<dependencyManagement>
    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-dependencies</artifactId>
            <version>${spring-boot.version}</version>
            <type>pom</type>
            <scope>import</scope>
        </dependency>
    </dependencies>
</dependencyManagement>

6.3集成方式的区别

        两种集成方式的区别：

        第一种项目继承parent的方式其实在spring-boot-starter-parent中也是继承了spring-boot-dependencies依赖，并且提供了很多常见的相关配置：比如properties(参数)，plugins(插件)

        可以看到整个spring-boot-starter-parent项目中配置了各种各样的插件：

<parent>
  <groupId>org.springframework.boot</groupId>
  <artifactId>spring-boot-dependencies</artifactId>
  <version>3.2.2</version>
</parent>
<artifactId>spring-boot-starter-parent</artifactId>
<packaging>pom</packaging>
<name>spring-boot-starter-parent</name>
<description>Parent pom providing dependency and plugin management for applications built with Maven</description>
<properties>
  <java.version>17</java.version>
  <resource.delimiter>@</resource.delimiter>
  <maven.compiler.release>${java.version}</maven.compiler.release>
  <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
  <project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>
</properties>
<build>
  <resources>
    <resource>
      <directory>${basedir}/src/main/resources</directory>
      <filtering>true</filtering>
      <includes>
        <include>**/application*.yml</include>
        <include>**/application*.yaml</include>
        <include>**/application*.properties</include>
      </includes>
    </resource>
    <resource>
      <directory>${basedir}/src/main/resources</directory>
      <excludes>
        <exclude>**/application*.yml</exclude>
        <exclude>**/application*.yaml</exclude>
        <exclude>**/application*.properties</exclude>
      </excludes>
    </resource>
  </resources>
  <pluginManagement>
    <plugins>
      <plugin>
        <groupId>org.apache.maven.plugins</groupId>
        <artifactId>maven-compiler-plugin</artifactId>
        <configuration>
          <parameters>true</parameters>
        </configuration>
       </plugin>
       ..............
    <plugins>   
  <pluginManagement>
</build>

        所以使用继承方式集成时有以下几个优点。

        1.插件只需要引入坐标即可，无需额外配置，因为父工程中已经配置好插件了，如果需要自定义配置的时候，也可以去更改插件的配置。
 

<plugin>
    <groupId>org.apache.maven.plugins</groupId>
    <artifactId>maven-compiler-plugin</artifactId>
</plugin>

        2.可以直接定义properties参数覆盖依赖的版本，如果不想使用SpringBoot继承的版本，想要使用自定义的版本，直接使用对应properties参数覆盖版本号即可：

<slf4j.version>1.7.36</slf4j.version>

        但是如果是导入的spring-boot-dependencies依赖的集成方式，则需要显示导入依赖并指定版本：

<dependency>
    <groupId>org.slf4j</groupId>
    <artifactId>slf4j-api</artifactId>
    <version>${slf4j.version}</version>
</dependency>

        但是继承spring-boot-starter-parnet项目的缺点也是十分明显的：Maven仅仅支持单继承模式，扩展继承了spring-boot-starter-parent工程就不能再继承其他工程了，如果项目是公司的子项目，需要依赖于公司的主项目时，就不能使用继承的方式，只能使用引入spring-boot-dependencies依赖的方式。

        两种方式都可以正常的使用SpringBoot，继承的方式可以节省很多配置，快速迭代开发，引入依赖的方式在设计上更加合理，扩展性更强，建议在一开始设计的时候就确定到底要采用哪种方式构建SpringBoot应用工程。

7.SpringBoot接口快速开发

7.1快速构建SpringBoot项目

        Spring提供一站式生成Spring应用的网站：Spring Initializr

        IDEA也帮我们集成了快速生成Spring应用的工具：

        由于spring提供的官方网站start.spring.io只有最近的版本支持，如果想要更久远的版本支持(比如2.x/3.x等)，可以将SpringBoot的服务源更改为阿里巴巴的start.spring.io。

        这里我使用的时阿里巴巴的start.aliyun.io，使用的是SpringBoot3.0.2的版本。

        pom配置文件：

        构建出的SpringBoot项目是采用的引入spring-boot-dependencies依赖的方式实现的集成SpringBoot。

        默认引入的依赖：

        1.spring-boot-starter依赖，这是starter的底层基础依赖，借助这个依赖可以实现自动配置和默认配置。

        2.spring-boot-starter-test依赖，这是SpringBoot的测试依赖。

        默认引入的插件：

        1.maven-compiler-plugin插件，这个插件主要是负责Maven工程编译。

        2.spring-boot-maven-plugin插件，这个插件是SpringBoot使用Maven构建的基础插件。

<?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>
    <groupId>com.xinghai</groupId>
    <artifactId>springboot3-demo</artifactId>
    <version>0.0.1-SNAPSHOT</version>
    <name>springboot3-demo</name>
    <description>springboot3-demo</description>
    <properties>
        <java.version>17</java.version>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
        <project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>
        <spring-boot.version>3.0.2</spring-boot.version>
    </properties>
    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter</artifactId>
        </dependency>

        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
        </dependency>
    </dependencies>
    <dependencyManagement>
        <dependencies>
            <dependency>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-dependencies</artifactId>
                <version>${spring-boot.version}</version>
                <type>pom</type>
                <scope>import</scope>
            </dependency>
        </dependencies>
    </dependencyManagement>

    <build>
        <plugins>
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-compiler-plugin</artifactId>
                <version>3.8.1</version>
                <configuration>
                    <source>17</source>
                    <target>17</target>
                    <encoding>UTF-8</encoding>
                </configuration>
            </plugin>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
                <version>${spring-boot.version}</version>
                <configuration>
                    <mainClass>com.xinghai.Springboot3DemoApplication</mainClass>
                    <skip>true</skip>
                </configuration>
                <executions>
                    <execution>
                        <id>repackage</id>
                        <goals>
                            <goal>repackage</goal>
                        </goals>
                    </execution>
                </executions>
            </plugin>
        </plugins>
    </build>
</project>

        也会生成一个启动类： 

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

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

        生成一个SpringBootTest测试类：

import org.junit.jupiter.api.Test;
import org.springframework.boot.test.context.SpringBootTest;

@SpringBootTest
class Springboot3DemoApplicationTests {
    @Test
    void contextLoads() {
    }
}

        总结快速创建的SpringBoot应用搭建的体系：

7.2导入WEB依赖

        我们想要构建WEB程序需要导入SpringBoot的WEB依赖，如果在创建项目的时候我们没有选择spring-boot-starter-web，就需要我们手动导入以下依赖：

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

        导入这个依赖之后就可以开发SpringWeb项目了。

7.3编写接口

        随意编写一个RestFul的接口：

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

@RestController
public class HelloController {

    @RequestMapping("/hello")
    public String helloWorld() {
        return "Hello World";
    }

}

7.4启动应用

        在IDE中启动SpringBoot应用主要有以下两种方案：

        1.使用SpringBoot提供的启动类中的main方法启动：

                启动类中提供了一个静态main方法，可以直接调用执行，启动SpringBoot应用。

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

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

        2.使用Maven应用构建插件运行

        如果SpringBoot引用集成了Maven插件，spring-boot-maven-plugin：

<plugin>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-maven-plugin</artifactId>
    <version>${spring-boot.version}</version>
    <configuration>
        <mainClass>com.xinghai.Springboot3DemoApplication</mainClass>
        <skip>true</skip>
    </configuration>
    <executions>
        <execution>
            <id>repackage</id>
            <goals>
                <goal>repackage</goal>
            </goals>
        </execution>
    </executions>
</plugin>

        只要配置了这个插件，就可以使用Maven命令启动：

        mvn spring-boot:run。

        在Maven插件中的配置：

        注意配置spring-boot-maven-plugin插件中，configuration中主类千万不要配置skip跳过，如果配置就无法使用mvn spring-boot:run指令启动了。

<plugin>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-maven-plugin</artifactId>
    <version>${spring-boot.version}</version>
    <configuration>
        <mainClass>com.xinghai.Springboot3DemoApplication</mainClass>
        <!--<skip>true</skip>-->
    </configuration>
    <executions>
        <execution>
            <id>repackage</id>
            <goals>
                <goal>repackage</goal>
            </goals>
        </execution>
    </executions>
</plugin>

        在IDEA中配置mvn spring-boot:run指令启动SpringBoot项目：

        使用maven指令启动项目：

        其实Maven应用建议使用这种启动方式，因为Maven命令启动可以使用到Maven的各种插件，如果直接使用SpringBoot的启动类中的静态main方法启动就无法利用到这些插件，就可能会抛出错误。

        要点：建议使用Maven的方式启动项目，不建议使用main方法启动项目。

7.5测试接口

        可以正常测试访问：

8.SpringBoot快速Maven构建

8.1maven-mvnd

8.1.1基本介绍

        当我们使用Maven构建项目的时候，会经历编译，测试，打包的过程，但是Maven传统打包速度太慢了，一个多模块项目打包需要很长很长的时间，所以Maven就开启了一个新的项目：Maven-mvnd项目，这个项目借助的是Gradle和Takari中的技术，以加速Maven的构建速度。

        maven-mvnd不能独立使用，必须依赖于Maven，可以将maven-mvnd看作是Maven的插件，辅助Maven的构建流程，使得构建流程可以更快更高效。

        maven-mvnd开源项目地址如下：apache/maven-mvnd： Apache Maven 守护进程

        

        maven-mvnd底层实现原理：

        1.mvnd嵌入内置了Maven（因此无需单独安装Maven）

        2.实际的构建发生在一个长期存在的后台进程中，也被称之为守护线程。

        3.一个守护程序实例可以为来自客户端的多个连续请求提供服务。

        4.客户端使用GraalVM构建的原生可执行文件。与传统JVM相比，启动速度更快，使用内存更少。

        5.如果没有空闲的守护进程提供构建请求，则可以并行生成多个守护线程提供构建请求。

        优点：

        1.无需每次构建时都重新启动JVM。

        2.持有Mave插件类的类加载器缓存在多个构建中，因此插件jar只能被读取和解析一次。

        3.由JVM内部的即时编译器(JIT)生成的本机代码也被保留。与传统的Maven相比，JIT编译花费的时间更少，在重复构建期间，JIT优化代码可以立即使用。

        

        在默认情况下，mvnd使用多个CPU内核进行构建（多线程构建），使用的核心数量符合以下公式：

Math.max(Runtime.getRuntime().availableProcessors() - 1, 1);

        下面是官方给出的在24核心CPU机器上的构建图：

        构建完成后，控制台会输出完整的Maven构建日志。

8.1.2安装使用

        下面暂时只展示在windows下安装maven-mvnd。

        其他系统可以直接去官方网址去查看怎么安装，整体来看还是比较简单的：apache/maven-mvnd： Apache Maven 守护进程

        1.github上给出的手动安装教程：

        2.进入下载平台：

        3.下载1.0.2版本的压缩包：

        4.解压下载的文件：

        5.将解压后的文件的bin文件夹配置到环境变量中：

        6.测试是否安装成功：

        使用mvnd --version测试。

        可以发现已经安装maven-mvnd成功，maven-mvnd的版本是1.0.2，maven的版本是3.9.9。

8.1.3附加能力

        除了Maven的内置能力以外，还提供了一些附加能力。

        --status：查看当所有的守护进程列表：

        --stop：停止所有运行的守护进程：

8.1.4性能测试

        接下来以苍穹外卖项目为准，去对比打包测试。

        苍穹外卖项目结构比较简单，仅有三个子模块，所以使用Maven打包其实也花费不了多少时间，后面会专门出一期文章分析这个maven-mvnd打包工具的魅力。

        1.准备两个苍穹外卖项目：

        2.A项目设置使用普通的Maven：

        3.B项目设置使用maven-mvnd中的Maven仓库：

        4.对A和B项目使用对应的构建指令：

        A项目使用mvn clean install -DskipTests指令构建

        传统Maven打包方式大概花费时间为9.343秒：

        B项目使用mvnd clean install -DskipTests指令构建

        maven-mvnd打包方式大概花费时间为5.249秒：

        可以看到确实是有性能上的成倍的提升，其实对于更大的项目，maven-mvnd的打包性能提升会更大，而且maven-mvnd也支持更好的调参处理，设置更好的参数甚至可以达到数十倍的性能提升。

        当你学会使用maven-mvnd打包工具的时候，就可以在简历中写明：借助新时代打包工具maven-mvnd，实现打包性能数倍的提升，帮助公司降低了打包的时间成本消耗，提高了项目打包上线的效率。

8.2maven-wrapper

8.2.1基本介绍

        SpringBoot提供了Maven相关快捷脚本，即在SpringBoot应用中提供MavenWrapper脚本，实现免自配置安装，快速使用Maven。

        MavenWrapper脚本是Spring提供的一站式生成Spring应用项目中内置的快速免安装使用Maven的脚本化工具。

        在Spring官方一站式生成Spring应用的网站中，生成的SpringBoot项目都会写带MavenWrapper脚本：

        生成的项目中内置了MavenWrapper的windows指令和linux指令：

        mvnw（Linux版本）

        mvnw.cmd（Windows版本）

        从/.mvn/wrapper/maven-wrapper.properties中可以配置当前项目想要使用的Maven版本。

        Maven Wrrapper其实就是可以自动化配置项目所使用的Maven，使用Maven Wrapper可以快速将Maven集成到项目中。

        总结一下Maven Wrapper的使用场景：

        1.想省心，不想自己安装配置Maven环境。

        2.不同的应用，需要使用不同版本的Maven，比如已有的Maven版本不合适，需要使用特定的Maven版本。

        Maven Wrapper的原理其实是，通过配置，将不同版本的Maven自动拉取到本地，直接使用本地配置好的Maven即可：

8.2.2使用方式

        Spring一站式生成应用系统，已经为我们准备好Maven Wrapper，无需再去下载安装了，如果自己在IDEA安装的SpringBoot应用需要使用Maven Wrapper，直接将两个脚本文件和.mvn复制过去即可。

        Maven Wrapper的命令：

        其实Maven Wrapper中的命令和Maven中是一样的，只不过在Maven中调用命令是使用的mvn，在Maven Wrapper中调用命令使用的是./mvnw（windows中的脚本文件）

        当然IDEA中也已经集成了Maven Wrapper的指令，直接使用也是完全可以的：

8.2.3IDEA中设置mwnw

        配置之后，就可以使用项目中配置的Maven了，项目会自动将配置的Maven下载到本地，辅助我们使用：

8.2.4总结

        Maven-mvnd：需要提升构建打包速度时使用。

        Maven-Wrapper：不想自己配置Maven版本，想要自动化配置/快速更换适应项目的Maven版本时使用。

9.SpringBoot-CLI

        这个模块将在以后用到的时候进行深入讲解，这个一般的时候是用不到的，但是也是深入了解SpringBoot必备的知识点。