Spring Boot 2 快速教程：WebFlux处理流程（五）

06-01 1435阅读

WebFlux请求处理流程

下面是spring mvc的请求处理流程

具体步骤：

第一步：发起请求到前端控制器(DispatcherServlet)
第二步：前端控制器请求HandlerMapping查找 Handler （可以根据xml配置、注解进行查找）
匹配条件包括：请求路径、请求方法、header信息等
第三步：处理器映射器HandlerMapping向前端控制器返回Handler，HandlerMapping会把请求映射为HandlerExecutionChain对象（包含一个Handler处理器（页面控制器）对象，多个HandlerInterceptor拦截器对象），通过这种策略模式，很容易添加新的映射策略
HandlerInterceptor是请求路径上的拦截器，需要自己实现这个接口以拦截请求，做一些对handler的前置和后置处理工作。
第四步：前端控制器调用处理器适配器去执行Handler
第五步：处理器适配器HandlerAdapter将会根据适配的结果去执行Handler
第六步：Handler执行完成给适配器返回ModelAndView
第七步：处理器适配器向前端控制器返回ModelAndView （ModelAndView是springmvc框架的一个底层对象，包括 Model和view）
第八步：前端控制器请求视图解析器去进行视图解析（根据逻辑视图名解析成真正的视图(jsp)），通过这种策略很容易更换其他视图技术，只需要更改视图解析器即可
第九步：视图解析器向前端控制器返回View
第十步：前端控制器进行视图渲染（视图渲染将模型数据(在ModelAndView对象中)填充到request域）
第十一步：前端控制器向用户响应结果

图解：注解驱动请求的webflux请求处理流程

我们可以对比SpringMVC的请求流程图对比来看

我们可以看到，处理流程基本一样，有以下主要的点不同
- 处理核心
  - WebFlux--DispatcherHandler
  - SpringMvc--DispatcherServlet
  - 返回值处理器
    - WebFlux--HandlerResultHandler
    - SpringMvc--HandlerMethodReturnValueHandler
    - 内容协商配置器
      - WebFlux--RequestedContentTypeResolverBuilder
      - SpringMvc--ContentNegotiationConfigurer
        还有很多就不一一例举了，想知道核心组件对比结果的同学，可以看下图。注意很多图上的组件名称相同，但是包的位置是不同的，所以大家要注意区分，不要弄混了。
        
        Web MVC VS. WebFlux 核心组件对比
        
        WebFlux 都有哪些核心组件
        
        Spring WebFlux 包含多个核心组件，它们共同构成了完整的响应式 Web 应用框架。下面是一些主要的核心组件：
        
        DispatcherHandler：这是 WebFlux 的中央调度器，类似于 Spring MVC 中的 DispatcherServlet。它负责发现和调度 HTTP 请求处理器（handlers），并处理请求映射、调用和结果处理。
        
        HandlerMapping：这个接口用于将请求映射到对应的处理器（handler）。它在应用程序上下文中被检测到，并用于确定请求应该由哪个处理器处理。
        
        HandlerAdapter：这个接口帮助 DispatcherHandler 调用任何类型的处理器，而不需要关心具体的调用方式。它为不同的处理器提供了调用策略。
        
        HandlerResultHandler：这个接口处理处理器调用后的结果，并生成最终的响应。它负责将处理器的结果转换为客户端可以接收的格式。
        
        WebFilter：WebFilter 接口定义了一组过滤器，这些过滤器可以对请求和响应进行预处理和后处理。
        
        ServerWebExchange：这个类封装了 HTTP 请求和响应的所有信息，例如请求头、请求体、URI、参数等。
        
        ServerHttpRequest 和 ServerHttpResponse：这两个类分别代表服务器接收的 HTTP 请求和发送的 HTTP 响应。
        
        WebSession：用于管理特定客户端的会话信息。
        
        Reactive Streams：WebFlux 基于 Reactive Streams 规范，使用非阻塞背压机制来处理数据流。
        
        Reactor 库：作为 Spring 5 的反应式编程基础，Reactor 提供了非阻塞的编程模型和工具，包括 Flux 和 Mono 等反应式类型。
        
        WebClient：这是 Spring 5 中引入的非阻塞、支持响应式流的 HTTP 客户端，用于与其它服务进行通信。
        
        Spring Data Reactive：提供对响应式数据访问的支持，例如 Reactive Repositories。
        
        Spring Security Reactive：提供对响应式安全访问控制的支持。
        
        HttpHandler：定义了最低级别的反应式 HTTP 请求处理合同，作为不同运行时之间的共同基础。
        
        ContextPathCompositeHandler：允许在不同的上下文路径上注册多个应用程序。
        
        这些组件共同工作，为开发人员提供了一个强大且灵活的响应式 Web 应用开发平台。通过这些组件，开发者可以构建出能够高效处理大量并发请求的应用程序。下面针对这些组件，V 哥将一一详细介绍核心源码的实现过程，帮助兄弟们彻底理解。
        
        1. DispatcherHandler
        
        DispatcherHandler 是 Spring WebFlux 的核心组件，它的作用类似于 Spring MVC 中的 DispatcherServlet。它负责将传入的 HTTP 请求分发给相应的处理器（handler），并处理请求的映射、调用和结果处理。以下是对 DispatcherHandler 组件源码实现逻辑和步骤的详细分析：
        
        初始化过程
        
        ApplicationContextAware 实现：DispatcherHandler 实现了 ApplicationContextAware 接口，这意味着它可以访问到 Spring 应用上下文中的 Bean。
        
        HandlerMapping、HandlerAdapter 和 HandlerResultHandler 的初始化：DispatcherHandler 在初始化时会查找 Spring 应用上下文中所有的 HandlerMapping、HandlerAdapter 和 HandlerResultHandler 并初始化它们。
        
        protected void initStrategies(ApplicationContext context) { // ... 省略部分代码 ... this.handlerMappings = ...; this.handlerAdapters = ...; this.resultHandlers = ...; }
        
        请求处理过程
        
        获取 HandlerMappings：DispatcherHandler 会通过 handlerMappings 来查找能够处理当前请求的 HandlerMapping。
        
        映射请求到 Handler：使用找到的 HandlerMapping 将请求映射到具体的处理器（可能是一个 @Controller 方法或者一个 RouterFunction）。
        
        调用 Handler：一旦找到处理器，DispatcherHandler 会使用适当的 HandlerAdapter 来调用处理器。
        
        处理结果：处理器的执行结果会被 HandlerResultHandler 处理，生成响应。
        
        核心方法：handle
        
        DispatcherHandler 的核心方法是 handle，它定义了请求处理的流程：
        
        public Mono handle(ServerWebExchange exchange) { // 检查是否初始化了 handlerMappings if (this.handlerMappings == null) { return createNotFoundError(); } // 使用 handlerMappings 来查找 handler return Flux.fromIterable(this.handlerMappings) .concatMap(mapping -> mapping.getHandler(exchange)) .next() // 获取第一个 handler .switchIfEmpty(createNotFoundError()) // 如果没有找到 handler，返回错误 .flatMap(handler -> invokeHandler(exchange, handler)) // 调用 handler .flatMap(result -> handleResult(exchange, result)); // 处理结果 }
        
        错误处理
        
        createNotFoundError：如果没有找到合适的处理器，DispatcherHandler 会创建一个表示 "Not Found" 的响应。
        其他组件的协同工作
        
        HandlerMapping：负责将请求 URL 映射到具体的处理器。
        HandlerAdapter：负责调用具体的处理器，Spring WebFlux 支持多种类型的处理器，HandlerAdapter 使得 DispatcherHandler 无需关心具体的调用细节。
        HandlerResultHandler：负责处理处理器的返回值，并将其转换为 HTTP 响应。
        DispatcherHandler 的设计使得它非常灵活，可以很容易地扩展新的 HandlerMapping、HandlerAdapter 或 HandlerResultHandler 来支持不同的处理器类型和返回类型。
        
        以上就是 DispatcherHandler 组件的源码实现逻辑和步骤的分析。通过这种方式，Spring WebFlux 能够以非阻塞的方式处理 Web 请求，提高应用的性能和可伸缩性。
        
        2. HandlerMapping
        
        HandlerMapping 是 Spring WebFlux 中的一个接口，它定义了将请求映射到处理器（handler）的逻辑。HandlerMapping 的实现类负责根据请求的类型、URL 模式等信息来确定哪个具体的处理器应该处理当前的请求。以下是对 HandlerMapping 组件的源码实现逻辑和步骤的详细分析：
        
        HandlerMapping 接口定义
        
        HandlerMapping 接口定义了以下关键方法：
        
        public interface HandlerMapping { Mono getHandler(ServerWebExchange exchange); void afterPropertiesSet(); }
        
        getHandler：根据给定的 ServerWebExchange 对象，返回一个 Mono 对象，该 Mono 完成时包含请求的处理器。
        afterPropertiesSet：在所有属性都设置之后调用，允许 HandlerMapping 实现进行初始化。
        主要实现类
        
        Spring WebFlux 提供了几个 HandlerMapping 的实现类，主要包括：
        
        RequestMappingHandlerMapping：处理基于注解的映射，例如 @RequestMapping、@GetMapping 等。
        
        RouterFunctionMapping：处理基于 RouterFunction 的函数式路由。
        
        SimpleUrlHandlerMapping：处理简单的 URL 到对象的映射。
        
        RequestMappingHandlerMapping 源码分析
        
        RequestMappingHandlerMapping 是最常用的 HandlerMapping 实现之一，下面是它的一些关键实现逻辑：
        
        注册和解析：在初始化时，RequestMappingHandlerMapping 会扫描所有的 beans，查找带有 @RequestMapping 注解的方法，并注册这些方法作为请求的处理器。
        
        映射处理：RequestMappingHandlerMapping 使用 Pattern 对象来存储和匹配 URL 模式。
        
        getHandler 方法实现：
        
        @Override public Mono getHandler(ServerWebExchange exchange) { String lookupPath = getPath(exchange); return getHandlerInternal(exchange) .filter(h -> matchesRoute(lookupPath, h)) .switchIfEmpty(Mono.defer(() -> getBestMatchingHandler(lookupPath, exchange))); }
        
        getPath：从 ServerWebExchange 中提取请求路径。
        getHandlerInternal：返回一个包含所有注册处理器的 Mono。
        filter 和 matchesRoute：检查处理器是否与请求路径匹配。
        getBestMatchingHandler：如果没有找到精确匹配的处理器，尝试找到最佳匹配的处理器。
        映射匹配逻辑
        
        映射匹配逻辑通常涉及以下步骤：
        
        路径匹配：检查请求的路径是否与注册的 URL 模式匹配。
        
        请求方法匹配：如果 URL 模式匹配，进一步检查请求的方法（GET、POST 等）是否与处理器支持的方法匹配。
        
        参数条件匹配：检查请求是否包含处理器所需的参数。
        
        头信息匹配：检查请求头是否满足特定的条件。
        
        消费和产生媒体类型匹配：检查请求的 Accept 头和 Content-Type 是否与处理器支持的媒体类型匹配。
        
        性能优化
        
        RequestMappingHandlerMapping 还实现了一些性能优化措施，例如缓存匹配的 URL 模式，以减少重复的模式匹配操作。
        
        小结一下
        
        HandlerMapping 组件是 Spring WebFlux 请求处理流程中的关键部分，它负责将进入的请求映射到正确的处理器。通过使用不同的 HandlerMapping 实现，Spring WebFlux 支持灵活的请求映射策略，以适应不同的应用场景。
        
        3. HandlerAdapter
        
        HandlerAdapter 接口在 Spring WebFlux 中扮演着至关重要的角色，它的作用是将 DispatcherHandler 找到的处理器（handler）适配到具体的执行逻辑上。HandlerAdapter 使得 DispatcherHandler 无需关心具体的处理器类型，只需要通过 HandlerAdapter 来调用处理器即可。以下是对 HandlerAdapter 组件的源码实现逻辑和步骤的详细分析：
        HandlerAdapter 接口定义
        
        HandlerAdapter 接口定义了以下关键方法：
        
        public interface HandlerAdapter { boolean supports(Object handler); Mono handle(ServerWebExchange exchange, Object handler, Object... args); }
        
        supports：检查给定的处理器是否被当前 HandlerAdapter 支持。
        handle：调用处理器，并返回一个 Mono 对象，表示异步的调用过程。
        主要实现类
        
        Spring WebFlux 提供了几个 HandlerAdapter 的实现类，主要包括：
        
        RequestMappingHandlerAdapter：支持基于注解的控制器方法，如带有 @RequestMapping 注解的方法。
        
        HttpHandlerAdapter：支持 HttpHandler 接口的处理器。
        
        ControllerEndpointHandlerAdapter：支持 ControllerEndpoint 接口的处理器，通常用于 WebFlux 函数式编程。
        
        RouterFunctionHandlerAdapter：支持 RouterFunction 接口，用于函数式路由。
        
        RequestMappingHandlerAdapter 源码分析
        
        RequestMappingHandlerAdapter 是最常用的 HandlerAdapter 实现之一，下面是它的一些关键实现逻辑：
        
        支持性检查：supports 方法检查给定的处理器是否是 Controller 或者 RequestMapping 注解的方法。
        @Override public boolean supports(Object handler) { return (handler instanceof HandlerFunction) || (handler instanceof Controller) || AnnotationUtils.findAnnotation(handler.getClass(), RequestMapping.class) != null; }
        
        调用处理器：handle 方法调用处理器，并处理返回值。
        
        @Override public Mono handle(ServerWebExchange exchange, Object handler) { // 调用具体的处理器 return ((HandlerFunction) handler).handle(exchange); }
        
        调用处理器的逻辑
        
        调用处理器的逻辑通常涉及以下步骤：
        
        参数解析：解析请求中的参数，并将其转换为方法参数。
        
        调用方法：调用处理器的方法，并将解析后的参数传递给方法。
        
        处理返回值：处理方法的返回值，将其转换为响应。
        
        异步处理：如果处理器返回的是 Mono 或 Flux，HandlerAdapter 需要处理这些异步结果。
        
        错误处理
        
        HandlerAdapter 还负责处理调用过程中的异常，将异常转换为合适的响应。
        
        小结一下
        
        HandlerAdapter 组件是 Spring WebFlux 请求处理流程中的关键部分，它解耦了 DispatcherHandler 和具体的处理器实现。通过使用不同的 HandlerAdapter 实现，Spring WebFlux 支持了多种类型的处理器，包括基于注解的控制器、函数式路由以及 HttpHandler 接口的实现。这种设计提高了框架的灵活性和可扩展性。
        
        4. HandlerResultHandler
        
        HandlerResultHandler 组件在 Spring WebFlux 中负责处理由 HandlerAdapter 调用处理器后返回的结果。它将这些结果转换为客户端可以接收的 HTTP 响应。以下是对 HandlerResultHandler 组件的源码实现逻辑和步骤的详细分析：
        
        HandlerResultHandler 接口定义
        
        HandlerResultHandler 接口定义了以下关键方法：
        
        public interface HandlerResultHandler { boolean supports(HandlerResult result); Mono handleResult(ServerWebExchange exchange, HandlerResult result); }
        
        supports：检查给定的 HandlerResult 是否被当前 HandlerResultHandler 支持。
        handleResult：处理 HandlerResult，生成响应并返回一个 Mono 对象，表示异步的处理过程。
        主要实现类
        
        Spring WebFlux 提供了几个 HandlerResultHandler 的实现类，主要包括：
        
        ServerResponseResultHandler：处理 ServerResponse 类型的返回值。
        ResponseEntityResultHandler：处理 ResponseEntity 类型的返回值。
        ModelAndViewResultHandler：处理 ModelAndView 类型的返回值，通常用于视图渲染。
        ServerResponseResultHandler 源码分析
        
        ServerResponseResultHandler 是处理 ServerResponse 类型结果的 HandlerResultHandler 实现：
        
        支持性检查：supports 方法检查 HandlerResult 是否包含 ServerResponse 对象。
        @Override public boolean supports(HandlerResult result) { return result.getReturnValue() instanceof ServerResponse; }
        
        处理结果：handleResult 方法处理 ServerResponse 对象，并生成响应。
        @Override public Mono handleResult(ServerWebExchange exchange, HandlerResult result) { ServerResponse response = (ServerResponse) result.getReturnValue(); return response.writeTo(exchange, result.isCommitted()); }
        
        处理结果的逻辑
        
        处理结果的逻辑通常涉及以下步骤：
        
        获取返回值：从 HandlerResult 中获取处理器的返回值。
        
        检查类型：根据返回值的类型，选择合适的处理逻辑。
        
        生成响应：将返回值转换为 HTTP 响应。例如，ServerResponse 已经包含了响应的状态码、头信息和体。
        
        异步处理：如果返回值是异步的（如 Mono 或 Flux），则需要处理这些异步结果。
        
        写入响应：将生成的响应写入到 ServerWebExchange 中。
        
        错误处理
        
        HandlerResultHandler 还负责处理结果处理过程中的异常，将异常转换为合适的响应。
        
        小结一下
        
        HandlerResultHandler 组件是 Spring WebFlux 请求处理流程中的关键部分，它负责将处理器的返回值转换为 HTTP 响应。通过使用不同的 HandlerResultHandler 实现，Spring WebFlux 支持了多种返回值类型，包括 ServerResponse、ResponseEntity 和 ModelAndView。这种设计提高了框架的灵活性和可扩展性，允许开发者以不同的方式处理响应结果。
        
        HandlerResultHandler 的实现通常需要考虑响应的异步特性，确保即使在异步流的情况下也能正确地生成和发送响应。此外，它还需要与 ServerWebExchange 紧密协作，以便访问和操作请求和响应的上下文信息。
        
        5. WebFilter
        
        WebFilter 接口是 Spring WebFlux 中用于拦截和处理 Web 请求和响应的组件。它允许开发者在请求到达具体的处理器之前或之后，对请求或响应进行额外的处理，例如日志记录、安全性检查、跨域处理等。以下是对 WebFilter 组件的源码实现逻辑和步骤的详细分析：
        
        WebFilter 接口定义
        
        WebFilter 接口定义了以下关键方法：
        
        public interface WebFilter { Mono filter(ServerWebExchange exchange, WebFilterChain chain); }
        
        filter：对给定的 ServerWebExchange 对象进行处理，并通过 WebFilterChain 调用链中的下一个 WebFilter 或最终的处理器。
        过滤器链
        
        在 Spring WebFlux 中，WebFilter 通常会被组织成一个过滤器链，每个 WebFilter 都可以决定是继续过滤请求还是将请求传递给链中的下一个 WebFilter。这种链式调用模式使得过滤器的执行顺序非常重要。
        
        主要实现类
        
        Spring WebFlux 提供了一些内置的 WebFilter 实现类，例如：
        
        ServerHttpSecurity：用于安全性检查。
        CorsFilter：用于处理跨源资源共享（CORS）。
        WebFilterChain：代表过滤器链的上下文，允许调用链中的下一个 WebFilter。
        过滤器链的构建
        
        过滤器链通常在应用程序的配置中构建，例如使用 WebFilter 接口的实现类：
        
        @Configuration public class WebFluxConfig { @Bean public WebFilter myCustomFilter() { return (exchange, chain) -> { // 在这里可以对请求进行预处理 return chain.filter(exchange).subscriberContext(ctx -> ctx.put("customKey", "customValue")); }; } }
        
        WebFilter 的实现逻辑
        
        实现 WebFilter 接口的 filter 方法通常涉及以下步骤：
        
        预处理：在调用 chain.filter(exchange) 之前，对 ServerWebExchange 进行任何必要的预处理，例如修改请求头、查询参数等。
        
        调用链：使用 WebFilterChain 的 filter 方法将请求传递给链中的下一个 WebFilter。这通常会返回一个 Mono，表示异步的过滤过程。
        
        后处理：在 chain.filter(exchange) 完成后，对 ServerWebExchange 进行任何必要的后处理，例如修改响应头、响应体等。
        
        错误处理：处理在过滤过程中可能发生的异常，并决定是抛出新的错误、返回特定的响应或继续过滤链。
        
        异步处理
        
        由于 filter 方法返回的是 Mono，WebFilter 的实现需要考虑异步处理。这意味着在过滤过程中，可以返回异步的响应，而不会阻塞整个请求的处理。
        
        小结一下
        
        WebFilter 组件是 Spring WebFlux 中用于拦截和处理 Web 请求和响应的强大工具。通过实现 WebFilter 接口并构建过滤器链，开发者可以灵活地对请求和响应进行预处理和后处理，以及实现各种横切关注点，如安全性、日志记录、CORS 处理等。这种设计提高了应用程序的模块性和可维护性，同时保持了非阻塞和异步的特性。
        
        6. ServerWebExchange
        
        ServerWebExchange 是 Spring WebFlux 中的一个核心组件，它封装了 HTTP 请求和响应的上下文信息，为 Web 服务器和应用程序之间提供了一个交互的接口。以下是对 ServerWebExchange 组件的源码实现逻辑和步骤的详细分析：
        
        ServerWebExchange 接口定义
        
        ServerWebExchange 接口定义了对 HTTP 请求和响应的访问和操作：
        
        public interface ServerWebExchange { ServerHttpRequest getRequest(); ServerHttpResponse getResponse(); void beforeCommit(); boolean isCommitted(); void setCommitted(boolean committed); Context getContext(); }
        
        getRequest()：返回当前的 ServerHttpRequest 对象，包含请求的详细信息。
        getResponse()：返回当前的 ServerHttpResponse 对象，用于构造响应。
        beforeCommit()：在响应提交之前调用，允许进行一些清理或准备操作。
        isCommitted()：检查响应是否已经提交。
        setCommitted(boolean committed)：设置响应是否提交的状态。
        getContext()：返回与当前交换关联的 Context，用于存储和传递附加信息。
        核心属性
        
        ServerWebExchange 通常包含以下核心属性：
        
        request：ServerHttpRequest 对象，封装了 HTTP 请求的详细信息，如头信息、URI、方法等。
        response：ServerHttpResponse 对象，用于构造和发送 HTTP 响应。
        principal：可能包含当前请求的认证主体（Principal）。
        session：可能包含当前请求的会话信息。
        attributes：一个 Map，用于存储与请求相关的属性。
        请求和响应的处理
        
        ServerWebExchange 在请求和响应的处理中扮演着核心角色：
        
        请求获取：通过 getRequest() 方法获取请求对象，访问请求的各种信息。
        
        响应构造：通过 getResponse() 方法获取响应对象，构造响应的状态码、头信息和响应体。
        
        上下文管理：使用 Context 对象存储和传递请求和响应过程中的附加信息。
        
        提交管理：通过 beforeCommit()、isCommitted() 和 setCommitted() 方法管理响应的提交状态。
        
        过滤器链：在 WebFilter 的实现中，ServerWebExchange 对象在过滤器链中传递，每个过滤器都可以访问和修改请求和响应。
        
        异步处理
        
        由于 WebFlux 是响应式的，ServerWebExchange 支持异步处理：
        
        响应可以通过非阻塞的方式写入，例如使用 ServerHttpResponse 的异步方法。
        请求和响应的处理可以在不同的线程或事件循环中进行。
        小结一下
        
        ServerWebExchange 是 Spring WebFlux 中处理 HTTP 请求和响应的核心组件。它提供了一个统一的接口来访问和操作请求和响应数据，同时支持异步非阻塞的处理方式。通过 ServerWebExchange，开发者可以在 Web 服务器和应用程序之间进行高效的数据交换和状态管理，实现高性能的响应式 Web 应用。
        
        ServerWebExchange 的实现通常需要考虑响应式的编程模型，确保在处理请求和构造响应时不会阻塞事件循环，从而充分利用 WebFlux 的性能优势。此外，它还提供了丰富的上下文管理功能，使得在复杂的请求处理流程中，可以方便地存储和传递附加信息。
        
        7. ServerHttpRequest和ServerHttpResponse
        
        ServerHttpRequest 和 ServerHttpResponse 是 Spring WebFlux 中的两个核心接口，它们分别表示服务器接收的 HTTP 请求和发送的 HTTP 响应。以下是对这两个组件的源码实现逻辑和步骤的详细分析：
        
        ServerHttpRequest 接口定义
        
        ServerHttpRequest 接口定义了对 HTTP 请求的访问：
        
        public interface ServerHttpRequest { URI getURI(); HttpMethod getMethod(); String getHeader(String headerName); MultiValueMap getHeaders(); DataBufferFactory bufferFactory(); // 省略其他方法... }
        
        getURI()：返回请求的 URI。
        getMethod()：返回 HTTP 方法（如 GET、POST 等）。
        getHeader(String headerName)：根据名称获取请求头的值。
        getHeaders()：返回包含所有请求头的 MultiValueMap。
        bufferFactory()：返回用于创建数据缓冲区（DataBuffer）的工厂。
        ServerHttpResponse 接口定义
        
        ServerHttpResponse 接口定义了对 HTTP 响应的构造和发送：
        
        public interface ServerHttpResponse { HttpStatusSeriesStatus.Series getStatusSeries(); void setStatusCode(HttpStatus statusCode); String getHeader(String headerName); MultiValueMap getHeaders(); void setComplete(); DataBufferFactory bufferFactory(); Mono writeWith(Publisher

免责声明：我们致力于保护作者版权，注重分享，被刊用文章因无法核实真实出处，未能及时与作者取得联系，或有版权异议的，请联系管理员，我们会立即处理! 部分文章是来自自研大数据AI进行生成,内容摘自(百度百科,百度知道,头条百科,中国民法典,刑法,牛津词典,新华词典,汉语词典,国家院校,科普平台)等数据,内容仅供学习参考,不准确地方联系删除处理! 图片声明：本站部分配图来自人工智能系统AI生成,觅知网授权图片,PxHere摄影无版权图库和百度，360，搜狗等多加搜索引擎自动关键词搜索配图，如有侵权的图片，请第一时间联系我们。