Boost HTTP Client Performance with Java NIO and Async Callbacks

Request Time Model

A three‑phase model is used to analyse request latency in QPS measurements: before – preparation before the request is sent. request and response – the actual network exchange. after – post‑processing after the response is received.

The total time is T, while rt denotes the time spent in the request and response phase.

Java NIO Overview

Java NIO (Non‑blocking or New I/O) operates on channels and buffers . It can allocate off‑heap memory via native calls and expose it through a DirectByteBuffer that lives in the Java heap. Because the buffer points directly to native memory, data copies between the JVM heap and native memory are avoided, which can significantly improve throughput for I/O‑bound workloads.

Applying NIO to HTTP Interface Testing

In the request and response phase the work can be split into three sub‑steps:

Send the HTTP request.

Wait for the server to produce a response.

Read the response bytes.

By delegating the waiting and reading to a separate thread (or to the NIO event loop) the main thread can immediately issue the next request. This “pipeline” style dramatically raises the request‑issuing rate, especially for APIs with long response times. A local single‑thread benchmark showed roughly a 30× increase in throughput; the gain diminishes under higher concurrency but remains noticeable.

HttpAsyncClient Integration

Apache HttpAsyncClient implements the non‑blocking model on top of Java NIO. Add the library to the project, for example with Maven:

<dependency>
  <groupId>org.apache.httpcomponents</groupId>
  <artifactId>httpasyncclient</artifactId>
  <version>4.1.4</version>
</dependency>

The core asynchronous execution method is:

@Override
public Future<HttpResponse> execute(final HttpUriRequest request,
                                 final FutureCallback<HttpResponse> callback) {
    return execute(request, HttpClientContext.create(), callback);
}

HttpRequestBase

(e.g., HttpGet, HttpPost) is the usual request object passed to this method.

Fire‑and‑Forget Execution

This variant sends a request and deliberately discards the response. Passing null as the callback causes the client to release the connection as soon as the response is received.

public static void executeSync(HttpRequestBase request) {
    ClientManage.httpAsyncClient.execute(request, null);
}

Logging Callback

A FutureCallback can be supplied to log the response body or warning messages.

public static void executeSyncWithLog(HttpRequestBase request) {
    ClientManage.httpAsyncClient.execute(request, logCallback);
}

public static final FutureCallback<HttpResponse> logCallback = new FutureCallback<HttpResponse>() {
    @Override
    public void completed(HttpResponse httpResponse) {
        HttpEntity entity = httpResponse.getEntity();
        String content = getContent(entity);
        logger.info("Response: {}", content);
    }
    @Override
    public void failed(Exception e) {
        logger.warn("Response failed", e);
    }
    @Override
    public void cancelled() {
        logger.warn("Execution cancelled");
    }
};

JSON‑Parsing Callback (FunTester)

When the test needs to verify the response payload, the callback can parse the body into a com.alibaba.fastjson.JSONObject and store it for later assertions.

public static void executeSyncWithResponse(HttpRequestBase request, JSONObject response) {
    ClientManage.httpAsyncClient.execute(request, new FunTester(response));
}

private static class FunTester implements FutureCallback<HttpResponse> {
    private JSONObject response;
    public FunTester(JSONObject response) { this.response = response; }
    @Override
    public void completed(HttpResponse result) {
        HttpEntity entity = result.getEntity();
        String content = getContent(entity);
        response = JSON.parseObject(content);
    }
    @Override
    public void failed(Exception e) {
        logger.warn("Response failed", e);
    }
    @Override
    public void cancelled() {
        logger.warn("Execution cancelled");
    }
}

Performance Comparison Note

The three methods above (fire‑and‑forget, logging, JSON parsing) can be benchmarked against the synchronous HttpClient implementation to quantify the benefit of the NIO‑based asynchronous approach. Local services that respond instantly may mask the difference, so a realistic latency‑bound endpoint is recommended for measurement.

Illustration of the Request Model