2016-11-4 藍藍設計的小編
我們先從示例應用程序的一些摘錄開始。下面是暴露Person
對象的響應信息庫。很類似于傳統的,非響應信息庫,只不過它返回Flux<Person>而傳統的返回List<Person>,以及返回Mono<Person>
的地方返回Person。Mono<Void>用作完成標識:指出何時保存被完成。關于Reactor類型的更多信息,請參閱
public interface PersonRepository { Mono<Person> getPerson(int id); 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); return Response.ok().body(fromPublisher(person, Person.class));
})
.and(route(GET("/person"),
request -> {
Flux<Person> people = repository.allPeople(); return Response.ok().body(fromPublisher(people, Person.class));
}))
.and(route(POST("/person"),
request -> {
Mono<Person> person = request.body(toMono(Person.class)); return Response.ok().build(repository.savePerson(person));
}));
下面我們要介紹如何運行,比如在Reactor Netty中:
HttpHandler httpHandler = RouterFunctions.toHttpHandler(route);
ReactorHttpHandlerAdapter adapter = new ReactorHttpHandlerAdapter(httpHandler);
HttpServer server = HttpServer.create("localhost", 8080);
server.startAndAwait(adapter);
最后要做的一件事是試一試:
$ curl 'http://localhost:8080/person/1' {"name":"John Doe","age":42}
下面還有更多介紹,讓我們挖掘得更深!
我會通過徹底說明核心組件來介紹框架:HandlerFunction
,RouterFunction
,以及FilterFunction
。這三個接口以及文中描述的所有其他類型都可以在org.springframework.web.reactive.function包中找到。
HandlerFunction
這一新框架的起點是HandlerFunction<T>
,基本上是Function<Request, Response<T>>,其中Request
和Response是新定義的,一成不變的界面友好地來提供JDK-8 DSL到底層HTTP消息。對于構建Response
實體是一個方便的構建工具,非常類似于在ResponseEntity中看到的。對應到HandlerFunction
注解是一個帶有@RequestMapping的方法。
下面是一個簡單的“Hello World”處理函數的例子,返回有200狀態以及body為String的響應消息:
HandlerFunction<String> helloWorld =
request -> Response.ok().body(fromObject("Hello World"));
正如我們在上面的例子中看到的,處理函數是通過構建在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")) { return Optional.of(r -> Response.ok().body(fromObject("Hello World")));
} else { return Optional.empty();
}
};
一般不用寫完整的路由方法,而是靜態引入RouterFunctions.route(),這樣就可以用請求判斷式(RequestPredicate) (即 Predicate<Request>)和處理方法(HandlerFunction)創建路由方法了。如果判斷式判斷成功則返回處理方法,否則返回空結果。如下是用route方法方式重寫上面的例子:
RouterFunction<String> helloWorldRoute =
RouterFunctions.route(request -> request.path().equals("/hello-world"),
request -> Response.ok().body(fromObject("Hello World")));
你可以(靜態地)導入RequestPredicates.*以訪問常用的謂詞,基于路徑、HTTP方法、內容類型等等匹配。有了它,我們可以使helloWorldRoute更簡單:
RouterFunction<String> helloWorldRoute =
RouterFunctions.route(RequestPredicates.path("/hello-world"),
request -> Response.ok().body(fromObject("Hello World")));
組合函數
兩個路由函數可以組成一個新的路由函數,路由到任一個處理函數:如果第一個函數不匹配,那么就執行第二個。你可以通過調用RouterFunction.and(),像這樣組合兩個路由函數:
RouterFunction<?> route =
route(path("/hello-world"),
request -> Response.ok().body(fromObject("Hello World")))
.and(route(path("/the-answer"),
request -> Response.ok().body(fromObject("42"))));
如果路徑匹配/hello-world,以上將回應“Hello World”,如果匹配/the-answer,則同時返回“42”。如果兩者都不匹配,則返回一個空的Optional
。請注意,組合的路由函數會依次執行,因此在具體函數之前放入泛型函數是有意義的。
你也可以組合要求謂詞,通過調用and
或or。工作方式是這樣:對于and,如果兩個給定謂詞匹配的話,結果謂詞匹配,而如果兩者中的一個謂語匹配的話,那么就or匹配。例如:
RouterFunction<?> route =
route(method(HttpMethod.GET).and(path("/hello-world")),
request -> Response.ok().body(fromObject("Hello World")))
.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("Hello World")))
.and(route(GET("/the-answer"),
request -> Response.ok().body(fromObject(42))));
方法引用
順便說一句:到目前為止,我們已經編寫了所有的處理函數作為內聯的lambda表達式。雖然這在演示和短的例子中表現良好,但是不得不說這有一種會導致“混亂”的傾向,因為你要混合兩種擔憂:請求路由和請求處理。因此,我們要看看是否能夠讓事情變得更簡潔。首先,我們創建一個包含處理代碼的類:
class DemoHandler { public Response<String> helloWorld(Request request) { return Response.ok().body(fromObject("Hello World"));
} public Response<String> theAnswer(Request request) { return Response.ok().body(fromObject("42"));
}
}
注意,兩個方法都有一個兼容了處理函數的標志。這允許我們使用方法引用:
DemoHandler handler = new DemoHandler(); // or obtain via DI 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。讓我們向路由添加一個日志過濾器:
RouterFunction<?> route =
route(GET("/hello-world"), handler::helloWorld)
.and(route(GET("/the-answer"), handler::theAnswer))
.filter((request, next) -> {
System.out.println("Before handler invocation: " + request.path());
Response<?> response = next.handle(request);
Object body = response.body();
System.out.println("After handler invocation: " + body); return response;
});
需要注意的是,要不要調用下一個處理程序是可選的。這在安全和緩存方案中非常有用(如只在用戶有足夠權限的時候調用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);
String newBody = response.body().toUpperCase(); return Response.from(response).body(fromObject(newBody));
});
使用注解,相似的功能可以用@ControllerAdvice和/或ServletFilter來實現。
所有這一切都很好,但有一件事忘了:我們如何才能在實際的HTTP服務器中運行這些函數呢?答案勿庸置疑是通過調用另一個函數。你可以通過使用RouterFunctions.toHttpHandler()將路由函數轉換成HttpHandler。HttpHandler
是引進到Spring 5.0 M1的一個響應抽象:它允許你運行在各種響應運行時上:Reactor Netty、RxNetty、Servlet 3.1+,和Undertow。在這個例子中,我們已經表明了在Reactor Netty中運行route
是怎么樣的。對于Tomcat,它看起來像這樣:
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();
有一點要注意的是,上面的代碼不依賴于Spring應用程序上下文。就像JdbcTemplate
和其他Spring實用工具類,使用應用程序上下文是可選的:你可以在上下文中接通處理程序和路由函數,但它不是必需的。
還要注意的是,你也可以轉換路由函數為HandlerMapping,以便它可以在DispatcherHandler
中運行(可能需要有響應的@Controllers)。
讓我通過簡短的總結來得出結論:
藍藍設計( 91whvog3.cn )是一家專注而深入的界面設計公司,為期望卓越的國內外企業提供卓越的UI界面設計、BS界面設計 、 cs界面設計 、 ipad界面設計 、 包裝設計 、 圖標定制 、 用戶體驗 、交互設計、 網站建設 、平面設計服務