开篇词

该指南将引导你创建 “Hello, Spring!”。带有 Spring WebFlux（版本 5 的新功能）的 RESTful Web 服务，然后通过 WebClient（版本 5 的新功能）使用该服务。

该指南展示了使用 Spring WebFlux 的功能方法。你可以在 WebFlux 中使用注解。

 

你将创建的应用

我们将使用 Spring WebFlux 和该服务的 WebClient 使用者构建 RESTful 网络服务。我们可以在 System.out 和以下位置看到输出：

http://localhost:8080/hello

 

你将需要的工具

• 大概 15 分钟左右；
• 你最喜欢的文本编辑器或集成开发环境（IDE）
• JDK 1.8 或更高版本；
• Gradle 4+ 或 Maven 3.2+
• 你还可以将代码直接导入到 IDE 中：
  • Spring Too Suite (STS)
  • IntelliJ IDEA
     

如何完成这个指南

像大多数的 Spring 入门指南一样，你可以从头开始并完成每个步骤，也可以绕过你已经熟悉的基本设置步骤。如论哪种方式，你最终都有可以工作的代码。

• 要从头开始，移步至用 Gradle 来构建；
• 要跳过基础，执行以下操作：
  • 下载并解压缩该指南将用到的源代码，或借助 Git 来对其进行克隆操作：git clone https://github.com/spring-guides/gs-reactive-rest-service.git
  • 切换至 gs-reactive-rest-service/initial 目录；
  • 跳转至该指南的创建 WebFlux 句柄。

待一切就绪后，可以检查一下 gs-reactive-rest-service/complete 目录中的代码。
 

用 Gradle 来构建

首先，我们设置一个基本的构建脚本。在使用 Spring 构建应用时可以使用任何喜欢的构建系统，但此处包含使用 Gradle 和 Maven 所需的代码。如果你都不熟悉，请参阅使用 Gradle 构建 Java 项目或使用 Maven 构建 Java 项目。

创建目录结构

在我们选择的项目目录中，创建以下自目录结构；例如，在 *nix 系统上使用 mkdir -p src/main/java/hello：

└── src└── main└── java└── hello

创建 Gradle 构建文件

以下是初始 Gradle 构建文件。
build.gradle

buildscript {ext {springBootVersion = '2.2.4.RELEASE'}repositories {mavenCentral()}dependencies {classpath("org.springframework.boot:spring-boot-gradle-plugin:${springBootVersion}")}}apply plugin: 'java'apply plugin: 'eclipse'apply plugin: 'org.springframework.boot'apply plugin: 'io.spring.dependency-management'bootJar {baseName = 'gs-reactive-rest-service'version = '0.1.0'}sourceCompatibility = 1.8repositories {mavenCentral()}dependencies {compile('org.springframework.boot:spring-boot-starter-webflux')testCompile('org.springframework.boot:spring-boot-starter-test')testCompile('io.projectreactor:reactor-test')}

Spring Boot gradle 插件提供了许多方便的功能：

• 它收集类路径上的所有 jar，并构建一个可运行的单个超级 jar，这使执行和传输服务更加方便；
• 它搜索 public static void main() 方法并将其标记为可运行类；
• 它提供了一个内置的依赖解析器，用于设置版本号以及匹配 Spring Boot 依赖。我们可以覆盖所需的任何版本，但默认为 Boot 选择的一组版本。
   

用 Maven 来构建

首先，我们搭建一个基本的构建脚本。使用 Spring 构建应用时，可以使用任何喜欢的构建系统，但是此处包含了使用 Maven 所需的代码。如果你不熟悉 Maven，请参阅使用 Maven 构建 Java 项目。

创建目录结构

在我们选择的项目目录中，创建以下自目录结构；例如，在 *nix 系统上使用 mkdir -p src/main/java/hello：

└── src└── main└── java└── hello

创建 Maven 构建文件

以下是初始 Maven 构建文件。
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>org.springframework</groupId><artifactId>gs-reactive-rest-service</artifactId><version>0.1.0</version><parent><groupId>org.springframework.boot</groupId><artifactId>spring-boot-starter-parent</artifactId><version>2.2.4.RELEASE</version><relativePath/> <!-- lookup parent from repository --></parent><dependencies><dependency><groupId>org.springframework.boot</groupId><artifactId>spring-boot-starter-webflux</artifactId></dependency><dependency><groupId>org.springframework.boot</groupId><artifactId>spring-boot-starter-test</artifactId><scope>test</scope></dependency><dependency><groupId>io.projectreactor</groupId><artifactId>reactor-test</artifactId><scope>test</scope></dependency></dependencies><properties><java.version>1.8</java.version></properties><build><plugins><plugin><groupId>org.springframework.boot</groupId><artifactId>spring-boot-maven-plugin</artifactId></plugin></plugins></build></project>

Spring Boot Maven 插件提供了许多方便的功能：

• 它收集类路径上的所有 jar，并构建一个可运行的单个超级 jar，这使执行和传输服务更加方便；
• 它搜索 public static void main() 方法并将其标记为可运行类；
• 它提供了一个内置的依赖解析器，用于设置版本号以及匹配 Spring Boot 依赖。我们可以覆盖所需的任何版本，但默认为 Boot 选择的一组版本。
   

用 IDE 来构建

• 阅读如何将该指南直接导入 Spring Tool Suite；
• 阅读如何在 IntelliJ IDEA 中使用该指南。
   

创建 WebFlux 句柄

在 Spring Reactive 方法中，我们使用处理程序来处理请求并创建响应，如下示例所示：

src/main/java/hello/GreetingHandler.java

package hello;import org.springframework.http.MediaType;import org.springframework.stereotype.Component;import org.springframework.web.reactive.function.BodyInserters;import org.springframework.web.reactive.function.server.ServerRequest;import org.springframework.web.reactive.function.server.ServerResponse;import reactor.core.publisher.Mono;@Componentpublic class GreetingHandler {public Mono<ServerResponse> hello(ServerRequest request) {return ServerResponse.ok().contentType(MediaType.TEXT_PLAIN).body(BodyInserters.fromValue("Hello, Spring!"));}}

这个简单的反应式类始终返回 “Hello, Spring!”。它可能返回许多其他内容，包括来自数据库的项目流，通过计算生成的项目流，等等。请注意反应式代码：一个包含 ServerResponse 主体的 Mono 对象。
 

创建路由

在该应用中，我们使用路由来处理我们公开的唯一路由（"/hello"），如以下示例所示：

src/main/java/hello/GreetingRouter.java

package hello;import org.springframework.context.annotation.Bean;import org.springframework.context.annotation.Configuration;import org.springframework.http.MediaType;import org.springframework.web.reactive.function.server.RequestPredicates;import org.springframework.web.reactive.function.server.RouterFunction;import org.springframework.web.reactive.function.server.RouterFunctions;import org.springframework.web.reactive.function.server.ServerResponse;@Configurationpublic class GreetingRouter {@Beanpublic RouterFunction<ServerResponse> route(GreetingHandler greetingHandler) {return RouterFunctions.route(RequestPredicates.GET("/hello").and(RequestPredicates.accept(MediaType.TEXT_PLAIN)), greetingHandler::hello);}}

路由在 /hello 路径上侦听流量，并返回我们的反应式处理程序类提供的值。
 

创建 WebClient

Spring MVC RestTemplate 类本质上是阻塞的。因此，我们不想在反应式应用中使用它。对于反应式应用，Spring 提供了非阻塞的 WebClient 类。我们将使用 WebClient 实现来使用我们的 RESTful 服务：

src/main/java/hello/GreetingWebClient.java

package hello;import org.springframework.http.MediaType;import org.springframework.web.reactive.function.client.ClientResponse;import org.springframework.web.reactive.function.client.WebClient;import reactor.core.publisher.Mono;public class GreetingWebClient {private WebClient client = WebClient.create("http://localhost:8080");private Mono<ClientResponse> result = client.get().uri("/hello").accept(MediaType.TEXT_PLAIN).exchange();public String getResult() {return ">> result = " + result.flatMap(res -> res.bodyToMono(String.class)).block();}}

WebClient 使用反应式功能，以 Mono 的形式保存我们指定的 URI 的内容，并使用一个函数（在 getResult 方法中）将该内容转换为字符串。如果我们有不同的要求，则可以将其转换为字符串以外的形式。由于我们要将结果放入 System.out，因此这里将使用字符串。

WebClient 也可以用于非反应式阻塞服务进行通信。

 

使应用可执行

尽管可以将服务打包为传统的 WAR 文件以部署到外部应用服务器，但是下面演示的更简单的方法创建了一个独立的应用。我们将所有内容打包在一个可执行的 JAR 文件中，由一个经典的 Java main() 方法驱动。在该过程中，我们使用 Reactive Spring 的支持将 Netty 服务器作为 HTTP 运行时嵌入，而不是部署到外部实例。

src/main/java/hello/Application.java

package hello;import org.springframework.boot.SpringApplication;import org.springframework.boot.autoconfigure.SpringBootApplication;@SpringBootApplicationpublic class Application {public static void main(String[] args) {SpringApplication.run(Application.class, args);GreetingWebClient gwc = new GreetingWebClient();System.out.println(gwc.getResult());}}

@SpringBootApplication 是一个便利的注解，它添加了以下所有内容：

• @Configuration：将类标注为应用上下文 Bean 定义的源；
• @EnableAutoConfiguration：告诉 Spring Boot 根据类路径配置、其他 bean 以及各种属性的配置来添加 bean；
• @ComponentScan：告知 Spring 在 hello 包中寻找他组件、配置以及服务。

main() 方法使用 Spring Boot 的 SpringApplication.run() 方法启动应用。
 

构建可执行 JAR

我们可以结合 Gradle 或 Maven 来从命令行运行该应用。我们还可以构建一个包含所有必须依赖项、类以及资源的可执行 JAR 文件，然后运行该文件。在整个开发生命周期中，跨环境等等情况下，构建可执行 JAR 可以轻松地将服务作为应用进行发布、版本化以及部署。

如果使用 Gradle，则可以借助 ./gradlew bootRun 来运行应用。或通过借助 ./gradlew build 来构建 JAR 文件，然后运行 JAR 文件，如下所示：

java -jar build/libs/gs-reactive-rest-service-0.1.0.jar

如果使用 Maven，则可以借助 ./mvnw spring-boot:run 来运行该用。或可以借助 ./mvnw clean package 来构建 JAR 文件，然后运行 JAR 文件，如下所示：

java -jar target/gs-reactive-rest-service-0.1.0.jar

我们还可以将 JAR 应用转换成 WAR 应用。

显示日志记录输出。该服务应在几秒内启动并运行。

服务启动后，我们会看到以下内容：

>> result = Hello, Spring!

改行来自 WebClient 正在使用的反应式内容。自然，与将输出放入 System.out 相比，我们会发现输出更有趣。
 

测试应用

现在该应用正在运行，我们可以对其进行测试。首先，我们可以打开浏览器并转到 http://localhost:8080/hello，然后看到 “Hello, Spring!”。对于该指南，我们还创建了一个测试类，以使我们开始使用 WebTestClient 类进行测试。

src/test/java/hello/GreetingRouterTest.java

package hello;import org.junit.jupiter.api.Test;import org.junit.jupiter.api.extension.ExtendWith;import org.springframework.beans.factory.annotation.Autowired;import org.springframework.boot.test.context.SpringBootTest;import org.springframework.http.MediaType;import org.springframework.test.context.junit.jupiter.SpringExtension;import org.springframework.test.web.reactive.server.WebTestClient;@ExtendWith(SpringExtension.class)// We create a `@SpringBootTest`, starting an actual server on a `RANDOM_PORT`@SpringBootTest(webEnvironment = SpringBootTest.WebEnvironment.RANDOM_PORT)public class GreetingRouterTest {// Spring Boot will create a `WebTestClient` for you,// already configure and ready to issue requests against "localhost:RANDOM_PORT"@Autowiredprivate WebTestClient webTestClient;@Testpublic void testHello() {webTestClient// Create a GET request to test an endpoint.get().uri("/hello").accept(MediaType.TEXT_PLAIN).exchange()// and use the dedicated DSL to test assertions against the response.expectStatus().isOk().expectBody(String.class).isEqualTo("Hello, Spring!");}}

 

概述

恭喜你！我们已经开发了一个 Reactive Spring 应用，其中包括一个 WebClient 来使用 RESTful 服务！
 

想看指南的其他内容？请访问该指南的所属专栏：《Spring 官方指南》