public <T extends Response> void executeAsync(
        final Request request,
        final ResponseHandler<T> responseHandler,
        final HttpClientContext httpClientContext
) {

    HttpUriRequest clientRequest;
    try {
        clientRequest = createClientRequest(request);
    } catch (IOException e) {
        responseHandler.failed(e);
        return;
    }

    FutureCallback<HttpResponse> responseCallback = createCallback(responseHandler);
    getAsyncClient().execute(
            HttpAsyncMethods.create(clientRequest),
            asyncResponseConsumerFactory.create(),
            httpClientContext,
            responseCallback);
}
 

public static void main(final String[] args) throws Exception {
    CloseableHttpAsyncClient httpclient = HttpAsyncClients.createDefault();
    try {
        httpclient.start();
        Future<Boolean> future = httpclient.execute(HttpAsyncMethods.createGet("http://localhost:8080/"),
                new MyResponseConsumer(), null);
        Boolean result = future.get();
        if (result != null && result.booleanValue()) {
            System.out.println("Request successfully executed");
        } else {
            System.out.println("Request failed");
        }
        System.out.println("Shutting down");
    } finally {
        httpclient.close();
    }
    System.out.println("Done");
}
 

@SuppressWarnings("unchecked")
public void begin() throws InterruptedException {
	CloseableHttpAsyncClient httpclient = httpAsyncClientBuilder.build();
	httpclient.start();
	new Thread(() -> {
		while (true) {
			try {
				Url url = this.urlQueue.take();
				httpclient.execute(HttpAsyncMethods.createGet(url.url), new MyResponseConsumer(url), new MyFutureCallback(url));
			} catch (Exception e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
		}
	}).start();

}
 

public void executeRequest() {
    final HttpPost request = new HttpPost(mBuilder.mUri);
    for (Map.Entry<String, String> entry : mBuilder.mHeaders.entrySet()) {
        request.addHeader(entry.getKey(), entry.getValue());
    }
    final HttpEntity entity = new StringEntity(mBuilder.mContentInJson, mBuilder.mContentType);
    request.setEntity(entity);
    final HttpAsyncRequestProducer requestProducer = HttpAsyncMethods.create(request);
    this.mHttpClient.execute(requestProducer, ((Builder) mBuilder).mHttpAsyncResponseConsumer,
            ((Builder) mBuilder).mFutureCallback);
}
 

private void download() {
	if (Thread.interrupted() || isExceptional()) {
		lifecycle().cancelled();
		return;
	}

	FutureManager<T> manager = createFutureManager();
	DownloadRetryHandler retryHandler = new DownloadRetryHandler();
	DownloadSessionHandler<T> handler = new DownloadSessionHandler<>(task, DownloadCallbacks.group(DownloadCallbacks.fromCallback(manager), retryHandler));
	Future<T> downloadFuture = httpClient.execute(HttpAsyncMethods.createGet(task.getURI()), handler.consumer, handler.callback);
	manager.setFuture(downloadFuture);
}
 

public static Func1<String, Observable<ObservableHttpResponse>> postJSON(final String baseURL, final CloseableHttpAsyncClient httpClient) {

        final URI baseURI = URI.create(baseURL);

        return new Func1<String, Observable<ObservableHttpResponse>>() {
            @Override
            public Observable<ObservableHttpResponse> call(String json) {
                try {
                    return ObservableHttp.createRequest(HttpAsyncMethods.createPost(baseURI, json, ContentType.APPLICATION_JSON), httpClient).toObservable();
                } catch (UnsupportedEncodingException e) {
                    throw Exceptions.propagate(e);
                }
            }
        };
    }
 

protected HttpAsyncResponseConsumerFactory createHttpAsyncResponseConsumerFactory() {
    if (pooledResponseBuffersEnabled) {
        return new PoolingAsyncResponseConsumerFactory(createPool());
    }
    return () -> HttpAsyncMethods.createConsumer();
}
 

/**
 * Retries given HTTP request. Called internally only, from the HttpFuture
 *
 * @param httpUriRequest the HttpUriRequest to retry
 * @param responseConsumer the response consumer
 * @param numRetry The retry count
 * @return the resulting Future<HttpResponse> instance
 */
Future<HttpResponse> retryOperation( HttpUriRequest httpUriRequest, HttpAsyncResponseConsumer<HttpResponse> responseConsumer, int numRetry ) {
    httpUriRequest.setHeader( "X-Tio-Retry-Count", Integer.toString( numRetry ) );
    return responseConsumer == null ? asyncClient.execute( httpUriRequest, null ) : asyncClient.execute( HttpAsyncMethods.create( httpUriRequest ), responseConsumer, null, null );
}