spring5 的web开发技术栈
非阻塞的
运行在 netty 上的
需要 servlet3.1

官网链接——recative
image.png
目前主流关系型数据库是不支持 reactor 反应式编程
水平扩展，就是加人；垂直扩展，就是加班；

异步servlet、同步Servlet

创建dynamic web project，编写 servlet3.1 的 servlet。

同步的servlet

  1. package com.demo;
  3. import java.io.IOException;
  4. import java.util.concurrent.TimeUnit;
  6. import javax.servlet.ServletException;
  7. import javax.servlet.annotation.WebServlet;
  8. import javax.servlet.http.HttpServlet;
  9. import javax.servlet.http.HttpServletRequest;
  10. import javax.servlet.http.HttpServletResponse;
  12. @WebServlet("/TestSychServlet")
  13. public class TestSychServlet extends HttpServlet {
  14.     private static final long serialVersionUID = 1L;
  16.     protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
  17.         long t = System.currentTimeMillis();
  18.         doSomething(request, response);
  19.         System.out.println("TestSychServlet use time:"+(System.currentTimeMillis() - t));
  20.     }
  22.     private void doSomething(HttpServletRequest request, HttpServletResponse response) throws IOException {
  23.         try {
  24.             TimeUnit.SECONDS.sleep(3);
  25.         } catch (InterruptedException e) {
  26.             e.printStackTrace();
  27.         }
  28.         response.getWriter().write("TestSychServlet done");
  29.     }
  31.     protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
  32.         doGet(request, response);
  33.     }
  35. }

异步 servlet

异步servlet 编写步骤：

  1. 开启异步，AsyncContext asyncContext = request.startAsync();
  2. 另起线程（或线程池）执行业务逻辑，比如 CompletableFuture
  3. 业务处理完成，需要通知上下文 asyncContext.complete();

    异步例子

    ```java package com.demo;

import java.io.IOException; import java.util.concurrent.CompletableFuture; import java.util.concurrent.TimeUnit;

import javax.servlet.AsyncContext; import javax.servlet.ServletException; import javax.servlet.ServletRequest; import javax.servlet.ServletResponse; import javax.servlet.annotation.WebServlet; import javax.servlet.http.HttpServlet; import javax.servlet.http.HttpServletRequest; import javax.servlet.http.HttpServletResponse; /**

  • 异步servlet 编写步骤：
    1. 开启异步，AsyncContext asyncContext = request.startAsync();
    1. 另起线程执行业务逻辑，比如 CompletableFuture
    1. 业务处理完成，需要通知上下文 asyncContext.complete();

  • @author DELL / @WebServlet(value = “/TestAsychServlet2”, asyncSupported = true) public class TestAsychServlet2 extends HttpServlet { private static final long serialVersionUID = 1L;

    protected void doGet(HttpServletRequest request, HttpServletResponse response)

    1.      throws ServletException, IOException {
    2.  long t = System.currentTimeMillis();
    3.  // 开启异步
    4.  AsyncContext asyncContext = request.startAsync();
    5.  // 执行业务逻辑代码
    6.  CompletableFuture.runAsync(() -> doSomething(asyncContext, asyncContext.getRequest(), asyncContext.getResponse()));
    8.  System.out.println("TestAsychServlet2 use time:" + (System.currentTimeMillis() - t));

    }

    private void doSomething(AsyncContext asyncContext, ServletRequest servletRequest, ServletResponse servletResponse) {

    1.  // 模拟耗时
    2.  try {
    3.      TimeUnit.SECONDS.sleep(3);
    4.      System.out.println(">>>>>>>>>>> 3 seconds");
    5.  } catch (InterruptedException e) {
    6.      e.printStackTrace();
    7.  }
    9.  try {
    10.      servletResponse.getWriter().write("TestAsychServlet2 done");
    11.  } catch (IOException e) {
    12.      e.printStackTrace();
    13.  }
    15.  // 调用上下文中 AsyncContext asyncContext 通知完成结束
    16.  asyncContext.complete();

    }

    protected void doPost(HttpServletRequest request, HttpServletResponse response)

    1.      throws ServletException, IOException {
    2.  doGet(request, response);

    }

}

  1. <a name="HWlOw"></a>
  2. ## 输出结果：
  3. TestAsychServlet2 use time:1<br />
  4. >>>>>>>>>>> 3 seconds
  5. <br />TestAsychServlet2 use time:0
  6. <br />>>>>>>>>>>> 3 seconds
  7. <br />TestSychServlet use time:3001
  8. <a name="gKfwU"></a>
  9. ## 小结
  10. 异步和同步，对于前端browser 来说，都是相同耗时获取到响应结果，但是servlet本身时间是不同的。传统式 servlet 被业业务阻塞，异步式servlet没有。
  12. <a name="dqJAj"></a>
  13. # reactor
  14. reactor 就是 jdk8 stream + jdk9 reactive stream<br />flux [0-n]<br />mono [0-1]
  15. <a name="ps1g8"></a>
  16. ## reactor 中的 flux 小例子
  17. ```java
  18. package com.demo;
  20. import org.reactivestreams.Subscriber;
  21. import org.reactivestreams.Subscription;
  22. import reactor.core.Disposable;
  23. import reactor.core.publisher.Flux;
  25. public class TestReactorDemo {
  27.     public static void main(String[] args) {
  28.         // Reactor 相当于 jdk8 stream + jdk9 reactive stream
  29.         // Mono 代表 0-1 个元素
  30.         // Flux 代表 0-N 个元素
  31.         String[] strArr = {"1", "2", "3"};
  32.         // 创建流
  33.         Flux.fromArray(strArr)
  34.                 // 流中间处理
  35.                 .map(x -> Integer.parseInt(x))
  36.                 //  结束流，就是一个消费者
  37.                 .subscribe(System.out::println);
  38.         Subscriber<Integer> subscriber = new Subscriber<>() {
  39.             private Subscription subscription;
  40.             @Override
  41.             public void onSubscribe(Subscription subscription) {
  42.                 // 保存订阅关系
  43.                 this.subscription = subscription;
  44.                 System.out.println(">>>>>>>>>> 建立订阅");
  45.                 // 发个订阅要求
  46.                 subscription.request(1);
  47.             }
  49.             @Override
  50.             public void onNext(Integer integer) {
  51.                 // 订阅到的数据，并进行相关处理
  52.                 System.out.println(">>>>>>>>>>>>>> 数据:" + integer);
  53.                 // 继续订阅 request，或者结束 cancel
  54.                 subscription.request(1);
  55.             }
  57.             @Override
  58.             public void onError(Throwable throwable) {
  59.                 // 异常处理
  60.             }
  62.             @Override
  63.             public void onComplete() {
  64.                 // 发布者关闭
  65.                 System.out.println(">>>>>>>> 结束了");
  66.             }
  67.         };
  68.         Flux.fromArray(strArr)
  69.                 // 流中间处理
  70.                 .map(x -> Integer.parseInt(x))
  71.                 //  结束流，就是订阅，subscribe
  72.                 .subscribe(subscriber);
  73.     }
  74. }

Flux 的 subscribe 方法有多个，多态，api 如下：
image.png

Flux 小例子小结

Flux 惰性求值，流在最终操作时才开始有值产生（个人感觉就是 java8 流式处理一样的）

webflux

引入的是 reactive web（对应springWebFlux） ，不是原来的 web （对应 SpringMVC）
lombok 功能添加，-javaagent:lombok.jar （编辑 sts.ini 或者 eclipse.ini，idea 直接插件 lombok）

官网 webflux

传统方式

所谓传统方式就是 SpringMVC 样子相似，看代码：

传统方式 demo 1 简单使用

  1. package com.demo;
  3. import org.springframework.web.bind.annotation.GetMapping;
  4. import org.springframework.web.bind.annotation.RequestMapping;
  5. import org.springframework.web.bind.annotation.RestController;
  6. import reactor.core.publisher.Mono;
  8. /**
  9.  * 传统 SpringMVC 方式，使用 webflux
  10.  */
  11. @RestController
  12. @RequestMapping("/v1/test/")
  13. public class TestController {
  15.     /**
  16.      * 传统 SpringMVC
  17.      */
  18.     @GetMapping("/1")
  19.     public String get1() {
  20.         return "get1";
  21.     }
  23.     /**
  24.      * 传统方式，webflux
  25.      * @return
  26.      */
  27.     @GetMapping("/2")
  28.     public Mono<String> get2() {
  29.         return Mono.just("get2");
  30.     }
  31. }

传统方式 demo 2 模拟数据处理

  1. package com.demo;
  3. import java.util.concurrent.TimeUnit;
  4. import lombok.extern.slf4j.Slf4j;
  5. import org.springframework.web.bind.annotation.GetMapping;
  6. import org.springframework.web.bind.annotation.RequestMapping;
  7. import org.springframework.web.bind.annotation.RestController;
  8. import reactor.core.publisher.Mono;
  10. /**
  11.  * 传统 SpringMVC 方式，使用 webflux
  12.  */
  13. @Slf4j
  14. @RestController
  15. @RequestMapping("/v1/test/demo")
  16. public class TestDemo2Controller {
  18.     /**
  19.      * 传统 SpringMVC
  20.      */
  21.     @GetMapping("/1")
  22.     public String get1() {
  23.         log.info("get1 start");
  24.         String result = doSomething();
  25.         log.info("get1 end");
  26.         return result;
  27.     }
  29.     /**
  30.      * 传统方式，webflux
  31.      * @return
  32.      */
  33.     @GetMapping("/2")
  34.     public Mono<String> get2() {
  35.         log.info("get2 start");
  36.         Mono<String> result = Mono.fromSupplier(this::doSomething);
  37.         log.info("get2 end");
  38.         return result;
  39.     }
  41.     /**
  42.      * 模拟业务处理
  43.      * @return
  44.      */
  45.     private String doSomething() {
  46.         try {
  47.             TimeUnit.SECONDS.sleep(3);
  48.         } catch (InterruptedException e) {
  49.             e.printStackTrace();
  50.         }
  51.         return "do something";
  52.     }
  53. }

demo 2 访问结果：

浏览器：
image.png
日志：

  1. 2021-04-24 10:31:51.118  INFO 17036 --- [ctor-http-nio-2] com.demo.TestDemo2Controller             : get2 start
  2. 2021-04-24 10:31:51.118  INFO 17036 --- [ctor-http-nio-2] com.demo.TestDemo2Controller             : get2 end
  3. 2021-04-24 10:32:10.849  INFO 17036 --- [ctor-http-nio-2] com.demo.TestDemo2Controller             : get1 start
  4. 2021-04-24 10:32:13.849  INFO 17036 --- [ctor-http-nio-2] com.demo.TestDemo2Controller             : get1 end

中的关注time，还有后端的日志时间打印，可以发现 反应式编程是惰性的。

传统方式 demo 3 使用 Flux 返回多条数据

  1. package com.demo;
  3. import java.util.concurrent.TimeUnit;
  4. import java.util.stream.IntStream;
  5. import lombok.extern.slf4j.Slf4j;
  6. import org.springframework.web.bind.annotation.GetMapping;
  7. import org.springframework.web.bind.annotation.RequestMapping;
  8. import org.springframework.web.bind.annotation.RestController;
  9. import reactor.core.publisher.Flux;
  11. /**
  12.  * 传统 SpringMVC 方式，使用 webflux Flux 返回对象
  13.  *
  14.  * Flux 是 0-n 个元素
  15.  */
  16. @Slf4j
  17. @RestController
  18. @RequestMapping("/v1/test/flux")
  19. public class TestFluxController {
  21.     /**
  22.      * 传统 webflux，不指定产生方式，一次性全部返回
  23.      */
  24.     @GetMapping("/1")
  25.     public Flux<String> get1() {
  26.         log.info("get1 called");
  27.         return Flux.fromStream(IntStream.range(1, 6).mapToObj(x -> {
  28.             try {
  29.                 TimeUnit.SECONDS.sleep(2);
  30.             } catch (InterruptedException e) {
  31.                 e.printStackTrace();
  32.             }
  33.             return "from flux data:" + x;
  34.         }));
  35.     }
  37.     /**
  38.      * 传统方式，webflux，指定产生方式，一次只返回一个
  39.      */
  40.     @GetMapping(value = "/2", produces = {"text/event-stream"})
  41.     public Flux<String> get2() {
  42.         log.info("get2 called");
  43.         return Flux.fromStream(IntStream.range(1, 6).mapToObj(x -> {
  44.             try {
  45.                 TimeUnit.SECONDS.sleep(2);
  46.             } catch (InterruptedException e) {
  47.                 e.printStackTrace();
  48.             }
  49.             return "from flux data:" + x;
  50.         }));
  51.     }
  52. }

结果：

http://localhost:8080/v1/test/flux/1 请求结果：
image.png
http://localhost:8080/v1/test/flux/2 请求结果：
image.png
数据逐条显示在浏览器上！！！使用SSE server-sent event，基于 html5；使用传统方式时，一般都会写两个接口，一个是一次全部返回（不指定 produces），一个是逐条返回（指定 produces 为 text/event-stream）

使用 servlet 编写 SSE（使用的是 dynamic web的工程，不是 spring webflux）

  1. package com.demo;
  3. import java.io.IOException;
  4. import java.util.concurrent.TimeUnit;
  6. import javax.servlet.ServletException;
  7. import javax.servlet.annotation.WebServlet;
  8. import javax.servlet.http.HttpServlet;
  9. import javax.servlet.http.HttpServletRequest;
  10. import javax.servlet.http.HttpServletResponse;
  12. /**
  13.  * 测试使用 SSE server send event
  14.  *
  15.  * 逐条将结果返回到前端
  16.  */
  17. @WebServlet(name = "SSEDemoServlet", value = "/SSEDemoServlet")
  18. public class SSEDemoServlet extends HttpServlet {
  20.     @Override
  21.     protected void doPost(HttpServletRequest request, HttpServletResponse response)
  22.             throws ServletException, IOException {
  23.         doGet(request, response);
  24.     }
  26.     @Override
  27.     protected void doGet(HttpServletRequest request, HttpServletResponse response)
  28.             throws ServletException, IOException {
  29.         // 使用SSE 需要设置 response 消息头
  30.         response.setContentType("text/event-stream");
  31.         response.setCharacterEncoding("utf-8");
  32.         // 模拟数据
  33.         for (int i = 0; i < 5; i++) {
  34.             // 添加event id标识，格式：id: + id值 + 一个回车
  35.             response.getWriter().write("id:" + Math.random() + "\n");
  36.             // 添加event type标识，格式：event: + 事件名称 + 一个回车
  37.             response.getWriter().write("event:me\n");
  38.             // 数据的格式需要是这样： data: + 数据 + 2个回车
  39.             response.getWriter().write("data:" + i + "\n\n");
  40.             response.getWriter().flush();
  42.             try {
  43.                 TimeUnit.SECONDS.sleep(1);
  44.             } catch (InterruptedException e) {
  45.                 e.printStackTrace();
  46.             }
  47.         }
  48.     }
  49. }
  1. <!DOCTYPE html>
  2. <html lang="en">
  3. <head>
  4.   <meta charset="UTF-8">
  5.   <title>sse （Server Send Event）测试</title>
  6. </head>
  7. <body>
  8. <h1>测试 SSE Server Send Event</h1>
  10. </body>
  11. <script type="text/javascript">
  12.   // 初始化参数，参数为 url，此处使用相对路径
  13.   // sse 会自动链接服务器，不关闭一直会链接
  14.   var sse = new EventSource("SSEDemoServlet");
  16.   // 收到信息时的处理
  17.   sse.onmessage = function (ev) {
  18.     console.log("message", ev.data, ev);
  19.   }
  20.   // 添加时间监听
  21.   sse.addEventListener("me", function (evt) {
  22.     console.log("me event", evt.data, evt);
  23.     if (evt.data == 3) {
  24.       // 关闭链接
  25.       sse.close();
  26.     }
  27.   })
  28. </script>
  29. </html>

SSE 不关闭会一直拿数据，自动链接。
注意：在 spring webflux 中是没有 servlet3.1 jar包的，即使导入依赖

  1. <!-- https://mvnrepository.com/artifact/javax.servlet/javax.servlet-api -->
  2. <dependency>
  3.     <groupId>javax.servlet</groupId>
  4.     <artifactId>javax.servlet-api</artifactId>
  5.     <version>3.1.0</version>
  6.     <scope>provided</scope>
  7. </dependency>

对应的 servlet 无法正常访问（状态是200，但是response 的 header 不是自己设置的 text/event-stream），搞得没办法，先且在 dynamic web 项目中测试上面的 SSE demo。
image.png

使用 routerfunction 方式

主要变化是将原来的 HttpServletRequest 抽象成 ServerRequest，HttpServletResponse 抽象为 ServerResponser

开发步骤

handlerFunction（输入 ServerRequest，返回 ServerResponse）

  1. RouterFunction（请求url 和 HandlerFunction 对应起来）
  2. 建立一个HttpHandler 处理相关的请求
  3. Server 处理

    routerfunction 代码

    ```java package com.demo.webflux;

import org.springframework.context.annotation.Bean; import org.springframework.context.annotation.Configuration; import org.springframework.http.MediaType; import org.springframework.web.reactive.function.server.RequestPredicates; import org.springframework.web.reactive.function.server.RouterFunction; import org.springframework.web.reactive.function.server.RouterFunctions; import org.springframework.web.reactive.function.server.ServerResponse;

/**

  • 测试 webflux，使用 路由函数， routerfunction */ @Configuration public class TestWebFluxByRouterFunction {

    @Bean RouterFunction webfluxDemoRouter(WebFluxDemoHandler handler) {

    1.  return RouterFunctions
    2.          // 相当于类上的路径
    3.          .nest(RequestPredicates.path("/v1/web/flux/demo"),
    4.                  RouterFunctions
    5.                          // 相当于方法上的路径
    6.                          .route(RequestPredicates.GET("/"), handler::getAll)
    7.                          .andRoute(RequestPredicates.DELETE("/{id}"), handler::deleteById)
    8.                          .andRoute(RequestPredicates.POST("/add")
    9.                                  // 设置请求格式
    10.                                  .and(RequestPredicates.accept(MediaType.APPLICATION_JSON)), handler::add)
    11.                          .andRoute(RequestPredicates.GET("/init"), handler::init)
    12.                          .andRoute(RequestPredicates.GET("/{id}"), handler::getById)
    13.          );

    }

}

  1. 需要指定为 configuration，内部创建了 Bean 对象。
  3. <a name="V9H0D"></a>
  4. ### 建立一个 handler: WebFluxDemoHandler
  5. ```java
  6. package com.demo.webflux;
  8. import java.time.LocalDate;
  9. import java.util.Arrays;
  10. import java.util.List;
  11. import java.util.Objects;
  12. import java.util.stream.Collectors;
  13. import java.util.stream.IntStream;
  14. import org.springframework.http.MediaType;
  15. import org.springframework.stereotype.Component;
  16. import org.springframework.web.reactive.function.server.ServerRequest;
  17. import org.springframework.web.reactive.function.server.ServerResponse;
  18. import reactor.core.publisher.Flux;
  19. import reactor.core.publisher.Mono;
  21. /**
  22.  * 自定义一个 HandlerFunction，传入参数 {@link ServerRequest ServerRequest}， 返回 Mono<T> 此处 T 为 {@link ServerResponse
  23.  * ServerResponse}
  24.  *
  25.  * @see org.springframework.web.reactive.function.server.HandlerFunction#handle(ServerRequest)
  26.  */
  27. @Component
  28. public class WebFluxDemoHandler {
  30.     /**
  31.      * 模拟数据库数据
  32.      */
  33.     private List<WebFluxDemo> data = IntStream.range(1, 5)
  34.             .mapToObj(x -> WebFluxDemo.builder().id("1" + x).age(30 + x).birthday(LocalDate.now()).name("xiaohui" + x)
  35.                     .build())
  36.             .collect(Collectors.toList());
  38.     /**
  39.      * 初始化数据，并返回数据
  40.      */
  41.     public Mono<ServerResponse> init(ServerRequest request) {
  42.         this.data = IntStream.range(1, 5)
  43.                 .mapToObj(
  44.                         x -> WebFluxDemo.builder().id("1" + x).age(30 + x).birthday(LocalDate.now()).name("xiaohui" + x)
  45.                                 .build())
  46.                 .collect(Collectors.toList());
  47.         return ServerResponse.ok().contentType(MediaType.APPLICATION_JSON).body(Flux.fromIterable(data),
  48.                 WebFluxDemo.class);
  49.     }
  51.     /**
  52.      * 查询所有的数据
  53.      */
  54.     public Mono<ServerResponse> getAll(ServerRequest request) {
  55.         return ServerResponse.ok().contentType(MediaType.APPLICATION_JSON)
  56.                 .body(Flux.fromIterable(data), WebFluxDemo.class);
  57.     }
  59.     /**
  60.      * 根据id，查询数据
  61.      */
  62.     public Mono<ServerResponse> getById(ServerRequest request) {
  63.         String id = request.pathVariable("id");
  64.         WebFluxDemo first = data.stream().filter(x -> x.getId().equals(id)).findFirst().get();
  65.         Mono<ServerResponse> result = null;
  66.         if (Objects.isNull(first)) {
  67.             result = ServerResponse.notFound().build();
  68.         } else {
  69.             result = ServerResponse.ok().contentType(MediaType.APPLICATION_JSON).body(Mono.just(first),
  70.                     WebFluxDemo.class);
  71.         }
  72.         return result;
  73.     }
  75.     /**
  76.      * 根据id，删除数据
  77.      */
  78.     public Mono<ServerResponse> deleteById(ServerRequest request) {
  79.         String id = request.pathVariable("id");
  80.         WebFluxDemo first = data.stream().filter(x -> x.getId().equals(id)).findFirst().orElseGet(()->null);
  81.         Mono<ServerResponse> result = null;
  82.         if (Objects.isNull(first)) {
  83.             result = ServerResponse.notFound().build();
  84.         } else {
  85.             data.remove(first);
  86.             result = ServerResponse.ok().build();
  87.         }
  88.         return result;
  89.     }
  91.     /**
  92.      * 添加数据
  93.      */
  94.     public Mono<ServerResponse> add(ServerRequest request) {
  95.         return request.bodyToMono(WebFluxDemo.class).flatMap(demo -> {
  96.             data.add(demo);
  97.             return ServerResponse.ok().body(Mono.just(demo), WebFluxDemo.class);
  98.         }).switchIfEmpty(ServerResponse.badRequest().contentType(MediaType.TEXT_PLAIN).body(Mono.just("请求错误"),
  99.                 String.class));
  100.     }
  102. }

handler 返回值是 Mono，参数是 ServerRequest。

SSE 方式查询结果 ServerResponse.ok().contentType(MediaType.APPLICATION_JSON)：

  1.     /**
  2.      * 查询所有的数据
  3.      */
  4.     public Mono<ServerResponse> getAll(ServerRequest request) {
  5. //        return ServerResponse.ok().contentType(MediaType.APPLICATION_JSON)
  6. //                .body(Flux.fromIterable(data), WebFluxDemo.class);
  8.         return ServerResponse.ok().contentType(MediaType.TEXT_EVENT_STREAM).body(Flux.fromStream(IntStream.range(1, 5)
  9.                         .mapToObj(x -> {
  10.                             try {
  11.                                 TimeUnit.SECONDS.sleep(2);
  12.                             } catch (InterruptedException e) {
  13.                                 e.printStackTrace();
  14.                             }
  15.                             return WebFluxDemo.builder().id("1" + x).age(30 + x).birthday(LocalDate.now()).name(
  16.                                     "xiaohui" + x)
  17.                                     .build();
  18.                         })),
  19.                 WebFluxDemo.class);
  20.     }

routerfunction 方式如何设定为 text/event-stream （sse server send event），难道默认就是？
这个是需要设置的 ServerResponse.ok().contentType(MediaType.TEXT_EVENT_STREAM)。
image.png

普通 domain 类 WebFluxDemo

  1. package com.demo.webflux;
  3. import java.time.LocalDate;
  4. import lombok.AllArgsConstructor;
  5. import lombok.Builder;
  6. import lombok.Data;
  7. import lombok.NoArgsConstructor;
  9. /**
  10.  * 测试webflux 的一个对象信息
  11.  */
  12. @Data
  13. @Builder
  14. @NoArgsConstructor
  15. @AllArgsConstructor
  16. public class WebFluxDemo {
  17.     private String id;
  18.     private String name;
  19.     private Integer age;
  20.     private LocalDate birthday;
  21. }

数据库的crud操作

关系型引入 r2dbc，MongoDB已支持

小结

流式编程，就是要重点关注 publisher、subscriber、flow、flux、mono这几个。

问题

  1. webflux 中如何使用servlet原生编程
  2. web与webflux能否同时使用
  3. routerfunction 方式如何设定为 text/event-stream （sse server send event），难道默认就是？如何做到文章分段返回与渲染（长文章，图片）
  4. 关于routerfunction 方式的参数校验与errorhandler，mono.error等
  5. 反应式编程，什么时候指定 request请求数量的？publisher的关闭，subscriber 的订阅？