Examples of org.asynchttpclient.AsyncHttpClient

org.asynchttpclient.AsyncHttpClient

ing.com/").execute(); The code above will block until the response is fully received. To execute asynchronous HTTP request, you create an {@link AsyncHandler} or its abstract implementation, {@link AsyncCompletionHandler}

 AsyncHttpClient c = new AsyncHttpClient(); Future f = c.prepareGet("http://www.ning.com/").execute(new AsyncCompletionHandler() {  @Override public Response onCompleted(Response response) throws IOException { // Do something return response; } 
 @Override public void onThrowable(Throwable t) { } }); Response response = f.get(); 
 // We are just interested to retrieve the status code. Future f = c.prepareGet("http://www.ning.com/").execute(new AsyncCompletionHandler() { 
 @Override public Integer onCompleted(Response response) throws IOException { // Do something return response.getStatusCode(); } 
 @Override public void onThrowable(Throwable t) { } }); Integer statusCode = f.get();

You can also have more control about the how the response is asynchronously processed by using a {@link AsyncHandler}

 AsyncHttpClient c = new AsyncHttpClient(); Future f = c.prepareGet("http://www.ning.com/").execute(new AsyncHandler() { private StringBuilder builder = new StringBuilder();  @Override public STATE onStatusReceived(HttpResponseStatus s) throws Exception { // return STATE.CONTINUE or STATE.ABORT return STATE.CONTINUE } 
 @Override public STATE onHeadersReceived(HttpResponseHeaders bodyPart) throws Exception { // return STATE.CONTINUE or STATE.ABORT return STATE.CONTINUE 
 } @Override 
 public STATE onBodyPartReceived(HttpResponseBodyPart bodyPart) throws Exception { builder.append(new String(bodyPart)); // return STATE.CONTINUE or STATE.ABORT return STATE.CONTINUE } 
 @Override public String onCompleted() throws Exception { // Will be invoked once the response has been fully read or a ResponseComplete exception // has been thrown. return builder.toString(); } 
 @Override public void onThrowable(Throwable t) { } }); 
 String bodyResponse = f.get();

This class can also be used without the need of {@link AsyncHandler}

 AsyncHttpClient c = new AsyncHttpClient(); Future f = c.prepareGet(TARGET_URL).execute(); Response r = f.get();

Finally, you can configure the AsyncHttpClient using an {@link AsyncHttpClientConfig} instance

 AsyncHttpClient c = new AsyncHttpClient(new AsyncHttpClientConfig.Builder().setRequestTimeoutInMs(...).build()); Future f = c.prepareGet(TARGET_URL).execute(); Response r = f.get();

An instance of this class will cache every HTTP 1.1 connections and close them when the {@link AsyncHttpClientConfig#getReadTimeout()}expires. This object can hold many persistent connections to different host.


    @Test(groups = { "standalone", "default_provider" })
    public void testMultipleEntityHeaders() throws IOException, ExecutionException, TimeoutException, InterruptedException {
        final String[] clHeaders = new String[] { null, null };


        AsyncHttpClient ahc = getAsyncHttpClient(null);
        try {
            Request req = new RequestBuilder("GET").setUrl("http://localhost:" + port1 + "/MultiEnt").build();
            final CountDownLatch latch = new CountDownLatch(1);
            ahc.executeRequest(req, new AsyncHandler<Void>() {
                public void onThrowable(Throwable t) {
                    t.printStackTrace(System.out);
                }


                public STATE onBodyPartReceived(HttpResponseBodyPart objectHttpResponseBodyPart) throws Exception {
                    return STATE.CONTINUE;
                }


                public STATE onStatusReceived(HttpResponseStatus objectHttpResponseStatus) throws Exception {
                    return STATE.CONTINUE;
                }


                public STATE onHeadersReceived(HttpResponseHeaders response) throws Exception {
                    try {
                        int i = 0;
                        for (String header : response.getHeaders().get("Content-Length")) {
                            clHeaders[i++] = header;
                        }
                    } finally {
                        latch.countDown();
                    }
                    return STATE.CONTINUE;
                }


                public Void onCompleted() throws Exception {
                    return null;
                }
            }).get(3, TimeUnit.SECONDS);


            if (!latch.await(2, TimeUnit.SECONDS)) {
                fail("Time out");
            }
            assertNotNull(clHeaders[0]);
            assertNotNull(clHeaders[1]);


            // We can predict the order
            try {
                assertEquals(clHeaders[0], "2");
                assertEquals(clHeaders[1], "1");
            } catch (Throwable ex) {
                assertEquals(clHeaders[0], "1");
                assertEquals(clHeaders[1], "2");
            }
        } finally {
            ahc.close();
        }
    }

View Full Code Here

        AsyncHttpClientConfig config = new AsyncHttpClientConfig.Builder()//
        .setFollowRedirect(true)//
        .setAcceptAnyCertificate(true)//
        .build();


        AsyncHttpClient asyncHttpClient = getAsyncHttpClient(config);
        try {
            RequestBuilder rb = new RequestBuilder("GET").setProxyServer(ps).setUrl(getTargetUrl2());
            Future<Response> responseFuture = asyncHttpClient.executeRequest(rb.build(), new AsyncCompletionHandlerBase() {


                public void onThrowable(Throwable t) {
                    t.printStackTrace();
                    logger.debug(t.getMessage(), t);
                }


                @Override
                public Response onCompleted(Response response) throws Exception {
                    return response;
                }
            });
            Response r = responseFuture.get();
            assertEquals(r.getStatusCode(), 200);
            assertEquals(r.getHeader("X-Connection"), "keep-alive");
        } finally {
            asyncHttpClient.close();
        }
    }

View Full Code Here

        AsyncHttpClientConfig config = new AsyncHttpClientConfig.Builder()//
                .setFollowRedirect(true)//
                .setProxyServer(new ProxyServer(ProxyServer.Protocol.HTTPS, "127.0.0.1", port1))//
                .setAcceptAnyCertificate(true)//
                .build();
        AsyncHttpClient asyncHttpClient = getAsyncHttpClient(config);
        try {
            Future<Response> responseFuture = asyncHttpClient.executeRequest(new RequestBuilder("GET").setUrl(getTargetUrl2()).build(), new AsyncCompletionHandlerBase() {


                public void onThrowable(Throwable t) {
                    t.printStackTrace();
                    logger.debug(t.getMessage(), t);
                }


                @Override
                public Response onCompleted(Response response) throws Exception {
                    return response;
                }
            });
            Response r = responseFuture.get();
            assertEquals(r.getStatusCode(), 200);
            assertEquals(r.getHeader("X-Connection"), "keep-alive");
        } finally {
            asyncHttpClient.close();
        }
    }

View Full Code Here

        bc.setMaxConnections(1);
        bc.setConnectTimeout(1000);
        bc.setRequestTimeout(1000);
        bc.setFollowRedirect(true);


        AsyncHttpClient c = getAsyncHttpClient(bc.build());
        try {


            RequestBuilder builder = new RequestBuilder("POST");
            builder.setUrl(getTargetUrl());
            // made buff in stream big enough to mark.
            builder.setBody(new InputStreamBodyGenerator(new BufferedInputStream(new FileInputStream(LARGE_IMAGE_FILE), 400000)));


            Request r = builder.build();


            Response response = c.executeRequest(r).get();
            if (500 == response.getStatusCode()) {
                StringBuilder sb = new StringBuilder();
                sb.append("==============\n");
                sb.append("500 response from call\n");
                sb.append("Headers:" + response.getHeaders() + "\n");
                sb.append("==============\n");
                logger.debug(sb.toString());
                assertEquals(response.getStatusCode(), 500, "Should have 500 status code");
                assertTrue(response.getHeader("X-Exception").contains("invalid.chunk.length"), "Should have failed due to chunking");
                fail("HARD Failing the test due to provided InputStreamBodyGenerator, chunking incorrectly:" + response.getHeader("X-Exception"));
            } else {
                assertEquals(response.getResponseBodyAsBytes(), LARGE_IMAGE_BYTES);
            }
        } finally {
            c.close();
        }
    }

View Full Code Here

        AsyncHttpClientConfig cg = new AsyncHttpClientConfig.Builder()//
                .setMaxRedirects(5)//
                .setFollowRedirect(true)//
                .setAcceptAnyCertificate(true)//
                .build();
        AsyncHttpClient c = getAsyncHttpClient(cg);
        try {
            Response response = c.prepareGet(getTargetUrl()).setHeader("X-redirect", getTargetUrl2()).execute().get();
            assertNotNull(response);
            assertEquals(response.getStatusCode(), 200);
            assertEquals(response.getHeader("X-httpToHttps"), "PASS");
        } finally {
            c.close();
        }
    }

View Full Code Here

        AsyncHttpClientConfig cg = new AsyncHttpClientConfig.Builder()//
                .setMaxRedirects(5)//
                .setFollowRedirect(true)//
                .setAcceptAnyCertificate(true)//
                .build();
        AsyncHttpClient c = getAsyncHttpClient(cg);
        try {
            Response response = c.prepareGet(getTargetUrl()).setHeader("X-redirect", getTargetUrl2() + "/test2").execute().get();
            assertNotNull(response);
            assertEquals(response.getStatusCode(), 200);
            assertEquals(response.getHeader("X-httpToHttps"), "PASS");


            // Test if the internal channel is downgraded to clean http.
            response = c.prepareGet(getTargetUrl()).setHeader("X-redirect", getTargetUrl2() + "/foo2").execute().get();
            assertNotNull(response);
            assertEquals(response.getStatusCode(), 200);
            assertEquals(response.getHeader("X-httpToHttps"), "PASS");
        } finally {
            c.close();
        }
    }

View Full Code Here

        }
    }


    @Test(groups = { "standalone", "default_provider", "async" })
    public void asyncConnectInvalidPort() throws Exception {
        AsyncHttpClient client = getAsyncHttpClient(null);
        try {
            // pick a random unused local port
            int port = findFreePort();


            try {
                Response response = client.preparePost(String.format("http://127.0.0.1:%d/", port)).execute(new AsyncCompletionHandlerAdapter() {
                    @Override
                    public void onThrowable(Throwable t) {
                        t.printStackTrace();
                    }
                }).get();
                assertNull(response, "No ExecutionException was thrown");
            } catch (ExecutionException ex) {
                assertEquals(ex.getCause().getClass(), ConnectException.class);
            }
        } finally {
            client.close();
        }
    }

View Full Code Here

        }
    }


    @Test(groups = { "standalone", "default_provider", "async" })
    public void asyncConnectInvalidHandlerPort() throws Exception {
        AsyncHttpClient client = getAsyncHttpClient(null);
        try {
            final CountDownLatch l = new CountDownLatch(1);
            int port = findFreePort();


            client.prepareGet(String.format("http://127.0.0.1:%d/", port)).execute(new AsyncCompletionHandlerAdapter() {
                @Override
                public void onThrowable(Throwable t) {
                    try {
                        assertEquals(t.getClass(), ConnectException.class);
                    } finally {
                        l.countDown();
                    }
                }
            });


            if (!l.await(TIMEOUT, TimeUnit.SECONDS)) {
                fail("Timed out");
            }
        } finally {
            client.close();
        }
    }

View Full Code Here

        }
    }


    @Test(groups = { "online", "default_provider", "async" })
    public void asyncConnectInvalidHandlerHost() throws Exception {
        AsyncHttpClient client = getAsyncHttpClient(null);
        try {
            final CountDownLatch l = new CountDownLatch(1);


            client.prepareGet("http://null.apache.org:9999/").execute(new AsyncCompletionHandlerAdapter() {
                @Override
                public void onThrowable(Throwable t) {
                    if (t != null) {
                        if (t.getClass().equals(ConnectException.class)) {
                            l.countDown();
                        } else if (t.getClass().equals(UnresolvedAddressException.class)) {
                            l.countDown();
                        }
                    }
                }
            });


            if (!l.await(TIMEOUT, TimeUnit.SECONDS)) {
                fail("Timed out");
            }
        } finally {
            client.close();
        }
    }

View Full Code Here

        }
    }


    @Test(groups = { "standalone", "default_provider", "async" })
    public void asyncConnectInvalidFuturePort() throws Exception {
        AsyncHttpClient client = getAsyncHttpClient(null);
        try {
            final AtomicBoolean called = new AtomicBoolean(false);
            final AtomicBoolean rightCause = new AtomicBoolean(false);
            // pick a random unused local port
            int port = findFreePort();


            try {
                Response response = client.prepareGet(String.format("http://127.0.0.1:%d/", port)).execute(new AsyncCompletionHandlerAdapter() {
                    @Override
                    public void onThrowable(Throwable t) {
                        called.set(true);
                        if (t instanceof ConnectException) {
                            rightCause.set(true);
                        }
                    }
                }).get();
                assertNull(response, "No ExecutionException was thrown");
            } catch (ExecutionException ex) {
                assertEquals(ex.getCause().getClass(), ConnectException.class);
            }
            assertTrue(called.get(), "onThrowable should get called.");
            assertTrue(rightCause.get(), "onThrowable should get called with ConnectionException");
        } finally {
            client.close();
        }
    }

View Full Code Here

0 1 2 3 4 5 6 7 8 9

TOP

Related Classes of org.asynchttpclient.AsyncHttpClient

org.asynchttpclient.async.AsyncProvidersBasicTest

org.asynchttpclient.async.AsyncStreamHandlerTest

org.asynchttpclient.async.AsyncStreamLifecycleTest

org.asynchttpclient.async.AuthTimeoutTest

org.asynchttpclient.async.BasicAuthTest

org.asynchttpclient.async.BasicHttpsTest

org.asynchttpclient.async.BodyChunkTest

org.asynchttpclient.async.BodyDeferringAsyncHandlerTest

org.asynchttpclient.async.ByteBufferCapacityTest

org.asynchttpclient.async.ChunkingTest

All source code are property of their respective owners. Java is a trademark of Sun Microsystems, Inc and owned by ORACLE Inc. Contact coftware#gmail.com.