@Override public RouterFunctions.Builder POST(String pattern, HandlerFunction<ServerResponse> handlerFunction) { return add(RequestPredicates.POST(pattern), handlerFunction); }
@Override public RouterFunctions.Builder POST(String pattern, RequestPredicate predicate, HandlerFunction<ServerResponse> handlerFunction) { return add(RequestPredicates.POST(pattern).and(predicate), handlerFunction); }
@Override protected RouterFunction<?> routerFunction() { PersonHandler personHandler = new PersonHandler(); return route(GET("/mono"), personHandler::mono) .and(route(POST("/mono"), personHandler::postMono)) .and(route(GET("/flux"), personHandler::flux)); }
@Bean public RouterFunction<ServerResponse> route(TestHandler testHandler) { return RouterFunctions .route(RequestPredicates.GET("/route") .and(RequestPredicates.accept(MediaType.TEXT_PLAIN)), testHandler::route) .andRoute(RequestPredicates.POST("/route2") .and(RequestPredicates.contentType(MediaType.APPLICATION_JSON)), testHandler::route2) .andRoute(RequestPredicates.HEAD("/route3"), request -> ServerResponse.ok().build()); }
@Test public void allMethods() { URI uri = URI.create("http://localhost/path"); RequestPredicate predicate = RequestPredicates.GET("/p*"); MockServerRequest request = MockServerRequest.builder().method(HttpMethod.GET).uri(uri).build(); assertTrue(predicate.test(request)); predicate = RequestPredicates.HEAD("/p*"); request = MockServerRequest.builder().method(HttpMethod.HEAD).uri(uri).build(); assertTrue(predicate.test(request)); predicate = RequestPredicates.POST("/p*"); request = MockServerRequest.builder().method(HttpMethod.POST).uri(uri).build(); assertTrue(predicate.test(request)); predicate = RequestPredicates.PUT("/p*"); request = MockServerRequest.builder().method(HttpMethod.PUT).uri(uri).build(); assertTrue(predicate.test(request)); predicate = RequestPredicates.PATCH("/p*"); request = MockServerRequest.builder().method(HttpMethod.PATCH).uri(uri).build(); assertTrue(predicate.test(request)); predicate = RequestPredicates.DELETE("/p*"); request = MockServerRequest.builder().method(HttpMethod.DELETE).uri(uri).build(); assertTrue(predicate.test(request)); predicate = RequestPredicates.OPTIONS("/p*"); request = MockServerRequest.builder().method(HttpMethod.OPTIONS).uri(uri).build(); assertTrue(predicate.test(request)); }
public RouterFunction<ServerResponse> routes() { return nest(path("/test"), route(POST("/helloWorld2").and(accept(APPLICATION_JSON)), this::postHandler) .and(route(POST("/helloWorld"), this::getHandler) .and(route(GET("/rewrite"), this::rewriteHandler)) .and(route(GET("/pdm"), this::pdmHttpGet)) .and(route(GET("/oms"), this::omsHttpGet)) .and(route(GET("/timeout"), this::testRetry)))); }
@Test public void postRequestWithQueryStringParameters() throws Exception { ExchangeResult result = WebTestClient .bindToRouterFunction(RouterFunctions.route(POST("/foo"), (req) -> { req.body(BodyExtractors.toFormData()).block(); return null; })).configureClient().baseUrl("http://localhost").build().post() .uri(URI.create("http://localhost/foo?a=alpha&a=apple&b=br%26vo")) .exchange().expectBody().returnResult(); OperationRequest request = this.converter.convert(result); assertThat(request.getUri()) .isEqualTo(URI.create("http://localhost/foo?a=alpha&a=apple&b=br%26vo")); assertThat(request.getMethod()).isEqualTo(HttpMethod.POST); assertThat(request.getParameters()).hasSize(2); assertThat(request.getParameters()).containsEntry("a", Arrays.asList("alpha", "apple")); assertThat(request.getParameters()).containsEntry("b", Arrays.asList("br&vo")); }
@Test public void multipartUpload() throws Exception { MultiValueMap<String, Object> multipartData = new LinkedMultiValueMap<>(); multipartData.add("file", new byte[] { 1, 2, 3, 4 }); ExchangeResult result = WebTestClient .bindToRouterFunction(RouterFunctions.route(POST("/foo"), (req) -> { req.body(BodyExtractors.toMultipartData()).block(); return null; })).configureClient().baseUrl("http://localhost").build().post() .uri("/foo").body(BodyInserters.fromMultipartData(multipartData)) .exchange().expectBody().returnResult(); OperationRequest request = this.converter.convert(result); assertThat(request.getUri()).isEqualTo(URI.create("http://localhost/foo")); assertThat(request.getMethod()).isEqualTo(HttpMethod.POST); assertThat(request.getParts()).hasSize(1); OperationRequestPart part = request.getParts().iterator().next(); assertThat(part.getName()).isEqualTo("file"); assertThat(part.getSubmittedFileName()).isNull(); assertThat(part.getHeaders()).hasSize(2); assertThat(part.getHeaders().getContentLength()).isEqualTo(4L); assertThat(part.getHeaders().getContentDisposition().getName()).isEqualTo("file"); assertThat(part.getContent()).containsExactly(1, 2, 3, 4); }
.bindToRouterFunction(RouterFunctions.route(POST("/foo"), (req) -> { req.body(BodyExtractors.toMultipartData()).block(); return null;
@Test public void postRequestWithQueryStringAndFormDataParameters() throws Exception { MultiValueMap<String, String> parameters = new LinkedMultiValueMap<>(); parameters.addAll("a", Arrays.asList("apple")); ExchangeResult result = WebTestClient .bindToRouterFunction(RouterFunctions.route(POST("/foo"), (req) -> { req.body(BodyExtractors.toFormData()).block(); return null; })).configureClient().baseUrl("http://localhost").build().post() .uri(URI.create("http://localhost/foo?a=alpha&b=br%26vo")) .body(BodyInserters.fromFormData(parameters)).exchange().expectBody() .returnResult(); OperationRequest request = this.converter.convert(result); assertThat(request.getUri()) .isEqualTo(URI.create("http://localhost/foo?a=alpha&b=br%26vo")); assertThat(request.getMethod()).isEqualTo(HttpMethod.POST); assertThat(request.getParameters()).hasSize(2); assertThat(request.getParameters()).containsEntry("a", Arrays.asList("alpha", "apple")); assertThat(request.getParameters()).containsEntry("b", Arrays.asList("br&vo")); }
@Test public void postRequestWithFormDataParameters() throws Exception { MultiValueMap<String, String> parameters = new LinkedMultiValueMap<>(); parameters.addAll("a", Arrays.asList("alpha", "apple")); parameters.addAll("b", Arrays.asList("br&vo")); ExchangeResult result = WebTestClient .bindToRouterFunction(RouterFunctions.route(POST("/foo"), (req) -> { req.body(BodyExtractors.toFormData()).block(); return null; })).configureClient().baseUrl("http://localhost").build().post() .uri("/foo").body(BodyInserters.fromFormData(parameters)).exchange() .expectBody().returnResult(); OperationRequest request = this.converter.convert(result); assertThat(request.getUri()).isEqualTo(URI.create("http://localhost/foo")); assertThat(request.getMethod()).isEqualTo(HttpMethod.POST); assertThat(request.getParameters()).hasSize(2); assertThat(request.getParameters()).containsEntry("a", Arrays.asList("alpha", "apple")); assertThat(request.getParameters()).containsEntry("b", Arrays.asList("br&vo")); }
@Test public void postRequestWithNoContentType() throws Exception { ExchangeResult result = WebTestClient .bindToRouterFunction(RouterFunctions.route(POST("/foo"), (req) -> ServerResponse.ok().build())) .configureClient().baseUrl("http://localhost").build().post().uri("/foo") .exchange().expectBody().returnResult(); OperationRequest request = this.converter.convert(result); assertThat(request.getUri()).isEqualTo(URI.create("http://localhost/foo")); assertThat(request.getMethod()).isEqualTo(HttpMethod.POST); }
@Before public void setUp() { RouterFunction<ServerResponse> route = RouterFunctions .route(RequestPredicates.GET("/"), (request) -> ServerResponse.status(HttpStatus.OK) .body(fromObject(new Person("Jane", "Doe")))) .andRoute(RequestPredicates.GET("/{foo}/{bar}"), (request) -> ServerResponse.status(HttpStatus.OK) .body(fromObject(new Person("Jane", "Doe")))) .andRoute(RequestPredicates.POST("/upload"), (request) -> request.body(BodyExtractors.toMultipartData()) .map((parts) -> ServerResponse.status(HttpStatus.OK) .build().block())) .andRoute(RequestPredicates.GET("/set-cookie"), (request) -> ServerResponse.ok() .cookie(ResponseCookie.from("name", "value") .domain("localhost").httpOnly(true).build()) .build()); this.webTestClient = WebTestClient.bindToRouterFunction(route).configureClient() .baseUrl("https://api.example.com") .filter(documentationConfiguration(this.restDocumentation)).build(); }
@SuppressWarnings({ "unchecked" }) public <T> RouterFunction<?> functionEndpoints() { return route(POST("/"), request -> { Class<T> outputType = (Class<T>) this.inspector.getOutputType(this.function); FunctionWrapper wrapper = RequestProcessor.wrapper(function, null, null); Mono<ResponseEntity<?>> stream = request.bodyToMono(String.class) .flatMap(content -> processor.post(wrapper, content, false)); return stream.flatMap(entity -> status(entity.getStatusCode()) .headers(headers -> headers.addAll(entity.getHeaders())) .body(Mono.just((T) entity.getBody()), outputType)); }); }
@SuppressWarnings({ "unchecked" }) public <T> RouterFunction<?> functionEndpoints() { return route(POST("/"), request -> { Class<T> outputType = (Class<T>) this.inspector.getOutputType(this.function); FunctionWrapper wrapper = RequestProcessor.wrapper(function, null, null); Mono<ResponseEntity<?>> stream = request.bodyToMono(String.class) .flatMap(content -> processor.post(wrapper, content, false)); return stream.flatMap(entity -> status(entity.getStatusCode()) .headers(headers -> headers.addAll(entity.getHeaders())) .body(Mono.just((T) entity.getBody()), outputType)); }); }
@Bean public RouterFunction<ServerResponse> routes(PostHandler postHandler) { return route(GET("/posts"), postHandler::all) .andRoute(POST("/posts").and(contentType(APPLICATION_JSON)), postHandler::create) .andRoute(GET("/posts/{id}"), postHandler::get); } }
@Bean public RouterFunction<ServerResponse> routes(PostHandler postController) { return route(GET("/posts"), postController::all) .andRoute(POST("/posts"), postController::create) .andRoute(GET("/posts/{id}"), postController::get) .andRoute(PUT("/posts/{id}"), postController::update) .andRoute(DELETE("/posts/{id}"), postController::delete); }
@Bean public RouterFunction<ServerResponse> routes(PostHandler postController) { return route(GET("/posts"), postController::all) .andRoute(POST("/posts"), postController::create) .andRoute(GET("/posts/{id}"), postController::get) .andRoute(PUT("/posts/{id}"), postController::update) .andRoute(DELETE("/posts/{id}"), postController::delete); }
public RouterFunction<ServerResponse> routingFunction() { PersonRepository repository = new DummyPersonRepository(); PersonHandler handler = new PersonHandler(repository); return nest(path("/person"), nest(accept(APPLICATION_JSON), route(GET("/{id}"), handler::getPerson) .andRoute(method(HttpMethod.GET), handler::listPeople) ).andRoute(POST("/").and(contentType(APPLICATION_JSON)), handler::createPerson)); }