提交 5bd2a819 编写于 作者: 茶陵後's avatar 茶陵後 👍

Spring 文档校对 Merge

上级 524e88a1
# 使用 RESTful Web 服务
本指南将引导您完成创建使用 RESTful Web 服务的应用程序的过程
本指南将引导您创建一个提供 RESTful Web 服务的应用程序
## 你将建造什么
您将构建一个应用程序,该应用程序使用 Spring`RestTemplate`在https://quoters.apps.pcfone.io/api/random检索随机 Spring Boot 报价
您将构建一个应用程序,该应用程序使用 Spring`RestTemplate` 请求 https://quoters.apps.pcfone.io/api/random 获得一个随机的 Spring Boot 引文
## 你需要什么
......@@ -13,46 +13,46 @@
- [JDK 1.8](http://www.oracle.com/technetwork/java/javase/downloads/index.html)或更高版本
- [Gradle 4+](http://www.gradle.org/downloads)[Maven 3.2+](https://maven.apache.org/download.cgi)
- 您还可以将代码直接导入 IDE:
- [弹簧工具套件 (STS)](https://spring.io/guides/gs/sts)
- [Spring Tool Suite (STS)](https://spring.io/guides/gs/sts)
- [IntelliJ IDEA](https://spring.io/guides/gs/intellij-idea/)
## 如何完成本指南
像大多数 Spring[入门指南](https://spring.io/guides)一样,您可以从头开始并完成每个步骤,也可以绕过您已经熟悉的基本设置步骤。无论哪种方式,您最终都会得到工作代码。
像大多数 Spring[入门指南](https://spring.io/guides)一样,您可以从头开始并完成每个步骤,也可以绕过您已经熟悉的基本设置步骤。两种方式都会让您得到可以成功运行的代码。
**从头开始**,请继续[从 Spring Initializr 开始](https://spring.io/guides/gs/consuming-rest/#scratch)
**从头开始**,请参考[从 Spring Initializr 开始](https://spring.io/guides/gs/consuming-rest/#scratch)
**跳过基础知识**,请执行以下操作:
- [下载](https://github.com/spring-guides/gs-consuming-rest/archive/main.zip)并解压缩本指南的源存储库,或使用[Git](https://spring.io/understanding/Git)克隆它:`git clone https://github.com/spring-guides/gs-consuming-rest.git`
- 光盘进入`gs-consuming-rest/initial`
- 跳转到[获取 REST 资源](https://spring.io/guides/gs/consuming-rest/#initial)
- [下载](https://github.com/spring-guides/gs-consuming-rest/archive/main.zip)并解压缩本指南的源代码,或使用[Git](https://spring.io/understanding/Git)克隆它:`git clone https://github.com/spring-guides/gs-consuming-rest.git`
- 进入项目中的 `gs-consuming-rest/initial` 目录
- 继续阅读[获取 REST 资源](https://spring.io/guides/gs/consuming-rest/#initial)
**完成后**,您可以对照中的代码检查结果`gs-consuming-rest/complete`
**完成后**,您可以对照`gs-consuming-rest/complete`中的代码进行检查
## 从 Spring Initializr 开始
您可以使用这个[预先初始化的项目](https://start.spring.io/#!type=maven-project&language=java&platformVersion=2.5.5&packaging=jar&jvmVersion=11&groupId=com.example&artifactId=consuming-rest&name=consuming-rest&description=Demo project for Spring Boot&packageName=com.example.consuming-rest&dependencies=web)并单击 Generate 下载 ZIP 文件。此项目配置为适合本教程中的示例。
您可以使用这个[预先初始化的项目](https://start.spring.io/#!type=maven-project&language=java&platformVersion=2.5.5&packaging=jar&jvmVersion=11&groupId=com.example&artifactId=consuming-rest&name=consuming-rest&description=Demo project for Spring Boot&packageName=com.example.consuming-rest&dependencies=web) 单击 Generate 下载 ZIP 文件。此项目的配置适合教程中的示例。
手动初始化项目:
1. 导航到[https://start.spring.io](https://start.spring.io/)。该服务提取应用程序所需的所有依赖项,并为您完成大部分设置。
2. 选择 Gradle 或 Maven 以及您要使用的语言。本指南假定您选择了 Java。
3. 单击**Dependencies**并选择**Spring Web**
4. 单击**生成**
5. 下载生成的 ZIP 文件,该文件是根据您的选择配置的 Web 应用程序的存档
4. 单击**Generate**
5. 下载生成的 ZIP 文件,该文件是根据您的选择配置好的 Web 应用程序压缩包
如果您的 IDE 具有 Spring Initializr 集成,您可以从您的 IDE 完成此过程。
你也可以从 Github 上 fork 项目并在你的 IDE 或其他编辑器中打开它。
你也可以从 Github 上 fork 这个项目并在你的 IDE 或其他编辑器中打开它。
## 获取 REST 资源
完成项目设置后,您可以创建一个使用 RESTful 服务的简单应用程序。
完成项目设置后,您可以创建一个使用 RESTful 服务的简单应用程序。
一个 RESTful 服务已经在https://quoters.apps.pcfone.io/api/random建立起来。它随机获取有关 Spring Boot 的引用并将它们作为 JSON 文档返回。
在 https://quoters.apps.pcfone.io/api/random 已经提供了一个 RESTful 服务。它随机将有关 Spring Boot 的引文作为 JSON 文档的形式返回。
如果您通过 Web 浏览器或 curl 请求该 URL,您会收到如下所示的 JSON 文档:
如果您通过 Web 浏览器或 curl 命令请求该 URL,您会收到如下所示的 JSON 文档:
```
{
......@@ -64,11 +64,11 @@
}
```
这很容易,但在通过浏览器或 curl 获取时并不是非常有用
通过浏览器或 curl 获取响应很容易,但这种方式并不是用途很广
以编程方式使用 REST Web 服务的更有用的方法。为了帮助您完成这项任务,Spring 提供了一个方便的模板类,称为[`RestTemplate`](https://docs.spring.io/spring/docs/current/javadoc-api/org/springframework/web/client/RestTemplate.html). `RestTemplate`使与大多数 RESTful 服务的交互成为单行咒语。它甚至可以将该数据绑定到自定义域类型
以编程方式使用 REST Web 服务是更通用的方法。为了帮助您完成这项任务,Spring 提供了一个方便的模板类,称为[`RestTemplate`](https://docs.spring.io/spring/docs/current/javadoc-api/org/springframework/web/client/RestTemplate.html). `RestTemplate` 大大简化了与 RESTful 服务交互的代码。它甚至可以将该数据绑定到自定义的领域类
首先,您需要创建一个域类来包含您需要的数据。以下清单显示了`Quote`可以用作域类的类:
首先,您需要创建一个领域类来包含您需要的数据。以下清单显示了可以用作领域类的`Quote`类:
```
src/main/java/com/example/consumingrest/Quote.java
......@@ -114,11 +114,11 @@ public class Quote {
}
```
这个简单的 Java 类有一些属性和匹配的 getter 方法。它使用`@JsonIgnoreProperties`来自 Jackson JSON 处理库的注释来指示任何未绑定在此类型中的属性应被忽略。
这个简单的 Java 类有一些属性和对应的 getter 方法。用于 JSON 处理的 Jackson 库的 `@JsonIgnoreProperties` 注释意味着未绑定在此类中的属性都应被忽略。
要将您的数据直接绑定到您的自定义类型,您需要将变量名称指定为与从 API 返回的 JSON 文档中的键完全相同。如果您的 JSON 文档中的变量名称和键不匹配,您可以使用`@JsonProperty`注释来指定 JSON 文档的确切键。(此示例将每个变量名称与 JSON 键匹配,因此此处不需要该注释。)
要将数据直接绑定到自定义领域类,您需要在类中定义和 API 返回的 JSON 中的键完全相同的变量名称。如果您的 JSON 中的变量名称和键不匹配,您可以使用`@JsonProperty`注释来为变量指定对应的 JSON 的键。(此示例中每个变量名称都与 JSON 键匹配,因此此处不需要该注释。)
您还需要一个额外的类来嵌入内部引用本身。该类`Value`满足了这一需求,并显示在以下清单 (at `src/main/java/com/example/consumingrest/Value.java`) 中
您还需要一个额外的类来存储引文。`Value`类满足了这一需求,展示如下 (`src/main/java/com/example/consumingrest/Value.java`)
```
package com.example.consumingrest;
......@@ -160,11 +160,11 @@ public class Value {
}
```
使用相同的注释,但映射到其他数据字段。
个类使用了相同的注释,但数据会根据变量名映射到不同的字段。
## 完成申请
## 完成应用
Initalizr 创建一个带有`main()`方法的类。以下清单显示了 Initializr 创建的类(at `src/main/java/com/example/consumingrest/ConsumingRestApplication.java`):
Initalizr 创建了一个带有`main()`方法的类。以下代码显示了 Initializr 创建的类(`src/main/java/com/example/consumingrest/ConsumingRestApplication.java`):
```
package com.example.consumingrest;
......@@ -182,13 +182,13 @@ public class ConsumingRestApplication {
}
```
现在您需要向`ConsumingRestApplication`该类添加一些其他内容,以使其显示来自我们 RESTful 源的引用。您需要添加:
现在您需要向`ConsumingRestApplication`类添加一些代码,以使其展示 RESTful 源服务返回的引文。您需要添加:
- 一个记录器,用于将输出发送到日志(在此示例中为控制台)。
- A `RestTemplate`,它使用 Jackson JSON 处理库来处理传入的数据。
- A在启动`CommandLineRunner`时运行`RestTemplate`(并因此获取我们的报价)。
- 一个日志记录器,用于将输出发送到日志(在此示例中为控制台)。
- 一个 `RestTemplate`,它使用用于 JSON 处理的 Jackson 库来处理传入的数据。
- 一个在启动时用来运行 `RestTemplate``CommandLineRunner`(获取我们的引文)。
以下清单显示了完成的`ConsumingRestApplication`类 (at `src/main/java/com/example/consumingrest/ConsumingRestApplication.java`):
以下代码是最终的`ConsumingRestApplication`类 ( `src/main/java/com/example/consumingrest/ConsumingRestApplication.java`):
```
package com.example.consumingrest;
......@@ -229,29 +229,29 @@ public class ConsumingRestApplication {
## 运行应用程序
您可以使用 Gradle 或 Maven 从命令行运行应用程序。您还可以构建一个包含所有必要依赖项、类和资源的单个可执行 JAR 文件并运行它。构建可执行 jar 可以在整个开发生命周期、跨不同环境等中轻松地作为应用程序交付、版本化和部署服务
您可以使用 Gradle 或 Maven 从命令行运行应用程序。您还可以构建一个包含所有必要依赖项、类和资源的单个可执行 JAR 文件并运行它。构建一个可执行的 jar 可以在整个开发生命周期、不同环境中作为应用程序轻松地去交付、升级、部署
如果您使用 Gradle,则可以使用`./gradlew bootRun`. 或者,您可以使用构建 JAR 文件`./gradlew build`,然后运行 JAR 文件,如下所示:
如果您使用 Gradle,则可以使用`./gradlew bootRun` 去运行程序。或者,您可以使用`./gradlew build`构建 JAR 文件,然后运行 JAR 文件,如下所示:
```
java -jar build/libs/gs-consuming-rest-0.1.0.jar
```
如果您使用 Maven,则可以使用`./mvnw spring-boot:run`. 或者,您可以使用构建 JAR 文件,`./mvnw clean package`然后运行该 JAR 文件,如下所示:
如果您使用 Maven,则可以使用`./mvnw spring-boot:run`. 或者,您可以使用`./mvnw clean package`构建 JAR 文件,然后运行该 JAR 文件,如下所示:
```
java -jar target/gs-consuming-rest-0.1.0.jar
```
此处描述的步骤创建了一个可运行的 JAR。您还可以[构建经典的 WAR 文件](https://spring.io/guides/gs/convert-jar-to-war/)
以上描述的步骤是如何创建一个可运行的 JAR。您还可以[构建经典的 WAR 文件](https://spring.io/guides/gs/convert-jar-to-war/)
您应该看到类似于以下的输出,但带有随机引用
您应该会看到类似于下面内容的输出,但会包含随机的引文
```
2019-08-22 14:06:46.506 INFO 42940 --- [ main] c.e.c.ConsumingRestApplication : Quote{type='success', value=Value{id=1, quote='Working with Spring Boot is like pair-programming with the Spring developers.'}}
```
如果您看到显示为 的错误,`Could not extract response: no suitable HttpMessageConverter found for response type [class com.example.consumingrest.Quote]`则可能是您处于无法连接到后端服务的环境中(如果您可以访问它,它将发送 JSON)。也许您是公司代理的幕后黑手。尝试将`http.proxyHost``http.proxyPort`系统属性设置为适合您的环境的值。
如果您看到显示为的错误,`Could not extract response: no suitable HttpMessageConverter found for response type [class com.example.consumingrest.Quote]` 则可能是您处于无法访问到后端服务的环境中(如果您可以访问它,它将发送 JSON)。如果您是公司代理的管理员,尝试将 `http.proxyHost``http.proxyPort` 系统属性设置为适合您的环境的值。
## 概括
......
## 开发你的第一个 Spring Boot 应用程序
本节介绍如何开发一个小的“Hello World!” 突出 Spring Boot 的一些关键特性的 web 应用程序。我们使用 Maven 来构建这个项目,因为大多数 IDE 都支持它
本节介绍如何开发一个小的 “Hello World!” web 应用程序,用来突出 Spring Boot 的一些关键特性的。因为大多数 IDE 都支持 Maven,所以我们使用 Maven 来构建这个项目
Tip:
spring.io网站包含许多使用 Spring Boot 的“入门”[指南](https://spring.io/guides)[](https://spring.io/)如果您需要解决特定问题,请先检查那里
spring.io 网站包含许多使用 Spring Boot 的“入门”[指南](https://spring.io/guides)[](https://spring.io/) 如果您需要解决特定的问题,请先到那里查找解决方案
您可以通过转到[start.spring.io](https://start.spring.io/)并从依赖项搜索器中选择“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)了解更多详情。
如果您想简化以下构建项目的步骤,可以在 [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:
......@@ -26,11 +26,11 @@ Java version: 1.8.0_102, vendor: Oracle Corporation
Note:
此示例需要在其自己的目录中创建。后续说明假定您已经创建了一个合适的目录并且它是您的当前目录。
此示例需要创建在一个它自己单独的目录中。后续说明都是假定您已经创建了一个合适的目录并且它是您的当前目录。
### 创建 POM
我们需要从创建一个 Maven`pom.xml`文件开始。这`pom.xml`是用于构建项目的配方。打开您喜欢的文本编辑器并添加以下内容:
我们需要从创建一个 Maven`pom.xml`文件开始。这个`pom.xml`是用于构建项目的配方。打开您喜欢的文本编辑器并添加以下内容:
```xml
<?xml version="1.0" encoding="UTF-8"?>
......@@ -53,17 +53,17 @@ Note:
</project>
```
前面的清单应该给你一个工作构建。您可以通过运行对其进行测试`mvn package`(现在,您可以忽略“jar 将为空 - 没有内容被标记为包含!”警告)。
前面的内容应该会让您成功地构建项目。您可以运行 `mvn package` 进行测试(目前您可以忽略 “jar will be empty - no content was marked for inclusion!” 的警告)。
Note:
此时,您可以将项目导入 IDE(大多数现代 Java IDE 都包含对 Maven 的内置支持)。为简单起见,我们在此示例中继续使用纯文本编辑器。
### 添加类路径依赖项
### 添加 ClassPath 依赖项
Spring Boot 提供了许多“启动器”,可让您将 jars 添加到类路径中。我们的烟雾测试应用程序使用POM 部分中的`spring-boot-starter-parent``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`“祝福”依赖项的标签。
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`依赖项。在此之前,我们可以通过运行以下命令查看我们当前拥有的内容:
其他“Starters”提供了您在开发特定类型的应用程序时可能需要的依赖项。由于我们正在开发 Web 应用程序,因此我们添加了一个`spring-boot-starter-web`依赖项。我们可以通过运行以下命令查看我们当前依赖的内容:
```shell
$ mvn dependency:tree
......@@ -71,7 +71,7 @@ $ mvn dependency:tree
[INFO] com.example:myproject:jar:0.0.1-SNAPSHOT
```
`mvn dependency:tree`命令打印项目依赖项的树表示。您可以看到它`spring-boot-starter-parent`本身不提供任何依赖项。要添加必要的依赖项,请编辑您的并在该部分正下方`pom.xml`添加依赖项:`spring-boot-starter-web parent`
`mvn dependency:tree`命令会打印一个树,它表示了项目的依赖项。您可以看到`spring-boot-starter-parent`本身不提供任何依赖项。要添加必要的依赖项,请编辑您的`pom.xml`,在`parent`部分正下方添加依赖项:`spring-boot-starter-web`
```xml
<dependencies>
......@@ -82,11 +82,11 @@ $ mvn dependency:tree
</dependencies>
```
如果`mvn dependency:tree`再次运行,您会看到现在有许多附加依赖项,包括 Tomcat Web 服务器和 Spring Boot 本身。
如果再次运行 `mvn dependency:tree`,您会看到现在有许多附加依赖项,包括 Tomcat Web 服务器和 Spring Boot 本身。
### 编写代码
为了完成我们的应用程序,我们需要创建一个 Java 文件。默认情况下,Maven 从 编译源代码`src/main/java`,因此您需要创建该目录结构,然后添加一个名为`src/main/java/MyApplication.java`包含以下代码的文件
为了完成我们的应用程序,我们需要创建一个 Java 文件。默认情况下,Maven 从 `src/main/java` 编译源代码 ,因此您需要创建该目录结构,然后添加一个名为`src/main/java/MyApplication.java`的文件,这个文件包含以下代码
```java
@RestController
......@@ -105,34 +105,34 @@ public class MyApplication {
}
```
虽然这里没有太多代码,但有很多事情正在发生。我们将在接下来的几节中逐步介绍重要部分。
虽然这里没有太多代码,但已经产生了很大的作用。我们将在接下来的几节中逐步介绍重要的部分。
#### @RestController 和 @RequestMapping 注解
`MyApplication`我们类的第一个注释是`@RestController`. 这称为*构造型*注释。它为阅读代码的人和 Spring 提供了类扮演特定角色的提示。在这种情况下,我们的类是一个 web `@Controller`,因此 Spring 在处理传入的 Web 请求时会考虑它。
`MyApplication`类的第一个注解是`@RestController`. 这称为*构造型*注解。它告诉阅读代码的人和 Spring 这个类扮演了哪些特定的角色。在这个例子中,我们的类是一个 web `@Controller`,因此 Spring 在处理传入的 Web 请求时会使用它。
`@RequestMapping`注释提供“路由”信息。它告诉 Spring 任何带有该`/`路径的 HTTP 请求都应该映射到该`home`方法。注释告诉 Spring将`@RestController`结果字符串直接呈现给调用者。
`@RequestMapping` 注释提供“路由”信息。它告诉 Spring 任何带有`/`路径的 HTTP 请求都应该映射到 `home` 方法。`@RestController` 注释告诉 Spring 将结果以字符串的形式直接呈现给调用者。
Tip:
和注释是 Spring MVC 注释`@RestController``@RequestMapping`它们不是特定于 Spring Boot)。有关详细信息,请参阅 Spring 参考文档中的[MVC 部分](https://docs.spring.io/spring-framework/docs/5.3.16/reference/html/web.html#mvc)
`@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。
第二个类级别的注释是`@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`数组也被传递以公开任何命令行参数。
我们应用程序的最后一部分是`main`方法。这是一种遵循应用程序入口点的 Java 约定的标准方法。main 方法会委托给 Spring Boot 的 `SpringApplication` 类的 `run`方法。 `SpringApplication` 引导我们的应用程序,启动 Spring,然后启动自动配置的 Tomcat Web 服务器。我们需要将 `MyApplication.class` 作为参数传递给该 `run` 方法,去告诉 `SpringApplication` 哪个是主要的 Spring 组件。该 `args` 数组也传递了命令行参数。
### 运行示例
此时,您的应用程序应该可以工作了。由于您使用了`spring-boot-starter-parent`POM,因此您有一个有用的`run`目标,可用于启动应用程序。`mvn spring-boot:run`从根项目目录键入以启动应用程序。您应该会看到类似于以下内容的输出:
此时,您的应用程序应该可以工作了。由于您在POM中使用了`spring-boot-starter-parent`,因此您有了一个有用的`run`目标,可用于启动应用程序。通过命令行工具,在根项目目录输入 `mvn spring-boot:run`启动应用程序。您应该会看到类似于以下内容的输出:
```shell
$ mvn spring-boot:run
......@@ -156,7 +156,7 @@ $ mvn spring-boot:run
Hello World!
```
要优雅地退出应用程序,请按`ctrl-c`
要优雅地退出应用程序,请在命令行中`ctrl-c`
### 创建可执行 Jar
......@@ -164,13 +164,13 @@ Hello World!
可执行 jar 和 Java
Java 不提供加载嵌套 jar 文件(本身包含在 jar 中的 jar 文件)的标准方法。如果您希望分发一个独立的应用程序,这可能会出现问题。
Java 不提供加载嵌套 jar 文件(包含了 jar 的 jar 文件)的标准方法。如果您希望部署一个独立的应用程序,这可能会出现问题。
为了解决这个问题,许多开发人员使用“超级”罐子。一个 uber 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。
`spring-boot-maven-plugin`要创建一个可执行的 jar,我们需要将`pom.xml`. 为此,请在该`dependencies`部分下方插入以下行
要创建一个可执行的 jar,我们需要将`spring-boot-maven-plugin`添加到`pom.xml`. 为此,请在`dependencies`部分下方插入以下内容
```xml
<build>
......@@ -183,9 +183,9 @@ Spring Boot 采用了[不同的方法](https://docs.spring.io/spring-boot/docs/2
</build>
```
Note:
备注:
`spring-boot-starter-parent`POM 包含`<executions>`绑定`repackage`目标 的配置。如果不使用父 POM,则需要自己声明此配置。有关详细信息,请参阅[插件文档](https://docs.spring.io/spring-boot/docs/2.6.4/maven-plugin/reference/htmlsingle/#getting-started)
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`,如下:
......@@ -207,15 +207,15 @@ $ mvn package
[INFO] ------------------------------------------------------------------------
```
如果您查看`target`目录,您应该会看到`myproject-0.0.1-SNAPSHOT.jar`. 该文件的大小应约为 10 MB。如果你想偷看里面,你可以使用`jar tvf`,如下
如果您查看`target`目录,您应该会看到`myproject-0.0.1-SNAPSHOT.jar`. 该文件的大小应约为 10 MB。如果你想看 jar 里面的内容,可以使用`jar tvf`,如下所示
```shell
$ jar tvf target/myproject-0.0.1-SNAPSHOT.jar
```
`myproject-0.0.1-SNAPSHOT.jar.original`您还应该在目录中看到一个小得多的文件`target`。这是Maven在被Spring Boot重新打包之前创建的原始jar文件。
您还应该在 `target` 目录中看到一个小得多的文件 `myproject-0.0.1-SNAPSHOT.jar.original`。这是在被 Spring Boot 重新打包之前,Maven 创建的原始jar文件。
和以前一样,要退出应用程序,请按`ctrl-c`
如下所示,使用 "java -jar" 命令来运行应用程序
```shell
$ java -jar target/myproject-0.0.1-SNAPSHOT.jar
......@@ -233,6 +233,6 @@ $ java -jar target/myproject-0.0.1-SNAPSHOT.jar
........ Started MyApplication in 2.536 seconds (JVM running for 2.864)
```
As before, to exit the application, press `ctrl-c`.
和以前一样,要退出应用程序,请按`ctrl-c`
原文链接: https://docs.spring.io/spring-boot/docs/2.6.4/reference/html/getting-started.html#getting-started.first-application
\ No newline at end of file
Markdown is supported
0% .
You are about to add 0 people to the discussion. Proceed with caution.
先完成此消息的编辑!
想要评论请 注册