Merge pull request #10452 from rozagerardo/rozagerardo/JAVA-4311_improve-spring-5-weblcient-article

[JAVA-4311] Improve "Spring Webclient" article

spring-5-reactive/pom.xml

@@ -1,6 +1,7 @@
 <?xml version="1.0" encoding="UTF-8"?>
-<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+<project xmlns="http://maven.apache.org/POM/4.0.0"
-         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
+    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+    xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
     <modelVersion>4.0.0</modelVersion>
     <artifactId>spring-5-reactive</artifactId>
     <version>0.0.1-SNAPSHOT</version>
@@ -73,6 +74,12 @@
             <artifactId>spring-security-test</artifactId>
             <scope>test</scope>
         </dependency>
+        <dependency>
+            <groupId>io.projectreactor</groupId>
+            <artifactId>reactor-test</artifactId>
+            <scope>test</scope>
+        </dependency>
+
 
         <!-- Spring WebFlux WebSession -->
         <dependency>

spring-5-reactive/src/main/java/com/baeldung/web/reactive/client/Foo.java

@@ -0,0 +1,24 @@
+package com.baeldung.web.reactive.client;
+
+public class Foo {
+
+    private String name;
+
+    public Foo() {
+        super();
+    }
+
+    public Foo(String name) {
+        super();
+        this.name = name;
+    }
+
+    public String getName() {
+        return name;
+    }
+
+    public void setName(String name) {
+        this.name = name;
+    }
+
+}

spring-5-reactive/src/main/java/com/baeldung/web/reactive/client/WebClientApplication.java

@@ -2,9 +2,10 @@ package com.baeldung.web.reactive.client;
 
 import org.springframework.boot.SpringApplication;
 import org.springframework.boot.autoconfigure.SpringBootApplication;
+import org.springframework.boot.autoconfigure.security.reactive.ReactiveSecurityAutoConfiguration;
 
-@SpringBootApplication
+@SpringBootApplication(exclude = { ReactiveSecurityAutoConfiguration.class })
-public class WebClientApplication{
+public class WebClientApplication {
 
     public static void main(String[] args) {
         SpringApplication.run(WebClientApplication.class, args);

spring-5-reactive/src/main/java/com/baeldung/web/reactive/client/WebClientController.java

@@ -1,36 +1,18 @@
 package com.baeldung.web.reactive.client;
 
-import java.net.URI;
-import java.nio.charset.Charset;
-import java.time.ZonedDateTime;
-import java.util.Collections;
 import java.util.HashMap;
 import java.util.Map;
-import java.util.concurrent.TimeUnit;
 
-import org.reactivestreams.Publisher;
-import org.reactivestreams.Subscriber;
-import org.springframework.http.HttpHeaders;
-import org.springframework.http.HttpMethod;
 import org.springframework.http.HttpStatus;
 import org.springframework.http.MediaType;
-import org.springframework.http.ReactiveHttpOutputMessage;
-import org.springframework.http.client.reactive.ClientHttpRequest;
-import org.springframework.http.client.reactive.ReactorClientHttpConnector;
-import org.springframework.util.LinkedMultiValueMap;
-import org.springframework.util.MultiValueMap;
 import org.springframework.web.bind.annotation.GetMapping;
+import org.springframework.web.bind.annotation.PostMapping;
+import org.springframework.web.bind.annotation.RequestBody;
+import org.springframework.web.bind.annotation.RequestPart;
 import org.springframework.web.bind.annotation.ResponseStatus;
 import org.springframework.web.bind.annotation.RestController;
-import org.springframework.web.reactive.function.BodyInserter;
-import org.springframework.web.reactive.function.BodyInserters;
-import org.springframework.web.reactive.function.client.WebClient;
 
-import io.netty.channel.ChannelOption;
-import io.netty.handler.timeout.ReadTimeoutHandler;
-import io.netty.handler.timeout.WriteTimeoutHandler;
 import reactor.core.publisher.Mono;
-import reactor.netty.http.client.HttpClient;
 
 @RestController
 public class WebClientController {
@@ -43,74 +25,18 @@ public class WebClientController {
         return response;
     }
 
-    public void demonstrateWebClient() {
+    @PostMapping("/resource")
-        // request
+    public Mono<String> postStringResource(@RequestBody Mono<String> bodyString) {
-        WebClient.UriSpec<WebClient.RequestBodySpec> request1 = createWebClientWithServerURLAndDefaultValues().method(HttpMethod.POST);
+        return bodyString.map(body -> "processed-" + body);
-        WebClient.UriSpec<WebClient.RequestBodySpec> request2 = createWebClientWithServerURLAndDefaultValues().post();
-
-        // request body specifications
-        WebClient.RequestBodySpec uri1 = createWebClientWithServerURLAndDefaultValues().method(HttpMethod.POST)
-            .uri("/resource");
-        WebClient.RequestBodySpec uri2 = createWebClientWithServerURLAndDefaultValues().post()
-            .uri(URI.create("/resource"));
-
-        // request header specification
-        WebClient.RequestHeadersSpec<?> requestSpec1 = uri1.body(BodyInserters.fromPublisher(Mono.just("data"), String.class));
-        WebClient.RequestHeadersSpec<?> requestSpec2 = uri2.body(BodyInserters.fromValue("data"));
-
-        // inserters
-        BodyInserter<Publisher<String>, ReactiveHttpOutputMessage> inserter1 = BodyInserters.fromPublisher(Subscriber::onComplete, String.class);
-
-        LinkedMultiValueMap<String, String> map = new LinkedMultiValueMap<>();
-        map.add("key1", "value1");
-        map.add("key2", "value2");
-
-        BodyInserter<MultiValueMap<String, Object>, ClientHttpRequest> inserter2 = BodyInserters.fromMultipartData(map);
-        BodyInserter<Object, ReactiveHttpOutputMessage> inserter3 = BodyInserters.fromValue(new Object());
-        BodyInserter<String, ReactiveHttpOutputMessage> inserter4 = BodyInserters.fromValue("body");
-
-        // responses
-        WebClient.ResponseSpec response1 = uri1.body(inserter3)
-            .header(HttpHeaders.CONTENT_TYPE, MediaType.APPLICATION_JSON_VALUE)
-            .accept(MediaType.APPLICATION_JSON, MediaType.APPLICATION_XML)
-            .acceptCharset(Charset.forName("UTF-8"))
-            .ifNoneMatch("*")
-            .ifModifiedSince(ZonedDateTime.now())
-            .retrieve();
-        String response2 = uri1.exchangeToMono(response -> response.bodyToMono(String.class))
-            .block();
-        String response3 = uri2.retrieve()
-            .bodyToMono(String.class)
-            .block();
-        WebClient.ResponseSpec response4 = requestSpec2.retrieve();
     }
 
-    private WebClient createWebClient() {
+    @PostMapping("/resource-foo")
-        return WebClient.create();
+    public Mono<String> postFooResource(@RequestBody Mono<Foo> bodyFoo) {
+        return bodyFoo.map(foo -> "processedFoo-" + foo.getName());
     }
 
-    private WebClient createWebClientWithServerURL() {
+    @PostMapping(value = "/resource-multipart", consumes = MediaType.MULTIPART_FORM_DATA_VALUE)
-        return WebClient.create("http://localhost:8081");
+    public String handleFormUpload(@RequestPart("key1") String value1, @RequestPart("key2") String value2) {
+        return "processed-" + value1 + "-" + value2;
     }
-
-    private WebClient createWebClientConfiguringTimeout() {
-        HttpClient httpClient = HttpClient.create()
-            .option(ChannelOption.CONNECT_TIMEOUT_MILLIS, 5000)
-            .doOnConnected(conn -> conn.addHandlerLast(new ReadTimeoutHandler(5000, TimeUnit.MILLISECONDS))
-                .addHandlerLast(new WriteTimeoutHandler(5000, TimeUnit.MILLISECONDS)));
-
-        return WebClient.builder()
-            .clientConnector(new ReactorClientHttpConnector(httpClient))
-            .build();
-    }
-
-    private WebClient createWebClientWithServerURLAndDefaultValues() {
-        return WebClient.builder()
-            .baseUrl("http://localhost:8081")
-            .defaultCookie("cookieKey", "cookieValue")
-            .defaultHeader(HttpHeaders.CONTENT_TYPE, MediaType.APPLICATION_JSON_VALUE)
-            .defaultUriVariables(Collections.singletonMap("url", "http://localhost:8080"))
-            .build();
-    }
-
 }

spring-5-reactive/src/test/java/com/baeldung/web/client/WebClientIntegrationTest.java

@@ -0,0 +1,331 @@
+package com.baeldung.web.client;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+import java.net.URI;
+import java.nio.charset.StandardCharsets;
+import java.time.Duration;
+import java.time.ZonedDateTime;
+import java.util.Collections;
+import java.util.Map;
+import java.util.concurrent.TimeUnit;
+
+import org.junit.jupiter.api.Test;
+import org.reactivestreams.Publisher;
+import org.reactivestreams.Subscriber;
+import org.springframework.boot.test.context.SpringBootTest;
+import org.springframework.boot.test.context.SpringBootTest.WebEnvironment;
+import org.springframework.boot.web.server.LocalServerPort;
+import org.springframework.core.ParameterizedTypeReference;
+import org.springframework.core.codec.CodecException;
+import org.springframework.http.HttpHeaders;
+import org.springframework.http.HttpMethod;
+import org.springframework.http.HttpStatus;
+import org.springframework.http.MediaType;
+import org.springframework.http.ReactiveHttpOutputMessage;
+import org.springframework.http.client.reactive.ClientHttpRequest;
+import org.springframework.http.client.reactive.ReactorClientHttpConnector;
+import org.springframework.util.LinkedMultiValueMap;
+import org.springframework.util.MultiValueMap;
+import org.springframework.web.reactive.function.BodyInserter;
+import org.springframework.web.reactive.function.BodyInserters;
+import org.springframework.web.reactive.function.client.WebClient;
+import org.springframework.web.reactive.function.client.WebClient.RequestBodySpec;
+import org.springframework.web.reactive.function.client.WebClient.RequestBodyUriSpec;
+import org.springframework.web.reactive.function.client.WebClient.RequestHeadersSpec;
+import org.springframework.web.reactive.function.client.WebClient.RequestHeadersUriSpec;
+import org.springframework.web.reactive.function.client.WebClient.ResponseSpec;
+import org.springframework.web.reactive.function.client.WebClientRequestException;
+
+import com.baeldung.web.reactive.client.Foo;
+import com.baeldung.web.reactive.client.WebClientApplication;
+
+import io.netty.channel.ChannelOption;
+import io.netty.handler.timeout.ReadTimeoutHandler;
+import io.netty.handler.timeout.WriteTimeoutHandler;
+import reactor.core.publisher.Mono;
+import reactor.netty.http.client.HttpClient;
+import reactor.test.StepVerifier;
+
+@SpringBootTest(classes = WebClientApplication.class, webEnvironment = WebEnvironment.RANDOM_PORT)
+public class WebClientIntegrationTest {
+
+    @LocalServerPort
+    private int port;
+
+    private static final String BODY_VALUE = "bodyValue";
+    private static final ParameterizedTypeReference<Map<String, String>> MAP_RESPONSE_REF = new ParameterizedTypeReference<Map<String, String>>() {
+    };
+
+    @Test
+    public void givenDifferentWebClientCreationMethods_whenUsed_thenObtainExpectedResponse() {
+        // WebClient creation
+        WebClient client1 = WebClient.create();
+        WebClient client2 = WebClient.create("http://localhost:" + port);
+        WebClient client3 = WebClient.builder()
+            .baseUrl("http://localhost:" + port)
+            .defaultCookie("cookieKey", "cookieValue")
+            .defaultHeader(HttpHeaders.CONTENT_TYPE, MediaType.APPLICATION_JSON_VALUE)
+            .defaultUriVariables(Collections.singletonMap("url", "http://localhost:8080"))
+            .build();
+
+        // response assertions
+        StepVerifier.create(retrieveResponse(client1.post()
+            .uri("http://localhost:" + port + "/resource")))
+            .expectNext("processed-bodyValue")
+            .verifyComplete();
+        StepVerifier.create(retrieveResponse(client2))
+            .expectNext("processed-bodyValue")
+            .verifyComplete();
+        StepVerifier.create(retrieveResponse(client3))
+            .expectNext("processed-bodyValue")
+            .verifyComplete();
+        // assert response without specifying URI
+        StepVerifier.create(retrieveResponse(client1))
+            .expectErrorMatches(ex -> WebClientRequestException.class.isAssignableFrom(ex.getClass()) && ex.getMessage()
+                .contains("Connection refused"))
+            .verify();
+    }
+
+    @Test
+    public void givenDifferentMethodSpecifications_whenUsed_thenObtainExpectedResponse() {
+        // request specification
+        RequestBodyUriSpec uriSpecPost1 = createDefaultClient().method(HttpMethod.POST);
+        RequestBodyUriSpec uriSpecPost2 = createDefaultClient().post();
+        RequestHeadersUriSpec<?> requestGet = createDefaultClient().get();
+
+        // response assertions
+        StepVerifier.create(retrieveResponse(uriSpecPost1))
+            .expectNext("processed-bodyValue")
+            .verifyComplete();
+        StepVerifier.create(retrieveResponse(uriSpecPost2))
+            .expectNext("processed-bodyValue")
+            .verifyComplete();
+        StepVerifier.create(retrieveGetResponse(requestGet))
+            .expectNextMatches(nextMap -> nextMap.get("field")
+                .equals("value"))
+            .verifyComplete();
+    }
+
+    @Test
+    public void givenDifferentUriSpecifications_whenUsed_thenObtainExpectedResponse() {
+        // uri specification
+        RequestBodySpec bodySpecUsingString = createDefaultPostRequest().uri("/resource");
+        RequestBodySpec bodySpecUsingUriBuilder = createDefaultPostRequest().uri(uriBuilder -> uriBuilder.pathSegment("resource")
+            .build());
+        RequestBodySpec bodySpecusingURI = createDefaultPostRequest().uri(URI.create("http://localhost:" + port + "/resource"));
+        RequestBodySpec bodySpecOverridenBaseUri = createDefaultPostRequest().uri(URI.create("/resource"));
+        RequestBodySpec bodySpecOverridenBaseUri2 = WebClient.builder()
+            .baseUrl("http://localhost:" + port)
+            .build()
+            .post()
+            .uri(URI.create("/resource"));
+
+        // response assertions
+        StepVerifier.create(retrieveResponse(bodySpecUsingString))
+            .expectNext("processed-bodyValue")
+            .verifyComplete();
+        StepVerifier.create(retrieveResponse(bodySpecUsingUriBuilder))
+            .expectNext("processed-bodyValue")
+            .verifyComplete();
+        StepVerifier.create(retrieveResponse(bodySpecusingURI))
+            .expectNext("processed-bodyValue")
+            .verifyComplete();
+        // assert sending request overriding base URI
+        StepVerifier.create(retrieveResponse(bodySpecOverridenBaseUri))
+            .expectErrorMatches(ex -> WebClientRequestException.class.isAssignableFrom(ex.getClass()) && ex.getMessage()
+                .contains("Connection refused"))
+            .verify();
+        StepVerifier.create(retrieveResponse(bodySpecOverridenBaseUri2))
+            .expectErrorMatches(ex -> WebClientRequestException.class.isAssignableFrom(ex.getClass()) && ex.getMessage()
+                .contains("Connection refused"))
+            .verify();
+    }
+
+    @Test
+    public void givenDifferentBodySpecifications_whenUsed_thenObtainExpectedResponse() {
+        // request body specifications
+        RequestHeadersSpec<?> headersSpecPost1 = createDefaultPostResourceRequest().body(BodyInserters.fromPublisher(Mono.just(BODY_VALUE), String.class));
+        RequestHeadersSpec<?> headersSpecPost2 = createDefaultPostResourceRequest().body(BodyInserters.fromValue(BODY_VALUE));
+        RequestHeadersSpec<?> headersSpecPost3 = createDefaultPostResourceRequest().bodyValue(BODY_VALUE);
+        RequestHeadersSpec<?> headersSpecFooPost = createDefaultPostRequest().uri("/resource-foo")
+            .body(Mono.just(new Foo("fooName")), Foo.class);
+        BodyInserter<Object, ReactiveHttpOutputMessage> inserterPlainObject = BodyInserters.fromValue(new Object());
+        RequestHeadersSpec<?> headersSpecPlainObject = createDefaultPostResourceRequest().body(inserterPlainObject);
+
+        // request body specifications - using other inserter method (multipart request)
+        LinkedMultiValueMap<String, String> map = new LinkedMultiValueMap<>();
+        map.add("key1", "multipartValue1");
+        map.add("key2", "multipartValue2");
+        BodyInserter<MultiValueMap<String, Object>, ClientHttpRequest> inserterMultipart = BodyInserters.fromMultipartData(map);
+        RequestHeadersSpec<?> headersSpecInserterMultipart = createDefaultPostRequest().uri("/resource-multipart")
+            .body(inserterMultipart);
+
+        // response assertions
+        StepVerifier.create(retrieveResponse(headersSpecPost1))
+            .expectNext("processed-bodyValue")
+            .verifyComplete();
+        StepVerifier.create(retrieveResponse(headersSpecPost2))
+            .expectNext("processed-bodyValue")
+            .verifyComplete();
+        StepVerifier.create(retrieveResponse(headersSpecPost3))
+            .expectNext("processed-bodyValue")
+            .verifyComplete();
+        StepVerifier.create(retrieveResponse(headersSpecFooPost))
+            .expectNext("processedFoo-fooName")
+            .verifyComplete();
+        StepVerifier.create(retrieveResponse(headersSpecInserterMultipart))
+            .expectNext("processed-multipartValue1-multipartValue2")
+            .verifyComplete();
+        // assert error plain `new Object()` as request body
+        StepVerifier.create(retrieveResponse(headersSpecPlainObject))
+            .expectError(CodecException.class)
+            .verify();
+        // assert response for request with no body
+        Mono<Map<String, String>> responsePostWithNoBody = createDefaultPostResourceRequest().exchangeToMono(responseHandler -> {
+            assertThat(responseHandler.statusCode()).isEqualTo(HttpStatus.BAD_REQUEST);
+            return responseHandler.bodyToMono(MAP_RESPONSE_REF);
+        });
+        StepVerifier.create(responsePostWithNoBody)
+            .expectNextMatches(nextMap -> nextMap.get("error")
+                .equals("Bad Request"))
+            .verifyComplete();
+    }
+
+    @Test
+    public void givenPostSpecifications_whenHeadersAdded_thenObtainExpectedResponse() {
+        // request header specification
+        RequestHeadersSpec<?> headersSpecInserterStringWithHeaders = createDefaultPostResourceRequestResponse().header(HttpHeaders.CONTENT_TYPE, MediaType.APPLICATION_JSON_VALUE)
+            .accept(MediaType.APPLICATION_JSON, MediaType.APPLICATION_XML)
+            .acceptCharset(StandardCharsets.UTF_8)
+            .ifNoneMatch("*")
+            .ifModifiedSince(ZonedDateTime.now());
+
+        // response assertions
+        StepVerifier.create(retrieveResponse(headersSpecInserterStringWithHeaders))
+            .expectNext("processed-bodyValue")
+            .verifyComplete();
+    }
+
+    @Test
+    public void givenDifferentResponseSpecifications_whenUsed_thenObtainExpectedResponse() {
+        ResponseSpec responseSpecPostString = createDefaultPostResourceRequestResponse().retrieve();
+        Mono<String> responsePostString = responseSpecPostString.bodyToMono(String.class);
+        Mono<String> responsePostString2 = createDefaultPostResourceRequestResponse().exchangeToMono(response -> {
+            if (response.statusCode()
+                .equals(HttpStatus.OK)) {
+                return response.bodyToMono(String.class);
+            } else if (response.statusCode()
+                .is4xxClientError()) {
+                return Mono.just("Error response");
+            } else {
+                return response.createException()
+                    .flatMap(Mono::error);
+            }
+        });
+        Mono<String> responsePostNoBody = createDefaultPostResourceRequest().exchangeToMono(response -> {
+            if (response.statusCode()
+                .equals(HttpStatus.OK)) {
+                return response.bodyToMono(String.class);
+            } else if (response.statusCode()
+                .is4xxClientError()) {
+                return Mono.just("Error response");
+            } else {
+                return response.createException()
+                    .flatMap(Mono::error);
+            }
+        });
+        Mono<Map<String, String>> responseGet = createDefaultClient().get()
+            .uri("/resource")
+            .retrieve()
+            .bodyToMono(MAP_RESPONSE_REF);
+
+        // response assertions
+        StepVerifier.create(responsePostString)
+            .expectNext("processed-bodyValue")
+            .verifyComplete();
+        StepVerifier.create(responsePostString2)
+            .expectNext("processed-bodyValue")
+            .verifyComplete();
+        StepVerifier.create(responsePostNoBody)
+            .expectNext("Error response")
+            .verifyComplete();
+        StepVerifier.create(responseGet)
+            .expectNextMatches(nextMap -> nextMap.get("field")
+                .equals("value"))
+            .verifyComplete();
+    }
+
+    @Test
+    public void givenWebClientWithTimeoutConfigurations_whenRequestUsingWronglyConfiguredPublisher_thenObtainTimeout() {
+        HttpClient httpClient = HttpClient.create()
+            .option(ChannelOption.CONNECT_TIMEOUT_MILLIS, 1000)
+            .responseTimeout(Duration.ofMillis(1000))
+            .doOnConnected(conn -> conn.addHandlerLast(new ReadTimeoutHandler(1000, TimeUnit.MILLISECONDS))
+                .addHandlerLast(new WriteTimeoutHandler(1000, TimeUnit.MILLISECONDS)));
+
+        WebClient timeoutClient = WebClient.builder()
+            .clientConnector(new ReactorClientHttpConnector(httpClient))
+            .build();
+
+        BodyInserter<Publisher<String>, ReactiveHttpOutputMessage> inserterCompleteSuscriber = BodyInserters.fromPublisher(Subscriber::onComplete, String.class);
+        RequestHeadersSpec<?> headersSpecInserterCompleteSuscriber = timeoutClient.post()
+            .uri("/resource")
+            .body(inserterCompleteSuscriber);
+
+        StepVerifier.create(headersSpecInserterCompleteSuscriber.retrieve()
+            .bodyToMono(String.class))
+            .expectTimeout(Duration.ofMillis(2000))
+            .verify();
+    }
+
+    // helper methods to create default instances
+    private WebClient createDefaultClient() {
+        return WebClient.create("http://localhost:" + port);
+    }
+
+    private RequestBodyUriSpec createDefaultPostRequest() {
+        return createDefaultClient().post();
+    }
+
+    private RequestBodySpec createDefaultPostResourceRequest() {
+        return createDefaultPostRequest().uri("/resource");
+    }
+
+    private RequestHeadersSpec<?> createDefaultPostResourceRequestResponse() {
+        return createDefaultPostResourceRequest().bodyValue(BODY_VALUE);
+    }
+
+    // helper methods to retrieve a response based on different steps of the process (specs)
+    private Mono<String> retrieveResponse(WebClient client) {
+        return client.post()
+            .uri("/resource")
+            .bodyValue(BODY_VALUE)
+            .retrieve()
+            .bodyToMono(String.class);
+    }
+
+    private Mono<String> retrieveResponse(RequestBodyUriSpec spec) {
+        return spec.uri("/resource")
+            .bodyValue(BODY_VALUE)
+            .retrieve()
+            .bodyToMono(String.class);
+    }
+
+    private Mono<Map<String, String>> retrieveGetResponse(RequestHeadersUriSpec<?> spec) {
+        return spec.uri("/resource")
+            .retrieve()
+            .bodyToMono(MAP_RESPONSE_REF);
+    }
+
+    private Mono<String> retrieveResponse(RequestBodySpec spec) {
+        return spec.bodyValue(BODY_VALUE)
+            .retrieve()
+            .bodyToMono(String.class);
+    }
+
+    private Mono<String> retrieveResponse(RequestHeadersSpec<?> spec) {
+        return spec.retrieve()
+            .bodyToMono(String.class);
+    }
+}