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

equal deleted inserted replaced

-:087a6b6d4955
+:bbd688c6fbbb
 import java.util.Objects;
 import java.util.Optional;
 import java.util.concurrent.CompletableFuture;
 import java.util.concurrent.CompletionStage;
 import java.util.concurrent.Flow;
+import java.util.concurrent.Flow.Subscriber;
 import java.util.function.Consumer;
 import java.util.function.Function;
 import javax.net.ssl.SSLParameters;
 /**
 * @return a body subscriber
 */
 public BodySubscriber<T> apply(int statusCode, HttpHeaders responseHeaders);
 /**
+* Returns a response body handler that returns a {@link BodySubscriber
+* BodySubscriber}{@code <Void>} obtained from {@linkplain
+* BodySubscriber#fromSubscriber(Subscriber)}, with the given
+* {@code subscriber}.
+*
+* <p> The response body is not available through this, or the {@code
+* HttpResponse} API, but instead all response body is forwarded to the
+* given {@code subscriber}, which should make it available, if
+* appropriate, through some other mechanism, e.g. an entry in a
+* database, etc.
+*
+* @apiNote This method can be used as an adapter between {@code
+* BodySubscriber} and {@code Flow.Subscriber}.
+*
+* <p> For example:
+* <pre> {@code
+*  TextSubscriber subscriber = new TextSubscriber();
+*  HttpResponse<Void> response = client.sendAsync(request,
+*      BodyHandler.fromSubscriber(subscriber)).join();
+*  System.out.println(response.statusCode());
+* }</pre>
+*
+* @param subscriber the subscriber
+* @return a response body handler
+*/
+public static BodyHandler<Void>
+fromSubscriber(Subscriber<? super List<ByteBuffer>> subscriber) {
+Objects.requireNonNull(subscriber);
+return (status, headers) -> BodySubscriber.fromSubscriber(subscriber,
+s -> null);
+}
+/**
+* Returns a response body handler that returns a {@link BodySubscriber
+* BodySubscriber}{@code <T>} obtained from {@link
+* BodySubscriber#fromSubscriber(Subscriber, Function)}, with the
+* given {@code subscriber} and {@code finisher} function.
+*
+* <p> The given {@code finisher} function is applied after the given
+* subscriber's {@code onComplete} has been invoked. The {@code finisher}
+* function is invoked with the given subscriber, and returns a value
+* that is set as the response's body.
+*
+* @apiNote This method can be used as an adapter between {@code
+* BodySubscriber} and {@code Flow.Subscriber}.
+*
+* <p> For example:
+* <pre> {@code
+* TextSubscriber subscriber = ...;  // accumulates bytes and transforms them into a String
+* HttpResponse<String> response = client.sendAsync(request,
+*     BodyHandler.fromSubscriber(subscriber, TextSubscriber::getTextResult)).join();
+* String text = response.body();
+* }</pre>
+*
+* @param <S> the type of the Subscriber
+* @param <T> the type of the response body
+* @param subscriber the subscriber
+* @param finisher a function to be applied after the subscriber has completed
+* @return a response body handler
+*/
+public static <S extends Subscriber<? super List<ByteBuffer>>,T> BodyHandler<T>
+fromSubscriber(S subscriber, Function<S,T> finisher) {
+Objects.requireNonNull(subscriber);
+Objects.requireNonNull(finisher);
+return (status, headers) -> BodySubscriber.fromSubscriber(subscriber,
+finisher);
+}
+/**
 * Returns a response body handler which discards the response body and
 * uses the given value as a replacement for it.
 *
 * @param <U> the response body type
 * @param value the value of U to return as the body, may be {@code null}
 /**
 * Returns a {@code BodyHandler<String>} that returns a
 * {@link BodySubscriber BodySubscriber}{@code <String>} obtained from
 * {@link BodySubscriber#asString(Charset) BodySubscriber.asString(Charset)}.
-* If a charset is provided, the body is decoded using it. If charset is
+* The body is decoded using the given character set.
-* {@code null} then the handler tries to determine the character set
+*
-* from the {@code Content-encoding} header. If that charset is not
+* @param charset the character set to convert the body with
-* supported then {@link java.nio.charset.StandardCharsets#UTF_8 UTF_8}
-* is used.
-*
-* @param charset The name of the charset to interpret the body as. If
-*                {@code null} then the charset is determined from the
-*                <i>Content-encoding</i> header.
 * @return a response body handler
 */
 public static BodyHandler<String> asString(Charset charset) {
-return (status, headers) -> {
+Objects.requireNonNull(charset);
-if (charset != null) {
+return (status, headers) -> BodySubscriber.asString(charset);
-return BodySubscriber.asString(charset);
-}
-return BodySubscriber.asString(charsetFrom(headers));
-};
 }
 /**
 * Returns a {@code BodyHandler<Path>} that returns a
 * {@link BodySubscriber BodySubscriber}{@code <Path>} obtained from
 *          invoked to check delete access if the file is opened with
 *          the {@code DELETE_ON_CLOSE} option.
 */
 public static BodyHandler<Path> asFile(Path file, OpenOption... openOptions) {
 Objects.requireNonNull(file);
+List<OpenOption> opts = List.of(openOptions);
 SecurityManager sm = System.getSecurityManager();
 if (sm != null) {
 String fn = pathForSecurityCheck(file);
 sm.checkWrite(fn);
-List<OpenOption> opts = Arrays.asList(openOptions);
 if (opts.contains(StandardOpenOption.DELETE_ON_CLOSE))
 sm.checkDelete(fn);
 if (opts.contains(StandardOpenOption.READ))
 sm.checkRead(fn);
 }
 */
 //####: check if the dir exists and is writable??
 public static BodyHandler<Path> asFileDownload(Path directory,
 OpenOption... openOptions) {
 Objects.requireNonNull(directory);
+List<OpenOption> opts = List.of(openOptions);
 SecurityManager sm = System.getSecurityManager();
 if (sm != null) {
 String fn = pathForSecurityCheck(directory);
 sm.checkWrite(fn);
-List<OpenOption> opts = Arrays.asList(openOptions);
 if (opts.contains(StandardOpenOption.DELETE_ON_CLOSE))
 sm.checkDelete(fn);
 if (opts.contains(StandardOpenOption.READ))
 sm.checkRead(fn);
 }
 *
 * @param consumer a Consumer to accept the response body
 * @return a response body handler
 */
 public static BodyHandler<Void> asByteArrayConsumer(Consumer<Optional<byte[]>> consumer) {
+Objects.requireNonNull(consumer);
 return (status, headers) -> BodySubscriber.asByteArrayConsumer(consumer);
 }
 /**
 * Returns a {@code BodyHandler<byte[]>} that returns a
 * @return a body handler
 * @throws IllegalArgumentException if {@code bufferSize <= 0}
 */
 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) -> BodySubscriber
 .buffering(downstreamHandler.apply(status, headers),
 bufferSize);
 * @return a CompletionStage for the response body
 */
 public CompletionStage<T> getBody();
 /**
+* Returns a body subscriber that forwards all response body to the
+* given {@code Flow.Subscriber}. The {@linkplain #getBody()} completion
+* stage} of the returned body subscriber completes after one of the
+* given subscribers {@code onComplete} or {@code onError} has been
+* invoked.
+*
+* @apiNote This method can be used as an adapter between {@code
+* BodySubscriber} and {@code Flow.Subscriber}.
+*
+* @param <S> the type of the Subscriber
+* @param subscriber the subscriber
+* @return a body subscriber
+*/
+public static <S extends Subscriber<? super List<ByteBuffer>>> BodySubscriber<Void>
+fromSubscriber(S subscriber) {
+return new ResponseSubscribers.SubscriberAdapter<S,Void>(subscriber, s -> null);
+}
+/**
+* Returns a body subscriber that forwards all response body to the
+* given {@code Flow.Subscriber}. The {@linkplain #getBody()} completion
+* stage} of the returned body subscriber completes after one of the
+* given subscribers {@code onComplete} or {@code onError} has been
+* invoked.
+*
+* <p> The given {@code finisher} function is applied after the given
+* subscriber's {@code onComplete} has been invoked. The {@code finisher}
+* function is invoked with the given subscriber, and returns a value
+* that is set as the response's body.
+*
+* @apiNote This method can be used as an adapter between {@code
+* BodySubscriber} and {@code Flow.Subscriber}.
+*
+* @param <S> the type of the Subscriber
+* @param <T> the type of the response body
+* @param subscriber the subscriber
+* @param finisher a function to be applied after the subscriber has
+*                 completed
+* @return a body subscriber
+*/
+public static <S extends Subscriber<? super List<ByteBuffer>>,T> BodySubscriber<T>
+fromSubscriber(S subscriber,
+Function<S,T> finisher) {
+return new ResponseSubscribers.SubscriberAdapter<S,T>(subscriber, finisher);
+}
+/**
 * Returns a body subscriber which stores the response body as a {@code
 * String} converted using the given {@code Charset}.
 *
 * <p> The {@link HttpResponse} using this subscriber is available after
 * the entire response has been read.
 *
 * @param charset the character set to convert the String with
 * @return a body subscriber
 */
 public static BodySubscriber<String> asString(Charset charset) {
+Objects.requireNonNull(charset);
 return new ResponseSubscribers.ByteArraySubscriber<>(
 bytes -> new String(bytes, charset)
 );
 }
 *          invoked to check delete access if the file is opened with the
 *          {@code DELETE_ON_CLOSE} option.
 */
 public static BodySubscriber<Path> asFile(Path file, OpenOption... openOptions) {
 Objects.requireNonNull(file);
+List<OpenOption> opts = List.of(openOptions);
 SecurityManager sm = System.getSecurityManager();
 if (sm != null) {
 String fn = pathForSecurityCheck(file);
 sm.checkWrite(fn);
-List<OpenOption> opts = Arrays.asList(openOptions);
 if (opts.contains(StandardOpenOption.DELETE_ON_CLOSE))
 sm.checkDelete(fn);
 if (opts.contains(StandardOpenOption.READ))
 sm.checkRead(fn);
 }

branch	http-client-branch
changeset 56008	bbd688c6fbbb
parent 55973	4d9b002587db
parent 48408	4f830b447edf
child 56009	cf8792f51dee