此版本仍在开发中，尚未被视为稳定版本。如需最新稳定版本，请使用 Spring Boot 4.0.4!spring-doc.cadn.net.cn

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

本节介绍如何开发一个小型的“Hello World!” Web 应用程序，以突出展示 Spring Boot 的一些关键特性。您可以选择 Maven 或 Gradle 作为构建系统。spring-doc.cadn.net.cn

spring.io 网站包含许多使用 Spring Boot 的“入门”指南。如果您需要解决特定问题，请首先在此处查找。spring-doc.cadn.net.cn

您可以通过访问 start.spring.io 并在依赖项搜索器中选择“Web”Starters，来简化以下步骤。这样即可生成一个新的项目结构，使您能够立即开始编码。有关更多详细信息，请参阅 start.spring.io 用户指南。spring-doc.cadn.net.cn

前提条件

在开始之前，请打开终端并运行以下命令，以确保您已安装有效版本的 Java：spring-doc.cadn.net.cn

$ java -version
openjdk version "17.0.18" 2026-01-20 LTS
OpenJDK Runtime Environment (build 17.0.18+10-LTS)
OpenJDK 64-Bit Server VM (build 17.0.18+10-LTS, mixed mode, sharing)

此示例需要在其自身的目录中创建。后续说明假设您已创建了一个合适的目录，并且该目录是您的当前工作目录。

Maven

如果要使用 Maven，请确保已安装 Maven：spring-doc.cadn.net.cn

$ mvn -v
Apache Maven 3.9.12 (848fbb4bf2d427b72bdb2471c22fced7ebd9a7a1)
Maven home: /Users/developer/.sdkman/candidates/maven/current
Java version: 17.0.18, vendor: BellSoft, runtime: /Users/developer/.sdkman/candidates/java/17.0.18-librca

Gradle

如果要使用 Gradle，请确保已安装 Gradle：spring-doc.cadn.net.cn

$ gradle --version

------------------------------------------------------------
Gradle 8.14.4
------------------------------------------------------------

Build time:    2026-01-23 16:30:23 UTC
Revision:      ad5ff774b4b0e9a8a0cf1a14ca70d7230003c3ad

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

使用 Maven 设置项目

我们需要首先创建一个 Maven pom.xml 文件。 pom.xml 是用于构建项目的配置说明。打开您最喜爱的文本编辑器，并添加以下内容：spring-doc.cadn.net.cn

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

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

    <!-- you don't need this if you are using a release version -->
    <repositories>
        <repository>
            <id>spring-snapshots</id>
            <url>https://repo.spring.io/snapshot</url>
            <snapshots>
                <enabled>true</enabled>
            </snapshots>
        </repository>
    </repositories>
    <pluginRepositories>
        <pluginRepository>
            <id>spring-snapshots</id>
            <url>https://repo.spring.io/snapshot</url>
            <snapshots>
                <enabled>true</enabled>
            </snapshots>
        </pluginRepository>
    </pluginRepositories>
</project>

上述清单应能为你提供一个可运行的构建。spring-doc.cadn.net.cn

您可以通过运行 mvn package 来测试它（目前可忽略“jar 将为空——未标记任何内容以包含在内！”警告）。spring-doc.cadn.net.cn

此时，您可以将该项目导入集成开发环境（IDE）中（大多数现代 Java IDE 都内置了对 Maven 的支持）。为简化起见，本示例中我们继续使用纯文本编辑器。

使用 Gradle 搭建项目

我们需要首先创建一个 Gradle build.gradle 文件。 build.gradle 是用于构建项目的构建脚本。打开您最喜爱的文本编辑器，并添加以下内容：spring-doc.cadn.net.cn

plugins {
	id 'java'
	id 'org.springframework.boot' version '3.5.13-SNAPSHOT'
    id 'io.spring.dependency-management' version '1.1.7'
}

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

java {
	toolchain {
		languageVersion = JavaLanguageVersion.of(17)
	}
}

repositories {
	mavenCentral()
    // you don't need this if you are using a release version
	maven { url 'https://repo.spring.io/snapshot' }
}

dependencies {
}

上述代码清单应能为您提供一个可正常运行的构建。您可以通过运行 gradle classes 来测试它。spring-doc.cadn.net.cn

此时，您可以将该项目导入集成开发环境（IDE）中（大多数现代 Java IDE 都内置了对 Gradle 的支持）。为简化起见，本示例中我们继续使用纯文本编辑器。

添加类路径依赖项

Spring Boot 提供了多个 Starter，可让您将 JAR 包添加到类路径中。 Starter 提供了在开发特定类型应用程序时可能需要的依赖项。spring-doc.cadn.net.cn

Maven

大多数 Spring Boot 应用程序在 POM 文件的 spring-boot-starter-parent 部分使用 parent。 spring-boot-starter-parent 是一个特殊的Starters（starter），可提供有用的 Maven 默认配置。它还提供了一个 dependency-management 部分，使您可以省略对“受支持”依赖项的 version 标签。spring-doc.cadn.net.cn

由于我们正在开发一个 Web 应用程序，因此需要添加一个 spring-boot-starter-web 依赖项。在此之前，我们可以通过运行以下命令来查看当前的项目结构：spring-doc.cadn.net.cn

$ 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 依赖项：spring-doc.cadn.net.cn

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

如果再次运行 mvn dependency:tree，您会发现现在增加了若干其他依赖项，其中包括 Tomcat Web 服务器和 Spring Boot 本身。spring-doc.cadn.net.cn

Gradle

大多数 Spring Boot 应用程序使用 org.springframework.boot Gradle 插件。该插件提供了有用的默认配置和 Gradle 任务。 io.spring.dependency-management Gradle 插件提供依赖项管理，因此您可以省略针对“受支持”依赖项的 version 标签。spring-doc.cadn.net.cn

$ gradle dependencies

> Task :dependencies

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

gradle dependencies 命令将打印项目依赖关系的树状结构。目前，该项目没有任何依赖项。要添加必要的依赖项，请编辑您的 build.gradle 文件，并在 dependencies 部分中添加 spring-boot-starter-web 依赖项：spring-doc.cadn.net.cn

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

如果再次运行 gradle dependencies，您会发现现在增加了若干其他依赖项，其中包括 Tomcat Web 服务器和 Spring Boot 本身。spring-doc.cadn.net.cn

编写代码

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

Javaspring-doc.cadn.net.cn
Kotlinspring-doc.cadn.net.cn

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)
}

虽然此处代码不多，但实际执行的内容却相当丰富。接下来的几节中，我们将逐步讲解其中的重要部分。spring-doc.cadn.net.cn

@RestController 和 @RequestMapping 注解

我们 MyApplication 类上的第一个注解是 @RestController。这被称为一种 构造型 注解。它为阅读代码的人员以及 Spring 框架提供提示，表明该类承担特定的角色。在本例中，我们的类是一个 Web @Controller，因此 Spring 在处理传入的 Web 请求时会将其纳入考虑范围。spring-doc.cadn.net.cn

@RequestMapping 注解提供“路由”信息。它告诉 Spring：任何路径为 / 的 HTTP 请求都应映射到 home 方法。 @RestController 注解告诉 Spring 将返回的字符串直接渲染并返回给调用方。spring-doc.cadn.net.cn

@Controller 和 @RestController 注解是 Spring MVC 的注解（它们并非 Spring Boot 特有）。有关更多详细信息，请参阅 Spring 参考文档中的 MVC 章节。

@SpringBootApplication 注解

第二个类级别注解是 @SpringBootApplication。该注解被称为元注解，它组合了 @SpringBootConfiguration、@EnableAutoConfiguration 和 @ComponentScan。spring-doc.cadn.net.cn

其中，我们在此最关注的注解是 @EnableAutoConfiguration。 @EnableAutoConfiguration 告诉 Spring Boot 根据你已添加的 JAR 依赖项“推测”你希望如何配置 Spring。由于 spring-boot-starter-web 添加了 Tomcat 和 Spring MVC，自动配置会假定你正在开发 Web 应用程序，并据此相应地设置 Spring。spring-doc.cadn.net.cn

Starters与自动配置

自动配置旨在与起步依赖（starters）良好协作，但这两者概念上并无直接关联。您可以自由地在起步依赖之外选择所需的 JAR 依赖。 Spring Boot 仍会尽力为您的应用程序执行自动配置。spring-doc.cadn.net.cn

“main” 方法

我们应用程序的最后一部分是 main 方法。这是一个遵循 Java 应用程序入口点约定的标准方法。我们的 main 方法通过调用 run，将控制权委托给 Spring Boot 的 SpringApplication 类。 SpringApplication 启动我们的应用程序，首先启动 Spring，而 Spring 进而启动自动配置的 Tomcat Web 服务器。我们需要将 MyApplication.class 作为参数传递给 run 方法，以告知 SpringApplication 哪个是主要的 Spring 组件。 args 数组也会被一并传入，用于暴露所有命令行参数。spring-doc.cadn.net.cn

运行示例

Maven

此时，您的应用程序应该可以正常运行。由于您使用了 spring-boot-starter-parent POM，因此您拥有一个实用的 run 目标，可用于启动应用程序。在项目根目录下输入 mvn spring-boot:run 以启动应用程序。您将看到类似以下内容的输出：spring-doc.cadn.net.cn

$ mvn spring-boot:run

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

如果您在 Web 浏览器中打开 localhost:8080，应该会看到以下输出：spring-doc.cadn.net.cn

Hello World!

要优雅地退出应用程序，请按 ctrl-c。spring-doc.cadn.net.cn

Gradle

此时，您的应用程序应该可以正常运行。由于您使用了 org.springframework.boot Gradle 插件，因此拥有一个实用的 bootRun 构建目标，可用于启动应用程序。在项目根目录下输入 gradle bootRun 以启动应用程序。您将看到类似以下内容的输出：spring-doc.cadn.net.cn

$ gradle bootRun

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

如果您在 Web 浏览器中打开 localhost:8080，应该会看到以下输出：spring-doc.cadn.net.cn

Hello World!

要优雅地退出应用程序，请按 ctrl-c。spring-doc.cadn.net.cn

创建可执行的Jar包

我们通过创建一个完全自包含的可执行 JAR 文件来完成本示例，该文件可在生产环境中直接运行。可执行 JAR（有时称为“uber JAR”或“fat JAR”）是包含已编译类以及代码运行所需全部 JAR 依赖项的归档文件。spring-doc.cadn.net.cn

可执行的 JAR 文件和 Java

Java 并未提供加载嵌套 JAR 文件（即自身包含在另一个 JAR 文件内的 JAR 文件）的标准方法。如果你希望分发一个自包含的应用程序，这可能会带来问题。spring-doc.cadn.net.cn

为了解决这一问题，许多开发人员会使用“胖”jar（uber jar）。 “胖”jar 将应用程序所有依赖项中的全部类打包进单个归档文件中。这种做法的问题在于，很难看清应用程序中具体包含了哪些库。此外，如果多个 jar 文件使用了相同的文件名（但内容不同），也可能引发问题。spring-doc.cadn.net.cn

Spring Boot 采用了一种不同的方法，允许您直接嵌套 JAR 文件。spring-doc.cadn.net.cn

Maven

要创建可执行的 JAR 文件，我们需要将 spring-boot-maven-plugin 添加到我们的 pom.xml 中。为此，请将以下几行插入到 dependencies 部分正下方：spring-doc.cadn.net.cn

<build>
	<plugins>
		<plugin>
			<groupId>org.springframework.boot</groupId>
			<artifactId>spring-boot-maven-plugin</artifactId>
		</plugin>
	</plugins>
</build>

spring-boot-starter-parent POM 包含用于绑定 repackage 目标的 <executions> 配置。如果您不使用父 POM，则需要自行声明此配置。详情请参阅插件文档。

保存您的 pom.xml，然后在命令行中运行 mvn package，具体如下：spring-doc.cadn.net.cn

$ 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:3.5.13-SNAPSHOT:repackage (default) @ myproject ---
[INFO] ------------------------------------------------------------------------
[INFO] BUILD SUCCESS
[INFO] ------------------------------------------------------------------------

如果您查看 target 目录，应该能看到 myproject-0.0.1-SNAPSHOT.jar。该文件大小约为 18 MB。如果您想查看其内部结构，可以使用 jar tvf，具体方法如下：spring-doc.cadn.net.cn

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

您还应在 target 目录中看到一个名为 myproject-0.0.1-SNAPSHOT.jar.original 的更小文件。这是 Maven 在 Spring Boot 对其进行重新打包之前所创建的原始 JAR 文件。spring-doc.cadn.net.cn

要运行该应用程序，请使用 java -jar 命令，如下所示：spring-doc.cadn.net.cn

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

  .   ____          _            __ _ _
 /\\ / ___'_ __ _ _(_)_ __  __ _ \ \ \ \
( ( )\___ | '_ | '_| | '_ \/ _` | \ \ \ \
 \\/  ___)| |_)| | | | | || (_| |  ) ) ) )
  '  |____| .__|_| |_|_| |_\__, | / / / /
 =========|_|==============|___/=/_/_/_/
 :: Spring Boot ::  (v3.5.13-SNAPSHOT)
....... . . .
....... . . . (log output here)
....... . . .
........ Started MyApplication in 0.497 seconds (process running for 0.651)

与之前一样，要退出应用程序，请按 ctrl-c。spring-doc.cadn.net.cn

Gradle

要创建一个可执行的 JAR 文件，我们需要在命令行中运行 gradle bootJar，如下所示：spring-doc.cadn.net.cn

$ gradle bootJar

BUILD SUCCESSFUL in 639ms
3 actionable tasks: 3 executed

如果您查看 build/libs 目录，应该能看到 myproject-0.0.1-SNAPSHOT.jar。该文件大小约为 18 MB。如果您想查看其内部结构，可以使用 jar tvf，具体方法如下：spring-doc.cadn.net.cn

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

要运行该应用程序，请使用 java -jar 命令，如下所示：spring-doc.cadn.net.cn

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

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

与之前一样，要退出应用程序，请按 ctrl-c。spring-doc.cadn.net.cn