此版本仍在开发中，尚未被视为稳定版本。对于最新的稳定版本，请使用 Spring Boot 3.4.4！spring-doc.cadn.net.cn

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

本节介绍如何开发一个小型的 “Hello World！” Web 应用程序，其中重点介绍了 Spring Boot 的一些关键功能。您可以选择 Maven 或 Gradle 作为构建系统。spring-doc.cadn.net.cn

spring.io Web 站点包含许多使用 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.4.1" 2022-08-12 LTS
OpenJDK Runtime Environment (build 17.0.4.1+1-LTS)
OpenJDK 64-Bit Server VM (build 17.0.4.1+1-LTS, mixed mode, sharing)

此示例需要在其自己的目录中创建。后续说明假定您已创建合适的目录，并且它是您的当前目录。

Maven 系列

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

$ mvn -v
Apache Maven 3.8.5 (3599d3414f046de2324203b78ddcf9b5e4388aa0)
Maven home: usr/Users/developer/tools/maven/3.8.5
Java version: 17.0.4.1, vendor: BellSoft, runtime: /Users/developer/sdkman/candidates/java/17.0.4.1-librca

Gradle

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

$ gradle --version

------------------------------------------------------------
Gradle 8.1.1
------------------------------------------------------------

Build time:   2023-04-21 12:31:26 UTC
Revision:     1cf537a851c635c364a4214885f8b9798051175b

Kotlin:       1.8.10
Groovy:       3.0.15
Ant:          Apache Ant(TM) version 1.10.11 compiled on July 10 2021
JVM:          17.0.7 (BellSoft 17.0.7+7-LTS)
OS:           Linux 6.2.12-200.fc37.aarch64 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>

	<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>3.5.0-SNAPSHOT</version>
	</parent>

	<!-- 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>
			<repository>
				<id>spring-milestones</id>
				<url>https://repo.spring.io/milestone</url>
			</repository>
		</repositories>
		<pluginRepositories>
			<pluginRepository>
				<id>spring-snapshots</id>
				<url>https://repo.spring.io/snapshot</url>
			</pluginRepository>
			<pluginRepository>
				<id>spring-milestones</id>
				<url>https://repo.spring.io/milestone</url>
			</pluginRepository>
		</pluginRepositories>
</project>

前面的清单应该为您提供一个有效的版本。spring-doc.cadn.net.cn

您可以通过运行mvn package（现在，您可以忽略 “jar will be empty - no content was marked for inclusion！” 警告）。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.0-SNAPSHOT'
}

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

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

repositories {
	mavenCentral()
	maven { url 'https://repo.spring.io/milestone' }
	maven { url 'https://repo.spring.io/snapshot' }
}

dependencies {
}

前面的清单应该为您提供一个有效的版本。您可以通过运行gradle classes.spring-doc.cadn.net.cn

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

添加 Classpath 依赖项

Spring Boot 提供了许多Starters，允许您将 jar 添加到 Classpath 中。 Starters 提供在开发特定类型的应用程序时可能需要的依赖项。spring-doc.cadn.net.cn

Maven 系列

大多数 Spring Boot 应用程序都使用spring-boot-starter-parent在parent部分。这spring-boot-starter-parent是一个特殊的Starters，它提供有用的 Maven 默认值。它还提供了一个dependency-management部分，以便您可以省略version标记中。spring-doc.cadn.net.cn

由于我们正在开发一个 Web 应用程序，因此我们添加了一个spring-boot-starter-webDependency。在此之前，我们可以通过运行以下命令来查看我们当前拥有的内容：spring-doc.cadn.net.cn

$ mvn dependency:tree

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

这mvn dependency:treecommand 打印项目依赖项的树表示形式。你可以看到spring-boot-starter-parent本身不提供任何依赖项。要添加必要的依赖项，请编辑pom.xml并添加spring-boot-starter-web依赖项紧邻parent部分：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.bootGradle 插件。此插件提供有用的默认值和 Gradle 任务。这io.spring.dependency-managementGradle 插件提供依赖项管理，因此您可以省略version标记中。spring-doc.cadn.net.cn

$ gradle dependencies

> Task :dependencies

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

这gradle dependenciescommand 打印项目依赖项的树表示形式。目前，该项目没有依赖项。要添加必要的依赖项，请编辑build.gradle并添加spring-boot-starter-webdependency 在dependencies部分：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)
}



Although there is not much code here, quite a lot is going on.
We step through the important parts in the next few sections.spring-doc.cadn.net.cn


The @RestController and @RequestMapping Annotations

The first annotation on our MyApplication class is @RestController.
This is known as a stereotype annotation.
It provides hints for people reading the code and for Spring that the class plays a specific role.
In this case, our class is a web @Controller, so Spring considers it when handling incoming web requests.spring-doc.cadn.net.cn


The @RequestMapping annotation provides “routing” information.
It tells Spring that any HTTP request with the  path should be mapped to the /home method.
The @RestController annotation tells Spring to render the resulting string directly back to the caller.spring-doc.cadn.net.cn








The @RestController and @RequestMapping annotations are Spring MVC annotations (they are not specific to Spring Boot).
See the MVC section in the Spring Reference Documentation for more details.






The @SpringBootApplication Annotation

The second class-level annotation is @SpringBootApplication.
This annotation is known as a meta-annotation, it combines @SpringBootConfiguration, @EnableAutoConfiguration and @ComponentScan.spring-doc.cadn.net.cn


Of those, the annotation we’re most interested in here is @EnableAutoConfiguration.
@EnableAutoConfiguration tells Spring Boot to “guess” how you want to configure Spring, based on the jar dependencies that you have added.
Since spring-boot-starter-web added Tomcat and Spring MVC, the auto-configuration assumes that you are developing a web application and sets up Spring accordingly.spring-doc.cadn.net.cn



Starters and Auto-configuration

Auto-configuration is designed to work well with starters, but the two concepts are not directly tied.
You are free to pick and choose jar dependencies outside of the starters.
Spring Boot still does its best to auto-configure your application.spring-doc.cadn.net.cn





The “main” Method

The final part of our application is the main method.
This is a standard method that follows the Java convention for an application entry point.
Our main method delegates to Spring Boot’s SpringApplication class by calling run.
SpringApplication bootstraps our application, starting Spring, which, in turn, starts the auto-configured Tomcat web server.
We need to pass MyApplication.class as an argument to the run method to tell SpringApplication which is the primary Spring component.
The args array is also passed through to expose any command-line arguments.spring-doc.cadn.net.cn



Running the Example


Maven

At this point, your application should work.
Since you used the spring-boot-starter-parent POM, you have a useful run goal that you can use to start the application.
Type mvn spring-boot:run from the root project directory to start the application.
You should see output similar to the following:spring-doc.cadn.net.cn



$ mvn spring-boot:run

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



If you open a web browser to localhost:8080, you should see the following output:spring-doc.cadn.net.cn



Hello World!



To gracefully exit the application, press ctrl-c.spring-doc.cadn.net.cn



Gradle

At this point, your application should work.
Since you used the org.springframework.boot Gradle plugin, you have a useful bootRun goal that you can use to start the application.
Type gradle bootRun from the root project directory to start the application.
You should see output similar to the following:spring-doc.cadn.net.cn



$ gradle bootRun

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



If you open a web browser to localhost:8080, you should see the following output:spring-doc.cadn.net.cn



Hello World!



To gracefully exit the application, press ctrl-c.spring-doc.cadn.net.cn





Creating an Executable Jar


We finish our example by creating a completely self-contained executable jar file that we could run in production.
Executable jars (sometimes called “uber jars” or “fat jars”) are archives containing your compiled classes along with all of the jar dependencies that your code needs to run.spring-doc.cadn.net.cn



Executable jars and Java

Java does not provide a standard way to load nested jar files (jar files that are themselves contained within a jar).
This can be problematic if you are looking to distribute a self-contained application.spring-doc.cadn.net.cn


To solve this problem, many developers use “uber” jars.
An uber jar packages all the classes from all the application’s dependencies into a single archive.
The problem with this approach is that it becomes hard to see which libraries are in your application.
It can also be problematic if the same filename is used (but with different content) in multiple jars.spring-doc.cadn.net.cn


Spring Boot takes a different approach and lets you actually nest jars directly.spring-doc.cadn.net.cn




Maven

To create an executable jar, we need to add the spring-boot-maven-plugin to our pom.xml.
To do so, insert the following lines just below the dependencies section:spring-doc.cadn.net.cn



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









The spring-boot-starter-parent POM includes <executions> configuration to bind the repackage goal.
If you do not use the parent POM, you need to declare this configuration yourself.
See the plugin documentation for details.





Save your pom.xml and run mvn package from the command line, as follows: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.0-SNAPSHOT:repackage (default) @ myproject ---
[INFO] ------------------------------------------------------------------------
[INFO] BUILD SUCCESS
[INFO] ------------------------------------------------------------------------



If you look in the target directory, you should see myproject-0.0.1-SNAPSHOT.jar.
The file should be around 18 MB in size.
If you want to peek inside, you can use jar tvf, as follows:spring-doc.cadn.net.cn



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



You should also see a much smaller file named myproject-0.0.1-SNAPSHOT.jar.original in the target directory.
This is the original jar file that Maven created before it was repackaged by Spring Boot.spring-doc.cadn.net.cn


To run that application, use the java -jar command, as follows:spring-doc.cadn.net.cn



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

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



As before, to exit the application, press ctrl-c.spring-doc.cadn.net.cn



Gradle

To create an executable jar, we need to run gradle bootJar from the command line, as follows:spring-doc.cadn.net.cn



$ gradle bootJar

BUILD SUCCESSFUL in 639ms
3 actionable tasks: 3 executed



If you look in the build/libs directory, you should see myproject-0.0.1-SNAPSHOT.jar.
The file should be around 18 MB in size.
If you want to peek inside, you can use jar tvf, as follows:spring-doc.cadn.net.cn



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



To run that application, use the java -jar command, as follows: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.999 seconds (process running for 1.253)



As before, to exit the application, press ctrl-c.spring-doc.cadn.net.cn