Apache HttpComponents – HttpClient Quick Start (original) (raw)

• Download ‘Binary’ package of the latest HttpClient 5.5 release or configure dependency on HttpClient and Fluent HCmodules using a dependency manager of your choice as described here.
• HttpClient 5.5 requires Java 1.8 or newer.
• The below code fragment illustrates the execution of HTTP GET and POST requests using the HttpClient native API.

try (CloseableHttpClient httpclient = HttpClients.createDefault()) {  
    ClassicHttpRequest httpGet = ClassicRequestBuilder.get("http://httpbin.org/get")  
            .build();  
    // The underlying HTTP connection is still held by the response object  
    // to allow the response content to be streamed directly from the network socket.  
    // In order to ensure correct deallocation of system resources  
    // the user MUST call CloseableHttpResponse#close() from a finally clause.  
    // Please note that if response content is not fully consumed the underlying  
    // connection cannot be safely re-used and will be shut down and discarded  
    // by the connection manager.  
    httpclient.execute(httpGet, response -> {  
        System.out.println(response.getCode() + " " + response.getReasonPhrase());  
        final HttpEntity entity1 = response.getEntity();  
        // do something useful with the response body  
        // and ensure it is fully consumed  
        EntityUtils.consume(entity1);  
        return null;  
    });  
    ClassicHttpRequest httpPost = ClassicRequestBuilder.post("http://httpbin.org/post")  
            .setEntity(new UrlEncodedFormEntity(Arrays.asList(  
                    new BasicNameValuePair("username", "vip"),  
                    new BasicNameValuePair("password", "secret"))))  
            .build();  
    httpclient.execute(httpPost, response -> {  
        System.out.println(response.getCode() + " " + response.getReasonPhrase());  
        final HttpEntity entity2 = response.getEntity();  
        // do something useful with the response body  
        // and ensure it is fully consumed  
        EntityUtils.consume(entity2);  
        return null;  
    });  
}  

• The same requests can be executed using a simpler, albeit less flexible, fluent API.

// The fluent API relieves the user from having to deal with manual deallocation of system  
// resources at the cost of having to buffer response content in memory in some cases.  
Request.Get("http://targethost/homepage")  
    .execute().returnContent();  
Request.Post("http://targethost/login")  
    .bodyForm(Form.form().add("username",  "vip").add("password",  "secret").build())  
    .execute().returnContent();  

• The below code fragment illustrates the execution of HTTP requests using HttpClient async API.

try (CloseableHttpAsyncClient httpclient = HttpAsyncClients.createDefault()) {  
    // Start the client  
    httpclient.start();  
    // Execute request  
    SimpleHttpRequest request1 = SimpleRequestBuilder.get("http://httpbin.org/get").build();  
    Future<SimpleHttpResponse> future = httpclient.execute(request1, null);  
    // and wait until response is received  
    SimpleHttpResponse response1 = future.get();  
    System.out.println(request1.getRequestUri() + "->" + response1.getCode());  
    // One most likely would want to use a callback for operation result  
    CountDownLatch latch1 = new CountDownLatch(1);  
    SimpleHttpRequest request2 = SimpleRequestBuilder.get("http://httpbin.org/get").build();  
    httpclient.execute(request2, new FutureCallback<SimpleHttpResponse>() {  
        @Override  
        public void completed(SimpleHttpResponse response2) {  
            latch1.countDown();  
            System.out.println(request2.getRequestUri() + "->" + response2.getCode());  
        }  
        @Override  
        public void failed(Exception ex) {  
            latch1.countDown();  
            System.out.println(request2.getRequestUri() + "->" + ex);  
        }  
        @Override  
        public void cancelled() {  
            latch1.countDown();  
            System.out.println(request2.getRequestUri() + " cancelled");  
        }  
    });  
    latch1.await();  
    // In real world one most likely would want also want to stream  
    // request and response body content  
    CountDownLatch latch2 = new CountDownLatch(1);  
    AsyncRequestProducer producer3 = AsyncRequestBuilder.get("http://httpbin.org/get").build();  
    AbstractCharResponseConsumer<HttpResponse> consumer3 = new AbstractCharResponseConsumer<HttpResponse>() {  
        HttpResponse response;  
        @Override  
        protected void start(HttpResponse response, ContentType contentType) throws HttpException, IOException {  
            this.response = response;  
        }  
        @Override  
        protected int capacityIncrement() {  
            return Integer.MAX_VALUE;  
        }  
        @Override  
        protected void data(CharBuffer data, boolean endOfStream) throws IOException {  
            // Do something useful  
        }  
        @Override  
        protected HttpResponse buildResult() throws IOException {  
            return response;  
        }  
        @Override  
        public void releaseResources() {  
        }  
    };  
    httpclient.execute(producer3, consumer3, new FutureCallback<HttpResponse>() {  
        @Override  
        public void completed(HttpResponse response3) {  
            latch2.countDown();  
            System.out.println(request2.getRequestUri() + "->" + response3.getCode());  
        }  
        @Override  
        public void failed(Exception ex) {  
            latch2.countDown();  
            System.out.println(request2.getRequestUri() + "->" + ex);  
        }  
        @Override  
        public void cancelled() {  
            latch2.countDown();  
            System.out.println(request2.getRequestUri() + " cancelled");  
        }  
    });  
    latch2.await();  
}