Spring Boot快速入门：打造Hello World应用

本文还有配套的精品资源，点击获取

简介：Spring Boot简化了Spring应用的初始搭建和开发过程，允许开发者快速启动并运行Java应用。本文通过创建一个简单的“Hello, World!”应用，演示了如何在IntelliJ IDEA中使用Spring Initializr创建Spring Boot项目，并解决Tomcat外置启动问题。我们从创建项目开始，包含Web依赖，编写主程序类和Controller，并展示了内嵌与外置Tomcat容器的配置与使用。此教程是Spring Boot学习之旅的起点，帮助初学者快速掌握Spring Boot的基础知识。

1. Spring Boot框架简介

Spring Boot是一种流行的Java应用开发框架，它为开发者提供了快速开发和运行Spring应用程序的能力。它简化了配置流程，使得开发者能够迅速搭建一个独立的、生产级别的基于Spring框架的应用。

在本章中，我们将简要回顾Spring Boot的由来，理解其设计哲学，并探讨为何它在现代Java开发中成为首选框架之一。

Spring Boot的设计哲学

• 约定优于配置 ：Spring Boot通过默认配置简化了项目的配置工作，使开发者可以专注于代码实现，而不是繁琐的配置文件。
• 自动配置 ：它提供了大量自动配置选项，根据类路径中的jar包依赖，自动配置应用的基础设施。
• 独立运行 ：Spring Boot应用可以打包为一个独立的Jar文件，无需外部依赖，简化部署和运维过程。

在了解Spring Boot的基本概念之后，我们可以在接下来的章节深入学习如何创建和管理一个Spring Boot项目。这将涉及项目初始化、核心配置、内嵌Servlet容器的配置等关键步骤。

2. 创建Spring Boot项目基础

2.1 项目初始化

2.1.1 使用Spring Initializr进行项目构建

在现代Java开发中，Spring Initializr是构建新Spring Boot项目的一个非常受欢迎的起点。它是一个网页应用，帮助开发者快速生成Spring Boot项目的基础结构。通过这个工具，开发者只需选择需要的组件，然后下载生成的项目压缩包即可。

在访问Spring Initializr时（https://start.spring.io/），我们可以看到一系列的选项，如项目类型、语言、Spring Boot版本、项目元数据（Group和Artifact名称）、包名、Java版本等。此外，还可以选择项目将需要的依赖项（Dependencies），比如Web、JPA、Security等。

使用Spring Initializr构建项目的基本步骤如下：

1. 打开Spring Initializr网站。
2. 填写项目基本信息，例如Group和Artifact。
3. 选择项目的构建工具，通常是Maven或Gradle。
4. 选择Spring Boot版本和Java版本。
5. 选择项目需要的依赖项。
6. 点击“Generate”按钮，下载生成的项目。

生成的项目是一个基础的Maven或Gradle项目结构，其中包括了 pom.xml 或 build.gradle 文件，并已经配置了所选依赖。

2.1.2 项目结构和关键依赖分析

下载并解压生成的项目后，我们可以看到标准的目录结构，一般如下所示：

my-spring-boot-project/
├── src/
│   ├── main/
│   │   ├── java/
│   │   │   └── com/
│   │   │       └── mycompany/
│   │   │           └── myapp/ # 主程序包
│   │   │               ├── MyApplication.java # 应用入口类
│   │   │               └── controller/ # 控制器包
│   │   ├── resources/
│   │   │   ├── application.properties # 核心配置文件
│   │   │   └── static/ # 存放静态资源，如CSS/JS/图片
│   │   └── templates/ # 存放模板文件，如Thymeleaf模板
│   └── test/
│       └── java/
│           └── com/
│               └── mycompany/
│                   └── myapp/ # 单元测试包
└── pom.xml # Maven构建文件

关键依赖分析：

• Spring Boot Starter Web：包含了构建web应用（包括RESTful）的所有依赖，如Spring MVC、Tomcat。
• Spring Boot Starter Test：包含用于测试Spring Boot应用的库，如JUnit、Mockito。
• Spring Boot Starter Data JPA：为JPA/Hibernate提供支持，用于数据库操作。
• Spring Boot Starter Security：提供基础的安全性功能。

在 pom.xml 或 build.gradle 中可以看到这些依赖项已经被添加到项目中，并且通常会被指定为scope为 compile ，这意味着这些依赖会被包含在编译后的类路径中。

2.2 Spring Boot的核心配置

2.2.1 application.properties与application.yml简介

Spring Boot允许开发者通过两种配置文件来设置配置属性—— application.properties 和 application.yml 。这两种文件都位于项目的 src/main/resources 目录下。配置文件中可以定义诸如服务器端口、数据库连接、日志级别等配置项。

• application.properties ：是一个简单的键值对形式的配置文件。
• application.yml ：利用YAML（YAML Ain't Markup Language）格式，提供了一种更易读的方式来组织数据。

比如，我们可以在 application.properties 文件中设置服务器端口：

server.port=8080

或者在 application.yml 文件中：

server:
  port: 8080

两种格式的配置文件在功能上是等价的，选择哪一种取决于个人偏好和团队约定。

2.2.2 配置文件的作用域和加载顺序

Spring Boot的配置文件可以有不同的作用域，这允许你在不同的环境中运行同一应用，而无需更改代码。这些作用域包括：

• application ：通用配置，适用于任何环境。
• application-{profile}.properties ：特定环境的配置，如 application-dev.properties 用于开发环境。
• application-{profile}.yml ：同样用于特定环境。

在配置文件加载顺序上，Spring Boot会按照以下规则进行配置加载：

1. 命令行参数：如 java -jar app.jar --server.port=9090 。
2. 特定环境的配置文件：如 application-{profile}.properties 。
3. application-{profile}.yml 。
4. 通用配置文件： application.properties 或 application.yml 。
5. 默认配置：由Spring Boot的jar包内提供的默认配置文件。
6. @Configuration 注解类内的 @PropertySource 。
7. 通过 ServletConfig 初始化参数。
8. 通过 ServletContext 初始化参数。

当存在相同的配置属性时，后加载的配置会覆盖先前的配置。比如，命令行参数配置的属性会覆盖配置文件中的同名属性。

在代码中获取配置属性值时，通常使用 @Value 注解或者 Environment 对象：

@Configuration
public class AppConfig {
    @Value("${server.port}")
    private int serverPort;

    public void displayServerPort() {
        System.out.println("Server Port: " + serverPort);
    }
}

通过这样的配置和加载顺序，Spring Boot提供了灵活性来管理不同环境下的配置差异。这在进行部署到开发、测试和生产环境时非常有用。

3. 内嵌Servlet容器与Tomcat配置

3.1 内嵌Servlet容器

3.1.1 Servlet技术回顾

Servlet是Java EE核心组件之一，它运行在服务器端并处理客户端请求，生成响应。在Web应用中，Servlet负责接收来自用户的请求，执行业务逻辑处理，并返回结果。它被设计为一种以请求/响应为中心的服务器端组件，扩展了Java的 Servlet API，通过 javax.servlet 包提供。

历史上，Servlet的运行依赖于外部的Servlet容器，如Tomcat、Jetty或GlassFish等，但随着Spring Boot的出现，它提供了一种方便的方式将Servlet容器嵌入到应用程序中。这样做的好处是可以将Web应用打包为一个独立的可执行的Jar文件，简化了部署过程。

3.1.2 Spring Boot内嵌容器的自动配置机制

Spring Boot对内嵌Servlet容器的集成是基于自动配置机制实现的。当Spring Boot项目中包含Tomcat、Jetty或Undertow等依赖时，Spring Boot会自动配置相应的Servlet容器。

• spring-boot-starter-web ：这是包含Servlet API及Tomcat依赖的起步依赖，包含了自动配置Web应用所需的所有组件。
• 自动配置类：Spring Boot定义了多个自动配置类，如 EmbeddedTomcatAutoConfiguration 、 EmbeddedJettyAutoConfiguration 和 EmbeddedUndertowAutoConfiguration ，这些类会在条件满足时自动配置对应的Servlet容器。

内嵌Servlet容器的优点包括：

• 简化部署流程 ：无需手动配置外部Servlet容器，应用可以打包为单个可执行文件。
• 开发便捷 ：支持快速启动和热部署，无需重启Servlet容器即可加载类路径中的更改。
• 资源占用较少 ：与传统的Servlet容器相比，内嵌容器的资源占用更少，适合轻量级应用。

3.2 Tomcat配置详解

3.2.1 如何自定义Tomcat端口和参数

虽然Spring Boot的自动配置功能已经足够强大，但在实际开发过程中，我们可能需要根据自己的需求进行一些自定义配置，比如修改Tomcat端口号或添加一些启动参数。

• 修改端口：可以在 application.properties 或 application.yml 文件中添加如下配置来修改Tomcat端口：

# application.properties
server.port=8081

或者

# application.yml
server:
  port: 8081

• 添加启动参数：可以通过配置 server.tomcat虚拟主机配置 来自定义Tomcat启动参数：

# application.properties
server.tomcat.uri-encoding=UTF-8

3.2.2 定制和优化Tomcat配置

Spring Boot允许开发者通过配置属性定制Tomcat的许多方面。以下是一些常见的配置示例：

• 设置最大连接数 ：

server.tomcat.max-connections=10000

• 设置最大线程数 ：

server.tomcat.max-threads=200

• 修改会话超时时间 ：

server.tomcat.session-timeout=30

• 启用压缩 ：

server.tomcat.compression=on
server.tomcat.compression-min-response-size=2048

这些配置可以帮助你优化Tomcat的性能，但需要注意的是，应该根据实际的应用负载和资源状况进行合理配置，避免不恰当的设置导致资源浪费或者性能瓶颈。

通过自定义和优化配置，我们可以更灵活地调整Tomcat的行为，使其更适合我们的应用场景，从而提高应用的性能和稳定性。

4. IntelliJ IDEA中Spring Boot应用的创建与启动

4.1 开发环境准备

4.1.1 安装和配置IntelliJ IDEA

IntelliJ IDEA 是一款功能强大的 Java 开发工具，它提供了许多针对 Spring Boot 的优化和支持。首先，确保你的计算机满足运行 IntelliJ IDEA 的最低系统要求。接下来，访问 JetBrains 官网 下载并安装适合你操作系统的 IntelliJ IDEA 版本。社区版是免费的，适合个人学习使用；而专业版则提供企业级支持，适合专业开发。

安装完成后，启动 IntelliJ IDEA 并进行初步配置。首先，导入你的开发环境设置（如果有的话），然后通过 File > Settings (在 Mac 上是 IntelliJ IDEA > Preferences ) 进入设置界面。在设置界面中，你可以定制 IDE 的外观、编辑器、构建工具等。

4.1.2 IDEA对Spring Boot的支持与插件安装

IntelliJ IDEA 对 Spring Boot 提供了内置支持，包括项目创建向导、自动配置、代码提示、运行和调试等。为了充分利用这些功能，确保你的 IDE 安装了 Spring Assistant 插件。安装插件的步骤如下：

1. 打开 IntelliJ IDEA 并进入 File > Settings > Plugins 。
2. 点击 "Marketplace" 标签页，然后在搜索框中输入 "Spring Assistant"。
3. 找到插件后，点击 "Install" 按钮进行安装，重启 IDE 以激活插件。

安装 Spring Assistant 插件后，你的开发体验将得到极大的提升。例如，它可以帮助你更便捷地生成 Spring Boot 的项目结构、自动导入所需的依赖以及在编写代码时提供有用的建议。

4.2 创建和启动应用

4.2.1 使用Spring Initializr在IDEA中创建项目

在 IntelliJ IDEA 中创建一个新项目非常简单。以下是详细步骤：

1. 打开 IntelliJ IDEA，选择 File > New > Project... 。
2. 在弹出的窗口中，选择左侧的 "Spring Initializr" 选项。
3. 输入项目的 Group 、 Artifact 信息，并选择项目的 JDK 版本。
4. 点击 "Next"，然后从左侧选择你需要的 Spring Boot 启动器（Starters）。
5. 完成其他项目配置选项后，点击 "Finish"。

Spring Initializr 会为你生成一个基础的 Spring Boot 项目结构，并且 IntelliJ IDEA 会自动导入所需的依赖。

4.2.2 在IDEA中运行和调试Spring Boot应用

创建项目后，接下来是运行和调试应用程序：

1. 找到位于 src/main/java 下的主类，这个类通常包含一个 main 方法，并用 @SpringBootApplication 注解标记。
2. 右键点击主类文件，选择 "Run '主类名'" 来启动应用。
3. 你可以看到控制台输出，显示应用启动的信息。
4. 如果需要调试应用，设置断点，在需要的地方点击行号旁边的空白区域，然后选择 Debug '主类名' 来启动调试模式。

调试模式允许你逐行执行代码、查看变量值以及评估表达式，这对于理解应用程序的行为和解决问题非常有帮助。

在 IntelliJ IDEA 中运行 Spring Boot 应用非常直接，通过这些步骤，你可以快速开始你的开发工作。调试功能则让你有能力深入研究应用的执行流程，确保代码按预期工作。

5. 编写Hello World Controller

编写你的第一个Spring Boot Controller不仅仅是一个简单的编程任务，它是理解Spring MVC和Spring Boot核心概念的一个重要步骤。这个过程涉及对MVC架构的理解、路由配置以及如何使用Spring Boot简化Web开发流程。

5.1 Controller基本概念

5.1.1 MVC架构概述

MVC（Model-View-Controller）是一种广泛使用的软件设计模式，主要用于组织代码以分离业务逻辑（Model）、数据访问层（Controller）和用户界面（View）。在Web应用中，这种模式允许开发者分别关注应用的不同方面，使得代码更加模块化，易于维护和测试。

• Model ：代表应用数据的对象，用于存储和管理数据。
• View ：负责展示数据，将数据转换成用户可以看见的格式（如HTML页面）。
• Controller ：处理用户请求，将请求转发给相应的模型处理，然后选择视图进行展示。

5.1.2 Controller的作用与实现方式

在Spring Boot中，Controller是处理Web请求的关键组件。它被设计为用于处理HTTP请求，调用业务逻辑层的数据，并最终返回响应。

• 处理HTTP请求 ：Controller可以通过不同的注解来处理GET、POST、PUT、DELETE等HTTP请求。例如，使用 @GetMapping 来处理GET请求，使用 @PostMapping 来处理POST请求。
• 路由与视图解析 ：Controller通过注解指定的路由信息来接收请求，并返回相应的视图名称或者数据。Spring Boot使用ViewResolver来查找响应的视图组件，或者直接返回数据（如JSON）。

5.2 实现Hello World

5.2.1 编写简单的Controller类

在Spring Boot应用中，创建一个简单的Controller非常直接。首先，你需要在你的项目中添加相关的依赖和配置。接下来，你可以创建一个新的类并使用 @Controller 注解。

假设我们要创建一个简单的“Hello World”应用，首先需要一个Controller类，像下面这样：

import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.GetMapping;

@Controller
public class HelloWorldController {

    @GetMapping("/hello")
    public String helloWorld() {
        return "hello";
    }
}

上述代码创建了一个简单的Controller类，并定义了一个方法来处理对 /hello 路径的GET请求。当请求到达时，它会返回一个视图名称“hello”，Spring Boot会根据配置找到对应的视图模板并渲染它。

5.2.2 配置路由与返回视图或数据

在Spring Boot中，配置路由是非常灵活的。你可以使用 @GetMapping 、 @PostMapping 、 @PutMapping 、 @DeleteMapping 等注解来定义不同的路由。

在本例中，我们使用 @GetMapping 来定义一个路由：

@GetMapping("/hello")
public String helloWorld() {
    return "hello";
}

上面的代码段是一个非常基础的例子，没有参数和复杂的逻辑。对于返回简单数据（如JSON或XML），你可以使用 @RestController 注解替代 @Controller ，并使用 @ResponseBody 来直接返回数据，例如：

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

@RestController
public class HelloWorldController {

    @GetMapping("/hello")
    public String helloWorld() {
        return "Hello, World!";
    }
}

在以上代码中，当访问 /hello 路径时，客户端将直接接收到字符串 Hello, World! ，而不是视图名称。

通过上述过程，你已经完成了从理解Spring Boot Controller的基本概念到创建一个简单的Hello World应用的整个过程。这个基础的示例为深入学习和开发更复杂的Spring Boot应用奠定了坚实的基础。

6. 解决IDEA中Tomcat外置启动问题

6.1 外置Tomcat的启动过程

6.1.1 外置Tomcat与内嵌Tomcat的区别

外置Tomcat指的是将Tomcat服务器作为独立的服务运行在操作系统之上，而不是在应用程序内部。与内嵌Tomcat相比，外置Tomcat拥有以下几个显著的区别：

1. 部署灵活性 ：使用外置Tomcat，可以在不重启整个应用的情况下部署或卸载Web应用。
2. 资源管理 ：外置Tomcat由操作系统统一管理资源，对于资源的监控和优化更加方便。
3. 可维护性 ：外置Tomcat由于是独立的服务，更容易进行更新和维护。
4. 独立性 ：每个Spring Boot应用可以配置为使用不同的Tomcat版本，这在外置Tomcat的情况下更为灵活。

6.1.2 配置IDEA以使用外置Tomcat

要在IntelliJ IDEA中配置使用外置Tomcat，你需要按照以下步骤操作：

1. 下载并安装Tomcat ： 下载与你的Spring Boot应用兼容的Tomcat版本，并按照官方文档进行安装。

2. 配置Tomcat的环境变量 ： 确保Tomcat的 bin 目录已经添加到你的系统PATH环境变量中，这样可以在命令行中直接运行Tomcat命令。

3. 在IDEA中添加Tomcat服务器 ： 打开IntelliJ IDEA，选择 File -> Project Structure -> Facets ，点击 + 添加新的服务器配置，选择Tomcat版本并指向你的Tomcat安装目录。

4. 配置应用部署 ： 在 Run/Debug Configurations 中添加新的Tomcat Server，并选择相应的应用进行部署。

6.2 解决常见问题

6.2.1 Classpath和依赖冲突问题

在使用IDEA启动外置Tomcat时，可能会遇到依赖冲突问题，特别是在类路径（classpath）上。以下是解决这类问题的一些技巧：

• 依赖管理工具 ：确保使用Maven或Gradle等依赖管理工具，它们能够帮助管理依赖版本，避免冲突。
• Maven插件冲突解决 ：如果使用Maven构建项目，可以通过 maven-shade-plugin 等插件来解决依赖冲突。
• Gradle依赖解决 ：Gradle提供了灵活的依赖解决策略，比如可以通过 configurations 和 resolutionStrategy 来定制依赖解析。

6.2.2 热部署与配置调试技巧

热部署是指在不重启服务器的情况下更新应用的功能，极大地提高了开发效率。要在外置Tomcat上启用热部署，可以使用以下方法：

• Maven插件配置 ：在 pom.xml 中配置 cargo-maven2-plugin 插件，使得它能够在应用部署后自动检测类路径的更改。
• Gradle配置 ：在 build.gradle 中使用 cargo 插件并设置 deployOnStart 为 true 和 scanInterval 为较短的时间间隔。

调试技巧：

• IDEA调试配置 ：确保在IDEA的 Run/Debug Configurations 中正确配置了Tomcat服务器。设置断点和日志输出，这样在运行时可以捕获和调试问题。
• 日志管理 ：使用SLF4J和Logback等日志库来管理应用日志，配置合适的日志级别和输出格式，有助于快速定位和解决问题。

<!-- 例如maven-cargo-plugin的配置 -->
<plugin>
    <groupId>org.codehaus.cargo</groupId>
    <artifactId>cargo-maven2-plugin</artifactId>
    <version>1.6.6</version>
    <configuration>
        <container>
            <containerId>tomcat8x</containerId>
            <type>remote</type>
        </container>
        <configuration>
            <type>runtime</type>
            <properties>
                <cargo.hostname>localhost</cargo.hostname>
                <cargo.protocol>http</cargo.protocol>
                <cargo.tomcat.manager.url>http://localhost:8080/manager/text</cargo.tomcat.manager.url>
                <cargo.tomcat.port>8080</cargo.tomcat.port>
            </properties>
        </configuration>
    </configuration>
</plugin>

// Gradle中cargo插件的配置示例
configurations {
    cargo {
        resolutionStrategy {
            eachDependency {
                if (requested.group == 'org.apache.tomcat' && requested.name == 'tomcat-juli') {
                    useVersion '8.0.0'
                }
            }
        }
    }
}

在这一章节中，我们深入了解了如何在IntelliJ IDEA中配置和启动外置Tomcat服务器，并且探讨了常见问题的解决方法。通过使用外置Tomcat，开发者可以获得更高的部署灵活性和更优的资源管理。同时，通过依赖管理工具和热部署插件，可以有效避免类路径和依赖冲突，并快速地进行应用调试，从而提升开发效率和应用质量。

7. Spring Boot应用结构与项目文件概览

在深入了解Spring Boot的应用结构和项目文件前，有必要先来回顾一下Maven和Gradle这两种常用的项目管理工具在Spring Boot项目中的应用。Maven和Gradle都用于管理项目的依赖、构建和生命周期，Spring Boot项目通常也会采用这两种工具之一。

7.1 项目文件结构解析

7.1.1 标准的Maven/Gradle项目目录结构

一个标准的Maven项目目录结构如下：

my-spring-boot-app/
|-- src/
|   |-- main/
|   |   |-- java/
|   |   |-- resources/
|   |   `-- webapp/
|   `-- test/
|       |-- java/
|       `-- resources/
`-- pom.xml

• src/main/java 存放Java源代码。
• src/main/resources 存放配置文件、静态资源等。
• src/main/webapp 是Web应用根目录，对于Spring Boot可能不会经常用到，因为Spring Boot更倾向于打成Jar包执行。
• src/test/java 存放测试代码。
• pom.xml 是Maven项目的配置文件，定义了项目的依赖、构建配置等。

相对的，一个Gradle项目目录结构则类似：

my-spring-boot-app/
|-- build.gradle
|-- gradlew
|-- gradlew.bat
|-- settings.gradle
|-- src/
|   |-- main/
|   |   |-- java/
|   |   |-- resources/
|   |   `-- assets/
|   `-- test/
|       |-- java/
|       `-- resources/
`-- build/
    `-- classes/

• build.gradle 是Gradle项目的构建脚本。
• settings.gradle 用于配置项目范围内的设置。
• src/main/java 和 src/main/resources 与Maven结构相同。
• src/main/assets 用于存放静态资源，而Web应用资源通常放在 src/main/webapp 。
• build/ 是Gradle构建过程生成的目录。

7.1.2 Spring Boot项目特有的目录与文件

Spring Boot项目结构在标准Maven/Gradle目录结构的基础上添加了一些特有的目录和文件，例如：

• application.properties 或 application.yml ：项目配置文件，用于定制应用的配置，比如数据库连接、应用端口等。
• static/ ：存放静态资源文件，比如JavaScript、CSS和图片文件。
• templates/ ：存放模板文件，如Thymeleaf模板文件，用于生成动态网页内容。

7.2 项目文件详解

7.2.1 Java源码文件的组织

在 src/main/java 目录下，根据Maven或Gradle的约定，源码文件通常被组织在对应包路径下：

com.example.demo
|-- Application.java
|-- controller/
|   `-- HelloController.java
|-- service/
|   `-- HelloWorldService.java
|-- repository/
|   `-- GreetingRepository.java
`-- model/
    `-- Greeting.java

• Application.java 是Spring Boot应用的启动类，通常带有 @SpringBootApplication 注解。
• controller 包用于存放控制器（Controller）类。
• service 包用于存放服务（Service）类。
• repository 包用于存放数据访问对象（Repository）。
• model 包用于存放数据模型（Model）类。

7.2.2 静态资源和模板文件的存放

静态资源如图片、样式表、JavaScript文件等通常放在 src/main/resources/static 目录下。模板文件则通常放在 src/main/resources/templates 目录下，Spring Boot默认支持多种模板引擎，比如Thymeleaf、FreeMarker等。

7.2.3 配置文件的位置与作用

Spring Boot的配置文件有多种格式，如YAML（推荐格式）、properties等，它们可以放在 src/main/resources 目录下。

• application.properties 是一个通用的配置文件，可以配置许多Spring Boot应用的属性。
• application.yml 是一个YAML格式的配置文件，具有更好的可读性和结构化特性。

配置文件的作用域可以是整个应用，也可以是特定的环境（开发、测试、生产等）。Spring Boot通过激活不同的profile来加载对应的配置文件。

7.3 应用打包与部署

7.3.1 打包成可执行的Jar文件

Spring Boot应用的一个强大特性是可以打包成一个独立的Jar文件，包含所有依赖，并且可以作为“胖Jar”直接运行。使用Maven或Gradle构建工具可以轻松完成这一任务：

# 使用Maven
mvn clean package

# 使用Gradle
./gradlew build

构建成功后， target 或 build/libs 目录下会生成可执行的Jar文件。

7.3.2 部署Spring Boot应用到服务器

部署Spring Boot应用到服务器十分简单，只需将打包好的Jar文件传输到服务器上，然后使用命令：

java -jar my-spring-boot-app.jar

为了方便管理和维护，通常我们会使用如Supervisor、Systemd等工具来管理Jar文件的启动和停止。

总结而言，理解和熟悉Spring Boot项目文件结构和内容是非常重要的，这不仅有助于在开发过程中高效地组织代码和资源，也确保了在部署和维护过程中能够快速定位和解决问题。

本文还有配套的精品资源，点击获取

简介：Spring Boot简化了Spring应用的初始搭建和开发过程，允许开发者快速启动并运行Java应用。本文通过创建一个简单的“Hello, World!”应用，演示了如何在IntelliJ IDEA中使用Spring Initializr创建Spring Boot项目，并解决Tomcat外置启动问题。我们从创建项目开始，包含Web依赖，编写主程序类和Controller，并展示了内嵌与外置Tomcat容器的配置与使用。此教程是Spring Boot学习之旅的起点，帮助初学者快速掌握Spring Boot的基础知识。

本文还有配套的精品资源，点击获取