1 /*

     2  * Copyright (c) 2017, Oracle and/or its affiliates. All rights reserved.

     3  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.

     4  *

     5  * This code is free software; you can redistribute it and/or modify it

     6  * under the terms of the GNU General Public License version 2 only, as

     7  * published by the Free Software Foundation.

     8  *

     9  * This code is distributed in the hope that it will be useful, but WITHOUT

    10  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or

    11  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License

    12  * version 2 for more details (a copy is included in the LICENSE file that

    13  * accompanied this code).

    14  *

    15  * You should have received a copy of the GNU General Public License version

    16  * 2 along with this work; if not, write to the Free Software Foundation,

    17  * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.

    18  *

    19  * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA

    20  * or visit www.oracle.com if you need additional information or have any

    21  * questions.

    22  */

    23 

    24 import java.io.IOException;

    25 import java.io.InputStream;

    26 import java.io.InputStreamReader;

    27 import java.io.Reader;

    28 import java.net.URI;

    29 import jdk.incubator.http.HttpClient;

    30 import jdk.incubator.http.HttpHeaders;

    31 import jdk.incubator.http.HttpRequest;

    32 import jdk.incubator.http.HttpResponse;

    33 import java.nio.ByteBuffer;

    34 import java.nio.charset.Charset;

    35 import java.util.ArrayList;

    36 import java.util.Iterator;

    37 import java.util.List;

    38 import java.util.Locale;

    39 import java.util.Optional;

    40 import java.util.concurrent.ArrayBlockingQueue;

    41 import java.util.concurrent.BlockingQueue;

    42 import java.util.concurrent.CompletableFuture;

    43 import java.util.concurrent.CompletionStage;

    44 import java.util.concurrent.Flow;

    45 import java.util.stream.Stream;

    46 import static java.lang.System.err;

    47 

    48 /*

    49  * @test

    50  * @bug 8187503

    51  * @summary An example on how to read a response body with InputStream...

    52  * @run main/othervm -Dtest.debug=true BodyProcessorInputStreamTest

    53  * @author daniel fuchs

    54  */

    55 public class BodyProcessorInputStreamTest {

    56 

    57     public static boolean DEBUG = Boolean.getBoolean("test.debug");

    58 

    59     /**

    60      * Examine the response headers to figure out the charset used to

    61      * encode the body content.

    62      * If the content type is not textual, returns an empty Optional.

    63      * Otherwise, returns the body content's charset, defaulting to

    64      * ISO-8859-1 if none is explicitly specified.

    65      * @param headers The response headers.

    66      * @return The charset to use for decoding the response body, if

    67      *         the response body content is text/...

    68      */

    69     public static Optional<Charset> getCharset(HttpHeaders headers) {

    70         Optional<String> contentType = headers.firstValue("Content-Type");

    71         Optional<Charset> charset = Optional.empty();

    72         if (contentType.isPresent()) {

    73             final String[] values = contentType.get().split(";");

    74             if (values[0].startsWith("text/")) {

    75                 charset = Optional.of(Stream.of(values)

    76                     .map(x -> x.toLowerCase(Locale.ROOT))

    77                     .map(String::trim)

    78                     .filter(x -> x.startsWith("charset="))

    79                     .map(x -> x.substring("charset=".length()))

    80                     .findFirst()

    81                     .orElse("ISO-8859-1"))

    82                     .map(Charset::forName);

    83             }

    84         }

    85         return charset;

    86     }

    87 

    88     public static void main(String[] args) throws Exception {

    89         HttpClient client = HttpClient.newHttpClient();

    90         HttpRequest request = HttpRequest

    91             .newBuilder(new URI("http://hg.openjdk.java.net/jdk9/sandbox/jdk/shortlog/http-client-branch/"))

    92             .GET()

    93             .build();

    94 

    95         // This example shows how to return an InputStream that can be used to

    96         // start reading the response body before the response is fully received.

    97         // In comparison, the snipet below (which uses

    98         // HttpResponse.BodyHandler.asString()) obviously will not return before the

    99         // response body is fully read:

   100         //

   101         // System.out.println(

   102         //    client.sendAsync(request, HttpResponse.BodyHandler.asString()).get().body());

   103 

   104         CompletableFuture<HttpResponse<InputStream>> handle =

   105             client.sendAsync(request, HttpResponse.BodyHandler.asInputStream());

   106         if (DEBUG) err.println("Request sent");

   107 

   108         HttpResponse<InputStream> pending = handle.get();

   109 

   110         // At this point, the response headers have been received, but the

   111         // response body may not have arrived yet. This comes from

   112         // the implementation of HttpResponseInputStream::getBody above,

   113         // which returns an already completed completion stage, without

   114         // waiting for any data.

   115         // We can therefore access the headers - and the body, which

   116         // is our live InputStream, without waiting...

   117         HttpHeaders responseHeaders = pending.headers();

   118 

   119         // Get the charset declared in the response headers.

   120         // The optional will be empty if the content type is not

   121         // of type text/...

   122         Optional<Charset> charset = getCharset(responseHeaders);

   123 

   124         try (InputStream is = pending.body();

   125             // We assume a textual content type. Construct an InputStream

   126             // Reader with the appropriate Charset.

   127             // charset.get() will throw NPE if the content is not textual.

   128             Reader r = new InputStreamReader(is, charset.get())) {

   129 

   130             char[] buff = new char[32];

   131             int off=0, n=0;

   132             if (DEBUG) err.println("Start receiving response body");

   133             if (DEBUG) err.println("Charset: " + charset.get());

   134 

   135             // Start consuming the InputStream as the data arrives.

   136             // Will block until there is something to read...

   137             while ((n = r.read(buff, off, buff.length - off)) > 0) {

   138                 assert (buff.length - off) > 0;

   139                 assert n <= (buff.length - off);

   140                 if (n == (buff.length - off)) {

   141                     System.out.print(buff);

   142                     off = 0;

   143                 } else {

   144                     off += n;

   145                 }

   146                 assert off < buff.length;

   147             }

   148 

   149             // last call to read may not have filled 'buff' completely.

   150             // flush out the remaining characters.

   151             assert off >= 0 && off < buff.length;

   152             for (int i=0; i < off; i++) {

   153                 System.out.print(buff[i]);

   154             }

   155 

   156             // We're done!

   157             System.out.println("Done!");

   158         }

   159     }

   160 

   161 }