Desired features: Apache Http support for caching etags using Hazelcast cache and metrics

I have worked on an HTTP client where I am calling a remote service, which uses ETags. I needed to cache the etags but I did not want to implement the whole logic.

We also use metrics to determine/graph client calls, etc.

I could not find a readily available solution with Hazelcast, but with EhCache.

The classes which would be desirable are the equivalent of:

• com.codahale.metrics.ehcache.InstrumentedEhcache (metrics) See https://metrics.dropwizard.io/3.1.0/apidocs/com/codahale/metrics/ehcache/InstrumentedEhcache.html
• org.apache.http.impl.client.cache.ehcache.EhcacheHttpCacheStorage (does the HTTP etags caching). See https://hc.apache.org/httpcomponents-client-ga/httpclient-cache/apidocs/org/apache/http/impl/client/cache/ehcache/EhcacheHttpCacheStorage.html
• org.springframework.cache.ehcache.EhCacheManagerFactoryBean See https://docs.spring.io/spring/docs/current/javadoc-api/org/springframework/cache/ehcache/EhCacheManagerFactoryBean.html

What follows is part of a Java @Configuration class, where it shows how the Java beans that I am using from ehcache are connected to apache HttpClient.

---

import com.codahale.metrics.MetricRegistry;
import com.codahale.metrics.ehcache.InstrumentedEhcache;

import org.apache.http.client.HttpClient;
import org.apache.http.client.cache.HttpCacheStorage;
import org.apache.http.client.config.RequestConfig;
import org.apache.http.config.ConnectionConfig;
import org.apache.http.conn.HttpClientConnectionManager;
import org.apache.http.impl.client.CloseableHttpClient;
import org.apache.http.impl.client.HttpClientBuilder;
import org.apache.http.impl.client.cache.CacheConfig;
import org.apache.http.impl.client.cache.CachingHttpClientBuilder;
import org.apache.http.impl.client.cache.ehcache.EhcacheHttpCacheStorage;
import org.apache.http.impl.conn.PoolingHttpClientConnectionManager;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.cache.ehcache.EhCacheManagerFactoryBean;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.Import;
 

@Bean
CacheConfig cacheConfig() {
    return CacheConfig
            .custom()
            .setMaxCacheEntries((catalogCacheSize == null) ? 1024 : catalogCacheSize)
            .build();
}
 
@Bean
HttpCacheStorage httpCacheStorage(@Qualifier("ehCacheCacheManager") final EhCacheManagerFactoryBean ehCacheCacheManager, final MetricRegistry metricRegistry) {
    final net.sf.ehcache.CacheManager cacheManager = ehCacheCacheManager.getObject();
    final net.sf.ehcache.Cache ehCache = cacheManager.getCache(appId + "-catalogCache");
    if (ehCache != null) {
        final net.sf.ehcache.Ehcache decoratedCache = InstrumentedEhcache.instrument(metricRegistry, ehCache);
        cacheManager.replaceCacheWithDecoratedCache(ehCache, decoratedCache);
    }
    return (new EhcacheHttpCacheStorage(cacheManager.getEhcache(appId + "-catalogCache")));
}

private CloseableHttpClient getHttpClient(final MetricRegistry metricRegistry,
                                          final CacheConfig cacheConfig,
                                          final HttpCacheStorage httpCacheStorage,
                                          final HttpClientConnectionManager connectionManager,
                                          final int socketTimeout,
                                          final int connectionTimeout,
                                          final int connectionRequestTimeout,
                                          final boolean redirectsEnabled,
                                          final String name) {
    final ConnectionConfig connectionConfig = ConnectionConfig.copy(ConnectionConfig.DEFAULT)
                                                              .setCharset(UTF_8)
                                                              .build();

    final RequestConfig requestConfig = RequestConfig.copy(RequestConfig.DEFAULT)
                                                     .setSocketTimeout(socketTimeout)
                                                     .setConnectTimeout(connectionTimeout)
                                                     .setConnectionRequestTimeout(connectionRequestTimeout)
                                                     .build();

    HttpClientBuilder builder = CachingHttpClientBuilder.create()
                                                        .setCacheConfig(cacheConfig)
                                                        .setHttpCacheStorage(httpCacheStorage)
                                                       .useSystemProperties()
                                                        .setConnectionManager(connectionManager)
                                                        .disableRedirectHandling()
                                                        .setDefaultConnectionConfig(connectionConfig)
                                                        .setDefaultRequestConfig(requestConfig)
                                                        .disableAutomaticRetries();
    if (!redirectsEnabled) {
        builder = builder.disableRedirectHandling();
    }
    return new XXXXHttpClient(builder.build(), metricRegistry, null, Optional.fromNullable(name));
}