HTTP Client Management

/**
 * Factory interface for creating Apache HTTP clients
 */
public interface ApacheHttpClientFactory {
    /**
     * Create an HttpClientBuilder with default configuration
     * @return A configured HttpClientBuilder
     */
    HttpClientBuilder createBuilder();
    
    /**
     * Create a CloseableHttpClient with default configuration
     * @return A configured CloseableHttpClient
     */
    CloseableHttpClient createHttpClient();
}

/**
 * Default implementation of Apache HTTP client factory
 */
public class DefaultApacheHttpClientFactory implements ApacheHttpClientFactory {
    /**
     * Create factory with default configuration
     */
    public DefaultApacheHttpClientFactory();
    
    /**
     * Create factory with custom connection manager factory
     * @param connectionManagerFactory The connection manager factory
     */
    public DefaultApacheHttpClientFactory(ApacheHttpClientConnectionManagerFactory connectionManagerFactory);
    
    @Override
    public HttpClientBuilder createBuilder() {
        // Returns configured HttpClientBuilder
    }
    
    @Override  
    public CloseableHttpClient createHttpClient() {
        // Returns configured CloseableHttpClient
    }
}

@Configuration
public class HttpClientConfig {
    
    @Bean
    public ApacheHttpClientFactory apacheHttpClientFactory() {
        return new DefaultApacheHttpClientFactory();
    }
    
    @Bean
    public CloseableHttpClient httpClient(ApacheHttpClientFactory factory) {
        return factory.createHttpClient();
    }
    
    @Bean
    public RestTemplate restTemplate(CloseableHttpClient httpClient) {
        HttpComponentsClientHttpRequestFactory factory = 
            new HttpComponentsClientHttpRequestFactory(httpClient);
        return new RestTemplate(factory);
    }
}

@Service
public class HttpService {
    
    @Autowired
    private ApacheHttpClientFactory httpClientFactory;
    
    public void makeCustomRequest() {
        try (CloseableHttpClient client = httpClientFactory.createHttpClient()) {
            HttpGet request = new HttpGet("https://api.example.com/data");
            
            try (CloseableHttpResponse response = client.execute(request)) {
                // Process response
                String content = EntityUtils.toString(response.getEntity());
                System.out.println(content);
            }
        } catch (IOException e) {
            // Handle exception
        }
    }
}

/**
 * Factory for creating Apache HTTP connection managers
 */
public interface ApacheHttpClientConnectionManagerFactory {
    /**
     * Create a connection manager
     * @return A configured connection manager
     */
    HttpClientConnectionManager newConnectionManager();
    
    /**
     * Create a connection manager with SSL context support
     * @param disableSslValidation Whether to disable SSL validation
     * @param maxTotalConnections Maximum total connections
     * @param maxConnectionsPerRoute Maximum connections per route
     * @return A configured connection manager
     */
    HttpClientConnectionManager newConnectionManager(boolean disableSslValidation, 
                                                   int maxTotalConnections, 
                                                   int maxConnectionsPerRoute);
    
    /**
     * Create a connection manager with custom timeouts
     * @param disableSslValidation Whether to disable SSL validation
     * @param maxTotalConnections Maximum total connections
     * @param maxConnectionsPerRoute Maximum connections per route  
     * @param timeToLive Connection time to live
     * @param timeUnit Time unit for time to live
     * @return A configured connection manager
     */
    HttpClientConnectionManager newConnectionManager(boolean disableSslValidation,
                                                   int maxTotalConnections,
                                                   int maxConnectionsPerRoute,
                                                   long timeToLive,
                                                   TimeUnit timeUnit);
    
    /**
     * Create a connection manager with registry and timeouts
     * @param disableSslValidation Whether to disable SSL validation
     * @param maxTotalConnections Maximum total connections
     * @param maxConnectionsPerRoute Maximum connections per route
     * @param timeToLive Connection time to live
     * @param timeUnit Time unit for time to live
     * @param registryBuilder Registry builder for connection socket factories
     * @return A configured connection manager
     */
    HttpClientConnectionManager newConnectionManager(boolean disableSslValidation,
                                                   int maxTotalConnections,
                                                   int maxConnectionsPerRoute,
                                                   long timeToLive,
                                                   TimeUnit timeUnit,
                                                   RegistryBuilder registryBuilder);
}

/**
 * Default implementation of Apache connection manager factory
 */
public class DefaultApacheHttpClientConnectionManagerFactory 
    implements ApacheHttpClientConnectionManagerFactory {
    
    /**
     * Create factory with default configuration
     */
    public DefaultApacheHttpClientConnectionManagerFactory();
    
    @Override
    public HttpClientConnectionManager newConnectionManager() {
        return newConnectionManager(false, 200, 20);
    }
    
    @Override
    public HttpClientConnectionManager newConnectionManager(boolean disableSslValidation,
                                                          int maxTotalConnections,
                                                          int maxConnectionsPerRoute) {
        return newConnectionManager(disableSslValidation, maxTotalConnections, 
                                  maxConnectionsPerRoute, -1, TimeUnit.MILLISECONDS);
    }
    
    // Additional overloaded methods implemented
}

/**
 * Factory interface for creating OkHttp clients
 */
public interface OkHttpClientFactory {
    /**
     * Create an OkHttpClient.Builder with default configuration
     * @param disableSslValidation Whether to disable SSL validation
     * @return A configured OkHttpClient.Builder
     */
    OkHttpClient.Builder createBuilder(boolean disableSslValidation);
    
    /**
     * Create an OkHttpClient with default configuration
     * @return A configured OkHttpClient
     */
    OkHttpClient createHttpClient();
}

/**
 * Default implementation of OkHttp client factory  
 */
public class DefaultOkHttpClientFactory implements OkHttpClientFactory {
    /**
     * Create factory with default configuration
     */
    public DefaultOkHttpClientFactory();
    
    /**
     * Create factory with custom connection pool factory
     * @param connectionPoolFactory The connection pool factory
     */
    public DefaultOkHttpClientFactory(OkHttpClientConnectionPoolFactory connectionPoolFactory);
    
    @Override
    public OkHttpClient.Builder createBuilder(boolean disableSslValidation) {
        // Returns configured OkHttpClient.Builder
    }
    
    @Override
    public OkHttpClient createHttpClient() {
        // Returns configured OkHttpClient
    }
}

@Configuration
public class OkHttpConfig {
    
    @Bean
    public OkHttpClientFactory okHttpClientFactory() {
        return new DefaultOkHttpClientFactory();
    }
    
    @Bean
    public OkHttpClient okHttpClient(OkHttpClientFactory factory) {
        return factory.createHttpClient();
    }
}

@Service
public class OkHttpService {
    
    @Autowired
    private OkHttpClientFactory okHttpClientFactory;
    
    public void makeRequest() {
        OkHttpClient client = okHttpClientFactory.createHttpClient();
        
        Request request = new Request.Builder()
            .url("https://api.example.com/data")
            .build();
        
        try (Response response = client.newCall(request).execute()) {
            if (response.isSuccessful()) {
                String content = response.body().string();
                System.out.println(content);
            }
        } catch (IOException e) {
            // Handle exception
        }
    }
    
    public void makeCustomRequest() {
        OkHttpClient.Builder builder = okHttpClientFactory.createBuilder(false);
        
        // Customize the client
        OkHttpClient client = builder
            .connectTimeout(30, TimeUnit.SECONDS)
            .readTimeout(30, TimeUnit.SECONDS)
            .addInterceptor(new LoggingInterceptor())
            .build();
        
        // Use customized client
        Request request = new Request.Builder()
            .url("https://api.example.com/data")
            .build();
        
        try (Response response = client.newCall(request).execute()) {
            // Process response
        } catch (IOException e) {
            // Handle exception
        }
    }
}

/**
 * Factory for creating OkHttp connection pools
 */
public interface OkHttpClientConnectionPoolFactory {
    /**
     * Create a connection pool
     * @param maxIdleConnections Maximum idle connections
     * @param keepAliveDuration Keep alive duration
     * @param timeUnit Time unit for keep alive duration
     * @return A configured ConnectionPool
     */
    ConnectionPool create(int maxIdleConnections, long keepAliveDuration, TimeUnit timeUnit);
}

/**
 * Default implementation of OkHttp connection pool factory
 */
public class DefaultOkHttpClientConnectionPoolFactory implements OkHttpClientConnectionPoolFactory {
    /**
     * Create factory with default configuration
     */
    public DefaultOkHttpClientConnectionPoolFactory();
    
    @Override
    public ConnectionPool create(int maxIdleConnections, long keepAliveDuration, TimeUnit timeUnit) {
        return new ConnectionPool(maxIdleConnections, keepAliveDuration, timeUnit);
    }
}

/**
 * Auto-configuration for HTTP client factories
 */
@Configuration
@ConditionalOnClass({CloseableHttpClient.class})
public class HttpClientConfiguration {
    
    /**
     * Apache HTTP client factory configuration
     */
    @Configuration
    @ConditionalOnProperty(name = "spring.cloud.httpclientfactories.apache.enabled", 
                          matchIfMissing = true)
    protected static class ApacheHttpClientFactoryConfiguration {
        
        @Bean
        @ConditionalOnMissingBean
        public ApacheHttpClientConnectionManagerFactory connectionManagerFactory() {
            return new DefaultApacheHttpClientConnectionManagerFactory();
        }
        
        @Bean
        @ConditionalOnMissingBean
        public ApacheHttpClientFactory apacheHttpClientFactory(
            ApacheHttpClientConnectionManagerFactory connectionManagerFactory) {
            return new DefaultApacheHttpClientFactory(connectionManagerFactory);
        }
    }
    
    /**
     * OkHttp client factory configuration
     */
    @Configuration
    @ConditionalOnClass(OkHttpClient.class)
    @ConditionalOnProperty(name = "spring.cloud.httpclientfactories.ok.enabled", 
                          matchIfMissing = true)
    protected static class OkHttpClientFactoryConfiguration {
        
        @Bean
        @ConditionalOnMissingBean
        public OkHttpClientConnectionPoolFactory connectionPoolFactory() {
            return new DefaultOkHttpClientConnectionPoolFactory();
        }
        
        @Bean
        @ConditionalOnMissingBean
        public OkHttpClientFactory okHttpClientFactory(
            OkHttpClientConnectionPoolFactory connectionPoolFactory) {
            return new DefaultOkHttpClientFactory(connectionPoolFactory);
        }
    }
}

# Apache HTTP client factory
spring.cloud.httpclientfactories.apache.enabled=true

# OkHttp client factory  
spring.cloud.httpclientfactories.ok.enabled=true

# Connection pool settings (implementation-specific)
spring.cloud.httpclient.connection-pool.max-total=200
spring.cloud.httpclient.connection-pool.default-max-per-route=20
spring.cloud.httpclient.connection-pool.time-to-live=900
spring.cloud.httpclient.connection-pool.time-to-live-unit=seconds

# SSL settings
spring.cloud.httpclient.ssl.trust-store=classpath:truststore.jks
spring.cloud.httpclient.ssl.trust-store-password=password
spring.cloud.httpclient.ssl.key-store=classpath:keystore.jks
spring.cloud.httpclient.ssl.key-store-password=password

@Configuration
public class CustomHttpClientConfig {
    
    @Bean
    public ApacheHttpClientFactory customApacheHttpClientFactory() {
        return new ApacheHttpClientFactory() {
            @Override
            public HttpClientBuilder createBuilder() {
                return HttpClients.custom()
                    .setConnectionManager(createCustomConnectionManager())
                    .setDefaultRequestConfig(createRequestConfig())
                    .setRetryHandler(createRetryHandler());
            }
            
            @Override
            public CloseableHttpClient createHttpClient() {
                return createBuilder().build();
            }
            
            private HttpClientConnectionManager createCustomConnectionManager() {
                try {
                    SSLContextBuilder sslContextBuilder = SSLContexts.custom();
                    sslContextBuilder.loadTrustMaterial(null, (x509Certificates, s) -> true);
                    
                    PoolingHttpClientConnectionManager connectionManager = 
                        new PoolingHttpClientConnectionManager(
                            RegistryBuilder.<ConnectionSocketFactory>create()
                                .register("http", PlainConnectionSocketFactory.getSocketFactory())
                                .register("https", new SSLConnectionSocketFactory(sslContextBuilder.build()))
                                .build()
                        );
                    
                    connectionManager.setMaxTotal(100);
                    connectionManager.setDefaultMaxPerRoute(20);
                    
                    return connectionManager;
                } catch (Exception e) {
                    throw new RuntimeException("Failed to create connection manager", e);
                }
            }
            
            private RequestConfig createRequestConfig() {
                return RequestConfig.custom()
                    .setConnectTimeout(5000)
                    .setSocketTimeout(10000)
                    .setConnectionRequestTimeout(5000)
                    .build();
            }
            
            private HttpRequestRetryHandler createRetryHandler() {
                return (exception, executionCount, context) -> {
                    if (executionCount >= 3) {
                        return false;
                    }
                    if (exception instanceof InterruptedIOException) {
                        return false;
                    }
                    if (exception instanceof UnknownHostException) {
                        return false;
                    }
                    if (exception instanceof SSLException) {
                        return false;
                    }
                    return true;
                };
            }
        };
    }
}

@Configuration
public class CustomOkHttpConfig {
    
    @Bean
    public OkHttpClientFactory customOkHttpClientFactory() {
        return new OkHttpClientFactory() {
            @Override
            public OkHttpClient.Builder createBuilder(boolean disableSslValidation) {
                OkHttpClient.Builder builder = new OkHttpClient.Builder()
                    .connectTimeout(30, TimeUnit.SECONDS)
                    .readTimeout(30, TimeUnit.SECONDS)
                    .writeTimeout(30, TimeUnit.SECONDS)
                    .connectionPool(new ConnectionPool(50, 5, TimeUnit.MINUTES))
                    .addInterceptor(new LoggingInterceptor())
                    .addInterceptor(new RetryInterceptor());
                
                if (disableSslValidation) {
                    disableSslVerification(builder);
                }
                
                return builder;
            }
            
            @Override
            public OkHttpClient createHttpClient() {
                return createBuilder(false).build();
            }
            
            private void disableSslVerification(OkHttpClient.Builder builder) {
                try {
                    TrustManager[] trustAllCerts = new TrustManager[]{
                        new X509TrustManager() {
                            @Override
                            public void checkClientTrusted(X509Certificate[] chain, String authType) {}
                            
                            @Override
                            public void checkServerTrusted(X509Certificate[] chain, String authType) {}
                            
                            @Override
                            public X509Certificate[] getAcceptedIssuers() {
                                return new X509Certificate[]{};
                            }
                        }
                    };
                    
                    SSLContext sslContext = SSLContext.getInstance("SSL");
                    sslContext.init(null, trustAllCerts, new java.security.SecureRandom());
                    
                    builder.sslSocketFactory(sslContext.getSocketFactory(), (X509TrustManager) trustAllCerts[0]);
                    builder.hostnameVerifier((hostname, session) -> true);
                } catch (Exception e) {
                    throw new RuntimeException("Failed to disable SSL verification", e);
                }
            }
        };
    }
}