WebFlux 示例程序

1.Spring WebFlux模块

  Spring Framework 5包含一个新 spring-webflux 模块。该模块包含对反应式HTTP和WebSocket客户端的支持以及反应式服务器Web应用程序（包括REST，HTML浏览器和WebSocket样式交互）。

2.Server

spring web-flux 支持2种不同的编程模型
1.支持Spring MVC @Controller 这种注解,用法大同小异
2.函数式 Java 8 lambda 风格的路由函数处理请求

WebFlux可以在支持Servlet 3.1非阻塞IO API以及其他异步运行时（如Netty和Undertow）的Servlet容器上运行。下图显示了服务器端两种技术栈，其中包括spring-webmvc模块左侧的传统基于Servlet的Spring MVC以及模块右侧的 基于响应式的spring-webflux。

webflux-overview.png

1.注解式编程:虽然可以使用与Spring MVC相同的注解,但其底层核心(HandlerMapping HandlerAdapter)有所不同 ,这其中 webFlux 操作和传递的对象是 非阻塞式 ServletHttpRequest 和 ServletHttpResponse 而不是 传统 Spring MVC 所操作 阻塞式的 HttpServletRequest 与 HttpServletResponse 对象

@RestController
public class PersonController {

    private final PersonRepository repository;

    public PersonController(PersonRepository repository) {
        this.repository = repository;
    }
    //从前台接收json/xml类型数据
    @PostMapping("/person")
    Mono create(@RequestBody Publisher personStream) {
        return this.repository.save(personStream).then();
    }
    //得到一个集合
    @GetMapping("/person")
    Flux list() {
        return this.repository.findAll();
    }
    //RestFul 风格传参
    @GetMapping("/person/{id}")
    Mono findById(@PathVariable String id) {
        return this.repository.findOne(id);
    }
}

2.函数式编程风格(HandlerFunctions RouterFunctions)

  2.1 HandlerFunctions http请求处理函数,本质上是一个 传入参数类型为ServerRequest 返回类型为Mono函数,在Spring MVC 中与之相对应的就是被@RequestMapping 注解所修饰的方法.ServerRequest并且ServerResponse接口可以提供JDK-8(Lambda)对底层HTTP消息的友好访问。对程序来说 响应流 暴露在Flux或Mono; 请求流以 Publisher作为主体。
下面是对Request 和 Response操作
1.取出Request body 到 Mono

Mono  string = request.bodyToMono（String.class）;

2.取出Request body 到 Flux 如果body内容是json 或者是 xml 可以将其反序列化为相应的实体类 这里的person 假设为一个实体类

Flux  people = request.bodyToFlux（Person.class）

3.bodyToMono和bodyToFlux 是 ServerRequest.body(BodyExtractor)的简写 上面两段代码相当于

Mono  string = request.body（BodyExtractors.toMono（String.class）;
Flux  people = request.body（BodyExtractors.toFlux（Person.class）;

4.同样 相应ServletResponse操作类似 该对象可以 通过其内部方法build.

Mono person = ...
ServerResponse.ok().contentType(MediaType.APPLICATION_JSON).body(person);

5.构建一个响应码为201的 ServerResponse(自己百度201啥意思)

URI location = "http:*****";
ServerResponse.created（location）.build（）;

6. Hello World functionHandler (接收一个ServerRequest 返回一个ServerResponse )

HandlerFunction helloWorld =
  request -> ServerResponse.ok().body(fromObject("Hello World"));

7.综合示例

import static org.springframework.http.MediaType.APPLICATION_JSON;
import static org.springframework.web.reactive.function.BodyInserters.fromObject;

public class PersonHandler {

    private final PersonRepository repository;

    public PersonHandler(PersonRepository repository) {
        this.repository = repository;
    }
    //查询出一个 people 集合 并将这个集合 序列化到响应体中
    public Mono listPeople(ServerRequest request) { 
        Flux people = repository.allPeople();
        return ServerResponse.ok().contentType(APPLICATION_JSON).body(people, Person.class);
    }
   //从请求体取出字符串(XML or Json 格式)反序列化为 实体对象
    public Mono createPerson(ServerRequest request) { 
        Mono person = request.bodyToMono(Person.class);
        return ServerResponse.ok().build(repository.savePerson(person));
    }
  //请求参数在路径中 rest风格
    public Mono getPerson(ServerRequest request) { 
   //pathVariable
        int personId = Integer.valueOf(request.pathVariable("id"));
   // 404
        Mono notFound = ServerResponse.notFound().build();
        Mono personMono = this.repository.getPerson(personId);
        return personMono
                .then(person -> ServerResponse.ok().contentType(APPLICATION_JSON).body(fromObject(person)))
                .otherwiseIfEmpty(notFound);
    }
}

  2.2 RouterFunctions 路由函数

传入http请求转入到 RouterFunctions 这个路由函数中, 如果请求匹配相应的路由函数,这个路由函数接收一个ServerRequest对象,并且返回一个Mono ,如果匹配不到,则返回一个Mono

1.一般情况下我们不需要重写一个路由函数,而是使用RouterFunctions.route(RequestPredicate, HandlerFunction)这个方法来创建router函数,其中RequestPredicate 封装了匹配规则,HandlerFunction 则可以理解为 匹配成功之后的回调函数,匹配不到的话则返回404,一般情况下我们也不需要重写RequestPredicate,RequestPredicates,这个实现类(多了个s)中已经封装了常用的匹配规则,比如:基于路径匹配,基于HTTP请求方法类型匹配(GET.PUT.POST.DELETE..),基于内容类型匹配(Content-Type)
示例1.

RouterFunction helloWorldRoute =
    RouterFunctions.route(RequestPredicates.path("/hello-world"),//根据路径匹配
    request -> Response.ok().body(fromObject("Hello World")));//Handler Functions 处理函数

2.路由函数的组合 如果第一个RountHandler 匹配不成功,则进入的下一个RountHandler,匹配顺序按代码顺序执行
常用方法:

1. RouterFunction.and(RouterFunction)
2. RouterFunction.andRoute(RequestPredicate, HandlerFunction) 
等价于以下的组合
2.1 RouterFunction.and()
2.2 RouterFunctions.route()

3.同路由函数的组合一样 请求约束RequestPredicates也可以类似的组合

//and 条件
1. RequestPredicate.and(RequestPredicate)
//or 条件
2. RequestPredicate.or(RequestPredicate)
3. RequestPredicates.GET(String) 等价于以下组合
 3.1 RequestPredicates.method(HttpMethod)
 3.2 RequestPredicates.path(String)

综合示例

import static org.springframework.http.MediaType.APPLICATION_JSON;
import static org.springframework.web.reactive.function.server.RequestPredicates.*;

PersonRepository repository = ...
PersonHandler handler = new PersonHandler(repository);

RouterFunction personRoute =
    route(GET("/person/{id}").and(accept(APPLICATION_JSON)), handler::getPerson)
        .andRoute(GET("/person").and(accept(APPLICATION_JSON)), handler::listPeople)
        .andRoute(POST("/person").and(contentType(APPLICATION_JSON)), handler::createPerson);//函数引用

3.Running a Server

流程走到这就只差一步了 那就是在HTTP Server运行路由函数,你可以用RouterFunctions.toHttpHandler(RouterFunction) 这个函数将路由函数转换为一个HttpHandler,这个HttpHandler可以运行在很多种 具备响应式运行环境的容器,比如
Reactor Netty, RxNetty, Servlet 3.1+, Undertow
Reactor Netty 下示例:

//构建一个路由函数
RouterFunction route = ...
//转换为 HttpHandler
HttpHandler httpHandler = RouterFunctions.toHttpHandler(route);
//Reactor Netty 适配器
ReactorHttpHandlerAdapter adapter = new ReactorHttpHandlerAdapter(httpHandler);
//构建一个简单的Netty HTTP服务器，监听提供的地址和端口。
HttpServer server = HttpServer.create(HOST, PORT);
//
server.newHandler(adapter).block();

Tomcat 示例：啥玩意啊没看懂 也不准备用Tomcat了

RouterFunction route = ...
HttpHandler httpHandler = RouterFunctions.toHttpHandler(route);
HttpServlet servlet = new ServletHttpHandlerAdapter(httpHandler);
Tomcat server = new Tomcat();
Context rootContext = server.addContext("", System.getProperty("java.io.tmpdir"));
Tomcat.addServlet(rootContext, "servlet", servlet);
rootContext.addServletMapping("/", "servlet");
tomcatServer.start();

4.HandlerFilterFunction

顾名思义这个这函数类似于 Servlet 中的 Filter ,在路由函数进行路由之前执行,本质上也类似与一个handler function , 过滤器执行完可以指向 handlerFunction 或者 另一个 HandlerFilterFunction(形成过滤器链),示例如下

import static org.springframework.http.HttpStatus.UNAUTHORIZED;

SecurityManager securityManager = ...
RouterFunction route = ...

RouterFunction filteredRoute =
    route.filter(request, next) -> {
        if (securityManager.allowAccessTo(request.path())) {
            return next.handle(request);
        }
        else {
            return ServerResponse.status(UNAUTHORIZED).build();
        }
  });

5.Client Side

WebClient client = WebClient.create("http://example.com");
Mono account = client.get()
        .url("/accounts/{id}", 1L)
        .accept(APPLICATION_JSON)
        .exchange(request)
        .then(response -> response.bodyToMono(Account.class));

参考链接:
1.https://docs.spring.io/spring/docs/5.0.0.BUILD-SNAPSHOT/spring-framework-reference/html/web-reactive.html
2.https://coyee.com/article/12086-spring-5-reactive-web