java Spring 5 新特性函数式Web框架详细介绍
javaSpring5新特性函数式Web框架
举例
我们先从示例应用程序的一些摘录开始。下面是暴露Person对象的响应信息库。很类似于传统的，非响应信息库，只不过它返回Flux<Person>而传统的返回List<Person>，以及返回Mono<Person>的地方返回Person。Mono<Void>用作完成标识：指出何时保存被完成。
publicinterfacePersonRepository{
Mono<Person>getPerson(intid);
Flux<Person>allPeople();
Mono<Void>savePerson(Mono<Person>person);
}
下面是我们如何暴露带有新的函数式web框架的资源库：
RouterFunction<?>route=route(GET("/person/{id}"),
request->{
Mono<Person>person=Mono.justOrEmpty(request.pathVariable("id"))
.map(Integer::valueOf)
.then(repository::getPerson);
returnResponse.ok().body(fromPublisher(person,Person.class));
})
.and(route(GET("/person"),
request->{
Flux<Person>people=repository.allPeople();
returnResponse.ok().body(fromPublisher(people,Person.class));
}))
.and(route(POST("/person"),
request->{
Mono<Person>person=request.body(toMono(Person.class));
returnResponse.ok().build(repository.savePerson(person));
}));
下面我们要介绍如何运行，比如在ReactorNetty中：
HttpHandlerhttpHandler=RouterFunctions.toHttpHandler(route);
ReactorHttpHandlerAdapteradapter=
newReactorHttpHandlerAdapter(httpHandler);
HttpServerserver=HttpServer.create("localhost",8080);
server.startAndAwait(adapter);
最后要做的一件事是试一试：
$curl'http://localhost:8080/person/1'
{"name":"JohnDoe","age":42}
下面还有更多介绍，让我们挖掘得更深！
核心组件
我会通过彻底说明核心组件来介绍框架：HandlerFunction，RouterFunction，以及FilterFunction。这三个接口以及文中描述的所有其他类型都可以在org.springframework.web.reactive.function包中找到。
HandlerFunction
这一新框架的起点是HandlerFunction<T>，基本上是Function<Request,Response<T>>，其中Request和Response是新定义的，一成不变的界面友好地来提供JDK-8DSL到底层HTTP消息。对于构建Response实体是一个方便的构建工具，非常类似于在ResponseEntity中看到的。对应到HandlerFunction注解是一个带有@RequestMapping的方法。
下面是一个简单的“HelloWorld”处理函数的例子，返回有200状态以及body为String的响应消息：
HandlerFunction<String>helloWorld=
request->Response.ok().body(fromObject("HelloWorld"));
正如我们在上面的例子中看到的，处理函数是通过构建在Reactor的基础上而完全响应：它们接受Flux，Mono，或任何其他相应的流Publisher作为响应类型。
要注意的一点，HandlerFunction本身是没有副作用的，因为它返回响应，而不是把它当作一个参数（参见Servlet.service(ServletRequest,ServletResponse)，这实质上是BiConsumer<ServletRequest,ServletResponse>）。没有副作用有很多好处：易于测试，编写和优化。
RouterFunction
传入的请求被路由到有RouterFunction<T>的处理函数（即Function<Request,Optional<HandlerFunction<T>>）路由到处理函数，如果它匹配的话；否则就返回一个空的结果。路由方法与@RequestMapping注解的作用相似。但是，还有一个显著的区别：用注解时路由会被限制到注解的value所能表达的范围，处理这些方法的覆盖是困难的；当用路由方法的时候，代码就在那里，可以轻松的覆盖或替换。
下面是一个有内嵌处理函数的路由函数的例子。它看起来有点冗长，但不要担心：我们会找到办法让它变短。
RouterFunction<String>helloWorldRoute=
request->{
if(request.path().equals("/hello-world")){
returnOptional.of(r->Response.ok().body(fromObject("HelloWorld")));
}else{
returnOptional.empty();
}
};
一般不用写完整的路由方法，而是静态引入RouterFunctions.route()，这样就可以用请求判断式（RequestPredicate）(即Predicate<Request>)和处理方法（HandlerFunction）创建路由方法了。如果判断式判断成功则返回处理方法，否则返回空结果。如下是用route方法方式重写上面的例子：
RouterFunction<String>helloWorldRoute=
RouterFunctions.route(request->request.path().equals("/hello-world"),
request->Response.ok().body(fromObject("HelloWorld")));
你可以（静态地）导入RequestPredicates.*以访问常用的谓词，基于路径、HTTP方法、内容类型等等匹配。有了它，我们可以使helloWorldRoute更简单：
RouterFunction<String>helloWorldRoute=
RouterFunctions.route(RequestPredicates.path("/hello-world"),
request->Response.ok().body(fromObject("HelloWorld")));
组合函数
两个路由函数可以组成一个新的路由函数，路由到任一个处理函数：如果第一个函数不匹配，那么就执行第二个。你可以通过调用RouterFunction.and()，像这样组合两个路由函数：
RouterFunction<?>route=
route(path("/hello-world"),
request->Response.ok().body(fromObject("HelloWorld")))
.and(route(path("/the-answer"),
request->Response.ok().body(fromObject("42"))));
如果路径匹配/hello-world，以上将回应“HelloWorld”，如果匹配/the-answer，则同时返回“42”。如果两者都不匹配，则返回一个空的Optional。请注意，组合的路由函数会依次执行，因此在具体函数之前放入泛型函数是有意义的。
你也可以组合要求谓词，通过调用and或or。工作方式是这样：对于and，如果两个给定谓词匹配的话，结果谓词匹配，而如果两者中的一个谓语匹配的话，那么就or匹配。例如：
RouterFunction<?>route=
route(method(HttpMethod.GET).and(path("/hello-world")),
request->Response.ok().body(fromObject("HelloWorld")))
.and(route(method(HttpMethod.GET).and(path("/the-answer")),
request->Response.ok().body(fromObject("42"))));
事实上，在RequestPredicates发现的大多数谓词是组合的！例如，RequestPredicates.GET(String)是RequestPredicates.method(HttpMethod)和RequestPredicates.path(String)的组合物。因此，我们可以将上面的代码重写为：
RouterFunction<?>route=
route(GET("/hello-world"),
request->Response.ok().body(fromObject("HelloWorld")))
.and(route(GET("/the-answer"),
request->Response.ok().body(fromObject(42))));
方法引用
顺便说一句：到目前为止，我们已经编写了所有的处理函数作为内联的lambda表达式。虽然这在演示和短的例子中表现良好，但是不得不说这有一种会导致“混乱”的倾向，因为你要混合两种担忧：请求路由和请求处理。因此，我们要看看是否能够让事情变得更简洁。首先，我们创建一个包含处理代码的类：
classDemoHandler{
publicResponse<String>helloWorld(Requestrequest){
returnResponse.ok().body(fromObject("HelloWorld"));
}
/*http://www.manongjc.com/article/1590.html*/
publicResponse<String>theAnswer(Requestrequest){
returnResponse.ok().body(fromObject("42"));
}
}
注意，两个方法都有一个兼容了处理函数的标志。这允许我们使用方法引用：
DemoHandlerhandler=newDemoHandler();//orobtainviaDI
RouterFunction<?>route=
route(GET("/hello-world"),handler::helloWorld)
.and(route(GET("/the-answer"),handler::theAnswer));
FilterFunction
由路由函数映射的路径可以通过调用RouterFunction.filter(FilterFunction<T,R>)进行过滤，其中FilterFunction<T,R>本质上是BiFunction<Request,HandlerFunction<T>,Response<R>>。函数的处理器（handler）参数代表的就是整个链条中的下一项:这是一个典型的HandlerFunction,但如果附加了多个过滤器的话，它也能够是另外的一个FilterFunction。让我们向路由添加一个日志过滤器：
//http://www.manongjc.com
RouterFunction<?>route=
route(GET("/hello-world"),handler::helloWorld)
.and(route(GET("/the-answer"),handler::theAnswer))
.filter((request,next)->{
System.out.println("Beforehandlerinvocation:"+request.path());
Response<?>response=next.handle(request);
Objectbody=response.body();
System.out.println("Afterhandlerinvocation:"+body);
returnresponse;
});
需要注意的是，要不要调用下一个处理程序是可选的。这在安全和缓存方案中非常有用（如只在用户有足够权限的时候调用next）。
由于route是一个无限路由函数，因此我们知道接下来的处理程序会返回什么类型的响应信息。这就是为什么我们最终在我们的过滤器中用Response<?>结束以及用Object响应body的原因。在处理程序类中，两种方法都返回Response<String>，所以应该有可能有String响应主体。我们可以通过使用RouterFunction.andSame()来代替and()做到这一点。这种组合方法需要参数路由函数是相同的类型。例如，我们可以让所有的响应变成大写：
RouterFunction<String>route=
route(GET("/hello-world"),handler::helloWorld)
.andSame(route(GET("/the-answer"),handler::theAnswer))
.filter((request,next)->{
Response<String>response=next.handle(request);
StringnewBody=response.body().toUpperCase();
returnResponse.from(response).body(fromObject(newBody));
});
使用注解，相似的功能可以用@ControllerAdvice和/或ServletFilter来实现。
运行服务端
所有这一切都很好，但有一件事忘了：我们如何才能在实际的HTTP服务器中运行这些函数呢？答案勿庸置疑是通过调用另一个函数。你可以通过使用RouterFunctions.toHttpHandler()将路由函数转换成HttpHandler。HttpHandler是引进到Spring5.0M1的一个响应抽象：它允许你运行在各种响应运行时上：ReactorNetty、RxNetty、Servlet3.1+，和Undertow。在这个例子中，我们已经表明了在ReactorNetty中运行route是怎么样的。对于Tomcat，它看起来像这样：
HttpHandlerhttpHandler=RouterFunctions.toHttpHandler(route);
HttpServletservlet=newServletHttpHandlerAdapter(httpHandler);
Tomcatserver=newTomcat();
ContextrootContext=server.addContext("",
System.getProperty("java.io.tmpdir"));
Tomcat.addServlet(rootContext,"servlet",servlet);
rootContext.addServletMapping("/","servlet");
tomcatServer.start();
有一点要注意的是，上面的代码不依赖于Spring应用程序上下文。就像JdbcTemplate和其他Spring实用工具类，使用应用程序上下文是可选的：你可以在上下文中接通处理程序和路由函数，但它不是必需的。
还要注意的是，你也可以转换路由函数为HandlerMapping，以便它可以在DispatcherHandler中运行（可能需要有响应的@Controllers）。
结论
让我通过简短的总结来得出结论：
- 处理函数通过返回响应处理请求。
- 路由函数路由到处理函数，并且可以与其他路由函数组合。
- 路由函数可以通过过滤器进行过滤。
- 路由函数可以在响应的web运行时中运行。
为了让大家能更全面的了解，我已经创建了一个使用泛函web框架的简单示例项目。下载地址
感谢阅读，希望能帮助到大家，谢谢大家对本站的支持！