getting-started_first-application.md

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

本节介绍如何开发一个小的 “Hello World！” web 应用程序，用来突出 Spring Boot 的一些关键特性的。因为大多数 IDE 都支持 Maven，所以我们使用 Maven 来构建这个项目。

Tip:

spring.io 网站包含许多使用 Spring Boot 的“入门”[指南](https://spring.io/guides)[。](https://spring.io/) 如果您需要解决特定的问题，请先到那里查找解决方案。

如果您想简化以下构建项目的步骤，可以在 [start.spring.io](https://start.spring.io/) 中选择 "Dependencies" 搜索器中的 “Web” 选项。这样做会生成一个全新的项目结构，以便您可以[立即开始编码](https://docs.spring.io/spring-boot/docs/2.6.4/reference/html/getting-started.html#getting-started.first-application.code)。查看[start.spring.io 用户指南](https://github.com/spring-io/start.spring.io/blob/main/USING.adoc)了解更多详情。

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

```
$ java -version
java version "1.8.0_102"
Java(TM) SE Runtime Environment (build 1.8.0_102-b14)
Java HotSpot(TM) 64-Bit Server VM (build 25.102-b14, mixed mode)
```

```
$ mvn -v
Apache Maven 3.5.4 (1edded0938998edf8bf061f1ceb3cfdeccf443fe; 2018-06-17T14:33:14-04:00)
Maven home: /usr/local/Cellar/maven/3.3.9/libexec
Java version: 1.8.0_102, vendor: Oracle Corporation
```

Note:

此示例需要创建在一个它自己单独的目录中。后续说明都是假定您已经创建了一个合适的目录并且它是您的当前目录。

### 创建 POM

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

```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>2.6.4</version>
    </parent>

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

</project>
```

前面的内容应该会让您成功地构建项目。您可以运行 `mvn package` 进行测试（目前您可以忽略 “jar will be empty - no content was marked for inclusion!” 的警告）。

Note:

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

### 添加 ClassPath 依赖项

Spring Boot 提供了许多“启动器” (stater) ，可让您将 jars 添加到 ClassPath 中。我们冒烟测试应用程序使用的是 POM 文件 "parent" 部分的 `spring-boot-starter-parent` 。`spring-boot-starter-parent` 是一个特殊的启动器，提供了有用的 Maven 默认值。它还提供了一个[`dependency-management`](https://docs.spring.io/spring-boot/docs/2.6.4/reference/html/using.html#using.build-systems.dependency-management)，以便您可以省略一部分依赖项的 `version` 标签。

其他“Starters”提供了您在开发特定类型的应用程序时可能需要的依赖项。由于我们正在开发 Web 应用程序，因此我们添加了一个`spring-boot-starter-web`依赖项。我们可以通过运行以下命令查看我们当前依赖的内容：

```shell
$ 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`

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

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

### 编写代码

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

```java
@RestController
@EnableAutoConfiguration
public class MyApplication {

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

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

}
```

虽然这里没有太多代码，但已经产生了很大的作用。我们将在接下来的几节中逐步介绍重要的部分。

#### @RestController 和 @RequestMapping 注解

`MyApplication`类的第一个注解是`@RestController`. 这称为*构造型*注解。它告诉阅读代码的人和 Spring 这个类扮演了哪些特定的角色。在这个例子中，我们的类是一个 web `@Controller`，因此 Spring 在处理传入的 Web 请求时会使用它。

`@RequestMapping` 注释提供“路由”信息。它告诉 Spring 任何带有`/`路径的 HTTP 请求都应该映射到 `home` 方法。`@RestController` 注释告诉 Spring 将结果以字符串的形式直接呈现给调用者。

Tip:

`@RestController` 和 `@RequestMapping` 注释是 Spring MVC 注释（它们不是特定只用于 Spring Boot）。有关详细信息，请参阅 Spring 参考文档中的[MVC 部分](https://docs.spring.io/spring-framework/docs/5.3.16/reference/html/web.html#mvc)。

#### @EnableAutoConfiguration 注解

第二个类级别的注释是`@EnableAutoConfiguration`. 这个注解告诉 Spring Boot 根据你添加的 jar 依赖来“猜测”你想如何配置 Spring。由于`spring-boot-starter-web`添加了 Tomcat 和 Spring MVC，自动配置功能会假定您正在开发 Web 应用程序并相应地设置 Spring。

```
启动器和自动配置
自动配置旨在与“启动器”很好地配合使用，但这两个概念并没有直接联系。您可以自由选择启动器之外的 jar 依赖项。Spring Boot 仍然尽力自动配置您的应用程序。
```

#### “main”方法

我们应用程序的最后一部分是`main`方法。这是一种遵循应用程序入口点的 Java 约定的标准方法。main 方法会委托给 Spring Boot 的 `SpringApplication` 类的 `run`方法。 `SpringApplication` 引导我们的应用程序，启动 Spring，然后启动自动配置的 Tomcat Web 服务器。我们需要将 `MyApplication.class` 作为参数传递给该 `run` 方法，去告诉 `SpringApplication` 哪个是主要的 Spring 组件。该 `args` 数组也传递了命令行参数。

### 运行示例

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

```shell
$ mvn spring-boot:run

  .   ____          _            __ _ _
 /\\ / ___'_ __ _ _(_)_ __  __ _ \ \ \ \
( ( )\___ | '_ | '_| | '_ \/ _` | \ \ \ \
 \\/  ___)| |_)| | | | | || (_| |  ) ) ) )
  '  |____| .__|_| |_|_| |_\__, | / / / /
 =========|_|==============|___/=/_/_/_/
 :: Spring Boot ::  (v2.6.4)
....... . . .
....... . . . (log output here)
....... . . .
........ Started MyApplication in 2.222 seconds (JVM running for 6.514)
```

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

```
Hello World!
```

要优雅地退出应用程序，请在命令行中按`ctrl-c`。

### 创建可执行 Jar

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

可执行 jar 和 Java

Java 不提供加载嵌套 jar 文件（包含了 jar 的 jar 文件）的标准方法。如果您希望部署一个独立的应用程序，这可能会出现问题。

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

Spring Boot 采用了[不同的方法](https://docs.spring.io/spring-boot/docs/2.6.4/reference/html/executable-jar.html#appendix.executable-jar)，让您实际上可以直接嵌套 jar。

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

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

备注:

POM中的 `spring-boot-starter-parent` 包含了 `<executions>` 的配置去绑定 `repackage` 的目标。如果不使用父 POM，则需要自己声明此配置。有关详细信息，请参阅[插件文档](https://docs.spring.io/spring-boot/docs/2.6.4/maven-plugin/reference/htmlsingle/#getting-started)。

保存`pom.xml`并从命令行运行`mvn package`，如下：

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

如果您查看`target`目录，您应该会看到`myproject-0.0.1-SNAPSHOT.jar`. 该文件的大小应约为 10 MB。如果你想看 jar 里面的内容，可以使用`jar tvf`，如下所示：

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

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

如下所示，使用 "java -jar" 命令来运行应用程序。

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

  .   ____          _            __ _ _
 /\\ / ___'_ __ _ _(_)_ __  __ _ \ \ \ \
( ( )\___ | '_ | '_| | '_ \/ _` | \ \ \ \
 \\/  ___)| |_)| | | | | || (_| |  ) ) ) )
  '  |____| .__|_| |_|_| |_\__, | / / / /
 =========|_|==============|___/=/_/_/_/
 :: Spring Boot ::  (v2.6.4)
....... . . .
....... . . . (log output here)
....... . . .
........ Started MyApplication in 2.536 seconds (JVM running for 2.864)
```

和以前一样，要退出应用程序，请按`ctrl-c`。

原文链接: https://docs.spring.io/spring-boot/docs/2.6.4/reference/html/getting-started.html#getting-started.first-application