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", "async" })
    public void asyncContentLenghtGETTest() throws Exception {
        AsyncHttpClient client = getAsyncHttpClient(null);
        try {
            Response response = client.prepareGet(getTargetUrl()).execute(new AsyncCompletionHandlerAdapter() {


                @Override
                public void onThrowable(Throwable t) {
                    fail("Unexpected exception", t);
                }
            }).get();


            assertNotNull(response);
            assertEquals(response.getStatusCode(), 200);
        } finally {
            client.close();
        }
    }

View Full Code Here

        }
    }


    @Test(groups = { "standalone", "default_provider", "async" })
    public void asyncResponseBodyTooLarge() throws Exception {
        AsyncHttpClient client = getAsyncHttpClient(null);
        try {
            Response response = client.preparePost(getTargetUrl()).setBody("0123456789").execute(new AsyncCompletionHandlerAdapter() {


                @Override
                public void onThrowable(Throwable t) {
                    fail("Unexpected exception", t);
                }
            }).get();


            assertNotNull(response.getResponseBodyExcerpt(Integer.MAX_VALUE));
        } finally {
            client.close();
        }
    }

View Full Code Here

        }
    }


    @Test(groups = { "standalone", "default_provider", "async" })
    public void asyncResponseEmptyBody() throws Exception {
        AsyncHttpClient client = getAsyncHttpClient(null);
        try {
            Response response = client.prepareGet(getTargetUrl()).execute(new AsyncCompletionHandlerAdapter() {


                @Override
                public void onThrowable(Throwable t) {
                    fail("Unexpected exception", t);
                }
            }).get();


            assertEquals(response.getResponseBody(), "");
        } finally {
            client.close();
        }
    }

View Full Code Here

        }
    }


    @Test(groups = { "standalone", "default_provider", "asyncAPI" })
    public void asyncAPIContentLenghtGETTest() throws Exception {
        AsyncHttpClient client = getAsyncHttpClient(null);
        try {
            // Use a l in case the assert fail
            final CountDownLatch l = new CountDownLatch(1);


            client.prepareGet(getTargetUrl()).execute(new AsyncCompletionHandlerAdapter() {


                @Override
                public Response onCompleted(Response response) throws Exception {
                    try {
                        assertEquals(response.getStatusCode(), 200);
                    } finally {
                        l.countDown();
                    }
                    return response;
                }


                @Override
                public void onThrowable(Throwable t) {
                }
            });


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

View Full Code Here

        }
    }


    @Test(groups = { "standalone", "default_provider", "asyncAPI" })
    public void asyncAPIHandlerExceptionTest() throws Exception {
        AsyncHttpClient client = getAsyncHttpClient(null);
        try {
            // Use a l in case the assert fail
            final CountDownLatch l = new CountDownLatch(1);


            client.prepareGet(getTargetUrl()).execute(new AsyncCompletionHandlerAdapter() {
                @Override
                public Response onCompleted(Response response) throws Exception {
                    throw new IllegalStateException("FOO");
                }


                @Override
                public void onThrowable(Throwable t) {
                    try {
                        if (t.getMessage() != null) {
                            assertEquals(t.getMessage(), "FOO");
                        }
                    } finally {
                        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 asyncDoGetDelayHandlerTest() throws Exception {
        AsyncHttpClient client = getAsyncHttpClient(new AsyncHttpClientConfig.Builder().setRequestTimeout(5 * 1000).build());
        try {
            FluentCaseInsensitiveStringsMap h = new FluentCaseInsensitiveStringsMap();
            h.add("LockThread", "true");


            // Use a l in case the assert fail
            final CountDownLatch l = new CountDownLatch(1);


            client.prepareGet(getTargetUrl()).setHeaders(h).execute(new AsyncCompletionHandlerAdapter() {


                @Override
                public Response onCompleted(Response response) throws Exception {
                    try {
                        fail("Must not receive a response");
                    } finally {
                        l.countDown();
                    }
                    return response;
                }


                @Override
                public void onThrowable(Throwable t) {
                    try {
                        if (t instanceof TimeoutException) {
                            assertTrue(true);
                        } else {
                            fail("Unexpected exception", t);
                        }
                    } finally {
                        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 asyncDoGetQueryStringTest() throws Exception {
        AsyncHttpClient client = getAsyncHttpClient(null);
        try {
            // Use a l in case the assert fail
            final CountDownLatch l = new CountDownLatch(1);


            AsyncCompletionHandler<Response> handler = new AsyncCompletionHandlerAdapter() {


                @Override
                public Response onCompleted(Response response) throws Exception {
                    try {
                        assertTrue(response.getHeader("X-pathInfo") != null);
                        assertTrue(response.getHeader("X-queryString") != null);
                    } finally {
                        l.countDown();
                    }
                    return response;
                }
            };


            Request req = new RequestBuilder("GET").setUrl(getTargetUrl() + "?foo=bar").build();


            client.executeRequest(req, handler).get();


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

View Full Code Here

        }
    }


    @Test(groups = { "standalone", "default_provider", "async" })
    public void asyncDoGetKeepAliveHandlerTest() throws Exception {
        AsyncHttpClient client = getAsyncHttpClient(null);
        try {
            // Use a l in case the assert fail
            final CountDownLatch l = new CountDownLatch(2);


            AsyncCompletionHandler<Response> handler = new AsyncCompletionHandlerAdapter() {


                String remoteAddr = null;


                @Override
                public Response onCompleted(Response response) throws Exception {
                    try {
                        assertEquals(response.getStatusCode(), 200);
                        if (remoteAddr == null) {
                            remoteAddr = response.getHeader("X-KEEP-ALIVE");
                        } else {
                            assertEquals(response.getHeader("X-KEEP-ALIVE"), remoteAddr);
                        }
                    } finally {
                        l.countDown();
                    }
                    return response;
                }
            };


            client.prepareGet(getTargetUrl()).execute(handler).get();
            client.prepareGet(getTargetUrl()).execute(handler);


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

View Full Code Here

        }
    }


    @Test(groups = { "online", "default_provider", "async" })
    public void asyncDoGetMaxRedirectTest() throws Exception {
        AsyncHttpClient client = getAsyncHttpClient(new Builder().setMaxRedirects(0).setFollowRedirect(true).build());
        try {
            // Use a l in case the assert fail
            final CountDownLatch l = new CountDownLatch(1);


            AsyncCompletionHandler<Response> handler = new AsyncCompletionHandlerAdapter() {


                @Override
                public Response onCompleted(Response response) throws Exception {
                    fail("Should not be here");
                    return response;
                }


                @Override
                public void onThrowable(Throwable t) {
                    t.printStackTrace();
                    try {
                        assertEquals(t.getClass(), MaxRedirectException.class);
                    } finally {
                        l.countDown();
                    }
                }
            };


            client.prepareGet("http://google.com").execute(handler);


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

View Full Code Here

        }
    }


    @Test(groups = { "online", "default_provider", "async" })
    public void asyncDoGetNestedTest() throws Exception {
        final AsyncHttpClient client = getAsyncHttpClient(null);
        try {
            // FIXME find a proper website that redirects the same number of times whatever the language
            // Use a l in case the assert fail
            final CountDownLatch l = new CountDownLatch(2);


            final AsyncCompletionHandlerAdapter handler = new AsyncCompletionHandlerAdapter() {


                private final static int MAX_NESTED = 2;


                private AtomicInteger nestedCount = new AtomicInteger(0);


                @Override
                public Response onCompleted(Response response) throws Exception {
                    try {
                        if (nestedCount.getAndIncrement() < MAX_NESTED) {
                            System.out.println("Executing a nested request: " + nestedCount);
                            client.prepareGet("http://www.lemonde.fr").execute(this);
                        }
                    } finally {
                        l.countDown();
                    }
                    return response;
                }


                @Override
                public void onThrowable(Throwable t) {
                    t.printStackTrace();
                }
            };


            client.prepareGet("http://www.lemonde.fr").execute(handler);


            if (!l.await(TIMEOUT, TimeUnit.SECONDS)) {
                fail("Timed out");
            }
        } 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.