Java11新特性之HttpClient小试牛刀

@test

public void testtimeout() throws ioexception, interruptedexception {

  //1.set connect timeout

  httpclient client = httpclient.newbuilder()

    .connecttimeout(duration.ofmillis( 5000 ))

    .followredirects(httpclient.redirect.normal)

    .build();

  //2.set read timeout

  httprequest request = httprequest.newbuilder()

    .uri(uri.create( "http://openjdk.java.net/" ))

    .timeout(duration.ofmillis( 5009 ))

    .build();

  httpresponse<string> response =

    client.send(request, httpresponse.bodyhandlers.ofstring());

  system.out.println(response.body());

}

caused by: java.net.http.httpconnecttimeoutexception: http connect timed out

  at java.net.http/jdk.internal.net.http.responsetimerevent.handle(responsetimerevent.java: 68 )

  at java.net.http/jdk.internal.net.http.httpclientimpl.purgetimeoutsandreturnnextdeadline(httpclientimpl.java: 1248 )

  at java.net.http/jdk.internal.net.http.httpclientimpl$selectormanager.run(httpclientimpl.java: 877 )

caused by: java.net.connectexception: http connect timed out

  at java.net.http/jdk.internal.net.http.responsetimerevent.handle(responsetimerevent.java: 69 )

  ... 2 more

java.net.http.httptimeoutexception: request timed out

  at java.net.http/jdk.internal.net.http.httpclientimpl.send(httpclientimpl.java: 559 )

  at java.net.http/jdk.internal.net.http.httpclientfacade.send(httpclientfacade.java: 119 )

  at com.example.httpclienttest.testtimeout(httpclienttest.java: 40 )

@test

public void testbasicauth() throws ioexception, interruptedexception {

  httpclient client = httpclient.newbuilder()

    .connecttimeout(duration.ofmillis( 5000 ))

    .authenticator( new authenticator() {

     @override

     protected passwordauthentication getpasswordauthentication() {

      return new passwordauthentication( "admin" , "password" .tochararray());

     }

    })

    .build();

  httprequest request = httprequest.newbuilder()

    .uri(uri.create( "http://localhost:8080/json/info" ))

    .timeout(duration.ofmillis( 5009 ))

    .build();

  httpresponse<string> response =

    client.send(request, httpresponse.bodyhandlers.ofstring());

  system.out.println(response.statuscode());

  system.out.println(response.body());

}

@test

public void testcookies() throws ioexception, interruptedexception {

  httpclient client = httpclient.newbuilder()

    .connecttimeout(duration.ofmillis( 5000 ))

    .build();

  httprequest request = httprequest.newbuilder()

    .uri(uri.create( "http://localhost:8080/json/cookie" ))

    .header( "cookie" , "jsessionid=4f994730-32d7-4e22-a18b-25667ddeb636; userid=java11" )

    .timeout(duration.ofmillis( 5009 ))

    .build();

  httpresponse<string> response =

    client.send(request, httpresponse.bodyhandlers.ofstring());

  system.out.println(response.statuscode());

  system.out.println(response.body());

}

@test

public void testsyncget() throws ioexception, interruptedexception {

  httpclient client = httpclient.newhttpclient();

  httprequest request = httprequest.newbuilder()

    .uri(uri.create( "https://www.baidu.com" ))

    .build();

  httpresponse<string> response =

    client.send(request, httpresponse.bodyhandlers.ofstring());

  system.out.println(response.body());

}

@test

public void testasyncget() throws executionexception, interruptedexception {

  httpclient client = httpclient.newhttpclient();

  httprequest request = httprequest.newbuilder()

    .uri(uri.create( "https://www.baidu.com" ))

    .build();

  completablefuture<string> result = client.sendasync(request, httpresponse.bodyhandlers.ofstring())

    .thenapply(httpresponse::body);

  system.out.println(result.get());

}

@test

public void testpostform() throws ioexception, interruptedexception {

  httpclient client = httpclient.newbuilder().build();

  httprequest request = httprequest.newbuilder()

    .uri(uri.create( "http://www.w3school.com.cn/demo/demo_form.asp" ))

    .header( "content-type" , "application/x-www-form-urlencoded" )

    .post(httprequest.bodypublishers.ofstring( "name1=value1&name2=value2" ))

    .build();

  httpresponse<string> response = client.send(request, httpresponse.bodyhandlers.ofstring());

  system.out.println(response.statuscode());

}

@test

public void testpostjsongetjson() throws executionexception, interruptedexception, jsonprocessingexception {

  objectmapper objectmapper = new objectmapper();

  stockdto dto = new stockdto();

  dto.setname( "hj" );

  dto.setsymbol( "hj" );

  dto.settype(stockdto.stocktype.sh);

  string requestbody = objectmapper

    .writerwithdefaultprettyprinter()

    .writevalueasstring(dto);

  httprequest request = httprequest.newbuilder(uri.create( "http://localhost:8080/json/demo" ))

    .header( "content-type" , "application/json" )

    .post(httprequest.bodypublishers.ofstring(requestbody))

    .build();

  completablefuture<stockdto> result = httpclient.newhttpclient()

    .sendasync(request, httpresponse.bodyhandlers.ofstring())

    .thenapply(httpresponse::body)

    .thenapply(body -> {

     try {

      return objectmapper.readvalue(body,stockdto. class );

     } catch (ioexception e) {

      return new stockdto();

     }

    });

  system.out.println(result.get());

}

@test

public void testuploadfile() throws ioexception, interruptedexception, urisyntaxexception {

  httpclient client = httpclient.newhttpclient();

  path path = path.of(getclass().getclassloader().getresource( "body.txt" ).touri());

  file file = path.tofile();

  string multipartformdataboundary = "java11httpclientformboundary" ;

  org.apache.http.httpentity multipartentity = multipartentitybuilder.create()

    .addpart( "file" , new filebody(file, contenttype.default_binary))

    .setboundary(multipartformdataboundary) //要设置，否则阻塞

    .build();

  httprequest request = httprequest.newbuilder()

    .uri(uri.create( "http://localhost:8080/file/upload" ))

    .header( "content-type" , "multipart/form-data; boundary=" + multipartformdataboundary)

    .post(httprequest.bodypublishers.ofinputstream(() -> {

     try {

      return multipartentity.getcontent();

     } catch (ioexception e) {

      e.printstacktrace();

      throw new runtimeexception(e);

     }

    }))

    .build();

  httpresponse<string> response =

    client.send(request, httpresponse.bodyhandlers.ofstring());

  system.out.println(response.body());

}

@test

public void testasyncdownload() throws executionexception, interruptedexception {

  httpclient client = httpclient.newhttpclient();

  httprequest request = httprequest.newbuilder()

    .uri(uri.create( "http://localhost:8080/file/download" ))

    .build();

  completablefuture<path> result = client.sendasync(request, httpresponse.bodyhandlers.offile(paths.get( "/tmp/body.txt" )))

    .thenapply(httpresponse::body);

  system.out.println(result.get());

}

@test

public void testconcurrentrequests(){

  httpclient client = httpclient.newhttpclient();

  list<string> urls = list.of( "http://www.baidu.com" , "http://www.alibaba.com/" , "http://www.tencent.com" );

  list<httprequest> requests = urls.stream()

    .map(url -> httprequest.newbuilder(uri.create(url)))

    .map(reqbuilder -> reqbuilder.build())

    .collect(collectors.tolist());

  list<completablefuture<httpresponse<string>>> futures = requests.stream()

    .map(request -> client.sendasync(request, httpresponse.bodyhandlers.ofstring()))

    .collect(collectors.tolist());

  futures.stream()

    .foreach(e -> e.whencomplete((resp,err) -> {

     if (err != null ){

      err.printstacktrace();

     } else {

      system.out.println(resp.body());

      system.out.println(resp.statuscode());

     }

    }));

  completablefuture.allof(futures

    .toarray(completablefuture<?>[]:: new ))

    .join();

}

@test

  public void testhandleexception() throws executionexception, interruptedexception {

   httpclient client = httpclient.newbuilder()

     .connecttimeout(duration.ofmillis( 5000 ))

     .build();

   httprequest request = httprequest.newbuilder()

     .uri(uri.create( "https://twitter.com" ))

     .build();

   completablefuture<string> result = client.sendasync(request, httpresponse.bodyhandlers.ofstring())

//    .whencomplete((resp,err) -> {

//     if(err != null){

//      err.printstacktrace();

//     }else{

//      system.out.println(resp.body());

//      system.out.println(resp.statuscode());

//     }

//    })

     .thenapply(httpresponse::body)

     .exceptionally(err -> {

      err.printstacktrace();

      return "fallback" ;

     });

   system.out.println(result.get());

  }

@test

public void testhttp2() throws urisyntaxexception {

  httpclient.newbuilder()

    .followredirects(httpclient.redirect.never)

    .version(httpclient.version.http_2)

    .build()

    .sendasync(httprequest.newbuilder()

        .uri( new uri( "https://http2.akamai.com/demo" ))

        .get()

        .build(),

      httpresponse.bodyhandlers.ofstring())

    .whencomplete((resp,t) -> {

     if (t != null ){

      t.printstacktrace();

     } else {

      system.out.println(resp.version());

      system.out.println(resp.statuscode());

     }

    }).join();

}

@test

public void testwebsocket() throws interruptedexception {

  httpclient client = httpclient.newhttpclient();

  websocket websocket = client.newwebsocketbuilder()

    .buildasync(uri.create( "ws://localhost:8080/echo" ), new websocket.listener() {

     @override

     public completionstage<?> ontext(websocket websocket, charsequence data, boolean last) {

      // request one more

      websocket.request( 1 );

      // print the message when it's available

      return completablefuture.completedfuture(data)

        .thenaccept(system.out::println);

     }

    }).join();

  websocket.sendtext( "hello " , false );

  websocket.sendtext( "world " , true );

  timeunit.seconds.sleep( 10 );

  websocket.sendclose(websocket.normal_closure, "ok" ).join();

}

public static class bytearraysubscriber<t> implements bodysubscriber<t> {

   private final function< byte [], t> finisher;

   private final completablefuture<t> result = new minimalfuture<>();

   private final list<bytebuffer> received = new arraylist<>();

   private volatile flow.subscription subscription;

   public bytearraysubscriber(function< byte [],t> finisher) {

    this .finisher = finisher;

   }

   @override

   public void onsubscribe(flow.subscription subscription) {

    if ( this .subscription != null ) {

     subscription.cancel();

     return ;

    }

    this .subscription = subscription;

    // we can handle whatever you've got

    subscription.request( long .max_value);

   }

   @override

   public void onnext(list<bytebuffer> items) {

    // incoming buffers are allocated by http client internally,

    // and won't be used anywhere except this place.

    // so it's free simply to store them for further processing.

    assert utils.hasremaining(items);

    received.addall(items);

   }

   @override

   public void onerror(throwable throwable) {

    received.clear();

    result.completeexceptionally(throwable);

   }

   static private byte [] join(list<bytebuffer> bytes) {

    int size = utils.remaining(bytes, integer.max_value);

    byte [] res = new byte [size];

    int from = 0 ;

    for (bytebuffer b : bytes) {

     int l = b.remaining();

     b.get(res, from, l);

     from += l;

    }

    return res;

   }

   @override

   public void oncomplete() {

    try {

     result.complete(finisher.apply(join(received)));

     received.clear();

    } catch (illegalargumentexception e) {

     result.completeexceptionally(e);

    }

   }

   @override

   public completionstage<t> getbody() {

    return result;

   }

  }