Apache HttpClient Connection Management

/**
 * Represents a managed connection whose state and life cycle is managed by
 * a connection manager. This interface extends {@link HttpClientConnection}
 * with methods to bind the connection to an arbitrary socket and
 * to obtain SSL session details.
 *
 * @since 4.3
 */
public interface ManagedHttpClientConnection extends HttpClientConnection, HttpInetConnection {

    /**
     * Returns connection ID which is expected to be unique
     * for the life span of the connection manager.
     */
    String getId();

    /**
     * Binds this connection to the given socket. The connection
     * is considered open if it is bound and the underlying socket
     * is connection to a remote host.
     *
     * @param socket the socket to bind the connection to.
     * @throws IOException
     */
    void bind(Socket socket) throws IOException;

    /**
     * Returns the underlying socket.
     */
    Socket getSocket();

    /**
     * Obtains the SSL session of the underlying connection, if any.
     * If this connection is open, and the underlying socket is an
     * {@link javax.net.ssl.SSLSocket SSLSocket}, the SSL session of
     * that socket is obtained. This is a potentially blocking operation.
     *
     * @return  the underlying SSL session if available,
     *          {@code null} otherwise
     */
    SSLSession getSSLSession();

}

HttpClientContext context = HttpClientContext.create();
HttpClientConnectionManager connMrg = new BasicHttpClientConnectionManager();
HttpRoute route = new HttpRoute(new HttpHost("localhost", 80));
// Request new connection. This can be a long process
ConnectionRequest connRequest = connMrg.requestConnection(route, null);
// Wait for connection up to 10 sec
HttpClientConnection conn = connRequest.get(10, TimeUnit.SECONDS);
try {
    // If not open
    if (!conn.isOpen()) {
        // establish connection based on its route info
        connMrg.connect(conn, route, 1000, context);
        // and mark it as route complete
        connMrg.routeComplete(conn, route, context);
    }
    // Do useful things with the connection.
} finally {
    connMrg.releaseConnection(conn, null, 1, TimeUnit.MINUTES);
}

PoolingHttpClientConnectionManager cm = new PoolingHttpClientConnectionManager();
// Increase max total connection to 200
cm.setMaxTotal(200);
// Increase default max connection per route to 20
cm.setDefaultMaxPerRoute(20);
// Increase max connections for localhost:80 to 50
HttpHost localhost = new HttpHost("locahost", 80);
cm.setMaxPerRoute(new HttpRoute(localhost), 50);

CloseableHttpClient httpClient = HttpClients.custom()
        .setConnectionManager(cm)
        .build();

ConnectionKeepAliveStrategy myStrategy = new ConnectionKeepAliveStrategy() {

    public long getKeepAliveDuration(HttpResponse response, HttpContext context) {
        // Honor 'keep-alive' header
        HeaderElementIterator it = new BasicHeaderElementIterator(
                response.headerIterator(HTTP.CONN_KEEP_ALIVE));
        while (it.hasNext()) {
            HeaderElement he = it.nextElement();
            String param = he.getName();
            String value = he.getValue();
            if (value != null && param.equalsIgnoreCase("timeout")) {
                try {
                    return Long.parseLong(value) * 1000;
                } catch(NumberFormatException ignore) {
                }
            }
        }
        HttpHost target = (HttpHost) context.getAttribute(
                HttpClientContext.HTTP_TARGET_HOST);
        if ("www.naughty-server.com".equalsIgnoreCase(target.getHostName())) {
            // Keep alive for 5 seconds only
            return 5 * 1000;
        } else {
            // otherwise keep alive for 30 seconds
            return 30 * 1000;
        }
    }

};
CloseableHttpClient client = HttpClients.custom()
        .setKeepAliveStrategy(myStrategy)
        .build();

public void createHttpClient() {
    HttpClientBuilder builder = HttpClientBuilder.create();

    builder.setMaxConnPerRoute(10);
    builder.setMaxConnTotal(100);
    builder.setConnectionTimeToLive(10, TimeUnit.MINUTES);

    RequestConfig requestConfig = RequestConfig.custom()
                                               .setConnectTimeout(1000)
        									   .setConnectionRequestTimeout(1000)
                                               .setSocketTimeout(2000)
                                               .build();
    builder.setDefaultRequestConfig(requestConfig);
    CloseableHttpClient client = builder.build();
}

// HttpClientBuilder.build 메소드

final PoolingHttpClientConnectionManager poolingmgr = new PoolingHttpClientConnectionManager(
     RegistryBuilder.<ConnectionSocketFactory>create()
         .register("http", PlainConnectionSocketFactory.getSocketFactory())
         .register("https", sslSocketFactoryCopy)
         .build(),
     null,
     null,
     dnsResolver,
     connTimeToLive, // HttpClientBuilder.setConnectionTimeToLive
     connTimeToLiveTimeUnit != null ? connTimeToLiveTimeUnit : TimeUnit.MILLISECONDS);

// 생략
if (maxConnTotal > 0) {
     poolingmgr.setMaxTotal(maxConnTotal);  // HttpClientBuilder.setMaxConnTotal
 }
 if (maxConnPerRoute > 0) {
     poolingmgr.setDefaultMaxPerRoute(maxConnPerRoute); // HttpClientBuilder.setMaxConnPerRoute
 }

protected CloseableHttpResponse doExecute(
        final HttpHost target,
        final HttpRequest request,
        final HttpContext context) throws IOException, ClientProtocolException {
    
    HttpExecutionAware execAware = null;
    if (request instanceof HttpExecutionAware) {
        execAware = (HttpExecutionAware) request;
    }
    try {
        final HttpRequestWrapper wrapper = HttpRequestWrapper.wrap(request, target);
        final HttpClientContext localcontext = HttpClientContext.adapt(
                context != null ? context : new BasicHttpContext());
        RequestConfig config = null;
        
        // localcontext 세팅
        setupContext(localcontext);
        // route 결정
        final HttpRoute route = determineRoute(target, wrapper, localcontext);
        // Http 요청 보내는 부분
        return this.execChain.execute(route, wrapper, localcontext, execAware);
    } catch (final HttpException httpException) {
        throw new ClientProtocolException(httpException);
    }
}

public interface ClientExecChain {

    CloseableHttpResponse execute(
            HttpRoute route,
            HttpRequestWrapper request,
            HttpClientContext clientContext,
            HttpExecutionAware execAware) throws IOException, HttpException;

}

// MainClientExec#execute

final ConnectionRequest connRequest = connManager.requestConnection(route, userToken);

// ... 생략

final RequestConfig config = context.getRequestConfig();

final HttpClientConnection managedConn;
try {
    final int timeout = config.getConnectionRequestTimeout();
    managedConn = connRequest.get(timeout > 0 ? timeout : 0, TimeUnit.MILLISECONDS);
}

// ... 생략

if (config.isStaleConnectionCheckEnabled()) {
    // validate connection
    if (managedConn.isOpen()) {
        this.log.debug("Stale connection check");
        if (managedConn.isStale()) {
            this.log.debug("Stale connection detected");
            managedConn.close();
        }
    }
}

@Override
public ConnectionRequest requestConnection(
        final HttpRoute route,
        final Object state) {
    
    // 생략
    final Future<CPoolEntry> future = this.pool.lease(route, state, null);
    return new ConnectionRequest() {

        @Override
        public boolean cancel() {
            return future.cancel(true);
        }

        @Override
        public HttpClientConnection get(
                final long timeout,
                final TimeUnit tunit) throws InterruptedException, ExecutionException, ConnectionPoolTimeoutException {
            final HttpClientConnection conn = leaseConnection(future, timeout, tunit);
            if (conn.isOpen()) {
                final HttpHost host;
                if (route.getProxyHost() != null) {
                    host = route.getProxyHost();
                } else {
                    host = route.getTargetHost();
                }
                final SocketConfig socketConfig = resolveSocketConfig(host);
                conn.setSocketTimeout(socketConfig.getSoTimeout());
            }
            return conn;
        }
    };
}

// AbstractConnPool#lease

public E get(final long timeout, final TimeUnit tunit) throws InterruptedException, ExecutionException, TimeoutException {
    
    final E entry = entryRef.get();
    if (entry != null) {
        return entry;
    }
    
    synchronized (this) {
        try {
            for (;;) {
                // 1
                final E leasedEntry = getPoolEntryBlocking(route, state, timeout, tunit, this);
                // 2
                if (validateAfterInactivity > 0)  {
                    if (leasedEntry.getUpdated() + validateAfterInactivity <= System.currentTimeMillis()) {
                        if (!validate(leasedEntry)) {
                            leasedEntry.close();
                            release(leasedEntry, false);
                            continue;
                        }
                    }
                }
                // entryRef에 커넥션을 setting한다. get()를 중복해서 호출해도 같은 객체를 반환한다.
                entryRef.set(leasedEntry);
                done.set(true);
                // 콜백 메소드를 실행한다.
                onLease(leasedEntry);
                if (callback != null) {
                    callback.completed(leasedEntry);
                }
                return leasedEntry;
            }
        } catch (final IOException ex) {
            done.set(true);
            if (callback != null) {
                callback.failed(ex);
            }
            throw new ExecutionException(ex);
        }
    }
}