# Apache HttpComponents Client

Apache HttpComponents Client is a comprehensive Java library for building HTTP client applications with support for HTTP/1.1, HTTP/2, and modern web standards. The library provides a robust, thread-safe foundation for executing HTTP requests with extensive configuration options including connection pooling, authentication, caching, and both synchronous and asynchronous execution models. Built on top of Apache HttpCore, it implements RFC-compliant HTTP protocols with production-ready features like automatic retry handling, redirect management, cookie support, and sophisticated credential management.

The client architecture uses a builder pattern for configuration, supports customization through interceptors and strategies, and offers three distinct API levels: a classic synchronous API for blocking I/O, an async API for non-blocking operations, and a fluent API for simplified request construction. With modules for caching (RFC 9111 compliant), connection pooling, authentication schemes (Basic, Digest, Bearer, Kerberos, NTLM), and protocol observation, it serves as a complete HTTP client solution for Java applications requiring reliable, high-performance HTTP communication.

## Create Basic HTTP Client

Factory method for creating a default HTTP client with standard configuration.

```java
import org.apache.hc.client5.http.classic.methods.HttpGet;
import org.apache.hc.client5.http.impl.classic.CloseableHttpClient;
import org.apache.hc.client5.http.impl.classic.HttpClients;
import org.apache.hc.core5.http.io.entity.EntityUtils;

public class BasicClientExample {
    public static void main(String[] args) throws Exception {
        // Create default client with standard settings
        try (CloseableHttpClient httpclient = HttpClients.createDefault()) {
            HttpGet httpget = new HttpGet("http://httpbin.org/get");

            // Execute with response handler for automatic resource cleanup
            String result = httpclient.execute(httpget, response -> {
                System.out.println("Status: " + response.getCode());
                return EntityUtils.toString(response.getEntity());
            });

            System.out.println("Response body: " + result);
        }
    }
}
```

## Configure Custom HTTP Client

Builder pattern for comprehensive client customization including connection pooling, timeouts, and protocol settings.

```java
import org.apache.hc.client5.http.config.ConnectionConfig;
import org.apache.hc.client5.http.config.RequestConfig;
import org.apache.hc.client5.http.impl.classic.CloseableHttpClient;
import org.apache.hc.client5.http.impl.classic.HttpClients;
import org.apache.hc.client5.http.impl.io.PoolingHttpClientConnectionManager;
import org.apache.hc.client5.http.impl.io.PoolingHttpClientConnectionManagerBuilder;
import org.apache.hc.core5.http.config.Http1Config;
import org.apache.hc.core5.http.io.SocketConfig;
import org.apache.hc.core5.util.TimeValue;
import org.apache.hc.core5.util.Timeout;

public class CustomClientExample {
    public static void main(String[] args) throws Exception {
        // Configure HTTP/1.1 protocol settings
        Http1Config h1Config = Http1Config.custom()
                .setMaxHeaderCount(200)
                .setMaxLineLength(2000)
                .build();

        // Create connection pool with custom configuration
        PoolingHttpClientConnectionManager connManager =
                PoolingHttpClientConnectionManagerBuilder.create()
                .build();

        // Configure socket settings
        connManager.setDefaultSocketConfig(SocketConfig.custom()
                .setTcpNoDelay(true)
                .build());

        // Configure connection behavior
        connManager.setDefaultConnectionConfig(ConnectionConfig.custom()
                .setConnectTimeout(Timeout.ofSeconds(30))
                .setSocketTimeout(Timeout.ofSeconds(30))
                .setValidateAfterInactivity(TimeValue.ofSeconds(10))
                .setTimeToLive(TimeValue.ofHours(1))
                .build());

        // Set connection pool limits
        connManager.setMaxTotal(100);
        connManager.setDefaultMaxPerRoute(10);

        // Create global request configuration
        RequestConfig defaultRequestConfig = RequestConfig.custom()
                .setConnectionRequestTimeout(Timeout.ofSeconds(5))
                .setResponseTimeout(Timeout.ofSeconds(30))
                .setRedirectsEnabled(true)
                .setMaxRedirects(5)
                .build();

        // Build client with custom configuration
        try (CloseableHttpClient httpclient = HttpClients.custom()
                .setConnectionManager(connManager)
                .setDefaultRequestConfig(defaultRequestConfig)
                .build()) {

            String result = httpclient.execute(
                new HttpGet("http://httpbin.org/get"),
                response -> EntityUtils.toString(response.getEntity())
            );
            System.out.println(result);
        }
    }
}
```

## HTTP Authentication

Credentials provider for automatic authentication with configurable schemes.

```java
import org.apache.hc.client5.http.auth.AuthScope;
import org.apache.hc.client5.http.auth.UsernamePasswordCredentials;
import org.apache.hc.client5.http.classic.methods.HttpGet;
import org.apache.hc.client5.http.impl.auth.CredentialsProviderBuilder;
import org.apache.hc.client5.http.impl.classic.CloseableHttpClient;
import org.apache.hc.client5.http.impl.classic.HttpClients;
import org.apache.hc.core5.http.HttpHost;
import org.apache.hc.core5.http.io.entity.EntityUtils;
import org.apache.hc.core5.http.message.StatusLine;

public class AuthenticationExample {
    public static void main(String[] args) throws Exception {
        // Create credentials provider with username/password
        try (CloseableHttpClient httpclient = HttpClients.custom()
                .setDefaultCredentialsProvider(CredentialsProviderBuilder.create()
                        .add(new HttpHost("httpbin.org", 80), "user", "passwd".toCharArray())
                        .build())
                .build()) {

            HttpGet httpget = new HttpGet("http://httpbin.org/basic-auth/user/passwd");

            System.out.println("Executing request " + httpget.getMethod() + " " + httpget.getUri());
            httpclient.execute(httpget, response -> {
                System.out.println("----------------------------------------");
                System.out.println(httpget + "->" + new StatusLine(response));
                System.out.println("Response: " + EntityUtils.toString(response.getEntity()));
                return null;
            });
        }
    }
}
```

## Asynchronous HTTP Requests

Non-blocking async client with Future-based callbacks for concurrent request execution.

```java
import org.apache.hc.client5.http.async.methods.SimpleHttpRequest;
import org.apache.hc.client5.http.async.methods.SimpleHttpResponse;
import org.apache.hc.client5.http.async.methods.SimpleRequestBuilder;
import org.apache.hc.client5.http.async.methods.SimpleRequestProducer;
import org.apache.hc.client5.http.async.methods.SimpleResponseConsumer;
import org.apache.hc.client5.http.impl.async.CloseableHttpAsyncClient;
import org.apache.hc.client5.http.impl.async.HttpAsyncClients;
import org.apache.hc.core5.concurrent.FutureCallback;
import org.apache.hc.core5.http.HttpHost;
import org.apache.hc.core5.http.message.StatusLine;
import org.apache.hc.core5.io.CloseMode;
import org.apache.hc.core5.reactor.IOReactorConfig;
import org.apache.hc.core5.util.Timeout;

import java.util.concurrent.Future;

public class AsyncClientExample {
    public static void main(String[] args) throws Exception {
        // Configure I/O reactor for async operations
        IOReactorConfig ioReactorConfig = IOReactorConfig.custom()
                .setSoTimeout(Timeout.ofSeconds(5))
                .build();

        CloseableHttpAsyncClient client = HttpAsyncClients.custom()
                .setIOReactorConfig(ioReactorConfig)
                .build();

        // Start async client
        client.start();

        HttpHost target = new HttpHost("httpbin.org");
        String[] requestUris = new String[] {"/", "/ip", "/user-agent", "/headers"};

        for (String requestUri : requestUris) {
            SimpleHttpRequest request = SimpleRequestBuilder.get()
                    .setHttpHost(target)
                    .setPath(requestUri)
                    .build();

            System.out.println("Executing request " + request);
            Future<SimpleHttpResponse> future = client.execute(
                    SimpleRequestProducer.create(request),
                    SimpleResponseConsumer.create(),
                    new FutureCallback<SimpleHttpResponse>() {

                        @Override
                        public void completed(SimpleHttpResponse response) {
                            System.out.println(request + "->" + new StatusLine(response));
                            System.out.println(response.getBody());
                        }

                        @Override
                        public void failed(Exception ex) {
                            System.out.println(request + "->" + ex);
                        }

                        @Override
                        public void cancelled() {
                            System.out.println(request + " cancelled");
                        }
                    });

            // Wait for completion (or handle async)
            future.get();
        }

        System.out.println("Shutting down");
        client.close(CloseMode.GRACEFUL);
    }
}
```

## Fluent API Requests

Simplified fluent interface for quick request construction and execution.

```java
import org.apache.hc.client5.http.fluent.Form;
import org.apache.hc.client5.http.fluent.Request;
import org.apache.hc.core5.http.ContentType;
import org.apache.hc.core5.http.HttpHost;
import org.apache.hc.core5.http.HttpVersion;
import org.apache.hc.core5.util.Timeout;

import java.io.File;

public class FluentApiExample {
    public static void main(String[] args) throws Exception {
        // Simple GET with timeout settings
        String content = Request.get("http://httpbin.org/get")
                .connectTimeout(Timeout.ofSeconds(1))
                .responseTimeout(Timeout.ofSeconds(5))
                .execute()
                .returnContent()
                .asString();
        System.out.println("GET response: " + content);

        // POST with custom body
        byte[] bytes = Request.post("http://httpbin.org/post")
                .useExpectContinue()
                .version(HttpVersion.HTTP_1_1)
                .bodyString("Important stuff", ContentType.DEFAULT_TEXT)
                .execute()
                .returnContent()
                .asBytes();
        System.out.println("POST response length: " + bytes.length);

        // POST form data through proxy
        Request.post("http://httpbin.org/post")
                .addHeader("X-Custom-header", "stuff")
                .viaProxy(new HttpHost("myproxy", 8080))
                .bodyForm(Form.form()
                        .add("username", "vip")
                        .add("password", "secret")
                        .build())
                .execute()
                .saveContent(new File("result.dump"));

        System.out.println("Form POST saved to file");
    }
}
```

## HTTP Caching Client

RFC 9111 compliant caching with pluggable storage backends.

```java
import org.apache.hc.client5.http.cache.CacheResponseStatus;
import org.apache.hc.client5.http.cache.HttpCacheContext;
import org.apache.hc.client5.http.classic.methods.HttpGet;
import org.apache.hc.client5.http.impl.cache.CachingHttpClients;
import org.apache.hc.client5.http.impl.classic.CloseableHttpClient;
import org.apache.hc.core5.http.io.entity.EntityUtils;

import java.io.File;

public class CachingClientExample {
    public static void main(String[] args) throws Exception {
        // Create in-memory cache client
        try (CloseableHttpClient cachingClient = CachingHttpClients.createMemoryBound()) {
            HttpCacheContext context = HttpCacheContext.create();
            HttpGet httpget = new HttpGet("http://httpbin.org/cache/3600");

            // First request - cache miss
            System.out.println("First request:");
            cachingClient.execute(httpget, context, response -> {
                System.out.println("Status: " + response.getCode());
                System.out.println("Cache status: " + context.getCacheResponseStatus());
                return EntityUtils.toString(response.getEntity());
            });

            // Second request - cache hit
            System.out.println("\nSecond request:");
            cachingClient.execute(httpget, context, response -> {
                System.out.println("Status: " + response.getCode());
                System.out.println("Cache status: " + context.getCacheResponseStatus());
                System.out.println("Is cache hit: " +
                    (context.getCacheResponseStatus() == CacheResponseStatus.CACHE_HIT));
                return EntityUtils.toString(response.getEntity());
            });
        }

        // Create file-based cache client
        File cacheDir = new File("/tmp/httpcache");
        try (CloseableHttpClient fileBasedClient = CachingHttpClients.createFileBound(cacheDir)) {
            String result = fileBasedClient.execute(
                new HttpGet("http://httpbin.org/cache/7200"),
                response -> EntityUtils.toString(response.getEntity())
            );
            System.out.println("\nFile-based cache response: " + result.substring(0, 100) + "...");
        }
    }
}
```

## Connection Pool Management

Thread-safe connection pooling with configurable limits and lifecycle management.

```java
import org.apache.hc.client5.http.HttpRoute;
import org.apache.hc.client5.http.classic.methods.HttpGet;
import org.apache.hc.client5.http.impl.classic.CloseableHttpClient;
import org.apache.hc.client5.http.impl.classic.HttpClients;
import org.apache.hc.client5.http.impl.io.PoolingHttpClientConnectionManager;
import org.apache.hc.client5.http.impl.io.PoolingHttpClientConnectionManagerBuilder;
import org.apache.hc.core5.http.HttpHost;
import org.apache.hc.core5.http.io.entity.EntityUtils;
import org.apache.hc.core5.pool.PoolStats;
import org.apache.hc.core5.util.TimeValue;

public class ConnectionPoolExample {
    public static void main(String[] args) throws Exception {
        // Create connection manager with pool configuration
        PoolingHttpClientConnectionManager connManager =
                PoolingHttpClientConnectionManagerBuilder.create().build();

        // Set total connection limit
        connManager.setMaxTotal(100);

        // Set per-route connection limit
        connManager.setDefaultMaxPerRoute(10);

        // Set specific route limit
        HttpRoute httpRoute = new HttpRoute(new HttpHost("httpbin.org", 80));
        connManager.setMaxPerRoute(httpRoute, 20);

        try (CloseableHttpClient httpclient = HttpClients.custom()
                .setConnectionManager(connManager)
                .build()) {

            // Execute request
            httpclient.execute(new HttpGet("http://httpbin.org/get"), response -> {
                EntityUtils.consume(response.getEntity());
                return null;
            });

            // Get pool statistics
            PoolStats totalStats = connManager.getTotalStats();
            System.out.println("Total connections: " + totalStats.getLeased());
            System.out.println("Available connections: " + totalStats.getAvailable());
            System.out.println("Pending connections: " + totalStats.getPending());
            System.out.println("Max connections: " + totalStats.getMax());

            // Close expired connections
            connManager.closeExpired();

            // Close idle connections after 1 minute
            connManager.closeIdle(TimeValue.ofMinutes(1));
        }
    }
}
```

## Request and Response Interceptors

Extensible interceptor chain for custom request/response processing.

```java
import org.apache.hc.client5.http.classic.methods.HttpGet;
import org.apache.hc.client5.http.impl.classic.CloseableHttpClient;
import org.apache.hc.client5.http.impl.classic.HttpClients;
import org.apache.hc.core5.http.EntityDetails;
import org.apache.hc.core5.http.HttpRequest;
import org.apache.hc.core5.http.HttpRequestInterceptor;
import org.apache.hc.core5.http.HttpResponse;
import org.apache.hc.core5.http.HttpResponseInterceptor;
import org.apache.hc.core5.http.io.entity.EntityUtils;
import org.apache.hc.core5.http.protocol.HttpContext;

public class InterceptorExample {
    public static void main(String[] args) throws Exception {
        // Custom request interceptor
        HttpRequestInterceptor requestInterceptor = new HttpRequestInterceptor() {
            @Override
            public void process(HttpRequest request, EntityDetails entity, HttpContext context) {
                System.out.println("Request interceptor: " + request.getMethod() + " " + request.getRequestUri());
                request.setHeader("X-Custom-Header", "MyCustomValue");
                request.setHeader("User-Agent", "MyCustomClient/1.0");
            }
        };

        // Custom response interceptor
        HttpResponseInterceptor responseInterceptor = new HttpResponseInterceptor() {
            @Override
            public void process(HttpResponse response, EntityDetails entity, HttpContext context) {
                System.out.println("Response interceptor: Status " + response.getCode());
                System.out.println("Content-Type: " + response.getFirstHeader("Content-Type"));
            }
        };

        // Build client with interceptors
        try (CloseableHttpClient httpclient = HttpClients.custom()
                .addRequestInterceptorFirst(requestInterceptor)
                .addResponseInterceptorLast(responseInterceptor)
                .build()) {

            String result = httpclient.execute(
                new HttpGet("http://httpbin.org/headers"),
                response -> EntityUtils.toString(response.getEntity())
            );

            System.out.println("Response body:\n" + result);
        }
    }
}
```

## Custom SSL/TLS Configuration

TLS socket strategy for custom certificate validation and protocol configuration.

```java
import org.apache.hc.client5.http.classic.methods.HttpGet;
import org.apache.hc.client5.http.config.TlsConfig;
import org.apache.hc.client5.http.impl.classic.CloseableHttpClient;
import org.apache.hc.client5.http.impl.classic.HttpClients;
import org.apache.hc.client5.http.impl.io.PoolingHttpClientConnectionManagerBuilder;
import org.apache.hc.client5.http.ssl.DefaultClientTlsStrategy;
import org.apache.hc.client5.http.ssl.TlsSocketStrategy;
import org.apache.hc.core5.http.io.entity.EntityUtils;
import org.apache.hc.core5.http.ssl.TLS;
import org.apache.hc.core5.ssl.SSLContexts;
import org.apache.hc.core5.ssl.TrustStrategy;
import org.apache.hc.core5.util.Timeout;

import javax.net.ssl.SSLContext;
import java.io.File;
import java.security.cert.X509Certificate;

public class CustomSslExample {
    public static void main(String[] args) throws Exception {
        // Option 1: Trust all certificates (NOT for production)
        SSLContext sslContext = SSLContexts.custom()
                .loadTrustMaterial(new TrustStrategy() {
                    @Override
                    public boolean isTrusted(X509Certificate[] chain, String authType) {
                        return true; // Trust all
                    }
                })
                .build();

        // Option 2: Load custom truststore
        File trustStoreFile = new File("truststore.jks");
        if (trustStoreFile.exists()) {
            sslContext = SSLContexts.custom()
                    .loadTrustMaterial(trustStoreFile, "password".toCharArray())
                    .build();
        }

        // Create TLS strategy
        TlsSocketStrategy tlsStrategy = new DefaultClientTlsStrategy(sslContext);

        // Configure TLS settings
        TlsConfig tlsConfig = TlsConfig.custom()
                .setHandshakeTimeout(Timeout.ofSeconds(30))
                .setSupportedProtocols(TLS.V_1_2, TLS.V_1_3)
                .build();

        // Build connection manager with TLS configuration
        try (CloseableHttpClient httpclient = HttpClients.custom()
                .setConnectionManager(PoolingHttpClientConnectionManagerBuilder.create()
                        .setTlsSocketStrategy(tlsStrategy)
                        .setDefaultTlsConfig(tlsConfig)
                        .build())
                .build()) {

            String result = httpclient.execute(
                new HttpGet("https://httpbin.org/get"),
                response -> {
                    System.out.println("Status: " + response.getCode());
                    return EntityUtils.toString(response.getEntity());
                }
            );

            System.out.println("Secure response: " + result.substring(0, 100) + "...");
        }
    }
}
```

## Multipart Form Data Upload

Multipart entity builder for file uploads and mixed form data.

```java
import org.apache.hc.client5.http.classic.methods.HttpPost;
import org.apache.hc.client5.http.entity.mime.MultipartEntityBuilder;
import org.apache.hc.client5.http.impl.classic.CloseableHttpClient;
import org.apache.hc.client5.http.impl.classic.HttpClients;
import org.apache.hc.core5.http.ContentType;
import org.apache.hc.core5.http.HttpEntity;
import org.apache.hc.core5.http.io.entity.EntityUtils;

import java.io.File;

public class MultipartUploadExample {
    public static void main(String[] args) throws Exception {
        try (CloseableHttpClient httpclient = HttpClients.createDefault()) {
            HttpPost httppost = new HttpPost("http://httpbin.org/post");

            // Build multipart entity
            File uploadFile = new File("document.pdf");
            HttpEntity entity = MultipartEntityBuilder.create()
                    .addTextBody("username", "john_doe")
                    .addTextBody("email", "john@example.com")
                    .addBinaryBody("file", uploadFile, ContentType.APPLICATION_OCTET_STREAM, uploadFile.getName())
                    .addTextBody("description", "Important document", ContentType.TEXT_PLAIN)
                    .build();

            httppost.setEntity(entity);

            String result = httpclient.execute(httppost, response -> {
                System.out.println("Upload status: " + response.getCode());
                System.out.println("Response reason: " + response.getReasonPhrase());
                return EntityUtils.toString(response.getEntity());
            });

            System.out.println("Server response:\n" + result);
        }
    }
}
```

## Proxy Configuration

HTTP and SOCKS proxy support with authentication.

```java
import org.apache.hc.client5.http.auth.AuthScope;
import org.apache.hc.client5.http.auth.UsernamePasswordCredentials;
import org.apache.hc.client5.http.classic.methods.HttpGet;
import org.apache.hc.client5.http.impl.auth.BasicCredentialsProvider;
import org.apache.hc.client5.http.impl.classic.CloseableHttpClient;
import org.apache.hc.client5.http.impl.classic.HttpClients;
import org.apache.hc.client5.http.impl.routing.DefaultProxyRoutePlanner;
import org.apache.hc.core5.http.HttpHost;
import org.apache.hc.core5.http.io.entity.EntityUtils;

public class ProxyExample {
    public static void main(String[] args) throws Exception {
        // Define proxy
        HttpHost proxy = new HttpHost("myproxy.example.com", 8080);

        // Configure proxy credentials if needed
        BasicCredentialsProvider credsProvider = new BasicCredentialsProvider();
        credsProvider.setCredentials(
                new AuthScope(proxy),
                new UsernamePasswordCredentials("proxy_user", "proxy_pass".toCharArray())
        );

        // Create route planner for proxy
        DefaultProxyRoutePlanner routePlanner = new DefaultProxyRoutePlanner(proxy);

        try (CloseableHttpClient httpclient = HttpClients.custom()
                .setRoutePlanner(routePlanner)
                .setDefaultCredentialsProvider(credsProvider)
                .build()) {

            String result = httpclient.execute(
                new HttpGet("http://httpbin.org/ip"),
                response -> {
                    System.out.println("Status: " + response.getCode());
                    return EntityUtils.toString(response.getEntity());
                }
            );

            System.out.println("Response via proxy:\n" + result);
        }
    }
}
```

## Custom Retry Strategy

Configurable retry logic for failed requests with exponential backoff support.

```java
import org.apache.hc.client5.http.HttpRequestRetryStrategy;
import org.apache.hc.client5.http.classic.methods.HttpGet;
import org.apache.hc.client5.http.impl.classic.CloseableHttpClient;
import org.apache.hc.client5.http.impl.classic.HttpClients;
import org.apache.hc.core5.http.HttpRequest;
import org.apache.hc.core5.http.HttpResponse;
import org.apache.hc.core5.http.io.entity.EntityUtils;
import org.apache.hc.core5.http.protocol.HttpContext;
import org.apache.hc.core5.util.TimeValue;

import javax.net.ssl.SSLException;
import java.io.IOException;
import java.io.InterruptedIOException;
import java.net.UnknownHostException;

public class RetryStrategyExample {
    public static void main(String[] args) throws Exception {
        // Custom retry strategy
        HttpRequestRetryStrategy retryStrategy = new HttpRequestRetryStrategy() {
            @Override
            public boolean retryRequest(HttpRequest request, IOException exception, int execCount, HttpContext context) {
                if (execCount > 3) {
                    return false; // Max 3 retries
                }
                if (exception instanceof InterruptedIOException) {
                    return false; // Timeout
                }
                if (exception instanceof UnknownHostException) {
                    return false; // Unknown host
                }
                if (exception instanceof SSLException) {
                    return false; // SSL handshake exception
                }
                return true; // Retry for other exceptions
            }

            @Override
            public boolean retryRequest(HttpResponse response, int execCount, HttpContext context) {
                int statusCode = response.getCode();
                // Retry on 503 Service Unavailable
                return statusCode == 503 && execCount <= 3;
            }

            @Override
            public TimeValue getRetryInterval(HttpResponse response, int execCount, HttpContext context) {
                // Exponential backoff: 1s, 2s, 4s
                return TimeValue.ofSeconds((long) Math.pow(2, execCount - 1));
            }
        };

        try (CloseableHttpClient httpclient = HttpClients.custom()
                .setRetryStrategy(retryStrategy)
                .build()) {

            String result = httpclient.execute(
                new HttpGet("http://httpbin.org/status/503"),
                response -> {
                    System.out.println("Final status: " + response.getCode());
                    return EntityUtils.toString(response.getEntity());
                }
            );

            System.out.println("Response after retries: " + result);
        } catch (IOException e) {
            System.out.println("Request failed after retries: " + e.getMessage());
        }
    }
}
```

## Cookie Management

Cookie store for persistent session management across requests.

```java
import org.apache.hc.client5.http.classic.methods.HttpGet;
import org.apache.hc.client5.http.cookie.BasicCookieStore;
import org.apache.hc.client5.http.cookie.Cookie;
import org.apache.hc.client5.http.cookie.CookieStore;
import org.apache.hc.client5.http.impl.classic.CloseableHttpClient;
import org.apache.hc.client5.http.impl.classic.HttpClients;
import org.apache.hc.client5.http.protocol.HttpClientContext;
import org.apache.hc.core5.http.io.entity.EntityUtils;

import java.util.List;

public class CookieManagementExample {
    public static void main(String[] args) throws Exception {
        // Create cookie store
        CookieStore cookieStore = new BasicCookieStore();

        try (CloseableHttpClient httpclient = HttpClients.custom()
                .setDefaultCookieStore(cookieStore)
                .build()) {

            // Create context
            HttpClientContext context = HttpClientContext.create();
            context.setCookieStore(cookieStore);

            // First request - server sets cookies
            httpclient.execute(new HttpGet("http://httpbin.org/cookies/set?session=abc123"), context, response -> {
                System.out.println("First request status: " + response.getCode());
                EntityUtils.consume(response.getEntity());
                return null;
            });

            // Print cookies
            List<Cookie> cookies = cookieStore.getCookies();
            System.out.println("\nCookies received:");
            for (Cookie cookie : cookies) {
                System.out.println("- " + cookie.getName() + " = " + cookie.getValue());
                System.out.println("  Domain: " + cookie.getDomain());
                System.out.println("  Path: " + cookie.getPath());
                System.out.println("  Expiry: " + cookie.getExpiryInstant());
            }

            // Second request - cookies sent automatically
            String result = httpclient.execute(
                new HttpGet("http://httpbin.org/cookies"),
                context,
                response -> EntityUtils.toString(response.getEntity())
            );

            System.out.println("\nSecond request response:\n" + result);
        }
    }
}
```

## Maven Dependency Configuration

Required dependencies for integrating Apache HttpClient into Java projects.

```xml
<!-- Main HTTP Client dependency -->
<dependency>
    <groupId>org.apache.httpcomponents.client5</groupId>
    <artifactId>httpclient5</artifactId>
    <version>5.0.1</version>
</dependency>

<!-- Fluent API (optional) -->
<dependency>
    <groupId>org.apache.httpcomponents.client5</groupId>
    <artifactId>httpclient5-fluent</artifactId>
    <version>5.0.1</version>
</dependency>

<!-- HTTP Caching support (optional) -->
<dependency>
    <groupId>org.apache.httpcomponents.client5</groupId>
    <artifactId>httpclient5-cache</artifactId>
    <version>5.0.1</version>
</dependency>

<!-- Windows-specific authentication (optional) -->
<dependency>
    <groupId>org.apache.httpcomponents.client5</groupId>
    <artifactId>httpclient5-win</artifactId>
    <version>5.0.1</version>
</dependency>

<!-- Core HTTP components (transitive dependency) -->
<dependency>
    <groupId>org.apache.httpcomponents.core5</groupId>
    <artifactId>httpcore5</artifactId>
    <version>5.0.1</version>
</dependency>

<!-- HTTP/2 support -->
<dependency>
    <groupId>org.apache.httpcomponents.core5</groupId>
    <artifactId>httpcore5-h2</artifactId>
    <version>5.0.1</version>
</dependency>

<!-- Logging API (required) -->
<dependency>
    <groupId>org.slf4j</groupId>
    <artifactId>slf4j-api</artifactId>
    <version>1.7.25</version>
</dependency>
```

Apache HttpComponents Client serves as a production-ready HTTP client library for Java applications requiring robust, scalable HTTP communication. Common use cases include building REST API clients, web scraping tools, microservice communication layers, and automated testing frameworks. The library excels in scenarios requiring connection pooling for high-throughput applications, sophisticated authentication flows, or compliance with HTTP caching standards. Its thread-safe design makes it ideal for multi-threaded server applications, while the async API provides high concurrency for I/O-bound operations.

Integration patterns typically involve creating a shared `CloseableHttpClient` instance configured via the builder pattern, which is then reused across the application lifecycle. For Spring applications, the client is often exposed as a singleton bean with custom connection managers and interceptors. The fluent API provides a lightweight alternative for simple use cases, while the caching module transparently optimizes bandwidth for cacheable resources. Authentication credentials can be managed globally through the credentials provider or per-request through the HTTP context, supporting complex multi-tenant scenarios with different authentication requirements per route.