WebFlux是Spring Framework 5引入的一个用于构建响应式Web应用程序的框架。与传统的Spring MVC基于Servlet的同步编程模型不同，WebFlux基于Reactive Streams规范，采用异步非阻塞的编程模型，可以更好地利用现代多核处理器和处理高并发请求。

WebFlux核心组件介绍

Handler和Router

与传统的传统的Controller和Request Mapping相比，在函数式编程模型中，处理请求逻辑是通过Handler实现，而路由的逻辑则是由Router配置实现，更加灵活和轻量。

Reactor

作为WebFlux的基础，它提供了两个核心抽象类Mono和Flux。这两个抽象类表示单值和多值异步序列。

ServerRequest和ServerResponse

这两个对象，ServerRequest表示HTTP请求。ServerResponse表示 HTTP 响应。

下面我们就来详细的介绍一下，使用WebFlux技术创建简单RESTful服务

添加依赖

在pom.xml文件中添加spring-boot-starter-webflux依赖，如下所示。

<dependencies>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-webflux</artifactId>
    </dependency>
    <!-- 其他依赖 -->
</dependencies>

创建模型类

创建一个简单User模型类，代码如下所示。

public class User {
    private String id;
    private String name;

    // Constructors, getters, and setters
    public User() {}

    public User(String id, String name) {
        this.id = id;
        this.name = name;
    }

    public String getId() {
        return id;
    }

    public void setId(String id) {
        this.id = id;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }
}

创建Handler类

根据上面的介绍使用Handler类处理请求逻辑，如下所示。

@Component
public class UserHandler {

    private final Map<String, User> users = new ConcurrentHashMap<>();

    public Mono<ServerResponse> getAllUsers(ServerRequest request) {
        Flux<User> userFlux = Flux.fromIterable(users.values());
        return ServerResponse.ok().contentType(MediaType.APPLICATION_JSON).body(userFlux, User.class);
    }

    public Mono<ServerResponse> getUserById(ServerRequest request) {
        String userId = request.pathVariable("id");
        Mono<User> userMono = Mono.justOrEmpty(users.get(userId));
        return userMono.flatMap(user ->
                ServerResponse.ok().contentType(MediaType.APPLICATION_JSON).bodyValue(user))
                .switchIfEmpty(ServerResponse.notFound().build());
    }

    public Mono<ServerResponse> createUser(ServerRequest request) {
        Mono<User> userMono = request.bodyToMono(User.class);
        return userMono.flatMap(user -> {
            users.put(user.getId(), user);
            return ServerResponse.ok().contentType(MediaType.APPLICATION_JSON).bodyValue(user);
        });
    }
}

配置Router类

配置Router路由操作类，用来进行请求路由处理，类似于Request Mapper。

@Configuration
public class UserRouter {

    @Bean
    public RouterFunction<ServerResponse> routerFunction(UserHandler userHandler) {
        return RouterFunctions
                .nest(path("/users"),
                        route(GET(""), userHandler::getAllUsers)
                        .andRoute(GET("/{id}"), userHandler::getUserById)
                        .andRoute(POST(""), userHandler::createUser));
    }
}

启动类

接下来的操作就是在启动类中支持WebFlux操作。如下所示。

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

@SpringBootApplication
public class WebFluxApplication {

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

总结

通过以上步骤，我们就可以实现一个简单的WebFlux版本的RESTful接口。我们就可以启动项目然后通过接口调用工具来发送相应的请求来测试这些接口操作，例如发送一个GET请求到http://localhost:8080/users来获取所有用户，发送一个POST请求到http://localhost:8080/users来创建一个新的用户，发送一个GET请求到http://localhost:8080/users/{id}来根据ID获取用户。

相比于传统的RESTful接口，通过WebFlux实现的RESTful接口性能更高一些。能够处理大量并发请求，而不会像传统阻塞模型那样消耗大量线程资源。通过注解驱动(类似Spring MVC)和函数式编程模型来构建应用程序，提供了统一的编程体验。

Spring WebFlux提供了一个现代的响应式编程模型，适用于高并发和低延迟的应用场景。通过响应式流和异步非阻塞的I/O操作，它可以在处理大量并发请求时表现出色。