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。
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<Void> create(@RequestBody Publisher<Person> personStream) {
return this.repository.save(personStream).then();
}
//得到一个集合
@GetMapping("/person")
Flux<Person> list() {
return this.repository.findAll();
}
//RestFul 风格传参
@GetMapping("/person/{id}")
Mono<Person> findById(@PathVariable String id) {
return this.repository.findOne(id);
}
}
2.函数式编程风格(HandlerFunctions RouterFunctions)
2.1 HandlerFunctions http请求处理函数,本质上是一个 传入参数类型为ServerRequest 返回类型为Mono<ServerResponse>函数,在Spring MVC 中与之相对应的就是被@RequestMapping 注解所修饰的方法.ServerRequest并且ServerResponse接口可以提供JDK-8(Lambda)对底层HTTP消息的友好访问。对程序来说 响应流 暴露在Flux或Mono; 请求流以 Publisher作为主体。
下面是对Request 和 Response操作
1.取出Request body 到 Mono<String>
Mono <String> string = request.bodyToMono（String.class）;
2.取出Request body 到 Flux 如果body内容是json 或者是 xml 可以将其反序列化为相应的实体类 这里的person 假设为一个实体类
Flux <Person> people = request.bodyToFlux（Person.class）
3.bodyToMono和bodyToFlux 是 ServerRequest.body(BodyExtractor)的简写 上面两段代码相当于
Mono <String> string = request.body（BodyExtractors.toMono（String.class）;
Flux <Person> people = request.body（BodyExtractors.toFlux（Person.class）;
4.同样 相应ServletResponse操作类似 该对象可以 通过其内部方法build.
Mono<Person> person = ...
ServerResponse.ok().contentType(MediaType.APPLICATION_JSON).body(person);
5.构建一个响应码为201的 ServerResponse(自己百度201啥意思)
URI location = "http:*****";
ServerResponse.created（location）.build（）;
- Hello World functionHandler (接收一个ServerRequest 返回一个ServerResponse )
HandlerFunction<ServerResponse> 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<ServerResponse> listPeople(ServerRequest request) {
Flux<Person> people = repository.allPeople();
return ServerResponse.ok().contentType(APPLICATION_JSON).body(people, Person.class);
}
//从请求体取出字符串(XML or Json 格式)反序列化为 实体对象
public Mono<ServerResponse> createPerson(ServerRequest request) {
Mono<Person> person = request.bodyToMono(Person.class);
return ServerResponse.ok().build(repository.savePerson(person));
}
//请求参数在路径中 rest风格
public Mono<ServerResponse> getPerson(ServerRequest request) {
//pathVariable
int personId = Integer.valueOf(request.pathVariable("id"));
// 404
Mono<ServerResponse> notFound = ServerResponse.notFound().build();
Mono<Person> 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<HandlerFunction> ,如果匹配不到,则返回一个Mono<Void>
1.一般情况下我们不需要重写一个路由函数,而是使用RouterFunctions.route(RequestPredicate, HandlerFunction)这个方法来创建router函数,其中RequestPredicate 封装了匹配规则,HandlerFunction 则可以理解为 匹配成功之后的回调函数,匹配不到的话则返回404,一般情况下我们也不需要重写RequestPredicate,RequestPredicates,这个实现类(多了个s)中已经封装了常用的匹配规则,比如:基于路径匹配,基于HTTP请求方法类型匹配(GET.PUT.POST.DELETE..),基于内容类型匹配(Content-Type)
示例1.
RouterFunction<ServerResponse> 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<ServerResponse> 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<ServerResponse> 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<ServerResponse> 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<ServerResponse> route = ...
RouterFunction<ServerResponse> 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> 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
