【热门主题】000017 Spring Boot 应用开发全攻略

📚一、Spring Boot 概述

📘（一）Spring Boot 是什么

Spring Boot 作为 Spring 框架的一个模块，其设计目的明确，旨在简化新 Spring 应用的初始搭建以及开发过程。它通过特定的配置方式，让开发人员无需再定义样板化的配置，极大地提高了开发效率。例如，在传统的 Spring 开发中，可能需要大量的 XML 配置文件来整合各种框架和库，但 Spring Boot 则大大简化了这一过程，它默认配置了很多框架的使用方式，就如同 Maven 整合了所有的 jar 包一样，Spring Boot 整合了众多框架，使得开发人员可以更专注于业务逻辑的实现。

📘（二）优势何在

Spring Boot 具有诸多显著优势。首先，它能够快速构建应用，开发人员可以创建独立的、生产级别的 Spring 应用，无需繁琐的 XML 配置或手动配置。其次，自动配置功能强大，会根据类路径上的库和配置自动配置 Spring Bean，减少了开发人员的配置工作量。再者，嵌入式服务器的支持使得可以内嵌 Tomcat、Jetty 或 Undertow 等 Web 服务器，简化了部署过程。同时，Spring Boot 应用可以作为独立的 Java 应用程序运行，无需部署到容器中，实现了独立运行。此外，它还内置了对各种库的版本依赖管理，减少了版本冲突的可能性，并且易于测试，支持单元测试和集成测试，使得测试更加方便。最后，内置的健康检查功能使得监控应用的健康状态变得更加简单。

📘（三）工作原理探究

Spring Boot 通过一系列步骤实现应用的快速构建。首先是注解驱动，使用 @SpringBootApplication 注解来配置应用程序的基本元信息，这个注解是 @Configuration、@EnableAutoConfiguration 和 @ComponentScan 的组合，分别起到表明该类是一个配置类、启用自动配置功能以及扫描当前包及其子包下的所有带有 @Component 注解的类的作用。其次是自动配置，根据类路径上的库和配置，自动配置 Spring Bean。然后是属性配置，使用 application.properties 或 application.yml 文件来配置应用的属性。再者，内置支持 Tomcat、Jetty 或 Undertow 作为 Web 服务器，提供嵌入式 Web 服务器。同时，提供命令行接口，支持各种运行模式，如开发、测试或生产模式。最后，通过嵌入式启动器提供各种依赖项，使构建过程更加简化，并且可以轻松地添加或移除组件，实现可插拔的组件功能。

📚二、开发准备

📘（一）Java 环境配置

Java 开发环境的配置是开发 Spring Boot 应用的基础。通常，我们需要确保系统安装了合适版本的 JDK。以 JDK 11 为例，首先从 Oracle 官网或其他可信的镜像站点下载 JDK 11 安装包。运行安装包后，按照提示逐步完成安装过程。
接下来是配置环境变量。编辑系统环境变量，新建变量名JAVA_HOME，变量值指向 JDK 的安装路径。例如，如果 JDK 安装在C:\Program Files\Java\jdk-11，则JAVA_HOME的值设置为该路径。然后，编辑PATH环境变量，添加%JAVA_HOME%\bin。这样可以在命令行中直接使用java和javac命令。
验证 JDK 安装是否成功，可以在命令行中输入java -version和javac -version。如果显示 JDK 的版本信息，说明安装和配置成功。

📘（二）IDE 选择与配置

IntelliJ IDEA 的安装与配置：
下载并安装 IntelliJ IDEA。可以从官方网站下载安装包，按照安装向导进行操作。
打开 IDEA 后，选择File -> New -> Project，在弹出的窗口中选择Spring Initializr，然后点击Next。
选择Project SDK，即 JDK 版本，确保与已安装的 JDK 版本一致。然后继续点击Next。
选择Project Metadata，输入项目名称、语言（建议选择 Java），选择 Java 框架，然后点击Next。
选择Project SDK，然后点击Finish，即完成项目创建。
Eclipse 的安装与配置：
下载并安装 Eclipse。从官方网站下载安装包，按照安装步骤进行安装。
打开 Eclipse，选择File -> New -> Project，在弹出的窗口中选择Spring Initializr，然后点击Next。
选择Project SDK，即 JDK 版本，然后继续点击Next。
选择Project Metadata，输入项目名称、语言（建议选择 Java），选择 Java 框架，然后点击Next。
选择Project SDK，然后点击Finish，即完成项目创建。

📘（三）Maven 与 Gradle 安装与配置

Maven 的安装与配置：
下载 Maven：在官网http://maven.apache.org/download.cgi下载 Maven 安装包。
配置环境变量：解压到一个路径，然后配置环境变量。新建变量名MAVEN_HOME，变量值为 Maven 的安装路径，例如D:\apache-maven-3.6.0。编辑变量名Path，在最前面加上%MAVEN_HOME%\bin。
检查是否配置成功：在命令行输入mvn -V，如果输出一堆信息，说明配置成功。
配置 Maven 仓库：打开maven文件夹下的config文件夹下的settings.xml；找到localRepository标签，解除注释并配置自己的 Maven 仓库路径，例如D:\idea\localRepository。配置远程仓库，找到mirrors标签，使用阿里镜像。配置好后记得保存。
在 IDEA 配置 Maven：点击File -> Settings -> Maven，按截图配置安装目录和选择刚刚 settings 配置文件；选择完 settings 之后，本地仓库自动改成 settings 文件中配置的；点击apply，再点击ok即配置完成。
Gradle 的安装与配置：
下载 Gradle：在官方网站下载所需的 Gradle 版本，推荐下载 all 版本，内含说明文档。
配置环境变量：在系统属性中，高级系统设置 -> 环境变量。在用户变量上新建一个PATH，值设置为刚才解压bin文件夹的位置；如果已经有了PATH，只需要在其后面添加即可，并用;分隔。
测试 Gradle：在命令行中输入gradle -v或gradle -version，如果没有提示找不到即是成功。

📚三、项目创建与结构解析

📘（一）使用 Spring Initializr 快速生成项目

Spring Initializr 是一个强大的工具，它极大地简化了 Spring Boot 项目的创建过程。我们可以通过网页访问 https://start.spring.io/ 来使用 Spring Initializr。在这个页面上，我们可以根据自己的需求进行项目配置。
首先，选择项目类型，通常我们会选择 Maven 项目或 Gradle 项目。假设我们选择 Maven 项目，接着选择 Java 作为编程语言。对于 Spring Boot 版本，我们可以根据实际情况选择一个稳定的版本，比如在撰写本文时，一些常用的稳定版本有 3.0.x 等。
然后，填写项目元数据。Group 可以使用组织域名的逆序，例如 “com.example”。Artifact 是应用程序的名称，可以根据项目的具体功能来命名。Name 为项目输入一个易于理解的名称。Description 可以填写对项目的简要描述，这是可选的。Package Name 会根据 Group 和 Artifact 自动生成，也可以根据需要进行调整。Packaging 可以选择 Jar 以创建独立的 JAR 文件，方便部署和运行。
配置好这些信息后，点击 “Generate” 按钮，Spring Initializr 会创建一个包含项目的 ZIP 文件。下载这个 ZIP 文件后，我们可以将其导入到 IDE 中。
对于 IntelliJ IDEA，我们可以选择 “File -> New -> Project from Existing Sources”，然后选择下载的 ZIP 文件。确保选择 “Import project from external model” 并选择 “Maven”。按照提示将项目导入到 IDE 中。
对于 Eclipse，需要安装 Maven 插件（如果尚未安装），然后通过 “File -> Import -> Existing Maven Projects” 导入项目。

📘（二）项目结构解析

一个基本的 Spring Boot 项目包含多个关键部分。
首先是源代码部分，通常位于 src/main/java 目录下。这里包含了项目的主程序类以及各个业务逻辑类。主程序类通常命名为 Application.java，它已经包含了 main 方法，用于启动 Spring Boot 应用。在这个类上通常会有 @SpringBootApplication 注解，这个注解是 @Configuration、@EnableAutoConfiguration 和 @ComponentScan 的组合，起到了配置应用程序基本元信息的作用。
在 src/main/java 目录下，我们还可以根据业务需求创建各种控制器类（如 @Controller 或 @RestController 注解的类）、服务类（@Service 注解的类）和数据访问类（如 @Repository 注解的类）。
其次是配置文件部分，通常位于 src/main/resources 目录下。这里可以存放 application.properties 或 application.yml 文件，用于外部化配置。这些配置文件可以用于设置应用的各种属性，比如数据库连接信息、服务器端口号等。
另外，还有静态资源部分，默认情况下，Spring Boot 从类路径中的 /static（或 /public 或 /resources 或 / META-INF/resources）目录中提供静态内容。这些静态资源可以包括 CSS 文件、JavaScript 文件、图片等，用于构建前端界面。
此外，项目结构中还可能包含测试代码部分，位于 src/test/java 目录下。这里可以编写单元测试和集成测试，以确保项目的各个部分功能正常。

📚四、配置管理

📘（一）配置文件应用

Spring Boot 的 application.properties 和 application.yml 是非常重要的配置文件，它们在项目中起着关键作用。
application.properties：
可以配置应用程序的默认设置，如服务器端口、数据库连接、日志级别等。例如，可以通过设置 server.port=8080 来指定服务器运行的端口。
用于环境特定配置，可以创建不同的 profile 来配置不同环境的属性，如开发、测试、生产环境。比如在开发环境中，可以设置 spring.datasource.url=jdbc:mysql://localhost:3306/dev_database，而在生产环境中设置为不同的数据库连接。
能够集成第三方服务，配置如消息队列、缓存、邮件服务、定时任务等中间件的属性。例如，spring.rabbitmq.host=localhost 可以设置 RabbitMQ 服务器的地址。
application.yml：
YAML（YAML Ain’t Markup Language）不是一个标记语言，以数据为中心，配置数据的时候具有面向对象的特征，比 json、xml 等更适合做配置文件。
YAML 基本语法为 key: value，表示一对键值对，冒号后面必须要有空格。使用空格缩进表示层级关系，左侧缩进的空格数目不重要，只要同一层级的元素左侧对齐即可，且 key 与 value 大小写敏感。
例如，配置服务器端口可以这样写：server: port: 8081。如果要配置一个对象，可以使用如下格式：student: name: zhoujielun age: 30。对于数组，可以用 - 值表示数组中的一个元素，比如 pets: - cat - dog - pig。

📘（二）外部化配置与 Profile

Spring Boot 支持外部化配置，通过配置文件的外部化配置可以实现不同环境配置的切换。
外部化配置：
Spring Boot 的应用配置可使用 properties 或 yml 文件等，在高优先级里设置的属性都会覆盖低优先级的相同属性。如果高优先级里没有设置某个属性，则会使用低优先级的设置的属性值。
优先级整体顺序为：Devtools 全局设置属性在你的主目录（~/.spring-boot-devtools.properties 当 devtools 处于激活状态时）；测试中的 @TestPropertySource 注解；测试中的 @SpringBootTest properties 注解属性；命令行参数；来自 SPRING_APPLICATION_JSON（嵌入在环境变量或系统属性中的内联 JSON）的属性；ServletConfig 初始化参数；ServletContext 初始化参数；来自 java:comp/env 的 JNDI 属性；Java 系统属性（System.getProperties ()）；操作系统环境变量；RandomValuePropertySource 配置的 random.* 属性值；jar 包外部的 application-{profile}.properties 或 application.yml（带 spring.profile）配置文件；jar 包内部的 application-{profile}.properties 或 application.yml（带 spring.profile）配置文件；jar 包外部的 application.properties 或 application.yml（不带 spring.profile）配置文件；jar 包内部的 application.properties 或 application.yml（不带 spring.profile）配置文件；@Configuration 注解类上的 @PropertySource；通过 SpringApplication.setDefaultProperties 指定的默认属性。
Profile：
Spring Boot 中通过 Profile 属性配置实现对不同环境提供不同配置功能的支持。可以通过激活、指定参数等方式快速切换环境。
分多个配置文件：不同环境的配置文件使用 application-{profile}.yml 的格式。例如，配置文件分为主配置文件 application.yml 和测试环境 application-dev.yml，生产环境 application-prod.yml 三个。在主配置文件中指定要使用的配置，如 spring.profiles.active: dev，默认为开发环境 dev，就对应使用 application-dev.yml 这个配置。
在一个文件中分块配置：通过 — 分隔创建两个环境的服务端口号，并制定所属环境。激活配置属性指定定义好的环境值。例如：spring.profiles:active: prod — server: port: 8083 spring:profiles: dev — server: port: 8084 spring:profiles: prod，指定属于生产环境。
通过命令行方式配置启动参数指定环境，如 java -jar target/demo-0.0.1-SNAPSHOT.jar --spring.profiles.active=prod。

📚五、Web 应用开发基础

Spring Boot 在 Web 应用开发方面提供了强大的支持，涵盖了构建 RESTful API、使用模板引擎构建动态 HTML 页面以及处理静态资源和配置国际化等重要内容。

📘（一）构建 RESTful API

构建 RESTful API 是现代 Web 应用开发的重要组成部分。在 Spring Boot 中，可以使用注解轻松构建 RESTful 风格的应用接口。
Spring Boot 的核心理念之一是约定优于配置，这在构建 RESTful API 时体现得淋漓尽致。通过使用@RestController注解标记类为 RESTful API 的控制器，并使用@RequestMapping定义 API 的路径。例如：

@RestController
@RequestMapping("/api/books")
public class BookController {
    private final BookService bookService;

    public BookController(BookService bookService) {
        this.bookService = bookService;
    }

    @PostMapping
    public Book createBook(@RequestBody Book book) {
        return bookService.createBook(book);
    }

    @GetMapping
    public List<Book> getAllBooks() {
        return bookService.getAllBooks();
    }

    @GetMapping("/{id}")
    public Book getBookById(@PathVariable("id") Long id) {
        return bookService.getBookById(id);
    }

    @DeleteMapping("/{id}")
    public ResponseEntity<?> deleteBook(@PathVariable("id") Long id) {
        bookService.deleteBook(id);
        return ResponseEntity.ok().build();
    }
}

在这个示例中，BookController类处理与书籍资源相关的 HTTP 请求。@PostMapping用于创建书籍资源，@GetMapping用于获取所有书籍或特定书籍，@DeleteMapping用于删除书籍资源。
设计 RESTful API 时，应遵循一些基本原则。例如，使用标准 HTTP 方法（GET、POST、PUT、DELETE）对应不同的资源操作，采用清晰的 URL 路径表示资源，正确使用状态码响应请求。

📘（二）Spring MVC 与 Thymeleaf 模板引擎

Spring Boot 与 Thymeleaf 模板引擎的结合使得构建动态 HTML 页面变得简单高效。
首先，引入 Thymeleaf 依赖：

org.springframework.boot
spring-boot-starter-thymeleaf

引入依赖后，Spring Boot 会自动配置 Thymeleaf 相关的 bean。
在控制器中，可以使用@Controller注解标记类，并通过方法返回模板名称，Thymeleaf 模板引擎会自动进行渲染。例如：

@Controller
@RequestMapping("/learn")
public class LearnResourceController {
    @RequestMapping("/")
    public ModelAndView index() {
        List<LearnResouce> learnList = new ArrayList<>();
        // 添加示例数据
        learnList.add(new LearnResouce("Author1", "Title1", "URL1"));
        return new ModelAndView("index", "learnList", learnList);
    }
}

在模板文件中，可以使用 Thymeleaf 的表达式和语法来展示动态数据。例如，在index.html模板文件中：

<!DOCTYPE html>
<html xmlns:th="http://www.thymeleaf.org">
<head>
    <meta charset="UTF-8">
    <title>Learn Resources</title>
</head>
<body>
    <h1>Learn Resources</h1>
    <ul>
        <li th:each="resource : ${learnList}" th:text="${resource.title}"></li>
    </ul>
</body>
</html>

📘（三）静态资源处理与国际化支持

静态资源处理：
Spring Boot 默认对静态资源的访问可以直接访问四个目录下的文件：classpath:/public/、classpath:/resources/、classpath:/static/、classpath:/META-INFO/resources/。
也可以自定义静态资源目录。例如，通过配置类：

   @Configuration
   public class ImageMvcConfig extends WebMvcConfigurerAdapter {
       @Override
       public void addResourceHandlers(ResourceHandlerRegistry registry) {
           registry.addResourceHandler("/image/**")
                  .addResourceLocations("classpath:/images/");
       }
   }

或者在application.yml中配置：

   spring:
     mvc:
       static-path-pattern: /image/**
     resources:
       static-locations: classpath:/images/

国际化支持：
首先在resources资源目录下创建国际化配置文件。例如，创建i18n.properties、i18n_zh_CN.properties、i18n_en_US.properties等文件，命名格式为xxx_zh_CN、xxx_en_US等，分别对应不同的语言和国家。
在application.yml或application.properties中配置国际化文件所在路径。例如：
spring.messages.basename=i18n

在页面代码中使用#{…}表达式来实现国际化。例如：

   <!DOCTYPE html>
   <html lang="en" xmlns:th="http://www.thymeleaf.org">
   <head>
       <meta charset="UTF-8">
       <title>Title</title>
   </head>
   <body>
       <p th:text="#{welcome.message}"></p>
   </body>
   </html>

还可以通过自定义国际化解析器，实现通过点击链接方式切换国际化。例如：

   public class MyLocaleResolver implements LocaleResolver {
       @Override
       public Locale resolveLocale(HttpServletRequest request) {
           String l = request.getParameter("l");
           Locale locale = Locale.getDefault();
           if (!StringUtils.isEmpty(l)) {
               String[] split = l.split("_");
               locale = new Locale(split[0], split[1]);
           }
           return locale;
       }

       @Override
       public void setLocale(HttpServletRequest request, HttpServletResponse response, Locale locale) {
       }
   }

然后将自定义解析器注入到 Spring 容器中。
通过以上方式，Spring Boot 为 Web 应用开发提供了全面的支持，包括构建 RESTful API、使用模板引擎构建动态页面以及处理静态资源和国际化等重要功能。

📚六、运行与部署

📘（一）本地运行与调试

在开发过程中，利用集成开发环境（IDE）进行 Spring Boot 应用的本地启动和调试是非常方便的。以 IntelliJ IDEA 为例，在项目结构视图中找到主程序类（通常命名为 Application.java），右键点击该类，选择 “Run” 或 “Debug” 选项即可启动应用或进行调试。在调试模式下，可以设置断点，逐行执行代码，查看变量的值，以便快速定位和解决问题。
Eclipse 的操作也类似，找到主程序类后，右键选择 “Run As” 或 “Debug As” 来启动或调试应用。本地运行和调试可以帮助开发人员在开发过程中及时发现和解决问题，提高开发效率。

📘（二）打包为可执行 jar 文件

使用 Maven 打包：
在项目的 pom.xml 文件中添加jar，确保项目以 JAR 包的形式进行打包。同时，需要添加标签，在其中配置，添加 Spring Boot 的 Maven 插件org.springframework.bootspring-boot-maven-plugin。
在项目根目录下运行命令mvn clean package -DskipTests或mvn clean package（如果不希望跳过测试）。打包完成后，在target目录下会生成一个以项目名称和版本号命名的 JAR 文件。
启动 JAR 文件可以使用命令java -jar target/xxx.jar。这种方式只要控制台关闭，服务就不能访问了。可以使用在后台运行的方式启动，如nohup java -jar target/xxx.jar &。也可以在启动的时候选择读取不同的配置文件，例如java -jar xxx.jar --spring.profiles.active=dev。还可以在启动的时候设置 JVM 参数，如java -Xdebug -Xrunjdwp:server=y,transport=dt_socket,address=8000,suspend=n -jar target/myapplication-0.0.1-SNAPSHOT.jar。
使用 Gradle 打包：
在 build.gradle 文件中配置插件和依赖。例如：

   buildscript {
       repositories {
           mavenLocal()
           maven { url "http://*.*.*.*:*/nexus/content/groups/public/" }
       }
       dependencies {
           classpath("org.springframework.boot:spring-boot-gradle-plugin:1.5.4.RELEASE")
       }
       apply plugin: 'java'
       apply plugin: 'org.springframework.boot'
       //注意这里使用 org.springframework.boot 的 bootJar 插件因此要引入这个插件
       apply plugin: 'org.springframework.boot'
       sourceCompatibility = '1.8'
       compileJava.options.encoding = 'UTF-8'
       compileTestJava.options.encoding = 'UFT8'
       repositories {
           maven { url 'http://maven.aliyun.com/nexus/content/groups/public' }
       }
       dependencies {
           implementation "org.springframework.boot:spring-boot-starter-web:${springBootVersion}"
           testImplementation "org.springframework.boot:spring-boot-starter-test:${springBootVersion}"
           testCompile group: 'junit', name: 'junit', version: '4.12'
           implementation group: 'mysql', name: 'mysql-connector-java', version: '8.0.18'
           implementation group: 'org.mybatis.spring.boot', name: 'mybatis-spring-boot-starter', version: '2.1.2'
           //        implementation files('lib/demo.main.jar')
       }
       // Main-Class 的目录 必须有的
       jar {
           String someString = ''
           configurations.runtime.each { someString = someString + " lib//" + it.name }
           manifest {
               attributes 'Main-Class': 'com.xu.Application'
               attributes 'Class-Path': someString
           }
       }
   }

执行构建命令gradle bootRepackage。打包完成后，JAR 文件会生成在项目根目录的build/libs下。通过命令行执行java -jar ×××.jar即可运行功能。

📘（三）部署到云平台

部署到 Heroku：
注册 Heroku 账号：访问 Heroku 官方网站（https://www.heroku.com/），注册一个免费账号。
安装 Heroku CLI：Heroku 提供了命令行工具，用于管理和部署应用程序。根据操作系统的不同，下载并安装相应的 Heroku CLI。
创建 Heroku 应用：使用 Heroku CLI 登录到账号，并创建一个新的 Heroku 应用。可以使用以下命令完成：heroku login，然后heroku create。
配置应用程序：在部署之前，需要对应用程序进行一些配置。首先，确保应用程序的根目录中包含一个有效的 Procfile 文件，用于指定启动应用程序的命令。例如，Procfile 文件内容可以是：web: java -jar your-application.jar。其次，确保应用程序使用了与 Heroku 兼容的数据库，如 PostgreSQL。
部署应用程序：使用 Heroku CLI 将应用程序部署到 Heroku。可以使用以下命令完成：git push heroku master。
启动应用程序：部署完成后，可以使用以下命令启动应用程序：heroku ps:scale web=1。部署到 Heroku 的 Spring Boot 应用程序可以通过 Heroku 提供的 URL 进行访问。
部署到阿里云：
申请阿里云服务器：
前往阿里云官网：https://www.aliyun.com/。
注册一个账号，登陆账号。
按如下步骤申请一个云服务器：根据自己的需要，选择合适的服务器配置。如果对配置不懂，可以选择 “一键购买”，买个差不多的服务器。注册过程中会让你设置账号密码和远程登陆密码，拿个笔记记下来，丢了就麻烦了。如果是学生，可以注册个学生认证，便宜很多。
购买完成后，回到首页，点击 “控制台”>>“云服务器 ECS”>>“实例”。在实例列表中就可以看到购买的云服务器。点进去，需要对服务器的安全组进行设置，除了自带的规则，还需要添加几个新的安全组。
回到 “实例列表”，点击实例 ID 进入服务器，点击 “远程连接”，输入 6 位连接密码，就可以看到申请的服务器了。然后按任意键登陆登录服务器，输入用户账号密码。
Xshell 的安装使用：
网页登陆云服务器的方式有弊端，一段时间不操作就会进入休眠，需要输入连接密码才能激活。所以采用 Xshell 登录云服务器。Xshell 是一个终端模拟软件，在本地 Windows 系统下安装这个软件，打开输入账号密码，就能登录远程的云服务器。
Xshell 下载官网：https://xshell.en.softonic.com/。如果官网下载太慢，可以百度一下 Xshell，很多资源，下载最新版的就行。下载完选择安装路径开始安装，这个软件很小，安装也简单。
打开 Xshell，新建一个会话，将公网 IP 输入到主机栏，端口号设置为 22（服务器的监听端口，ftp 默认为 21，sftp 为 22，如果设置 22 连不进去，那就换 21 试一下）。点击 “确定”>>“连接”，把服务器账号填进 “登录的用户名”，把服务器密码填进 “密码”。
云服务器上 jdk 的安装：
先用 Xshell 连接到云服务器或在阿里云官网中远程连接。
在本地 Windows 系统中下载 Linux 系统下的 jdk，jdk 下载官网：https://www.oracle.com/technetwork/java/javase/downloads/jdk8-downloads-2133151.html。下载需要的 jdk 版本。
下载完后，把文件传到云服务器上。在云服务器上安装rz命令，执行yum install lrzsz。然后把上传的文件放到/usr/java目录下（如果没有该目录则需要创建目录），先cd进入该目录，然后执行rz命令，选择安装包上传。
使用ls命令查看目录，确认安装包已存在。然后解压安装包，使用tar -zxvf jdk-版本号-linux-x64.tar.gz。解压后设置系统环境变量，找到文件/etc/profile，向其中添加如下代码：

     export JAVA_HOME=/usr/java/jdk1.8.0_221
     export CLASSPATH=$JAVA_HOME/lib/
     export PATH=$PATH:$JAVA_HOME/bin
     export PATH JAVA_HOME CLASSPATH

如果 jdk 版本不同，记得把export JAVA_HOME=/usr/java/jdk1.8.0_221这一行改成自己的版本。然后按 ESC 键退出编辑，输入:wq + 回车键保存退出文件。查看文件是否保存成功，使用cat profile。立即执行 profile 文件，使之生效，使用source /etc/profile。最后，使用java` 命令验证一下，如果可以看到版本信息就表示安装成功。
项目打包到云服务器，启动 tomcat：
在本地构建项目的 jar 文件，然后通过 scp 命令将 jar 文件传输到服务器。在服务器上运行项目，根据项目的具体需求进行配置和启动。
通过以上方法，可以实现 Spring Boot 应用的本地运行、打包为可执行 jar 文件以及部署到云平台，满足不同场景下的应用需求。

📚七、日志管理与监控

📘（一）日志配置与使用

Spring Boot 默认使用 Logback 作为日志框架，并支持 Slf4j 日志门面。通过 Logback/Slf4j 可以方便地配置日志输出级别和格式。
在 Spring Boot 中，可以通过 application.properties 或 application.yml 文件来配置日志级别。例如，设置根日志记录器的级别为 INFO：logging.level.root=INFO。如果要设置特定包的日志级别，可以使用以下格式：logging.level.包名=级别，比如logging.level.com.example=DEBUG。
配置日志输出格式也可以在配置文件中完成。在 application.yml 文件中，可以使用logging.pattern.console属性来设置控制台输出格式，例如：logging.pattern.console=%d{yyyy-MM-dd HH:mm:ss.SSS} [%thread] %-5level %logger{36} - %msg%n。这个格式表示输出日期时间、线程名、日志级别、日志记录器名称和日志消息，并以特定的格式进行排版。
此外，还可以通过编程方式配置日志级别和输出格式。例如，获取 Environment 对象，通过它获取日志级别和输出格式的属性值，然后使用 Logback 的 API 来设置日志级别和输出格式。

📘（二）Spring Boot Actuator 监控应用状态

Spring Boot Actuator 是 Spring Boot 提供的对应用系统的自省和监控的集成功能。可以通过 REST API 检查应用健康状态。
添加依赖
引入 Actuator 依赖即可使用其功能：org.springframework.bootspring-boot-starter-actuator。
配置 Actuator
可以在 application.yml 文件中进行 Actuator 的配置。例如，设置管理端口与逻辑接口端口分离：management.port：指定访问这些监控方法的端口，与逻辑接口端口分离。如果不想将这些暴露在 http 中，可以设置 management.port = -1。还可以设置管理地址，如只能通过本机监控，可以设置management.address = 123.0.0.1。
使用 Actuator 端点
通过 HTTP 访问 Actuator 端点可以获取应用的各种信息。例如：/actuator/health - 查看应用的健康状态；/actuator/info - 查看自定义的应用信息；/actuator/metrics - 查看应用的性能指标；/actuator/env - 查看应用的环境信息。
自定义健康检查
可以通过实现 HealthIndicator 接口来自定义健康检查逻辑。例如：

@Component
public class MyHealthIndicator implements HealthIndicator {
    @Override
    public Health health() {
        int errorCode = check();
        if (errorCode!= 0) {
            return Health.down().withDetail("Error Code", errorCode).build();
        }
        return Health.up().build();
    }
    private int check() {
        // 进行自定义的健康检查，返回错误码或 0 表示健康
        return 0;
    }
}

使用 Actuator 监控数据
可以将 Actuator 端点暴露给监控系统，如 Prometheus、Grafana 等，实现更高级的监控和告警功能，进一步提升应用的运维能力。
例如，访问localhost:8080/actuator/health可以查看应用的健康状态。如果配置了详细信息展示，如management.endpoint.health.show-details: always，则可以看到更详细的健康信息，包括应用依赖的组件状态等。如果应用中有 Redis 依赖，并且配置了详细信息展示，就可以看到 Redis 的健康状态信息。
还可以通过配置禁用某个组件的健康监测。例如，禁用 MongoDB 的组件健康监测可以这样配置：management.health.mongodb.enabled=false。或者禁用所有自动配置的健康指示器：management.health.defaults.enabled=false。
常见的健康指示器有很多，如磁盘空间指示器、数据库指示器等。除了使用自动引入的健康指示器之外，还可以自定义一个 Health Indicator，只需要实现 HealthIndicator 接口或者继承 AbstractHealthIndicator 类，如上面的示例代码所示。

📚八、安全实践与最佳实践

📘（一）Spring Security 基础配置

Spring Security 是一个强大的安全框架，为 Spring Boot 应用提供了认证和授权功能。以下是其基础配置的步骤：
添加依赖
在项目的 pom.xml 文件中添加 Spring Security 的依赖：

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

配置用户名和密码
可以在 application.properties 中配置默认的用户名、密码以及用户角色：

spring.security.user.name=admin
spring.security.user.password=123456
spring.security.user.roles=ADMIN

基于内存的认证
开发者可以自定义类继承 WebSecurityConfigurerAdapter，实现对 Spring Security 的更多自定义配置。例如：

@Configuration
public class MyWebSecurityConfig extends WebSecurityConfigurerAdapter {
    @Bean
    PasswordEncoder passwordEncoder() {
        return NoOpPasswordEncoder.getInstance();
    }

    @Override
    protected void configure(AuthenticationManagerBuilder auth) throws Exception {
        auth.inMemoryAuthentication()
               .withUser("admin").password("123456").roles("ADMIN")
               .and()
               .withUser("user").password("123456").roles("USER");
    }
}

HttpSecurity
通过重写 WebSecurityConfigurerAdapter 中的 configure (HttpSecurity http) 方法，可以实现更精细的资源访问控制。例如：

@Configuration
public class MyWebSecurityConfig extends WebSecurityConfigurerAdapter {
    @Bean
    PasswordEncoder passwordEncoder() {
        return NoOpPasswordEncoder.getInstance();
    }

    @Override
    protected void configure(AuthenticationManagerBuilder auth) throws Exception {
        auth.inMemoryAuthentication()
               .withUser("admin").password("123456").roles("ADMIN")
               .and()
               .withUser("user").password("123456").roles("USER");
    }

    @Override
    protected void configure(HttpSecurity http) throws Exception {
        http.authorizeRequests()
               .antMatchers("/admin/**").hasRole("ADMIN")
               .antMatchers("/user/**").access("hasAnyRole('ADMIN','USER')")
               .anyRequest().authenticated()
               .and()
               .formLogin()
               .loginProcessingUrl("/login")
               .permitAll()
               .and()
               .csrf().disable();
    }
}

登录表单详细配置
在前后端分离的开发方式中，可以对登录表单进行详细配置，以适应 JSON 数据交互。
注销登录
提供简单的配置即可实现注销登录功能：

.and().logout()
   .logoutUrl("/logout")
   .clearAuthentication(true)
   .addLogoutHandler(new LogoutHandler() {
        @Override
        public void logout(HttpServletRequest request, HttpServletResponse response, Authentication authentication) {
        }
    })
   .logoutSuccessHandler(new LogoutSuccessHandler() {
        @Override
        public void onLogoutSuccess(HttpServletRequest request, HttpServletResponse response, Authentication authentication) throws IOException, ServletException {
            response.sendRedirect("/login_page");
        }
    })
   .and();

📘（二）性能优化与资源管理

代码优化
减少不必要的多线程操作，避免过多的线程切换开销。例如，在处理一些非关键任务时，可以考虑合并操作或者延迟执行。
合理利用缓存，对于频繁访问的数据，可以使用缓存来减少数据库查询次数。比如使用 Spring 的缓存注解@Cacheable，可以将方法的结果缓存起来，下次调用时直接从缓存中获取结果。
优化查询语句，使用 Spring Data JPA 时，可以通过合理的查询方法命名或者使用 @Query 注解来优化数据库查询，减少不必要的查询结果返回。
异步处理
Spring Boot 工程中默认支持异步操作，需要在启动类的上面添加启动异步操作的注解@EnableAsync。例如：

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

定义切入点方法，假如此时某个业务方法需要执行异步操作，可以使用@Async注解对方法进行描述。例如：

    @Service
    public class AsyncService {
        @Async
        public void asyncMethod() {
            System.out.println("2. running in thread: " + Thread.currentThread().getName());
        }
    }

自定义线程池的配置，当 springboot 中默认的线程池配置不满足实际项目需求时，可以对线程池进行自定义的配置：

    spring.task.execution.pool.core-size=9
    spring.task.execution.pool.max-size=256
    spring.task.execution.pool.keep-alive=60000
    spring.task.execution.pool.queue-capacity=128
    spring.task.execution.thread-name-prefix=log-thread-

拒绝执行异常：RejectedExecutionException，处理能力达到并发上限（max-size）+（queue-capacity）就会报错。
资源池化
使用连接池管理数据库连接，例如使用 HikariCP 连接池。在 application.properties 中配置连接池参数：

    spring.datasource.hikari.minimum-idle=5
    spring.datasource.hikari.maximum-pool-size=10
    spring.datasource.hikari.connection-timeout=30000

通过资源池化，可以减少资源创建和销毁的开销，提高系统的性能和稳定性。
通过以上安全实践和性能优化与资源管理方法，可以提高 Spring Boot 应用的安全性和性能，使其更加稳定和高效。

📚九、进阶学习路径

📘（一）深入学习微服务架构

Spring Boot 在微服务架构中发挥着重要作用。微服务架构将一个应用拆分成一组小型服务，每个服务都专注于一个具体的业务功能。在 Spring Boot 中，可以通过使用 Spring Cloud 框架来实现微服务中的服务注册、服务发现、负载均衡等功能。
例如，使用 Spring Cloud 的 Eureka 作为服务注册中心，服务实例在启动时向 Eureka 注册自己，之后通过 Eureka 服务发现机制查询其他服务，实现服务发现。配置 Eureka 客户端和服务器：

spring:
  application:
    name: my-service
cloud:
  discovery:
    enabled: true
    register-with-eureka: true
    fetch-registry: true
instance:
  hostname: localhost
  port: 8761
eureka:
  client:
    service-url:
      defaultZone: http://${eureka.instance.hostname}:${eureka.instance.port}/eureka/

利用 Spring Boot 的模块化特性，将不同的功能拆分为独立的服务模块。每个服务可以独立开发、部署和扩展，提高了系统的灵活性和可维护性。
同时，Spring Boot 可以使用多种数据访问技术，如 JPA、Spring Data、MyBatis 等，对每个服务独立选择适合的数据访问技术，避免数据访问的耦合。使用分布式事务管理，确保跨服务的数据一致性。
在微服务架构中，部署和扩展变得更为复杂。Spring Boot 提供了 Docker、Kubernetes 等工具来支持微服务的部署和扩展。使用容器化技术，如 Docker，将每个微服务打包成独立的容器，利用 Kubernetes 等容器编排工具来管理微服务的部署和扩展。
以一个简单的电子商务平台为例，我们可以设计一个基于 Spring Boot 的微服务架构：创建不同的微服务模块，如用户服务、商品服务、订单服务等。使用 Spring Cloud 注册中心实现服务的注册与发现。利用 Spring Cloud Gateway 实现 API 网关，进行路由和过滤。使用分布式事务管理来保证不同微服务之间的数据一致性。部署微服务到容器中，并利用 Kubernetes 等工具进行管理和扩展。

📘（二）集成测试与单元测试策略

在软件开发过程中，测试是一种重要的质量保证手段。Spring Boot 作为一种轻量级的 Java 框架，具有很高的可扩展性和易用性。为了确保 Spring Boot 应用的质量，需要进行集成测试和单元测试。
单元测试是一种软件测试方法，它测试单个代码单元 (如方法、类或组件) 的功能和行为。单元测试的目的是确保代码的正确性、可维护性和可重用性。在 Spring Boot 应用中，单元测试通常使用 JUnit 框架进行编写。
例如，以下是一个简单的单元测试示例：

import org.junit.Test;
import static org.junit.Assert.*;
public class CalculatorTest {
    @Test
    public void testAdd() {
        Calculator calculator = new Calculator();
        int result = calculator.add(2,3);
        assertEquals(5, result);
    }
}

在上述实例中，我们使用 JUnit 框架编写了一个单元测试用例，测试了 Calculator 类的 add 方法。通过 assertEquals 方法，我们检查了结果是否与预期一致。
集成测试是一种软件测试方法，它测试多个单元组合在一起的代码。集成测试的目的是确保不同模块之间的交互正常，以及整个应用的功能和性能。在 Spring Boot 应用中，集成测试通常使用 Spring Boot Test 框架进行编写。
例如，以下是一个集成测试实例：

import org.springframework.boot.test.autoconfigure.web.servlet.AutoConfigureMockMvc;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.test.web.servlet.MockMvc;
import org.springframework.test.web.servlet.request.MockMvcRequestBuilders;
import org.springframework.test.web.servlet.result.MockMvcResultMatchers;
import org.springframework.beans.factory.annotation.Autowired;
@SpringBootTest
@AutoConfigureMockMvc
public class UserControllerTest {
    @Autowired
    private MockMvc mockMvc;
    @Test
    public void testListUsers() throws Exception {
        mockMvc.perform(MockMvcRequestBuilders.get("/users")).andExpect(MockMvcResultMatchers.status().isOk()).andExpect(MockMvcResultMatchers.content().string("[]"));
    }
}

在上述实例中，我们使用 Spring Boot Test 框架编写了一个集成测试用例，测试了 UserController 类的 listUsers 方法。通过 MockMvcRequestBuilders 和 MockMvcResultMatchers，我们构建了请求并检查了结果是否符合预期。
除了基本的单元测试和集成测试外，还应关注测试覆盖率。可以使用 JaCoCo 等工具来分析测试覆盖率，并确保测试覆盖到项目中的主要代码路径。同时，使用 Mockito 来模拟依赖，如数据库访问、外部服务调用等，可以使得单元测试更加灵活和高效。
例如，以下是一个使用 Mockito 的单元测试示例：

import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.mockito.Mockito.*;
import cn.juwatech.springbootexample.model.User;
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.autoconfigure.orm.jpa.DataJpaTest;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.boot.test.mock.mockito.MockBean;
import org.springframework.test.context.ActiveProfiles;
@SpringBootTest
@ActiveProfiles("test")
public class UserServiceMockTest {
    @MockBean
    private UserRepository userRepository;
    @Autowired
    private UserService userService;
    @Test
    public void testGetUserById() {
        User mockUser = new User();
        mockUser.setId(1L);
        mockUser.setName("Mock User");
        when(userRepository.findById(1L)).thenReturn(java.util.Optional.of(mockUser));
        User retrievedUser = userService.getUserById(1L);
        assertEquals("Mock User", retrievedUser.getName());
        verify(userRepository, times(1)).findById(1L);
    }
}

在上述示例中，我们使用了 @MockBean 注解来注入一个模拟的 UserRepository 实例，使用 when 和 thenReturn 方法来设置模拟对象的行为，并使用 verify 方法来验证方法的调用次数。

📘（三）社区资源与进一步学习资料

Spring Boot 拥有活跃的社区和丰富的学习资源。推荐加入 Spring 官方社区论坛、Stack Overflow、Reddit（Spring Boot subreddit）等平台，进行学习和交流。
Spring Boot 的官方 GitHub 页面和官方文档是获取最新版本的文档和技术信息的重要来源。访问官方文档可以了解 Spring Boot 的最新特性、最佳实践和使用方法。
此外，还有许多优秀的书籍和在线教程可以帮助深入学习 Spring Boot。例如，《Spring Boot 实战》《Spring Boot 微服务实战》等书籍，涵盖了从基础到高级的 Spring Boot 知识和实践案例。
在线教程方面，可以关注一些知名的技术博客和视频教程平台，如 CSDN、慕课网、B 站等，上面有很多关于 Spring Boot 的教程和实战项目分享。
通过参与社区、阅读文档和学习资源，可以不断提升对 Spring Boot 的理解和应用能力，掌握最新的技术动态和最佳实践。

📚十、开发技巧

Spring Boot 在开发过程中有许多实用的小技巧，可以提高开发效率和应用的灵活性。

📘（一）应用启动后执行任务

Spring Boot 提供了多种方式在应用启动后执行任务。其中，实现 ApplicationRunner 或 CommandLineRunner 接口是常用的方法。
实现 ApplicationRunner 接口的示例代码如下：

@Component
public class MyApplicationRunner implements ApplicationRunner {
    @Override
    public void run(ApplicationArguments args) throws Exception {
        System.out.println("应用程序启动完成后通过 ApplicationRunner 执行相关工作：" + Arrays.toString(args.getSourceArgs()));
    }
}

实现 CommandLineRunner 接口的示例代码如下：
@Component
public class MyCommandLineRunner implements CommandLineRunner {
    @Override
    public void run(String... args) throws Exception {
        System.out.println("应用程序启动完成后通过 CommandLineRunner 执行相关工作：" + Arrays.toString(args));
    }
}

这两个接口的实现类会在 Spring Boot 应用启动后自动执行其 run 方法，可以在其中进行一些初始化操作或其他需要在启动后执行的任务。

📘（二）访问启动参数

在定义 Bean 时，可以通过注入 ApplicationArguments 来获取应用程序的启动参数。示例代码如下：

@Configuration
public class ArgumentConfig {
    @Bean
    public Object object(ApplicationArguments args) {
        System.out.println(Arrays.toString(args.getSourceArgs()));
        return new Object();
    }
}

这样，在 Bean 的创建过程中，可以获取到应用程序的启动参数，以便根据参数进行不同的业务逻辑处理。

📘（三）配置文件生成随机值

在 Spring Boot 的配置文件中，可以使用 ${random} 来生成随机值。例如：
int 随机数
使用 ${random.int} 方式配置，结果从 int 的最大值、最小值中间产生，int 的最小值为 -2147483648，最大值为 2147483647。例如：server.port: ${random.int}。
使用 ${random.int(10000)} 方式配置，可以指定随机数的最大值，随机数的值将会在 0~10000 之间产生。例如：config.port: ${random.int(10000)}。如果需要指定随机数的最小值，可以使用 ${random.int[100,200]} 方式配置，这样只会从 100~200 之间产生随机数（包括最小值，不包括最大值）。
long 随机数
使用 ${random.long} 方式配置，结果会从 long 的最大值、最小值中间产生，long 的最小值为 -9223372036854775808，最大值为 9223372036854775807。例如：config.longValue: ${random.long}。
uuid 随机数
使用 ${random.uuid} 可以获得一个随机的 uuid 字符串。例如：config.uuid: ${random.uuid}。
在代码中，可以通过 @Value 注解注入随机值。示例代码如下：

@Component
public class RandomProperties {
    @Value("${random.uuid}")
    private String uuid;
    @Value("${random.int(1000)}")
    private int maxInt;
    @Value("${random.long(102400)}")
    private long maxLong;
}

📘（四）禁用命令行属性

在通过 jar 运行 Spring Boot 项目时，默认可以在命令行通过 --xxx=yyy 设置命令行属性。如果需要禁止命令行属性，可以在启动类中进行设置。示例代码如下：

public static void main(String[] args) {
    SpringApplication app = new SpringApplication(SpringBootFunctionsApplication.class);
    app.setAddCommandLineProperties(false);
    app.run(args);
    System.out.println("main method invoke...");
}

这样设置后，命令行属性将不再生效。

📘（五）配置文件加载优先级

Spring Boot 应用程序加载配置文件的地方及优先级顺序如下：
当前目录的 /config 子目录。
当前目录。
类路径路径下的 /config 目录。
类路径的根目录（classpath: /）。
这些位置的文件都会被加载，高优先级配置内容会覆盖低优先级配置的内容，并形成互补配置。默认加载的都是 application.properties 或 yml 文件，也可以在启动时指定配置文件名。例如：java -jar xxx.jar --spring.config.name=yyyy。还可以通过如下启动参数指定文件位置：java -jar xxx.jar --spring.config.location=classpath:/default.properties,classpath:/override.properties。

📘（六）YAML 配置文件缺陷

YAML 配置文件不支持 @PropertySource 注解的方式来加载配置文件，只能使用 properties 文件。例如：
@Configuration
@PropertySources({@PropertySource(“classpath:config.yml”)})
public class ArgumentConfig {}

这里是不会生效的，不支持 yml 文件，只能是 properties 文件。

📘（七）@EnableConfigurationProperties 的使用

当一个配置属性类只添加了 @ConfigurationProperties(prefix = “user”) 注解，而没有使用 @Component 注解，那么在 Spring 容器中是不会生成对应属性的 Bean。在任何使用了 @Configuration 注解的类上添加 @EnableConfigurationProperties(xx) 注解，那么对应有 @ConfigurationProperties 注解的类就会被 Environment 属性配置。
例如：

@Configuration
@EnableConfigurationProperties(RandomProperties.class)
public class ArgumentConfig {}

@ConfigurationProperties(prefix = "user")
public class RandomProperties {
    private String password;
    private int age;
    private long id;
    private String uuid;
}

📚十一、开发工具与实用库

📘（一）Lombok

Lombok 是一个可以极大简化 JavaBean 开发的工具。它通过简单的注解，帮助开发者省去了大量冗余的代码。
Lombok 注解解析：
@Getter/@Setter：该注解使用在类或者属性上，可以自动生成 getter 和 setter 方法。生成的 getter 遵循布尔属性的约定，例如 boolean 类型的属性 Foo，getter 方法为 isFoo 而不是 getFoo。在使用该注解时，会默认生成一个无参构造。
@Data：这个注解是最常用的注解之一，使用在类上。它结合了@ToString、@EqualsAndHashCode、@Getter和@Setter。本质上使用@Data注解，类默认会生成toString和EqualsAndHashCode方法以及每个字段都有@Setter和@getter。该注解也会生成一个公共构造函数，可以将任何@NonNull和 final 字段作为参数。虽然@Data注解非常有用，但是它没有与其他注解相同的控制粒度。
@EqualsAndHashCode：使用在类上，会同时生成equals和hashCode方法，包括所有非静态变量和非 transient 的变量。如果某些变量不想要加进判断，可以通过exclude排除，也可以使用of指定某些字段。
@NonNull：用在属性上，用于属性的非空检查，当放在 setter 方法的字段上，将生成一个空检查，如果为空，则抛出NullPointerException。该注解会默认生成一个无参构造。
@ToString：使用在类上，默认生成字段以名称 - 值的形式输出。
@Value：用在类上，会生成含所有参数的构造方法，get 方法，此外还提供了equals、hashCode、toString方法，但没有 setter。
@Builder：自动生成流式 set 值写法，从此之后再也不用写一堆 setter 了。注意，虽然只要加上@Builder注解，我们就能够用流式写法快速设定对象的值，但是 setter 还是必须要写不能省略的，因为 Spring 或是其他框架有很多地方都会用到对象的 getter/setter 对他们取值 / 赋值。所以通常是@Data和@Builder会一起用在同个类上，既方便我们流式写代码，也方便框架做事。
@Synchronized：synchronized是线程安全中一个重要的关键字，它是一种同步锁，主要用来保证在同一个时刻，只有一个线程可以执行某个方法或者某段代码块。一般使用synchronized去锁住代码块，而不是方法，因为锁住代码块效率更高。
在项目中使用 Lombok，首先需要在项目中添加依赖：

<dependency>
    <groupId>org.projectlombok</groupId>
    <artifactId>lombok</artifactId>
    <optional>true</optional>
</dependency>

并且在 IDE 中安装 Lombok 插件，以确保 IDE 能够识别 Lombok 注解并正确生成相应的代码。

📘（二）dev-tools

Spring Boot dev-tools 是一个为开发者服务的模块，主要用于项目热部署，尤其是在 web 应用开发中，当页面文件修改后能够快速生效。
其原理是使用了两个 ClassLoader，一个 Classloader 加载那些不会改变的类（第三方 Jar 包），另一个 ClassLoader 加载会更改的类，称为 restart ClassLoader。这样在有代码更改的时候，原来的 restart ClassLoader 被丢弃，重新创建一个 restart ClassLoader。由于需要加载的类相比较少，所以实现了较快的重启时间（通常在 5 秒以内）。
使用步骤如下：
添加相应的依赖：

org.springframework.boot spring-boot-devtools true

修改插件：

<build>
    <plugins>
        <!-- 用于将应用打成可直接运行的 jar（该 jar 就是用于生产环境中的 jar） 值得注意的是，如果没有引用 spring-boot-starter-parent 做 parent，
        且采用了上述的第二种方式，这里也要做出相应的改动 -->
        <plugin>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-maven-plugin</artifactId>
            <configuration>
                <!--fork : 如果没有该项配置，肯呢个 devtools 不会起作用，即应用不会 restart -->
                <fork>true</fork>
            </configuration>
        </plugin>
    </plugins>
</build>

修改配置文件：
spring:

    # 页面模板
    thymeleaf:
    # 不想每次修改页面都重启,改为 false，默认 true
    cache: false
    content-type: text/html
    # 编码格式
    encoding: UTF-8
    # 存放页面文件的目录
    prefix: classpath:/templates/
    # 页面文件后缀名
    suffix:.html
    # HTML5 严格校验很烦人，改成 LEGACYHTML5,默认为 HTML5
    mode: HTML5

在 IDEA 中设置自动构建，目录为：file -> settings -> compiler。
快捷键 Ctrl + Shift + Alt + /，点击 Registry 项。
然后找到 compiler.automake.allow.when.app.running 选项并勾选。
只有在 debug 方式启动 application 时，修改类文件才会热部署，run 和 debug 方式下，页面文件都会热部署。
（三）Spring Initailzr
Spring Initializr 是一个用于生成基于 JVM 的项目快速启动工具。它支持多种编程语言（如 Java、Kotlin 和 Groovy）和构建系统（如 Apache Maven 和 Gradle）。
项目快速启动：
可以通过网页访问https://start.spring.io/来使用 Spring Initializr。在这个页面上，可以根据自己的需求进行项目配置。
选择项目类型，通常会选择 Maven 项目或 Gradle 项目。接着选择 Java 作为编程语言。对于 Spring Boot 版本，可以根据实际情况选择一个稳定的版本。
填写项目元数据。Group 可以使用组织域名的逆序，Artifact 是应用程序的名称，Name 为项目输入一个易于理解的名称，Description 可以填写对项目的简要描述，这是可选的。Package Name 会根据 Group 和 Artifact 自动生成，也可以根据需要进行调整。Packaging 可以选择 Jar 以创建独立的 JAR 文件，方便部署和运行。
配置好这些信息后，点击 “Generate” 按钮，Spring Initializr 会创建一个包含项目的 ZIP 文件。下载这个 ZIP 文件后，可以将其导入到 IDE 中。
对于 IntelliJ IDEA，可以选择 “File -> New -> Project from Existing Sources”，然后选择下载的 ZIP 文件。确保选择 “Import project from external model” 并选择 “Maven”。按照提示将项目导入到 IDE 中。
对于 Eclipse，需要安装 Maven 插件（如果尚未安装），然后通过 “File -> Import -> Existing Maven Projects” 导入项目。
基本配置：
完成了框架引入，就需要做一些基础配置了。
支持哪些语言：Java、groovy、Kotlin。
支持哪些版本：1.8、11、13 。
支持哪些打包方式：jar、war 。将这些信息全部配置到 application.yml 文件中，如下：

initializr:
  packagings:
    - name: Jar
      id: jar
      default: true
    - name: War
      id: war
      default: false
  javaVersions:
    - id:13
      default: false
    - id: 11
      default: false
    - id: 1.8
      name: 8
      default: true
  languages:
    - name: Java
      id: java
      default: true
    - name: Kotlin
      id: kotlin
      default: false
    - name: Groovy
      id: groovy
      default: false

其中 name 是可选的，id 是必填的。每个配置项下，可以有一个默认值 (将 default 这是为 true 即可)，除了这些基本配置，我们还需要定义可以支持的项目类型：

initializr:
  types:
    - name: Maven Project
      id: maven-project
      description: Generate a Maven based project archive.
      tags:
        build: maven
        format: project
      default: true
      action: /starter.zip
    - name: Maven POM
      id: maven-build
      description: Generate a Maven pom.xml.
      tags:
        build: maven
        format: build
      default: false
      action: /pom.xml
    - name: Gradle Project
      id: gradle-project
      description: Generate a Gradle based project archive.
      tags:
        build: gradle
        format: project
      default: false
      action: /starter.zip
    - name: Gradle Config
      id: gradle-build
      description: Generate a Gradle build file.
      tags:
        build: gradle
        format: build
      default: false
      action: /build.gradle