响应式编程WebFlux基础实战练习

摸魚散人

已于 2024-01-13 18:10:03 修改

阅读量725

点赞数 15

分类专栏： # 响应式编程 Java学习笔记文章标签： java

于 2024-01-12 12:52:06 首次发布

本文链接：https://blog.csdn.net/Demo_00/article/details/135531474

版权

Java学习笔记同时被 2 个专栏收录

18 篇文章 0 订阅

订阅专栏

响应式编程

7 篇文章 0 订阅

订阅专栏

什么是WebFlux？
响应式编程WebFlux是Spring Framework 5中引入的一个全新的响应式编程框架，它基于Reactor库构建，提供了异步和非阻塞的事件处理。WebFlux框架设计用于处理长时间运行的异步任务，例如网络调用或数据库操作，而不会阻塞线程。这样可以提高系统的吞吐量和伸缩性。并在Netty，Undertow和Servlet 3.1 +容器等服务器上运行。

WebFlux基础实战练习

0. WebFlun环境准备

基于Spring Boot，项目依赖

<?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 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>
    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>3.1.6</version>
    </parent>

    <artifactId>chapter04-webflux</artifactId>

    <properties>
        <maven.compiler.source>17</maven.compiler.source>
        <maven.compiler.target>17</maven.compiler.target>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
    </properties>


    <dependencyManagement>
        <dependencies>
            <dependency>
                <groupId>io.projectreactor</groupId>
                <artifactId>reactor-bom</artifactId>
                <version>2023.0.0</version>
                <type>pom</type>
                <scope>import</scope>
            </dependency>
        </dependencies>
    </dependencyManagement>


    <dependencies>
        <dependency>
            <groupId>io.projectreactor</groupId>
            <artifactId>reactor-core</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-webflux</artifactId>
        </dependency>
        <dependency>
            <groupId>io.projectreactor</groupId>
            <artifactId>reactor-test</artifactId>
            <scope>test</scope>
        </dependency>
        <!-- Spring Boot Starter Test -->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
        </dependency>
        <dependency>
            <groupId>org.junit.jupiter</groupId>
            <artifactId>junit-jupiter</artifactId>
            <version>5.7.2</version>
            <scope>test</scope>
        </dependency>

    </dependencies>
</project>

启动类
Spring Boot 有一个 WebFlux 启动器，默认情况下，启动器使用 Netty

@SpringBootApplication
public class WebFluxMainApplication {

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

1. 基于注解的编程模式

WebFlux提供了两种主要的编程模式，分别是基于注解的编程模式（Annotation-based Programming）和函数式编程模式（Functional Programming）。

基于注解的编程模式（Annotation-based Programming）： 这是类似于传统的Spring MVC风格的编程模式。开发者可以使用注解来定义Controller、请求映射、参数绑定等，类似于Spring MVC的@Controller和@RequestMapping注解。使用这种模式，开发者可以通过注解轻松地定义和配置应用程序的各个组件。

WebFlux基于注解的编程模式的工作流程图：

代码示例

import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;
import reactor.core.publisher.Flux;
import reactor.core.publisher.Mono;

@RestController
public class WebFluxController {

    @GetMapping("/mono")
    public Mono<String> monoExample() {
        return Mono.just("Hello, Mono!");
    }

    @GetMapping("/flux")
    public Flux<Integer> fluxExample() {
        return Flux.just(1, 2, 3, 4, 5);
    }
}

测试

GET http://localhost:8080/mono 返回响应：Hello, Mono!

GET http://localhost:8080/flux 返回响应：[1,2,3,4,5]

2. 函数式编程模式

函数式编程模式（Functional Programming）： 这是WebFlux的另一种编程模式，它使用Router和Handler函数。开发者通过编写函数式的路由和处理器来定义请求的处理逻辑，而不是使用注解。这种模式更加灵活，并且适用于需要更直观、函数式风格的代码。

WebFlux基于函数式编程模式的工作流程图：

代码示例

@Configuration
public class WebFluxRouter {

    @Bean
    public RouterFunction<ServerResponse> routeExample(WebFluxHandler handler) {
        return route()
                .GET("/router/mono", handler::monoExample)
                .GET("/router/flux", handler::fluxExample)
                .build();
    }
}

@Component
class WebFluxHandler {

    public Mono<ServerResponse> monoExample(ServerRequest request) {
        return ok().contentType(MediaType.TEXT_PLAIN)
                .bodyValue("Hello, Mono from Router!");
    }

    public Mono<ServerResponse> fluxExample(ServerRequest request) {
        return ok().contentType(MediaType.APPLICATION_JSON)
                .body(Flux.just(1, 2, 3, 4, 5).collectList(), List.class);
    }

}

测试

GET http://localhost:8080/router/mono 返回响应：Hello, Mono from Router!

GET http://localhost:8080/flux 返回响应：[1,2,3,4,5]

3. 异常处理和全局错误处理

代码示例

@Component
@Order(-2)
public class WebFluxExceptionHandler implements WebExceptionHandler {

    @Override
    public Mono<Void> handle(ServerWebExchange exchange, Throwable ex) {
        if (ex instanceof ResponseStatusException) {
            return handleResponseStatusException(exchange, (ResponseStatusException) ex);
        }

        // Handle other types of exceptions if needed

        return Mono.error(ex);
    }

    private Mono<Void> handleResponseStatusException(ServerWebExchange exchange, ResponseStatusException ex) {
        exchange.getResponse().setStatusCode(ex.getStatusCode());
        return exchange.getResponse().setComplete();
    }
}

4. WebFlux集成测试

代码示例

import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.http.MediaType;
import org.springframework.test.web.reactive.server.WebTestClient;

@SpringBootTest(webEnvironment = SpringBootTest.WebEnvironment.RANDOM_PORT)
public class WebFluxIntegrationTest {

    @Autowired
    private WebTestClient webTestClient;

    @Test
    void testMonoEndpoint() {
        webTestClient.get()
                .uri("/router/mono")
                .exchange()
                .expectStatus().isOk()
                .expectBody(String.class).isEqualTo("Hello, Mono from Router!");
    }

    @Test
    void testFluxEndpoint() {
        webTestClient.get()
                .uri("/router/flux")
                .exchange()
                .expectStatus().isOk()
                .expectBodyList(Integer.class).isEqualTo(List.of(1, 2, 3, 4, 5));
    }
}