开发您的第一个 Spring Boot 应用程序

本节描述如何开发一个小型“Hello World!” Web 应用程序，该应用程序突出显示了 Spring Boot 的一些主要功能。您可以选择 Maven 或 Gradle 作为构建系统。

spring.io 网站包含许多使用 Spring Boot 的“入门”指南。如果您需要解决特定问题，请先在那里查看。

您可以通过访问 start.spring.io 并从依赖项搜索器中选择“Web”启动器来缩短以下步骤。这样做会生成一个新的项目结构，以便您可以立即开始编码。有关更多详细信息，请查看 start.spring.io 用户指南。

先决条件

在开始之前，打开终端并运行以下命令以确保您安装了有效版本的 Java

$ java -version
openjdk version "17.0.16" 2025-07-15 LTS
OpenJDK Runtime Environment (build 17.0.16+12-LTS)
OpenJDK 64-Bit Server VM (build 17.0.16+12-LTS, mixed mode, sharing)
此示例需要在其自己的目录中创建。后续说明假定您已创建了合适的目录并且该目录是您的当前目录。

Maven

如果您想使用 Maven，请确保您已安装 Maven

$ mvn -v
Apache Maven 3.9.11 (3e54c93a704957b63ee3494413a2b544fd3d825b)
Maven home: /Users/developer/.sdkman/candidates/maven/current
Java version: 17.0.16, vendor: BellSoft, runtime: /Users/developer/.sdkman/candidates/java/17.0.16-librca

Gradle

如果您想使用 Gradle，请确保您已安装 Gradle

$ gradle --version

------------------------------------------------------------
Gradle 8.14.3
------------------------------------------------------------

Build time:    2025-07-04 13:15:44 UTC
Revision:      e5ee1df3d88b8ca3a8074787a94f373e3090e1db

Kotlin:        2.0.21
Groovy:        3.0.24
Ant:           Apache Ant(TM) version 1.10.15 compiled on August 25 2024
Launcher JVM:  17.0.16 (BellSoft 17.0.16+12-LTS)
Daemon JVM:    /Users/developer/.sdkman/candidates/java/17.0.16-librca (no JDK specified, using current Java home)
OS:            Mac OS X 15.7.1 aarch64

使用 Maven 设置项目

我们需要首先创建一个 Maven pom.xml 文件。pom.xml 是用于构建项目的配方。打开您喜欢的文本编辑器并添加以下内容

<?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.example</groupId>
	<artifactId>myproject</artifactId>
	<version>0.0.1-SNAPSHOT</version>

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

	<!-- Additional lines to be added here... -->

</project>

前面的清单应该能为您提供一个可工作的构建。

您可以通过运行 mvn package 来测试它（目前，您可以忽略“jar 将为空 - 没有内容被标记为包含！”警告）。

此时，您可以将项目导入到 IDE 中（大多数现代 Java IDE 都包含对 Maven 的内置支持）。为简单起见，我们继续使用纯文本编辑器来处理此示例。

使用 Gradle 设置项目

我们需要首先创建一个 Gradle build.gradle 文件。build.gradle 是用于构建项目的构建脚本。打开您喜欢的文本编辑器并添加以下内容

plugins {
	id 'java'
	id 'org.springframework.boot' version '4.0.0'
}

apply plugin: 'io.spring.dependency-management'

group = 'com.example'
version = '0.0.1-SNAPSHOT'

java {
	sourceCompatibility = '17'
}

repositories {
	mavenCentral()
}

dependencies {
}

前面的清单应该能为您提供一个可工作的构建。您可以通过运行 gradle classes 来测试它。

此时，您可以将项目导入到 IDE 中（大多数现代 Java IDE 都包含对 Gradle 的内置支持）。为简单起见，我们继续使用纯文本编辑器来处理此示例。

添加类路径依赖项

Spring Boot 提供了许多启动器，可让您将 jar 添加到类路径中。启动器提供了您在开发特定类型的应用程序时可能需要的依赖项。

Maven

大多数 Spring Boot 应用程序在 POM 的 parent 部分使用 spring-boot-starter-parent。spring-boot-starter-parent 是一个特殊的启动器，它提供了有用的 Maven 默认值。它还提供了一个 dependency-management 部分，以便您可以省略“受祝福”依赖项的 version 标签。

由于我们正在开发一个 Web 应用程序，因此我们添加了 spring-boot-starter-web 依赖项。在此之前，我们可以通过运行以下命令查看我们目前拥有的内容

$ mvn dependency:tree

[INFO] com.example:myproject:jar:0.0.1-SNAPSHOT

mvn dependency:tree 命令打印项目依赖项的树形表示。您可以看到 spring-boot-starter-parent 本身不提供任何依赖项。要添加必要的依赖项，请编辑您的 pom.xml 并在 parent 部分下方立即添加 spring-boot-starter-web 依赖项

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

如果您再次运行 mvn dependency:tree，您会看到现在有许多额外的依赖项，包括 Tomcat Web 服务器和 Spring Boot 本身。

Gradle

大多数 Spring Boot 应用程序都使用 org.springframework.boot Gradle 插件。此插件提供了有用的默认值和 Gradle 任务。io.spring.dependency-management Gradle 插件提供了 依赖项管理，以便您可以省略“受祝福”依赖项的 version 标签。

由于我们正在开发一个 Web 应用程序，因此我们添加了 spring-boot-starter-web 依赖项。在此之前，我们可以通过运行以下命令查看我们目前拥有的内容

$ gradle dependencies

> Task :dependencies

------------------------------------------------------------
Root project 'myproject'
------------------------------------------------------------

gradle dependencies 命令打印项目依赖项的树形表示。目前，项目没有依赖项。要添加必要的依赖项，请编辑您的 build.gradle 并在 dependencies 部分中添加 spring-boot-starter-web 依赖项

dependencies {
	implementation 'org.springframework.boot:spring-boot-starter-web'
}

如果您再次运行 gradle dependencies，您会看到现在有许多额外的依赖项，包括 Tomcat Web 服务器和 Spring Boot 本身。

编写代码

要完成我们的应用程序，我们需要创建一个 Java 文件。默认情况下，Maven 和 Gradle 从 src/main/java 编译源代码，因此您需要创建该目录结构，然后添加一个名为 src/main/java/com/example/MyApplication.java 的文件以包含以下代码

  • Java

  • Kotlin

package com.example;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

@RestController
@SpringBootApplication
public class MyApplication {

	@RequestMapping("/")
	String home() {
		return "Hello World!";
	}

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

}
package com.example

import org.springframework.boot.autoconfigure.SpringBootApplication
import org.springframework.boot.runApplication
import org.springframework.web.bind.annotation.RequestMapping
import org.springframework.web.bind.annotation.RestController

@RestController
@SpringBootApplication
class MyApplication {

	@RequestMapping("/")
	fun home() = "Hello World!"

}

fun main(args: Array<String>) {
	runApplication<MyApplication>(*args)
}

尽管这里的代码不多，但正在发生的事情却很多。我们将在接下来的几节中逐步介绍重要的部分。

@RestController 和 @RequestMapping 注解

我们的 MyApplication 类上的第一个注解是 @RestController。这被称为原型注解。它为阅读代码的人和 Spring 提供了提示，说明该类扮演着特定的角色。在这种情况下，我们的类是一个 Web @Controller，因此 Spring 在处理传入的 Web 请求时会考虑它。

@RequestMapping 注解提供了“路由”信息。它告诉 Spring，任何路径为 / 的 HTTP 请求都应该映射到 home 方法。@RestController 注解告诉 Spring 将结果字符串直接渲染回调用者。

@RestController 和 @RequestMapping 注解是 Spring MVC 注解（它们不是 Spring Boot 特有的）。有关更多详细信息，请参阅 Spring 参考文档中的 MVC 部分。

@SpringBootApplication 注解

第二个类级别注解是 @SpringBootApplication。此注解被称为元注解，它结合了 @SpringBootConfiguration、@EnableAutoConfiguration 和 @ComponentScan。

其中，我们最感兴趣的注解是 @EnableAutoConfiguration。@EnableAutoConfiguration 告诉 Spring Boot 根据您添加的 jar 依赖项“猜测”您希望如何配置 Spring。由于 spring-boot-starter-web 添加了 Tomcat 和 Spring MVC，因此自动配置假定您正在开发 Web 应用程序并相应地设置 Spring。

启动器和自动配置

自动配置旨在与启动器协同工作，但这两个概念并非直接相关。您可以自由选择启动器之外的 jar 依赖项。Spring Boot 仍会尽力自动配置您的应用程序。

“main”方法

我们应用程序的最后一部分是 main 方法。这是一个遵循 Java 应用程序入口点约定的标准方法。我们的 main 方法通过调用 run 将委托给 Spring Boot 的 SpringApplication 类。SpringApplication 引导我们的应用程序，启动 Spring，Spring 又启动自动配置的 Tomcat Web 服务器。我们需要将 MyApplication.class 作为参数传递给 run 方法，以告知 SpringApplication 哪个是主要的 Spring 组件。args 数组也一并传递，以公开任何命令行参数。

运行示例

Maven

此时，您的应用程序应该可以工作。由于您使用了 spring-boot-starter-parent POM，因此您有一个有用的 run 目标，您可以使用它来启动应用程序。从根项目目录中键入 mvn spring-boot:run 以启动应用程序。您应该会看到类似于以下内容的输出

$ mvn spring-boot:run

  .   ____          _            __ _ _
 /\\ / ___'_ __ _ _(_)_ __  __ _ \ \ \ \
( ( )\___ | '_ | '_| | '_ \/ _` | \ \ \ \
 \\/  ___)| |_)| | | | | || (_| |  ) ) ) )
  '  |____| .__|_| |_|_| |_\__, | / / / /
 =========|_|==============|___/=/_/_/_/
 :: Spring Boot ::  (v4.0.0)
....... . . .
....... . . . (log output here)
....... . . .
........ Started MyApplication in 0.906 seconds (process running for 6.514)

如果您在 Web 浏览器中打开 localhost:8080，您应该会看到以下输出

Hello World!

要优雅地退出应用程序，请按 ctrl-c。

Gradle

此时，您的应用程序应该可以工作。由于您使用了 org.springframework.boot Gradle 插件，因此您有一个有用的 bootRun 目标，您可以使用它来启动应用程序。从根项目目录中键入 gradle bootRun 以启动应用程序。您应该会看到类似于以下内容的输出

$ gradle bootRun

  .   ____          _            __ _ _
 /\\ / ___'_ __ _ _(_)_ __  __ _ \ \ \ \
( ( )\___ | '_ | '_| | '_ \/ _` | \ \ \ \
 \\/  ___)| |_)| | | | | || (_| |  ) ) ) )
  '  |____| .__|_| |_|_| |_\__, | / / / /
 =========|_|==============|___/=/_/_/_/
 :: Spring Boot ::  (v4.0.0)
....... . . .
....... . . . (log output here)
....... . . .
........ Started MyApplication in 0.906 seconds (process running for 6.514)

如果您在 Web 浏览器中打开 localhost:8080，您应该会看到以下输出

Hello World!

要优雅地退出应用程序，请按 ctrl-c。

创建可执行 Jar

我们通过创建一个完全自包含的可执行 jar 文件来完成示例，我们可以在生产环境中运行该文件。可执行 jar（有时称为“uber jar”或“fat jar”）是包含您编译的类以及代码运行所需的所有 jar 依赖项的存档。

可执行 jar 和 Java

Java 不提供加载嵌套 jar 文件（本身包含在 jar 中的 jar 文件）的标准方法。如果您希望分发自包含的应用程序，这可能会带来问题。

为了解决这个问题，许多开发人员使用“uber”jar。uber jar 将所有应用程序依赖项中的所有类打包到一个存档中。这种方法的问题在于，很难看出应用程序中包含哪些库。如果多个 jar 中使用相同的文件名（但内容不同），也可能出现问题。

Spring Boot 采用 不同的方法，允许您直接嵌套 jar。

Maven

要创建可执行 jar，我们需要将 spring-boot-maven-plugin 添加到我们的 pom.xml 中。为此，请在 dependencies 部分下方插入以下行

<build>
	<plugins>
		<plugin>
			<groupId>org.springframework.boot</groupId>
			<artifactId>spring-boot-maven-plugin</artifactId>
		</plugin>
	</plugins>
</build>
spring-boot-starter-parent POM 包含 <executions> 配置以绑定 repackage 目标。如果您不使用父 POM，则需要自己声明此配置。有关详细信息，请参阅 插件文档。

保存您的 pom.xml 并从命令行运行 mvn package，如下所示

$ mvn package

[INFO] Scanning for projects...
[INFO]
[INFO] ------------------------------------------------------------------------
[INFO] Building myproject 0.0.1-SNAPSHOT
[INFO] ------------------------------------------------------------------------
[INFO] .... ..
[INFO] --- maven-jar-plugin:2.4:jar (default-jar) @ myproject ---
[INFO] Building jar: /Users/developer/example/spring-boot-example/target/myproject-0.0.1-SNAPSHOT.jar
[INFO]
[INFO] --- spring-boot-maven-plugin:4.0.0:repackage (default) @ myproject ---
[INFO] ------------------------------------------------------------------------
[INFO] BUILD SUCCESS
[INFO] ------------------------------------------------------------------------

如果您查看 target 目录，您应该会看到 myproject-0.0.1-SNAPSHOT.jar。该文件的大小应该在 18 MB 左右。如果您想查看内部，可以使用 jar tvf，如下所示

$ jar tvf target/myproject-0.0.1-SNAPSHOT.jar

您还应该在 target 目录中看到一个名为 myproject-0.0.1-SNAPSHOT.jar.original 的小得多的文件。这是 Maven 在被 Spring Boot 重新打包之前创建的原始 jar 文件。

要运行该应用程序，请使用 java -jar 命令，如下所示

$ java -jar target/myproject-0.0.1-SNAPSHOT.jar

  .   ____          _            __ _ _
 /\\ / ___'_ __ _ _(_)_ __  __ _ \ \ \ \
( ( )\___ | '_ | '_| | '_ \/ _` | \ \ \ \
 \\/  ___)| |_)| | | | | || (_| |  ) ) ) )
  '  |____| .__|_| |_|_| |_\__, | / / / /
 =========|_|==============|___/=/_/_/_/
 :: Spring Boot ::  (v4.0.0)
....... . . .
....... . . . (log output here)
....... . . .
........ Started MyApplication in 0.999 seconds (process running for 1.253)

如前所述，要退出应用程序，请按 ctrl-c。

Gradle

要创建可执行 jar，我们需要从命令行运行 gradle bootJar，如下所示

$ gradle bootJar

BUILD SUCCESSFUL in 639ms
3 actionable tasks: 3 executed

如果您查看 build/libs 目录，您应该会看到 myproject-0.0.1-SNAPSHOT.jar。该文件的大小应该在 18 MB 左右。如果您想查看内部，可以使用 jar tvf，如下所示

$ jar tvf build/libs/myproject-0.0.1-SNAPSHOT.jar

要运行该应用程序，请使用 java -jar 命令，如下所示

$ java -jar build/libs/myproject-0.0.1-SNAPSHOT.jar

  .   ____          _            __ _ _
 /\\ / ___'_ __ _ _(_)_ __  __ _ \ \ \ \
( ( )\___ | '_ | '_| | '_ \/ _` | \ \ \ \
 \\/  ___)| |_)| | | | | || (_| |  ) ) ) )
  '  |____| .__|_| |_|_| |_\__, | / / / /
 =========|_|==============|___/=/_/_/_/
 :: Spring Boot ::  (v{version-spring-boot})
....... . . .
....... . . . (log output here)
....... . . .
........ Started MyApplication in 0.999 seconds (process running for 1.253)

如前所述，要退出应用程序，请按 ctrl-c。

© . This site is unofficial and not affiliated with VMware.