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 zeroCopyFileWithBodyManipulationTest() throws IOException, ExecutionException, TimeoutException, InterruptedException, URISyntaxException {
        AsyncHttpClient client = getAsyncHttpClient(null);
        File tmp = new File(System.getProperty("java.io.tmpdir") + File.separator + "zeroCopy.txt");
        tmp.deleteOnExit();
        final FileOutputStream stream = new FileOutputStream(tmp);
        try {


            Response resp = client.preparePost("http://127.0.0.1:" + port1 + "/").setBody(SIMPLE_TEXT_FILE).execute(new AsyncHandler<Response>() {
                public void onThrowable(Throwable t) {
                }


                public STATE onBodyPartReceived(HttpResponseBodyPart bodyPart) throws Exception {
                    bodyPart.writeTo(stream);


                    if (bodyPart.getBodyPartBytes().length == 0) {
                        return STATE.ABORT;
                    }


                    return STATE.CONTINUE;
                }


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


                public STATE onHeadersReceived(HttpResponseHeaders headers) throws Exception {
                    return STATE.CONTINUE;
                }


                public Response onCompleted() throws Exception {
                    return null;
                }
            }).get();
            assertNull(resp);
            assertEquals(SIMPLE_TEXT_FILE.length(), tmp.length());
        } finally {
            stream.close();
            client.close();
        }
    }

View Full Code Here

    }


    // --------------------------------------------------------- Private Methods


    private void doTestNegative(final int status, boolean strict) throws Exception {
        AsyncHttpClient p = getAsyncHttpClient(new AsyncHttpClientConfig.Builder().setFollowRedirect(true).setStrict302Handling(strict).addResponseFilter(new ResponseFilter() {
            @Override
            public <T> FilterContext<T> filter(FilterContext<T> ctx) throws FilterException {
                // pass on the x-expect-get and remove the x-redirect
                // headers if found in the response
                ctx.getResponseHeaders().getHeaders().get("x-expect-post");
                ctx.getRequest().getHeaders().add("x-expect-post", "true");
                ctx.getRequest().getHeaders().remove("x-redirect");
                return ctx;
            }
        }).build());
        try {
            Request request = new RequestBuilder("POST").setUrl(getTargetUrl()).addFormParam("q", "a b").addHeader("x-redirect", +status + "@" + "http://localhost:" + port1 + "/foo/bar/baz").addHeader("x-negative", "true").build();
            Future<Integer> responseFuture = p.executeRequest(request, new AsyncCompletionHandler<Integer>() {


                @Override
                public Integer onCompleted(Response response) throws Exception {
                    return response.getStatusCode();
                }


                @Override
                public void onThrowable(Throwable t) {
                    t.printStackTrace();
                    fail("Unexpected exception: " + t.getMessage(), t);
                }


            });
            int statusCode = responseFuture.get();
            assertEquals(statusCode, 200);
        } finally {
            p.close();
        }
    }

View Full Code Here

            p.close();
        }
    }


    private void doTestPositive(final int status) throws Exception {
        AsyncHttpClient p = getAsyncHttpClient(new AsyncHttpClientConfig.Builder().setFollowRedirect(true).addResponseFilter(new ResponseFilter() {
            @Override
            public <T> FilterContext<T> filter(FilterContext<T> ctx) throws FilterException {
                // pass on the x-expect-get and remove the x-redirect
                // headers if found in the response
                ctx.getResponseHeaders().getHeaders().get("x-expect-get");
                ctx.getRequest().getHeaders().add("x-expect-get", "true");
                ctx.getRequest().getHeaders().remove("x-redirect");
                return ctx;
            }
        }).build());
        try {
            Request request = new RequestBuilder("POST").setUrl(getTargetUrl()).addFormParam("q", "a b").addHeader("x-redirect", +status + "@" + "http://localhost:" + port1 + "/foo/bar/baz").build();
            Future<Integer> responseFuture = p.executeRequest(request, new AsyncCompletionHandler<Integer>() {


                @Override
                public Integer onCompleted(Response response) throws Exception {
                    return response.getStatusCode();
                }


                @Override
                public void onThrowable(Throwable t) {
                    t.printStackTrace();
                    fail("Unexpected exception: " + t.getMessage(), t);
                }


            });
            int statusCode = responseFuture.get();
            assertEquals(statusCode, 200);
        } finally {
            p.close();
        }
    }

View Full Code Here

        return new Head302handler();
    }


    @Test(groups = { "standalone", "default_provider" })
    public void testHEAD302() throws IOException, BrokenBarrierException, InterruptedException, ExecutionException, TimeoutException {
        AsyncHttpClient client = getAsyncHttpClient(null);
        try {
            final CountDownLatch l = new CountDownLatch(1);
            Request request = new RequestBuilder("HEAD").setUrl("http://127.0.0.1:" + port1 + "/Test").build();


            client.executeRequest(request, new AsyncCompletionHandlerBase() {
                @Override
                public Response onCompleted(Response response) throws Exception {
                    l.countDown();
                    return super.onCompleted(response);
                }
            }).get(3, TimeUnit.SECONDS);


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

View Full Code Here

        }
    }


    @Test(groups = { "standalone", "default_provider" })
    public void postWithQS() throws IOException, ExecutionException, TimeoutException, InterruptedException {
        AsyncHttpClient client = getAsyncHttpClient(null);
        try {
            Future<Response> f = client.preparePost("http://127.0.0.1:" + port1 + "/?a=b").setBody("abc".getBytes()).execute();
            Response resp = f.get(3, TimeUnit.SECONDS);
            assertNotNull(resp);
            assertEquals(resp.getStatusCode(), HttpServletResponse.SC_OK);
        } finally {
            client.close();
        }
    }

View Full Code Here

        }
    }


    @Test(groups = { "standalone", "default_provider" })
    public void postWithNulParamQS() throws IOException, ExecutionException, TimeoutException, InterruptedException {
        AsyncHttpClient client = getAsyncHttpClient(null);
        try {
            Future<Response> f = client.preparePost("http://127.0.0.1:" + port1 + "/?a=").setBody("abc".getBytes()).execute(new AsyncCompletionHandlerBase() {


                @Override
                public STATE onStatusReceived(final HttpResponseStatus status) throws Exception {
                    if (!status.getUri().toUrl().equals("http://127.0.0.1:" + port1 + "/?a=")) {
                        throw new IOException(status.getUri().toUrl());
                    }
                    return super.onStatusReceived(status);
                }


            });
            Response resp = f.get(3, TimeUnit.SECONDS);
            assertNotNull(resp);
            assertEquals(resp.getStatusCode(), HttpServletResponse.SC_OK);
        } finally {
            client.close();
        }
    }

View Full Code Here

        }
    }


    @Test(groups = { "standalone", "default_provider" })
    public void postWithNulParamsQS() throws IOException, ExecutionException, TimeoutException, InterruptedException {
        AsyncHttpClient client = getAsyncHttpClient(null);
        try {
            Future<Response> f = client.preparePost("http://127.0.0.1:" + port1 + "/?a=b&c&d=e").setBody("abc".getBytes()).execute(new AsyncCompletionHandlerBase() {


                @Override
                public STATE onStatusReceived(final HttpResponseStatus status) throws Exception {
                    if (!status.getUri().toUrl().equals("http://127.0.0.1:" + port1 + "/?a=b&c&d=e")) {
                        throw new IOException("failed to parse the query properly");
                    }
                    return super.onStatusReceived(status);
                }


            });
            Response resp = f.get(3, TimeUnit.SECONDS);
            assertNotNull(resp);
            assertEquals(resp.getStatusCode(), HttpServletResponse.SC_OK);
        } finally {
            client.close();
        }
    }

View Full Code Here

        }
    }


    @Test(groups = { "standalone", "default_provider" })
    public void postWithEmptyParamsQS() throws IOException, ExecutionException, TimeoutException, InterruptedException {
        AsyncHttpClient client = getAsyncHttpClient(null);
        try {
            Future<Response> f = client.preparePost("http://127.0.0.1:" + port1 + "/?a=b&c=&d=e").setBody("abc".getBytes()).execute(new AsyncCompletionHandlerBase() {


                @Override
                public STATE onStatusReceived(final HttpResponseStatus status) throws Exception {
                    if (!status.getUri().toUrl().equals("http://127.0.0.1:" + port1 + "/?a=b&c=&d=e")) {
                        throw new IOException("failed to parse the query properly");
                    }
                    return super.onStatusReceived(status);
                }


            });
            Response resp = f.get(3, TimeUnit.SECONDS);
            assertNotNull(resp);
            assertEquals(resp.getStatusCode(), HttpServletResponse.SC_OK);
        } finally {
            client.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", "/foo/test").execute().get();
            assertNotNull(response);
            assertEquals(response.getStatusCode(), 302);
            assertEquals(response.getUri().toString(), getTargetUrl());
        } finally {
            c.close();
        }
    }

View Full Code Here


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


        AsyncHttpClient ahc = getAsyncHttpClient(null);
        try {
            Request req = new RequestBuilder("GET").setUrl("http://localhost:" + port1 + "/MultiOther").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 {
                    int i = 0;
                    for (String header : response.getHeaders().get("X-Forwarded-For")) {
                        xffHeaders[i++] = header;
                    }
                    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(xffHeaders[0]);
            assertNotNull(xffHeaders[1]);
            try {
                assertEquals(xffHeaders[0], "abc");
                assertEquals(xffHeaders[1], "def");
            } catch (AssertionError ex) {
                assertEquals(xffHeaders[1], "abc");
                assertEquals(xffHeaders[0], "def");
            }
        } finally {
            ahc.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.