Add client-side exception hierarchy

The `WebClient` has a new exception hierarchy:

* `WebClientException` is the root of all exceptions thrown by the
`WebClient`
* `WebClientResponseException` are all exceptions associated with
specific HTTP response status codes
* `WebClientErrorException` and `WebServerErrorException` are
respectively for 4xx and 5xx HTTP status codes

`ResponseExtractor` implementations are adapted to optionally throw
exceptions if it's impossible to extract the relevant parts of the
response (e.g. extracting the response body if the response is a 404).

This commit also introduces `ResponseErrorHandler`s that take care of
the whole exception mapping infrastructure. Since
`WebClientResponseException`s provide the status, headers and response
body, we also need a dedicated mechanism to extract information from the
response body at that level.

The `BodyExtractors` are responsible for extracting that information
from the exception, given they are provided with all the information
they need; in that case, message decoders are required.

To convey all this new information downstream, the `WebClient` now wraps
the message converters and response error handler instances into a
dedicated `WebClientConfig` object.

Author: bclozel

spring-web/src/main/java/org/springframework/http/client/reactive/ReactorClientHttpConnector.java

@@ -22,11 +22,14 @@
 import org.springframework.http.HttpMethod;
 
 import reactor.core.publisher.Mono;
+import reactor.io.netty.http.HttpException;
+import reactor.io.netty.http.HttpInbound;
 
 /**
  * Reactor-Netty implementation of {@link ClientHttpConnector}
  *
  * @author Brian Clozel
+ * @see reactor.io.netty.http.HttpClient
  * @since 5.0
  */
 public class ReactorClientHttpConnector implements ClientHttpConnector {
@@ -38,7 +41,10 @@ public Mono<ClientHttpResponse> connect(HttpMethod method, URI uri,
 		return reactor.io.netty.http.HttpClient.create(uri.getHost(), uri.getPort())
 				.request(io.netty.handler.codec.http.HttpMethod.valueOf(method.name()),
 						uri.toString(),
-						httpOutbound -> requestCallback.apply(new ReactorClientHttpRequest(method, uri, httpOutbound)))
+						httpClientRequest -> requestCallback
+								.apply(new ReactorClientHttpRequest(method, uri, httpClientRequest)))
+				.cast(HttpInbound.class)
+				.otherwise(HttpException.class, exc -> Mono.just(exc.getChannel()))
 				.map(httpInbound -> new ReactorClientHttpResponse(httpInbound));
 	}
 }

spring-web/src/main/java/org/springframework/http/client/reactive/ReactorClientHttpResponse.java

@@ -19,7 +19,7 @@
 import java.util.Collection;
 
 import reactor.core.publisher.Flux;
-import reactor.io.netty.http.HttpClientResponse;
+import reactor.io.netty.http.HttpInbound;
 
 import org.springframework.core.io.buffer.DataBuffer;
 import org.springframework.core.io.buffer.NettyDataBufferFactory;
@@ -34,16 +34,16 @@
  * {@link ClientHttpResponse} implementation for the Reactor-Netty HTTP client
  *
  * @author Brian Clozel
- * @since 5.0
  * @see reactor.io.netty.http.HttpClient
+ * @since 5.0
  */
 public class ReactorClientHttpResponse implements ClientHttpResponse {
 
 	private final NettyDataBufferFactory dataBufferFactory;
 
-	private final HttpClientResponse response;
+	private final HttpInbound response;
 
-	public ReactorClientHttpResponse(HttpClientResponse response) {
+	public ReactorClientHttpResponse(HttpInbound response) {
 		this.response = response;
 		this.dataBufferFactory = new NettyDataBufferFactory(response.delegate().alloc());
 	}

spring-web/src/main/java/org/springframework/web/client/reactive/BodyExtractor.java

@@ -0,0 +1,43 @@
+/*
+ * Copyright 2002-2016 the original author or authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.springframework.web.client.reactive;
+
+import java.util.List;
+
+import org.springframework.http.client.reactive.ClientHttpResponse;
+import org.springframework.http.converter.reactive.HttpMessageConverter;
+
+/**
+ * A {@code BodyExtractor} extracts the content of a raw {@link ClientHttpResponse},
+ * decoding the response body and using a target composition API.
+ *
+ * <p>See static factory methods in {@link ResponseExtractors}
+ * and {@link org.springframework.web.client.reactive.support.RxJava1ResponseExtractors}.
+ *
+ * @author Brian Clozel
+ * @since 5.0
+ */
+public interface BodyExtractor<T> {
+
+	/**
+	 * Extract content from the response body
+	 * @param clientResponse the raw HTTP response
+	 * @param messageConverters the message converters that decode the response body
+	 * @return the relevant content
+	 */
+	T extract(ClientHttpResponse clientResponse, List<HttpMessageConverter<?>> messageConverters);
+}

spring-web/src/main/java/org/springframework/web/client/reactive/DefaultResponseErrorHandler.java

@@ -0,0 +1,45 @@
+/*
+ * Copyright 2002-2016 the original author or authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.springframework.web.client.reactive;
+
+import java.util.List;
+
+import org.springframework.http.HttpStatus;
+import org.springframework.http.client.reactive.ClientHttpResponse;
+import org.springframework.http.converter.reactive.HttpMessageConverter;
+
+/**
+ * Default implementation of the {@link ResponseErrorHandler} interface
+ * that throws {@link WebClientErrorException}s for HTTP 4xx responses
+ * and {@link WebServerErrorException}s for HTTP 5xx responses.
+ *
+ * @author Brian Clozel
+ * @since 5.0
+ */
+public class DefaultResponseErrorHandler implements ResponseErrorHandler {
+
+	@Override
+	public void handleError(ClientHttpResponse response, List<HttpMessageConverter<?>> messageConverters) {
+		HttpStatus responseStatus = response.getStatusCode();
+		if (responseStatus.is4xxClientError()) {
+			throw new WebClientErrorException(response, messageConverters);
+		}
+		if (responseStatus.is5xxServerError()) {
+			throw new WebServerErrorException(response, messageConverters);
+		}
+	}
+}

spring-web/src/main/java/org/springframework/web/client/reactive/ResponseErrorHandler.java

@@ -0,0 +1,41 @@
+/*
+ * Copyright 2002-2016 the original author or authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.springframework.web.client.reactive;
+
+import java.util.List;
+
+import org.springframework.http.client.reactive.ClientHttpResponse;
+import org.springframework.http.converter.reactive.HttpMessageConverter;
+
+/**
+ * Strategy interface used by the {@link WebClient} to handle
+ * errors in {@link ClientHttpResponse}s if needed.
+ *
+ * @author Brian Clozel
+ * @see DefaultResponseErrorHandler
+ * @since 5.0
+ */
+public interface ResponseErrorHandler {
+
+	/**
+	 * Handle the error in the given response.
+	 * Implementations will typically inspect the {@link ClientHttpResponse#getStatusCode() HttpStatus}
+	 * of the response and throw {@link WebClientException}s in case of errors.
+	 */
+	void handleError(ClientHttpResponse response, List<HttpMessageConverter<?>> messageConverters);
+
+}

spring-web/src/main/java/org/springframework/web/client/reactive/ResponseExtractor.java

@@ -16,24 +16,28 @@
 
 package org.springframework.web.client.reactive;
 
-import java.util.List;
-
 import reactor.core.publisher.Mono;
 
 import org.springframework.http.client.reactive.ClientHttpResponse;
-import org.springframework.http.converter.reactive.HttpMessageConverter;
 
 /**
  * A {@code ResponseExtractor} extracts the relevant part of a
  * raw {@link org.springframework.http.client.reactive.ClientHttpResponse},
  * optionally decoding the response body and using a target composition API.
  *
- * <p>See static factory methods in {@link ResponseExtractors}.
+ * <p>See static factory methods in {@link ResponseExtractors} and
+ * {@link org.springframework.web.client.reactive.support.RxJava1ResponseExtractors}.
  *
  * @author Brian Clozel
  * @since 5.0
  */
 public interface ResponseExtractor<T> {
 
-	T extract(Mono<ClientHttpResponse> clientResponse, List<HttpMessageConverter<?>> messageConverters);
+	/**
+	 * Extract content from the response
+	 * @param clientResponse the raw HTTP response
+	 * @param webClientConfig the {@link WebClient} configuration information
+	 * @return the relevant part of the response
+	 */
+	T extract(Mono<ClientHttpResponse> clientResponse, WebClientConfig webClientConfig);
 }