jdk-sandbox: comparison src/java.net.http/share/classes/java/net/http/HttpResponse.java

equal deleted inserted replaced

-:b0c62cfc1d12
+:1b37529eaf3a
 */
 public HttpClient.Version version();
 /**
+* Initial response information supplied to a {@link BodyHandler} when a
+* response is initially received and before the body is processed.
+*/
+public interface ResponseInfo {
+/**
+* Provides the response status code
+* @return the response status code
+*/
+public int statusCode();
+/**
+* Provides the response headers
+* @return the response headers
+*/
+public HttpHeaders headers();
+/**
+* Provides the response protocol version
+* @return the response protocol version
+*/
+public HttpClient.Version version();
+}
+/**
 * A handler for response bodies.  The class {@link BodyHandlers BodyHandlers}
 * provides implementations of many common body handlers.
 *
 * <p> The {@code BodyHandler} interface allows inspection of the response
 * code and headers, before the actual response body is received, and is
 * responsible for creating the response {@link BodySubscriber
 * BodySubscriber}. The {@code BodySubscriber} consumes the actual response
 * body bytes and, typically, converts them into a higher-level Java type.
 *
-* <p> A {@code BodyHandler} is a function that takes two parameters: the
+* <p> A {@code BodyHandler} is a function that takes a {@link ResponseInfo}
-* response status code and the response headers; and which returns a
+* object; and which returns a
 * {@code BodySubscriber}. The {@code BodyHandler} is invoked when the
 * response status code and headers are available, but before the response
 * body bytes are received.
 *
 * <p> The following example uses one of the {@linkplain BodyHandlers
 * <p> In the second example, the function returns a different subscriber
 * depending on the status code.
 * <pre>{@code   HttpRequest request = HttpRequest.newBuilder()
 *        .uri(URI.create("http://www.foo.com/"))
 *        .build();
-*  BodyHandler<Path> bodyHandler = (status, headers) -> status == 200
+*  BodyHandler<Path> bodyHandler = (rspInfo) -> rspInfo.statusCode() == 200
 *                      ? BodySubscribers.ofFile(Paths.get("/tmp/f"))
 *                      : BodySubscribers.replacing(Paths.get("/NULL"));
 *  client.sendAsync(request, bodyHandler)
 *        .thenApply(HttpResponse::body)
 *        .thenAccept(System.out::println); }</pre>
 *
 * <p> The response body can be discarded using one of {@link
 * BodyHandlers#discarding() discarding} or {@link
 * BodyHandlers#replacing(Object) replacing}.
 *
-* @param statusCode the HTTP status code received
+* @param responseInfo the response info.
-* @param responseHeaders the response headers received
 * @return a body subscriber
 */
-public BodySubscriber<T> apply(int statusCode, HttpHeaders responseHeaders);
+public BodySubscriber<T> apply(ResponseInfo responseInfo);
 }
 /**
 * Implementations of {@link BodyHandler BodyHandler} that implement various
 * useful handlers, such as handling the response body as a String, or
 * @return a response body handler
 */
 public static BodyHandler<Void>
 fromSubscriber(Subscriber<? super List<ByteBuffer>> subscriber) {
 Objects.requireNonNull(subscriber);
-return (status, headers) -> BodySubscribers.fromSubscriber(subscriber,
+return (responseInfo) -> BodySubscribers.fromSubscriber(subscriber,
 s -> null);
 }
 /**
 * Returns a response body handler that returns a {@link BodySubscriber
 */
 public static <S extends Subscriber<? super List<ByteBuffer>>,T> BodyHandler<T>
 fromSubscriber(S subscriber, Function<? super S,? extends T> finisher) {
 Objects.requireNonNull(subscriber);
 Objects.requireNonNull(finisher);
-return (status, headers) -> BodySubscribers.fromSubscriber(subscriber,
+return (responseInfo) -> BodySubscribers.fromSubscriber(subscriber,
 finisher);
 }
 /**
 * Returns a response body handler that returns a {@link BodySubscriber
 * @return a response body handler
 */
 public static BodyHandler<Void>
 fromLineSubscriber(Subscriber<? super String> subscriber) {
 Objects.requireNonNull(subscriber);
-return (status, headers) ->
+return (responseInfo) ->
 BodySubscribers.fromLineSubscriber(subscriber,
 s -> null,
-charsetFrom(headers),
+charsetFrom(responseInfo.headers()),
 null);
 }
 /**
 * Returns a response body handler that returns a {@link BodySubscriber
 Objects.requireNonNull(subscriber);
 Objects.requireNonNull(finisher);
 // implicit null check
 if (lineSeparator != null && lineSeparator.isEmpty())
 throw new IllegalArgumentException("empty line separator");
-return (status, headers) ->
+return (responseInfo) ->
 BodySubscribers.fromLineSubscriber(subscriber,
 finisher,
-charsetFrom(headers),
+charsetFrom(responseInfo.headers()),
 lineSeparator);
 }
 /**
 * Returns a response body handler that discards the response body.
 *
 * @return a response body handler
 */
 public static BodyHandler<Void> discarding() {
-return (status, headers) -> BodySubscribers.discarding();
+return (responseInfo) -> BodySubscribers.discarding();
 }
 /**
 * Returns a response body handler that returns the given replacement
 * value, after discarding the response body.
 * @param <U> the response body type
 * @param value the value of U to return as the body, may be {@code null}
 * @return a response body handler
 */
 public static <U> BodyHandler<U> replacing(U value) {
-return (status, headers) -> BodySubscribers.replacing(value);
+return (responseInfo) -> BodySubscribers.replacing(value);
 }
 /**
 * Returns a {@code BodyHandler<String>} that returns a
 * {@link BodySubscriber BodySubscriber}{@code <String>} obtained from
 * @param charset the character set to convert the body with
 * @return a response body handler
 */
 public static BodyHandler<String> ofString(Charset charset) {
 Objects.requireNonNull(charset);
-return (status, headers) -> BodySubscribers.ofString(charset);
+return (responseInfo) -> BodySubscribers.ofString(charset);
 }
 /**
 * Returns a {@code BodyHandler<Path>} that returns a
 * {@link BodySubscriber BodySubscriber}{@code <Path>} obtained from
 * information.
 *
 * @return a response body handler
 */
 public static BodyHandler<InputStream> ofInputStream() {
-return (status, headers) -> BodySubscribers.ofInputStream();
+return (responseInfo) -> BodySubscribers.ofInputStream();
 }
 /**
 * Returns a {@code BodyHandler<Stream<String>>} that returns a
 * {@link BodySubscriber BodySubscriber}{@code <Stream<String>>} obtained
 * not have been completely received.
 *
 * @return a response body handler
 */
 public static BodyHandler<Stream<String>> ofLines() {
-return (status, headers) ->
+return (responseInfo) ->
-BodySubscribers.ofLines(charsetFrom(headers));
+BodySubscribers.ofLines(charsetFrom(responseInfo.headers()));
 }
 /**
 * Returns a {@code BodyHandler<Void>} that returns a
 * {@link BodySubscriber BodySubscriber}{@code <Void>} obtained from
 * @return a response body handler
 */
 public static BodyHandler<Void>
 ofByteArrayConsumer(Consumer<Optional<byte[]>> consumer) {
 Objects.requireNonNull(consumer);
-return (status, headers) -> BodySubscribers.ofByteArrayConsumer(consumer);
+return (responseInfo) -> BodySubscribers.ofByteArrayConsumer(consumer);
 }
 /**
 * Returns a {@code BodyHandler<byte[]>} that returns a
 * {@link BodySubscriber BodySubscriber}&lt;{@code byte[]}&gt; obtained
 * been completely written to the byte array.
 *
 * @return a response body handler
 */
 public static BodyHandler<byte[]> ofByteArray() {
-return (status, headers) -> BodySubscribers.ofByteArray();
+return (responseInfo) -> BodySubscribers.ofByteArray();
 }
 /**
 * Returns a {@code BodyHandler<String>} that returns a
 * {@link BodySubscriber BodySubscriber}{@code <String>} obtained from
 * been completely written to the string.
 *
 * @return a response body handler
 */
 public static BodyHandler<String> ofString() {
-return (status, headers) -> BodySubscribers.ofString(charsetFrom(headers));
+return (responseInfo) -> BodySubscribers.ofString(charsetFrom(responseInfo.headers()));
 }
 /**
 * Returns a {@code BodyHandler<Publisher<List<ByteBuffer>>>} that creates a
 * {@link BodySubscriber BodySubscriber}{@code <Publisher<List<ByteBuffer>>>}
 * information.
 *
 * @return a response body handler
 */
 public static BodyHandler<Publisher<List<ByteBuffer>>> ofPublisher() {
-return (status, headers) -> BodySubscribers.ofPublisher();
+return (responseInfo) -> BodySubscribers.ofPublisher();
 }
 /**
 * Returns a {@code BodyHandler} which, when invoked, returns a {@linkplain
 * BodySubscribers#buffering(BodySubscriber,int) buffering BodySubscriber}
 public static <T> BodyHandler<T> buffering(BodyHandler<T> downstreamHandler,
 int bufferSize) {
 Objects.requireNonNull(downstreamHandler);
 if (bufferSize <= 0)
 throw new IllegalArgumentException("must be greater than 0");
-return (status, headers) -> BodySubscribers
+return (responseInfo) -> BodySubscribers
-.buffering(downstreamHandler.apply(status, headers),
+.buffering(downstreamHandler.apply(responseInfo),
 bufferSize);
 }
 }
 /**

branch	http-client-branch
changeset 56410	1b37529eaf3a
parent 56405	3642d0ef7755
child 56438	f2f496ec03c6