Springboot 2.0---WebFlux请求处理流程

笔记是学习了小马哥在慕课网的课程的《Spring Boot 2.0深度实践之核心技术篇》的内容结合自己的需要和理解做的笔记。

前言

在了解了WebFlux核心组件之后，我们就该了解相应的请求流程了，在之前就写过几篇关于 SpringMvc 请求的流程笔记，如果之前有过了解的并且自己debugger 过的小伙伴，相信了解 WebFlux 的执行流程会很快。

我们知道WebFlux支持两种请求模式

• 注解驱动
• 函数式端点

接下来我们会重点讲一下函数式端点请求的具体流程，注解驱动由于跟SpringMVC很像，所以大家只要看一下流程图，基本就可以了解了。

注解驱动组件请求处理流程

流程图

下面我们先来看一下具体流程图

p14.png

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

p16.png

我们可以看到，处理流程基本一样，有以下主要的点不同

• 处理核心

  • WebFlux--DispatcherHandler
  • SpringMvc--DispatcherServlet

• 返回值处理器

  • WebFlux--HandlerResultHandler
  • SpringMvc--HandlerMethodReturnValueHandler

• 内容协商配置器

  • WebFlux--RequestedContentTypeResolverBuilder
  • SpringMvc--ContentNegotiationConfigurer

还有很多就不一一例举了，想知道核心组件对比结果的同学，可以看下图。注意很多图上的组件名称相同，但是包的位置是不同的，所以大家要注意区分，不要弄混了。

Web MVC VS. WebFlux 核心组件对比

p17.png

函数式端点请求处理流程

流程图

按照惯例，上流程图

p15.png

通过上图，我们可以看到，这个处理跟之前的注解驱动请求大有不同，但是请求的流程是万变不离其宗，只是组件有所变化。

源码解读

接下来我们就跟着流程图一步一步的来解读WebFlux函数端点式请求的源码。

装配阶段

由上图我们可以看到 RouterFunctionMapping是由WebFluxConfigurationSupport创建的，在之前的笔记中我们已经有说明。

我们接下来看一下RouterFunctions是怎么合并RouterFunction的并且如何关联到RouterFunctionMapping的。

我们先来看一下 RouterFunctionMapping关于装配阶段的代码。

public class RouterFunctionMapping extends AbstractHandlerMapping implements InitializingBean {

   @Nullable
   private RouterFunction routerFunction;
    //省略部分代码
    
    //afterPropertiesSet()方法 是组件初始化后回调 必须实现InitializingBean接口
    //
   @Override
   public void afterPropertiesSet() throws Exception {
      if (CollectionUtils.isEmpty(this.messageReaders)) {
         ServerCodecConfigurer codecConfigurer = ServerCodecConfigurer.create();
         this.messageReaders = codecConfigurer.getReaders();
      }

      //初始化routerFunction
      if (this.routerFunction == null) {
         initRouterFunctions();
      }
   }

   /**
    * Initialized the router functions by detecting them in the application context.
    * 从应用上下文中查找他们并初始化路由方法
    */
   protected void initRouterFunctions() {
      if (logger.isDebugEnabled()) {
         logger.debug("Looking for router functions in application context: " +
               getApplicationContext());
      }

      //查找合并所有路由方法的bean
      List> routerFunctions = routerFunctions();
      if (!CollectionUtils.isEmpty(routerFunctions) && logger.isInfoEnabled()) {
         routerFunctions.forEach(routerFunction -> logger.info("Mapped " + routerFunction));
      }
       
      //将一个请求中含有多个路由请求方法合并成一个方法
      this.routerFunction = routerFunctions.stream()
            .reduce(RouterFunction::andOther)
            .orElse(null);
   }

    //查找并合并所有路由方法
   private List> routerFunctions() {
       //声明 SortedRouterFunctionsContainer bean
      SortedRouterFunctionsContainer container = new SortedRouterFunctionsContainer();
       //自动注入到上下文中 
      obtainApplicationContext().getAutowireCapableBeanFactory().autowireBean(container);
      //返回路由
      return CollectionUtils.isEmpty(container.routerFunctions) ? Collections.emptyList() :
            container.routerFunctions;
   }
    //省略部分代码
   private static class SortedRouterFunctionsContainer {

      @Nullable
      private List> routerFunctions;

       //由上面的方法 自动注入bean时实现依赖查找，查找所有的 RouterFunction beans
       //并注入到 List> 中。这样就会得到所有实现路由方法的集合
      @Autowired(required = false)
      public void setRouterFunctions(List> routerFunctions) {
         this.routerFunctions = routerFunctions;
      }
   }

}

请求阶段

请求阶段的核心代码就是 org.springframework.web.reactive.DispatcherHandler#handle方法,我们来看一下源码。

@Override
public Mono handle(ServerWebExchange exchange) {
   if (logger.isDebugEnabled()) {
      ServerHttpRequest request = exchange.getRequest();
      logger.debug("Processing " + request.getMethodValue() + " request for [" + request.getURI() + "]");
   }
   if (this.handlerMappings == null) {
      return Mono.error(HANDLER_NOT_FOUND_EXCEPTION);
   }
   // 1.HTTP请求进来后执行的流程
   return Flux.fromIterable(this.handlerMappings)  //2 遍历handlerMappings定位RouterFunctionMapping
         .concatMap(mapping -> mapping.getHandler(exchange))   // 3.获取HandlerFunction
         .next()
         .switchIfEmpty(Mono.error(HANDLER_NOT_FOUND_EXCEPTION))  
         .flatMap(handler -> invokeHandler(exchange, handler))   //4.执行
         .flatMap(result -> handleResult(exchange, result));  //5. 处理结果
}

上面的代码已经把大部分的流程说明清楚了，那么我们来看一下lambda表达式中每个内部方法的具体实现。

首先我们来看一下步骤3的具体实现 org.springframework.web.reactive.handler.AbstractHandlerMapping#getHandler

@Override
public Mono