springboot webflux 简介

最新推荐文章于 2025-06-17 10:03:18 发布
最新推荐文章于 2025-06-17 10:03:18 发布
阅读量1.5k 收藏 2
点赞数
CC 4.0 BY-SA版权
分类专栏： webflux
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/weixin_43931625/article/details/106813361

springboot webflux 简介

 

官网：https://docs.spring.io/spring-boot/docs/2.3.0.RELEASE/reference/html/spring-boot-features.html#boot-features-webflux

 

**********************

简介

 

                      

基于reactor实现的异步非阻塞框架，较同步阻塞的MVC框架，可提升系统性能；

可使用MVC的注解操作，也可使用函数式编程；

支持传统的servlet容器，还可运行在支持nio的netty、undertow容器中

 

 

**********************

相关类与接口

 

ServerWebExchange：获取request、response、session

public interface ServerWebExchange {
    String LOG_ID_ATTRIBUTE = ServerWebExchange.class.getName() + ".LOG_ID";

    ServerHttpRequest getRequest();        //获取request
    ServerHttpResponse getResponse();      //获取response
    Map<String, Object> getAttributes();   //获取请求中的属性

    @Nullable
    default <T> T getAttribute(String name) {
        return this.getAttributes().get(name);
    }

    default <T> T getRequiredAttribute(String name) {
        T value = this.getAttribute(name);
        Assert.notNull(value, () -> {
            return "Required attribute '" + name + "' is missing";
        });
        return value;
    }

    default <T> T getAttributeOrDefault(String name, T defaultValue) {
        return this.getAttributes().getOrDefault(name, defaultValue);
    }

    Mono<WebSession> getSession();                 //获取webSession
    <T extends Principal> Mono<T> getPrincipal();  //获取认证用户

    Mono<MultiValueMap<String, String>> getFormData();      //获取表单参数
    Mono<MultiValueMap<String, Part>> getMultipartData();   //获取表单multipart数据

    LocaleContext getLocaleContext();              //获取国际化设置（Locale）

    @Nullable
    ApplicationContext getApplicationContext();    //获取应用上下文

    boolean isNotModified();
    boolean checkNotModified(Instant var1);
    boolean checkNotModified(String var1);
    boolean checkNotModified(@Nullable String var1, Instant var2);

    String transformUrl(String var1);
    void addUrlTransformer(Function<String, String> var1);

    String getLogPrefix();

    default ServerWebExchange.Builder mutate() {
        return new DefaultServerWebExchangeBuilder(this);
    }

    public interface Builder {           //构造ServeraWebExchange
        ServerWebExchange.Builder request(Consumer<org.springframework.http.server.reactive.ServerHttpRequest.Builder> var1);

        ServerWebExchange.Builder request(ServerHttpRequest var1);       //设置请求
        ServerWebExchange.Builder response(ServerHttpResponse var1);     //设置响应

        ServerWebExchange.Builder principal(Mono<Principal> var1);       //设置认证用户
        ServerWebExchange build();                                       //返回ServerWebExchange
    }
}

 

 

**********************

ServerHttpRequest

 

ServerHttpRequest

public interface ServerHttpRequest extends HttpRequest, ReactiveHttpInputMessage {
    String getId();

    RequestPath getPath();
    MultiValueMap<String, String> getQueryParams();
    MultiValueMap<String, HttpCookie> getCookies();

    @Nullable
    default InetSocketAddress getLocalAddress() {
        return null;
    }

    @Nullable
    default InetSocketAddress getRemoteAddress() {
        return null;
    }

    @Nullable
    default SslInfo getSslInfo() {
        return null;
    }

    default ServerHttpRequest.Builder mutate() {
        return new DefaultServerHttpRequestBuilder(this);
    }

    public interface Builder {
        ServerHttpRequest.Builder method(HttpMethod var1);
        ServerHttpRequest.Builder uri(URI var1);
        ServerHttpRequest.Builder path(String var1);
        ServerHttpRequest.Builder contextPath(String var1);

        ServerHttpRequest.Builder header(String var1, String... var2);
        ServerHttpRequest.Builder headers(Consumer<HttpHeaders> var1);

        ServerHttpRequest.Builder sslInfo(SslInfo var1);
        ServerHttpRequest build();
    }
}

 

HttpRequest

public interface HttpRequest extends HttpMessage {
    @Nullable
    default HttpMethod getMethod() {
        return HttpMethod.resolve(this.getMethodValue());  //将请求方法转换为HttpMethod
    }

    String getMethodValue();        //获取请求方法
    URI getURI();                   //获取请求uri
}

 

HttpMessage

public interface HttpMessage {
    HttpHeaders getHeaders();   //获取请求头
}

 

ReactiveHttpInputMessage

public interface ReactiveHttpInputMessage extends HttpMessage {
    Flux<DataBuffer> getBody();
}

 

 

**********************

ServerHttpResponse

 

ServerHttpResponse

public interface ServerHttpResponse extends ReactiveHttpOutputMessage {
    boolean setStatusCode(@Nullable HttpStatus var1);

    @Nullable
    HttpStatus getStatusCode();

    default boolean setRawStatusCode(@Nullable Integer value) {
        if (value == null) {
            return this.setStatusCode((HttpStatus)null);
        } else {
            HttpStatus httpStatus = HttpStatus.resolve(value);
            if (httpStatus == null) {
                throw new IllegalStateException("Unresolvable HttpStatus for general ServerHttpResponse: " + value);
            } else {
                return this.setStatusCode(httpStatus);
            }
        }
    }

    @Nullable
    default Integer getRawStatusCode() {
        HttpStatus httpStatus = this.getStatusCode();
        return httpStatus != null ? httpStatus.value() : null;
    }

    MultiValueMap<String, ResponseCookie> getCookies();
    void addCookie(ResponseCookie var1);
}

 

ReactiveHttpOutputMessage

public interface ReactiveHttpOutputMessage extends HttpMessage {
    DataBufferFactory bufferFactory();

    void beforeCommit(Supplier<? extends Mono<Void>> var1);
    boolean isCommitted();

    Mono<Void> writeWith(Publisher<? extends DataBuffer> var1);
    Mono<Void> writeAndFlushWith(Publisher<? extends Publisher<? extends DataBuffer>> var1);

    Mono<Void> setComplete();
}

 

 

**********************

WebSession

 

webSession：存储应用session数据

public interface WebSession {
    String getId();

    Map<String, Object> getAttributes();

    @Nullable
    default <T> T getAttribute(String name) {
        return this.getAttributes().get(name);
    }

    default <T> T getRequiredAttribute(String name) {
        T value = this.getAttribute(name);
        Assert.notNull(value, () -> {
            return "Required attribute '" + name + "' is missing.";
        });
        return value;
    }

    default <T> T getAttributeOrDefault(String name, T defaultValue) {
        return this.getAttributes().getOrDefault(name, defaultValue);
    }

    void start();
    boolean isStarted();

    Mono<Void> changeSessionId();

    Mono<Void> invalidate();
    Mono<Void> save();

    boolean isExpired();
    Instant getCreationTime();
    Instant getLastAccessTime();

    void setMaxIdleTime(Duration var1);
    Duration getMaxIdleTime();
}

 

 

**********************

context信息

 

LocaleContext：国际化上下文

public interface LocaleContext {
    @Nullable
    Locale getLocale();
}

 

ApplicationContext：应用上下文

public interface ApplicationContext extends EnvironmentCapable, ListableBeanFactory, HierarchicalBeanFactory, MessageSource, ApplicationEventPublisher, ResourcePatternResolver {
    @Nullable
    String getId();
    String getApplicationName();

    String getDisplayName();
    long getStartupDate();

    @Nullable
    ApplicationContext getParent();
    AutowireCapableBeanFactory getAutowireCapableBeanFactory() throws IllegalStateException;
}

 

 

**********************

函数式类与接口

 

**********************

RouterFunction

 

RouterFunction

@FunctionalInterface
public interface RouterFunction<T extends ServerResponse> {
    Mono<HandlerFunction<T>> route(ServerRequest var1);

    default RouterFunction<T> and(RouterFunction<T> other) {
        return new SameComposedRouterFunction(this, other);
    }

    default RouterFunction<?> andOther(RouterFunction<?> other) {
        return new DifferentComposedRouterFunction(this, other);
    }

    default RouterFunction<T> andRoute(RequestPredicate predicate, HandlerFunction<T> handlerFunction) {
        return this.and(RouterFunctions.route(predicate, handlerFunction));
    }

    default RouterFunction<T> andNest(RequestPredicate predicate, RouterFunction<T> routerFunction) {
        return this.and(RouterFunctions.nest(predicate, routerFunction));
    }

    default <S extends ServerResponse> RouterFunction<S> filter(HandlerFilterFunction<T, S> filterFunction) {
        return new FilteredRouterFunction(this, filterFunction);
    }

    default void accept(Visitor visitor) {
        visitor.unknown(this);
    }
}

 

RouterFunctionBuilder：构造RouterFunction

class RouterFunctionBuilder implements Builder {
    private List<RouterFunction<ServerResponse>> routerFunctions = new ArrayList();
    private List<HandlerFilterFunction<ServerResponse, ServerResponse>> filterFunctions = new ArrayList();

    RouterFunctionBuilder() {
    }

    public Builder add(RouterFunction<ServerResponse> routerFunction) {
        Assert.notNull(routerFunction, "RouterFunction must not be null");
        this.routerFunctions.add(routerFunction);
        return this;
    }

    private Builder add(RequestPredicate predicate, HandlerFunction<ServerResponse> handlerFunction) {
        this.routerFunctions.add(RouterFunctions.route(predicate, handlerFunction));
        return this;
    }

    public Builder GET(String pattern, HandlerFunction<ServerResponse> handlerFunction) {
        return this.add(RequestPredicates.GET(pattern), handlerFunction);
    }

    public Builder GET(String pattern, RequestPredicate predicate, HandlerFunction<ServerResponse> handlerFunction) {
        return this.add(RequestPredicates.GET(pattern).and(predicate), handlerFunction);
    }

    public Builder HEAD(String pattern, HandlerFunction<ServerResponse> handlerFunction) {
        return this.add(RequestPredicates.HEAD(pattern), handlerFunction);
    }

    public Builder HEAD(String pattern, RequestPredicate predicate, HandlerFunction<ServerResponse> handlerFunction) {
        return this.add(RequestPredicates.HEAD(pattern).and(predicate), handlerFunction);
    }

    public Builder POST(String pattern, HandlerFunction<ServerResponse> handlerFunction) {
        return this.add(RequestPredicates.POST(pattern), handlerFunction);
    }

    public Builder POST(String pattern, RequestPredicate predicate, HandlerFunction<ServerResponse> handlerFunction) {
        return this.add(RequestPredicates.POST(pattern).and(predicate), handlerFunction);
    }

    public Builder PUT(String pattern, HandlerFunction<ServerResponse> handlerFunction) {
        return this.add(RequestPredicates.PUT(pattern), handlerFunction);
    }

    public Builder PUT(String pattern, RequestPredicate predicate, HandlerFunction<ServerResponse> handlerFunction) {
        return this.add(RequestPredicates.PUT(pattern).and(predicate), handlerFunction);
    }

    public Builder PATCH(String pattern, HandlerFunction<ServerResponse> handlerFunction) {
        return this.add(RequestPredicates.PATCH(pattern), handlerFunction);
    }

    public Builder PATCH(String pattern, RequestPredicate predicate, HandlerFunction<ServerResponse> handlerFunction) {
        return this.add(RequestPredicates.PATCH(pattern).and(predicate), handlerFunction)
最低0.47元/天 解锁文章

200万优质内容无限畅学
WebFlux使用函数式编程
lxmtim的博客
09-22 578
Spring WebFlux包括WebFlux.Fn是一种轻量级函数式编程模型，其中函数用于路由和处理请求，契约设计为不可变。它是基于注释的编程模型的另一种选择，但在其他方面运行在相同的Reactive Core基础上。在WebFlux.Fn，HTTP请求由HandlerFunction处理：该函数接受ServerRequest并返回延迟的ServerResponse（即Mono）。请求和响应对象都有不可变的契约，提供对HTTP请求和响应的JDK 8友好访问。
Spring Cloud Gateway 读取请求传参
onpwerb的博客
05-16 7013
背景介绍 有个业务需求，要提供一套API接口给第三方调用。 在处理具体业务接口之前，设计上要先做个简单的鉴权，协商拟定了身份传参后，考虑到项目上已经用到了Spring Cloud Gateway ,就统一在网关模块做身份校验。 所以在服务端获取到请求的时候，要先拦截获取到请求传参，才能做后续的鉴权逻辑。 这里就需要解决一个问题：Spring Cloud Gateway 怎么读取请求传参？ 搜索关键词：spring cloud gateway get request body 问题描述 问题：Spring C
SpringCloud：学习Gateway网关拦截器的ServerWebExchange
热门推荐
z69183787的专栏
11-26 1万+
1.Gateway的拦截器 我们要在项目中实现一个拦截器，需要继承两个类：GlobalFilter, Ordered GlobalFilter：全局过滤拦截器，在gateway中已经有部分实现，具体参照：https://www.cnblogs.com/liukaifeng/p/10055862.html Ordered：拦截器的顺序，不多说 于是一个简单的拦截器就有了 @Slf4j @Component public class AuthFilter implements GlobalFil
Spring Boot - 实用功能24 - webflux
最新发布
qq_43350524的博客
06-17 683
Spring Boot - 实用功能24 - webflux
SpringWebFlux-3(请求数据获取学习笔记2021.11.10)
志豪的博客
01-26 2266
SpringWebFlux -3(5.3.12版学习笔记2021.11.10) 1.4.4 Model (模型) 与 Spring MVC 中的使用方式相同 您可以使用@ModelAttribute注解： 在method argument in @RequestMapping方法上，可以从模型创建或访问对象，并通过WebDataBinder将其绑定到请求。 作为@Controller或@ControllerAdvice类中的方法级 Comments，有助于在任何@RequestMapping方法调用
揭秘 WebFlux 中如何修改 request/response body
武汉红喜
05-06 6823
我们的一些企业对于HTTP服务有一些非正常的做法，它们客户端的请求body是加密的，即在服务端需要对请求body进行解密，而服务端响应的body也要求加密。本文就来揭秘这一需求在 WebFlux 中如何实现，我们给 request/response body 均增加一个表示时间戳的字段 start/end 来模拟请求数据解密和响应数据加密，思路如下。 首先我们需要知道，WebFlux 的过滤器/拦截器是统一用WebFilter 来表示的，与 Spring MVC 类似，对于 application/js.
springboot webflux demo
07-26
**SpringBoot WebFlux 概述** SpringBoot WebFlux 是 Spring Framework 5.0 引入的一个新特性，它提供了非阻塞式、反应式编程模型，用于构建高性能、低延迟的Web应用程序。WebFlux是Spring对Reactor模式的实现，...
重学SpringBoot3-Spring WebFlux简介
CoderJia的学习之路
10-19 4346
随着微服务架构的流行和对高并发、低延迟系统需求的增加，响应式编程逐渐成为现代应用开发的主流方式之一。Spring Boot 3 引入了对响应式编程的强大支持，其中 Spring WebFlux 是一个重要的模块。本文将介绍 Spring WebFlux 的概念、特点以及它在实际应用中的场景和优势。
springboot webflux webclient 使用示例
weixin_43931625的博客
06-23 1123
springbootwebfluxwebclient使用示例
springboot webflux 异常处理（@ControllerAdvice）
weixin_43931625的博客
06-20 1315
sprigboot webflux异常处理（@ControllerAdvice）
CVE-2024-38816
GalaxySpaceX的博客
10-18 3943
CVE-2024-38816
WebFlux 框架对 request 的 InputStream 和 response 的 OutputStream 的使用
小单的博客专栏
05-12 1906
说到 WebFlux 就要提到和对比 Servlet，这样也是为了保留和尽量靠近以前代码的实现逻辑，所以最常用的就是对请求的输入流和响应的输出流处理。 在 Servlet 中获取输入流和输出流 HttpServletRequest request; HttpServletResponse response; InputStream inputStream = request.getInputStream(); OutputStream outputStream = response.getOutputSt
spring webflux系列之文件流下载文件
BanQIJane的博客
05-27 5734
spring webflux系列之流下载文件（不用本地创建文件直接流下载） 继承上一篇spring webflux系列之上传文件（多）到七牛云篇 网上基本上全部教程都是创建本地文件 才去下载 又要删除本地文件 这里使用到流下载文件 也就是inputStream 和 outputStream 都行 还是直接贴代码（简易版本） @GetMapping(value = "/downloadFile") public Mono<Void> downloadTest(ServerHttpRes
SpringBoot（5）响应式编程WebFlux
weixin_43831002的博客
07-30 4494
WebFlux是从SpringFramework5.0开始引入响应式Web框架的。与SpringMVC不同,WebFlux不需要ServletAPI,在完全异步且无阻塞，并通过Reactor项目实现ReactiveStreams规范。WebFlux可以在资源有限的情况下提高系统的吞吐量和伸缩性（不是提高性能）。这意味着，在资源相同的情况下，WebFlux可以处理更多的请求（不是业务）。WebFlux除支持RESTfulWeb服务外，还可以用于提供动态HTML内容。MVC的工作流程是。...
网关模块之Spring的Web路由功能类RouterFunctions
攻城狮Chova的博客
10-28 4606
路由功能类RouterFunctions
springwebflux 页面_Spring Webflux国际化
weixin_42116847的博客
12-30 717
这篇技术文章中，我们将看到如何在Spring Webflux应用程序中使用不同语言以及 Thymeleaf模板框架。让我们使用这个命令创建一个新项目：spring init --dependencies=webflux --build=gradle --language=java spring-webflux-internationalization这是生成的build.gradle文件：b...
webflux客户端发请求处理响应时遇到的
kakadiablo的专栏
02-09 9857
研究exchangeFunction和WebClient的用法时，无意踩到个坑，下面代码的exchangeFunctionWithResponse2，执行时异常： java.lang.IllegalStateException: block()/blockFirst()/blockLast() are blocking, which is not supported in thread reac...
详细分析Java中的ServerHttpResponse（附Demo）
码农研究僧的博客
04-12 2184
接口是Spring Framework中的ServerHttpResponse接口，用于表示服务器端的HTTP响应
springboot 处理multipart/form-data 请求（对接流处理不缓存中间文件）
weixin_43877044的博客
12-07 2252
源代码分析 springboot 处理multipart/form-data 时，会将文件流缓存 public MultipartHttpServletRequest resolveMultipart(HttpServletRequest request) throws MultipartException { return new StandardMultipartHttpServletRequest(request, this.resolveLazily); }
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值