Spring5의 새로운 기능 - 기능적 웹 프레임워크의 세부 코드 예제-java지도 시간-php.cn

어제 Juergen의 블로그에서 언급했듯이 Spring 5.0의 두 번째 이정표는 새로운 기능적 웹 프레임워크의 도입입니다. 이번 글에서는 이 프레임워크에 대해 더 많은 정보를 제공하겠습니다.

예

샘플 애플리케이션에서 발췌한 내용부터 시작해 보겠습니다. 아래는 Person 객체 를 노출하는 응답 저장소입니다. Flux을 반환하는 반면 기존의 정보 기반은 List을 반환하고 Mono<Person>는 반환된 사람. Mono는 완료 플래그로 사용됩니다: 저장이 완료되는 시기를 나타냅니다. Reactor 유형에 대한 자세한 내용은 이 블로그 게시물을 참조하세요.

public interface PersonRepository {
    Mono<Person> getPerson(int id);
    Flux<Person> allPeople();
    Mono<Void> savePerson(Mono<Person> person);
}

로그인 후 복사

새 기능적 웹 프레임워크로 저장소를 노출하는 방법은 다음과 같습니다.

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 &#39;http://localhost:8080/person/1&#39;
{"name":"John Doe","age":42}

로그인 후 복사

아래에 더 많은 내용이 있으니 더 자세히 살펴보겠습니다!

핵심 컴포넌트

핵심 컴포넌트인 HandlerFunction，RouterFunction, FilterFunction에 대해 자세히 설명하여 프레임워크를 소개하겠습니다. 이 세 가지 인터페이스와 기사에 설명된 다른 모든 유형은 org.springframework.web.reactive.function 패키지에서 찾을 수 있습니다.

HandlerFunction

이 새로운 프레임워크의 시작점은 HandlerFunction<T>이며, 이는 기본적으로 Function>입니다. 여기서 Request 및 응답 기본 HTTP 메시지에 JDK-8 DSL을 제공하는 새로 정의된 사용자 친화적인 인터페이스입니다. Response 엔터티를 빌드하는 데는 ResponseEntity에서 볼 수 있는 것과 매우 유사한 편리한 빌드 도구가 있습니다. HandlerFunction 주석에 해당하는 것은 @RequestMapping을 사용하는 메서드입니다.

다음은 상태가 200이고 본문이 String인 응답 메시지를 반환하는 간단한 "Hello World" 처리 함수의 예입니다.

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

로그인 후 복사

위의 예에서 보았듯이 핸들러 함수는 Reactor 위에 구축되어 완전히 반응적입니다. 즉, Flux, Mono 또는 기타 해당 스트림Publisher을 응답 유형으로 받아들입니다.

한 가지 주의할 점은 HandlerFunction 자체는 응답을 매개변수로 처리하는 대신 응답을 반환하므로 부작용이 없다는 점입니다(본질적으로 BiConsumer< ServletRequest인 Servlet.service(ServletRequest,ServletResponse) 참조). 서블릿응답>). 부작용이 없으며 많은 이점이 있습니다. 테스트, 작성 및 최적화가 쉽습니다.

RouterFunction

들어오는 요청은 을 사용하여 핸들러 함수로 라우팅RouterFunction<T>됩니다(예: Function

다음은 핸들러 기능이 내장된 라우팅 기능의 예입니다. 조금 길어 보일 수도 있지만 걱정하지 마세요. 더 짧게 만드는 방법을 찾아보겠습니다.

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)이 라우팅 방법을 생성합니다. 판정이 성공하면 처리 방법이 반환되고, 그렇지 않으면 빈 결과가 반환됩니다. 다음은 경로 메소드를 사용하여 재작성된 위의 예입니다.

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)进行过滤，其中FilterFunction本质上是BiFunction>。函数的处理器（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响应主体。我们可以通过使用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）。