Spring Cloud Open Feign: HttpURLConnection and Apache HttpClient

Question

When using Feign, it defaults to using HttpURLConnection. I anticipated performance improvements by switching to Apache HttpClient for connection pooling. However, in my tests, the response time actually increased. I'm curious to know what might be causing this.

The reasons why I believed that using connection pooling reduces the time for API calls are as follows:

1. Connection Reuse:

   • Connection pooling reuses TCP connections across multiple HTTP requests. Instead of establishing a new connection each time, it leverages existing active connections, avoiding the overhead of connection setup and teardown.

2. Connection Overhead Reduction:

   • Setting up and tearing down TCP connections can be time-consuming and costly. Using connection pooling ensures the continuous reuse of connections, minimizing the costs associated with connection establishment and release.

3. Concurrency Management:

   • Connection pooling can manage HTTP connections to the server concurrently from multiple users or threads. This enables multiple requests to be sent and responses received simultaneously, enhancing performance.

4. Keep-Alive Utilization:

   • Connection pooling leverages the HTTP Keep-Alive header to maintain a persistent connection with the server. This allows multiple requests to be transmitted over the same connection, reducing network latency and improving performance.

5. Resource Efficiency:

   • By reusing connections, connection pooling prevents unnecessary connection creation, leading to efficient management of system resources.

HTTP connection pooling is particularly beneficial for web applications handling multiple simultaneous HTTP requests, contributing to enhanced performance.

test case

I conducted tests for two scenarios: one using HttpURLConnection and the other with Apache HttpClient.

I added the Apache HttpClient library to my Spring Boot project and confirmed that the execute() method of Apache HttpClient is being called. Also, I confirmed PoolingHttpClientConnectionManager.class is being used.

dependencies {
    implementation 'org.springframework.boot:spring-boot-starter-web'
    implementation 'org.springframework.cloud:spring-cloud-starter-openfeign'
    implementation 'io.github.openfeign:feign-httpclient' // 

    compileOnly 'org.projectlombok:lombok'
    annotationProcessor 'org.projectlombok:lombok'
    testImplementation 'org.springframework.boot:spring-boot-starter-test'
}

test code

I measured the execution time for the two scenarios mentioned above using the following code:

@SpringBootTest
public class HttpClientTest {

    @Autowired
    TestFeignClient testFeignClient;

    @Test
    void testWithMultiThread() {
        ExecutorService executorService = Executors.newFixedThreadPool(10);

        for (int i = 0; i < 10000; i++) {
            executorService.execute(() -> {
                testFeignClient.verifyMember(1);
            });
        }

        executorService.shutdown();
        while (!executorService.isTerminated()) {
        }
    }
}

test result

default

10000 times(thread 100): 0:00:12.198

apache client

10000 times(thread 100): 0:00:15.330

I expected the time to be shorter with Apache HttpClient due to connection pooling, but in 20 test runs, Apache HttpClient took more time in the majority of cases.