引言
Spring WebFlux 是 Spring Framework 5.0 中引入的一个全新的响应式编程框架，旨在为在Spring上构建响应式应用提供支持。它可以运行在传统的Servlet容器上，也可以运行在响应式服务器上，比如Netty、Undertow和Servlet 3.1+容器。与Spring MVC相比，Spring WebFlux是非阻塞的，并且更适用于处理长时间运行的异步任务和高并发的请求。Spring WebFlux包括以下几个核心部分：
1、反应式核心
基于Reactor库，提供了非阻塞的事件驱动编程模型。Reactor是一个响应式编程库，支持Mono（0或1个元素的异步序列）和Flux（0到N个元素的异步序列）类型，适用于单个和多个数据项的响应式流处理。
Reactor操作基于两个基本的响应式类型：Mono和Flux。
1.1、Reactor基础
-
Mono：表示0或1个元素的异步序列。常用于单个结果的异步操作，如异步的数据库查询或远程服务调用。
-
Flux：表示0到N个元素的异步序列。适用于多个元素的操作，如处理集合、流式数据处理。
1.2、操作符
在Reactor中，操作符是用于处理数据流的核心。它们可以修改数据流，过滤数据，合并多个流，处理错误等。下面是一些Reactor中常用的操作符及其简单说明和示例：
1.2.1. 创建操作符
-
just(): 创建一个包含固定元素的Flux或Mono。
-
fromArray(), fromIterable(), fromStream(): 从一个数组、Iterable或Stream创建Flux。
-
range(): 创建一个包含特定范围数字序列的Flux。
-
empty(): 创建一个不包含任何元素的Flux或Mono。
-
error(): 创建一个立即以指定错误终止的Flux或Mono。
1.2.2. 转换操作符
-
map(): 对流中的每个元素应用同步函数，并返回函数的结果。
-
flatMap(): 对流中的每个元素应用异步函数，并返回函数的结果，这些结果被合并到一个新的Flux中。
-
buffer(): 将多个元素收集到列表中，并将这些列表作为流中的新元素发出。
1.2.3. 过滤操作符
-
filter(): 只允许符合给定条件的元素通过。
-
distinct(): 仅通过尚未发出的唯一元素。
-
take(): 仅从当前流中获取前N个元素。
-
skip(): 跳过流中的前N个元素。
1.2.4. 合并操作符
-
merge(): 合并多个Flux中的元素，不保证元素顺序。
-
concat(): 按顺序连接多个Publisher的输出。
-
zip(): 将多个流中的元素按照一定的规则组合起来。
1.2.5. 错误处理操作符
-
onErrorReturn(): 遇到错误时返回一个默认值。
-
onErrorResume(): 遇到错误时使用另一个Publisher来继续。
-
retry(): 遇到错误时重试。
示例代码
import reactor.core.publisher.Flux;
public class ReactorExample {
public static void main(String[] args) {
// map操作符示例
Flux.just(1, 2, 3)
.map(i -> i * 2)
.subscribe(System.out::println); // 输出：2 4 6
// filter操作符示例
Flux.range(1, 5)
.filter(i -> i % 2 == 0)
.subscribe(System.out::println); // 输出：2 4
// flatMap操作符示例
Flux.just(5, 10)
.flatMap(i -> Flux.range(1, i))
.subscribe(System.out::println); // 输出：一系列数字，不一定按顺序
// merge操作符示例
Flux.merge(
Flux.just(1, 2, 3).delayElements(Duration.ofMillis(1)),
Flux.just(4, 5, 6).delayElements(Duration.ofMillis(1))
).subscribe(System.out::println); // 输出：两个序列的合并，元素顺序可能交错
}
}
1.3、反应式流的背景
Reactor遵循Reactive Streams规范，反应式流（Reactive Streams）是一种处理异步数据流的标准和规范，它定义了一套API，旨在以非阻塞的方式处理数据流的发布与订阅，从而实现流的背压（Backpressure）管理。背压是指在流处理中，消费者（Subscriber）能够告知生产者（Publisher）自己能够处理的数据的速度，以避免因为生产者发送数据过快而导致消费者处理不过来，最终可能导致OOM（内存溢出）或其他性能问题。
反应式流规范定义了以下四个主要的接口：
-
Publisher：发布者，负责发布数据流。它可以被订阅（Subscription）。
-
Subscriber：订阅者，订阅并处理来自Publisher的数据流。它定义了处理数据、完成信号和错误信号的方法。
-
Subscription：订阅关系，是Publisher和Subscriber之间的一座桥梁。提供了请求数据和取消订阅的方法，以实现背压管理。
-
Processor：处理器，充当了Publisher和Subscriber的角色，可以用于在数据流中添加处理逻辑。
背压管理（Backpressure） 是反应式流的核心特性之一，它允许Subscriber根据自己的处理能力动态地向Publisher请求数据，这样就可以避免数据堆积和潜在的内存问题。
举个例子：
import org.reactivestreams.Publisher;
import org.reactivestreams.Subscriber;
import org.reactivestreams.Subscription;
public class ReactiveStreamsExample {
public static void main(String[] args) {
Publisher<Integer> publisher = subscriber -> {
subscriber.onSubscribe(new Subscription() {
@Override
public void request(long n) {
for (int i = 1; i <= n; i++) {
subscriber.onNext(i);
}
subscriber.onComplete();
}
@Override
public void cancel() {
// 在这里处理取消订阅时的逻辑
}
});
};
Subscriber<Integer> subscriber = new Subscriber<>() {
@Override
public void onSubscribe(Subscription subscription) {
// 请求5个数据
subscription.request(5);
}
@Override
public void onNext(Integer item) {
System.out.println("处理数据: " + item);
}
@Override
public void onError(Throwable t) {
t.printStackTrace();
}
@Override
public void onComplete() {
System.out.println("处理完成");
}
};
publisher.subscribe(subscriber);
}
}
定义一个Publisher和一个Subscriber，通过Subscription实现背压管理。Subscriber在onSubscribe方法中通过subscription.request(5)请求了5个数据项，Publisher根据请求发送数据，然后发送完成信号。
在反应式编程中，重要的是理解这些操作是异步和非阻塞的。当对Flux或Mono执行操作时，实际上是在定义一个操作链，真正的数据处理会在订阅时异步发生。这种模型非常适合处理大量数据、实时数据流或者I/O密集型任务，因为它允许应用在等待数据时继续处理其他任务，从而提高了应用的吞吐量和响应性。
2、注解驱动的Web组件
在Spring WebFlux框架中，注解驱动的Web组件是构建响应式Web应用的核心之一。这种模式借鉴了Spring MVC的设计，让开发者能够以一种熟悉而简洁的方式定义路由、处理请求和生成响应。通过一系列的注解，Spring WebFlux提供了创建非阻塞控制器和处理器的能力，这些控制器和处理器能够处理异步和流式的数据。
-
核心注解
@Controller
这是Spring WebFlux中定义控制器的基础注解，与Spring MVC中的@Controller注解类似。它标记一个类作为Spring应用中的Web组件，这个组件能够处理HTTP请求。
@RequestMapping
用于定义类或方法的请求处理模式。它可以指定请求的URL路径、HTTP方法（GET、POST等）、请求参数、头部信息等。在WebFlux中，它可以处理传统的同步请求和异步的响应式请求。
@GetMapping, @PostMapping, @PutMapping, @DeleteMapping, @PatchMapping
这些是@RequestMapping的特化版本，分别对应HTTP的GET、POST、PUT、DELETE和PATCH方法。通过这些注解，可以更清晰地表达方法的目的和处理的HTTP方法。
-
响应式数据处理
在Spring WebFlux中，控制器方法可以直接返回Reactor的Mono或Flux类型，这代表了一个或多个异步数据项。这使得控制器能夠以非阻塞方式处理请求，提高了处理效率和应用的可伸缩性。
-
参数绑定和数据模型
@RequestBody
用于将HTTP请求体绑定到控制器方法的参数上。在响应式应用中，这通常用于处理JSON或XML类型的数据，参数类型可以是Mono<T>或Flux<T>，允许异步和非阻塞地处理请求体数据。
@PathVariable
从URL路径中提取变量绑定到控制器方法的参数上。这在处理RESTful API时特别有用，可以用于识别资源。
@RequestParam
用于将请求参数（通常是查询参数）绑定到控制器方法的参数上。这对于处理GET请求中的查询字符串特别有用。
@ModelAttribute
在Spring MVC中用于将请求参数绑定到JavaBean上。虽然在WebFlux中不常用，但它仍然可用于处理那些需要从请求中提取参数并绑定到对象的场景。
示例：
假设我们有一个图书管理系统，需要实现以下功能：
-
图书查询：根据图书ID查询图书详情。
-
图书列表：分页显示图书列表。
-
添加图书：向系统中添加新的图书。
-
更新图书信息：根据图书ID更新图书信息。
-
删除图书：根据图书ID删除图书。
首先，我们定义一个Book类来表示图书信息：
public class Book {
private String id;
private String title;
private String author;
private int pages;
// 省略构造器、getter和setter方法
}
接下来，创建一个模拟数据库交互的服务类BookService：
import reactor.core.publisher.Flux;
import reactor.core.publisher.Mono;
import java.util.HashMap;
import java.util.Map;
import java.util.UUID;
public class BookService {
private final Map<String, Book> books = new HashMap<>();
public Flux<Book> findAll() {
return Flux.fromIterable(books.values());
}
public Mono<Book> findById(String id) {
return Mono.justOrEmpty(books.get(id));
}
public Mono<Book> save(Book book) {
String id = UUID.randomUUID().toString();
book.setId(id);
books.put(id, book);
return Mono.just(book);
}
public Mono<Book> update(String id, Book book) {
books.put(id, book);
return Mono.just(book);
}
public Mono<Void> delete(String id) {
books.remove(id);
return Mono.empty();
}
}
现在，我们使用Spring WebFlux的注解来创建一个BookController，处理HTTP请求：
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.http.HttpStatus;
import org.springframework.web.bind.annotation.*;
import reactor.core.publisher.Flux;
import reactor.core.publisher.Mono;
@RestController
@RequestMapping("/books")
public class BookController {
@Autowired
private BookService bookService;
@GetMapping
public Flux<Book> list() {
return bookService.findAll();
}
@GetMapping("/{id}")
public Mono<Book> getById(@PathVariable String id) {
return bookService.findById(id);
}
@PostMapping
@ResponseStatus(HttpStatus.CREATED)
public Mono<Book> create(@RequestBody Book book) {
return bookService.save(book);
}
@PutMapping("/{id}")
public Mono<Book> update(@PathVariable String id, @RequestBody Book book) {
return bookService.update(id, book);
}
@DeleteMapping("/{id}")
@ResponseStatus(HttpStatus.NO_CONTENT)
public Mono<Void> delete(@PathVariable String id) {
return bookService.delete(id);
}
}
在这个例子中，我们创建了一个BookController类，它使用@RestController和@RequestMapping注解来定义了一个处理HTTP请求的控制器。这个控制器通过注入BookService来与模拟的数据库交互，并通过不同的HTTP方法（如GET、POST、PUT、DELETE）来实现图书的查询、添加、更新和删除操作。每个操作都返回了响应式的Mono或Flux类型，这就是Spring WebFlux支持响应式编程的关键特性。
3、函数式路由和处理
在Spring WebFlux中，除了传统的注解驱动的Web控制器外，还提供了一种基于函数式API的路由和处理方式。这种方式允许我们以更灵活、更函数式的风格来定义路由和处理逻辑，适合那些喜欢函数式编程或者需要更细粒度控制路由配置的开发者。
函数式路由和处理的核心概念是使用RouterFunction和HandlerFunction。RouterFunction用于定义路由规则，将HTTP请求路由到对应的处理器；HandlerFunction则是实际处理这些请求的函数。
优点
-
更清晰的路由配置：所有路由配置集中在一个地方，易于管理和查看。
-
更灵活的处理逻辑：可以轻松地组合和重用处理函数，增加代码的模块化和复用性。
-
函数式编程风格：利用Java 8的Lambda表达式，代码更简洁。
示例
假设我们还是用图书管理系统的业务场景，我们将使用函数式风格来重新实现之前注解驱动方式的部分功能，包括获取所有图书和添加图书的功能。
首先，我们需要定义处理函数：
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.web.reactive.function.server.RouterFunction;
import org.springframework.web.reactive.function.server.ServerRequest;
import org.springframework.web.reactive.function.server.ServerResponse;
import reactor.core.publisher.Mono;
import static org.springframework.web.reactive.function.server.RequestPredicates.*;
import static org.springframework.web.reactive.function.server.RouterFunctions.route;
@Configuration
public class BookRouter {
@Bean
public RouterFunction<ServerResponse> bookRoutes(BookHandler handler) {
return route(GET("/books"), handler::listBooks)
.andRoute(POST("/books"), handler::createBook);
}
}
public class BookHandler {
private final BookService bookService;
public BookHandler(BookService bookService) {
this.bookService = bookService;
}
public Mono<ServerResponse> listBooks(ServerRequest request) {
return ServerResponse.ok().body(bookService.findAll(), Book.class);
}
public Mono<ServerResponse> createBook(ServerRequest request) {
Mono<Book> bookMono = request.bodyToMono(Book.class);
return bookMono.flatMap(book ->
ServerResponse.status(HttpStatus.CREATED).body(bookService.save(book), Book.class));
}
}
在这个例子中，BookRouter配置类使用了RouterFunctionAPI来定义路由规则。我们定义了两个路由：一个是用于获取所有图书的GET请求(/books)，另一个是用于添加新图书的POST请求(/books)。对应的处理逻辑分别在BookHandler类的listBooks和createBook方法中实现。
这种方式将路由配置和处理逻辑分离，使得处理函数可以被多个路由复用，同时也让单元测试变得更加简单直接。此外，函数式的路由和处理方式能够提供更精细的控制，比如根据不同的条件应用不同的处理逻辑，或者动态构建路由规则等。
4、响应式客户端
在Spring WebFlux中，响应式客户端主要通过WebClient实现，它是一个非阻塞、响应式的HTTP客户端，用于调用RESTful服务。与传统的RestTemplate相比，WebClient提供了更灵活的API来处理异步和非阻塞的网络调用，同时支持Reactor的Mono和Flux类型，使得与响应式编程模型无缝集成。
主要特性
-
非阻塞式执行：
WebClient是非阻塞的，可以在同一线程上发起多个并发的网络请求，不会导致线程阻塞等待网络响应。 -
支持响应式编程：与Reactor库集成，支持
Mono和Flux类型，便于处理单个或多个异步操作的结果。 -
灵活的请求处理：提供了丰富的API来构建HTTP请求，支持GET、POST、PUT、DELETE等方法，以及请求头、请求体、查询参数等的自定义。
-
错误处理：支持基于Reactor的错误处理机制，可以优雅地处理网络错误和数据转换异常。
-
客户端过滤器：允许定义客户端过滤器来拦截和修改发出的请求和返回的响应，例如添加认证信息、日志记录等。
使用示例
假设我们要使用WebClient来调用一个返回图书列表的REST API，并处理返回的结果。以下是使用WebClient进行网络调用的示例：
import org.springframework.web.reactive.function.client.WebClient;
import reactor.core.publisher.Flux;
public class WebClientExample {
public static void main(String[] args) {
WebClient webClient = WebClient.create("http://example.com/api/books");
Flux<Book> books = webClient.get() // 创建GET请求
.retrieve() // 检索响应
.bodyToFlux(Book.class); // 将响应体转换为Flux<Book>
books.subscribe(book -> System.out.println(book.getTitle()));
}
static class Book {
private String title;
// 省略getter和setter
public String getTitle() {
return title;
}
}
}
在这个例子中，我们首先使用WebClient.create方法创建了一个WebClient实例，并指定了要调用的API的基础URL。然后，我们使用get方法创建了一个GET请求，通过retrieve方法检索响应，并使用bodyToFlux方法将响应体转换为Flux<Book>，最后通过subscribe方法订阅结果并打印每本书的标题。
错误处理
WebClient还提供了强大的错误处理功能。你可以使用onErrorMap、onErrorResume等操作符来处理可能发生的错误：
webClient.get()
.retrieve()
.bodyToFlux(Book.class)
.onErrorResume(e -> { // 处理错误的情况
System.out.println("Error: " + e.getMessage());
return Flux.empty(); // 返回一个空的Flux，避免异常终止
})
.subscribe(book -> System.out.println(book.getTitle()));
客户端过滤器
WebClient支持客户端过滤器，允许你在请求发送前后执行一些操作。这在添加认证信息、日志记录等场景下非常有用：
WebClient webClient = WebClient.builder()
.baseUrl("http://example.com/api")
.filter((request, next) -> {
System.out.println("Sending request to " + request.url());
return next.exchange(request);
})
.build();
这些特性使WebClient成为Spring WebFlux中进行响应式网络调用的首选工具，既支持高性能的非阻塞IO操作，又提供了丰富的API和灵活的错误处理机制，非常适合在现代的响应式微服务架构中使用。
5、测试支持
在Spring WebFlux中，测试支持是通过spring-test模块提供的，它包含了一套丰富的测试工具和API，专门为响应式应用设计。这些工具不仅支持传统的Spring MVC应用的测试，也支持响应式Web应用的测试，允许开发者以声明式和响应式的方式编写测试代码。我们来深入探讨下Spring WebFlux的测试支持，特别是针对响应式控制器和客户端的测试。
1. 测试响应式Web组件
当你使用Spring WebFlux开发响应式Web应用时，很可能会涉及到@RestController和@RequestMapping等注解来创建响应式控制器。Spring提供了WebTestClient，一个非阻塞的Web客户端，用于测试这些响应式Web组件。
使用WebTestClient测试响应式控制器
WebTestClient可以绑定到一个具体的路由并发起请求，也可以运行在真实的服务器环境中。它提供了一套流式的API来构造请求、发送请求并验证响应。
示例：测试一个返回图书列表的响应式Web控制器。
首先，我们有一个简单的图书控制器：
@RestController
@RequestMapping("/books")
public class BookController {
private final BookService bookService;
// 构造函数和其他方法省略
@GetMapping
public Flux<Book> listBooks() {
return bookService.findAll();
}
}
然后，我们可以使用WebTestClient来测试这个控制器：
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.autoconfigure.web.reactive.WebFluxTest;
import org.springframework.context.annotation.Import;
import org.springframework.test.web.reactive.server.WebTestClient;
@WebFluxTest(BookController.class)
@Import(BookService.class) // 如果BookService是你自定义的服务，需要导入到测试环境中
public class BookControllerTest {
@Autowired
private WebTestClient webTestClient;
@Test
public void testListBooks() {
webTestClient.get().uri("/books")
.exchange()
.expectStatus().isOk()
.expectBodyList(Book.class).hasSize(10); // 假设我们期望返回10本书
}
}
在这个测试用例中，我们通过@WebFluxTest注解来指定要测试的控制器，并通过@Import注解来导入需要的服务。WebTestClient被自动配置并注入到测试环境中，我们使用它发起一个GET请求，并验证响应状态和响应体。
2. 测试响应式客户端
在使用WebClient进行响应式网络调用时，Spring也提供了相应的测试支持来模拟外部服务的响应，从而可以在不依赖外部服务的情况下测试你的客户端逻辑。
使用MockWebServer测试WebClient
MockWebServer来自OkHttp库，它可以用来模拟HTTP服务，非常适合与WebClient结合使用来测试响应式客户端逻辑。
示例：测试使用WebClient调用外部图书服务的客户端。
public class BookClient {
private final WebClient webClient;
public BookClient(WebClient.Builder webClientBuilder) {
this.webClient = webClientBuilder.baseUrl("http://example.com/api").build();
}
public Flux<Book> listBooks() {
return webClient.get().uri("/books")
.retrieve()
.bodyToFlux(Book.class);
}
}
// 测试类
public class BookClientTest {
private MockWebServer server;
@BeforeEach
public void setUp() throws IOException {
server = new MockWebServer();
server.start();
}
@AfterEach
public void tearDown() throws IOException {
server.shutdown();
}
@Test
public void testListBooks() {
// 配置MockWebServer响应
server.enqueue(new MockResponse()
.setBody("[{\"title\":\"Book One\"}, {\"title\":\"Book Two\"}]")
.addHeader("Content-Type", "application/json"));
// 使用MockWebServer的URL更新WebClient
BookClient bookClient = new BookClient(WebClient.builder().baseUrl(server.url("/").toString()));
StepVerifier.create(bookClient.listBooks())
.expectNextMatches(book -> book.getTitle().equals("Book One"))
.expectNextMatches(book -> book.getTitle().equals("Book Two"))
.verifyComplete();
}
}
在这个例子中，我们首先启动了一个MockWebServer并配置了期望的响应。然后，在测试中我们创建了一个BookClient实例，将WebClient的基础URL设置为MockWebServer的URL。通过这种方式，当BookClient发起网络请求时，实际上是向我们的MockWebServer发起的，这样我们就可以在不依赖外部真实服务的情况下测试我们的客户端逻辑。
通过WebTestClient和MockWebServer等工具，Spring WebFlux提供了强大的测试支持，使得开发者能够以响应式的方式轻松地测试Web组件和客户端逻辑，从而确保响应式应用的质量和稳定性。
结束语
通过上面内容的学习，我们大概了解Spring WebFlux的关键特性和使用方法。Spring不断演化以适应日益复杂的开发需求，响应式编程的引入更是让其在处理高并发、高性能应用方面迈出了重要一步。这既是对Spring生态系统的一次深入探索，也是对响应式编程思想的一次全面理解。
扫一扫
728
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
