使用httpclient连接池

package com.bltx.sprider.interfaceData;

import java.io.IOException;
import java.io.InterruptedIOException;
import java.net.UnknownHostException;
import java.security.NoSuchAlgorithmException;
import javax.annotation.PostConstruct;
import javax.net.ssl.SSLContext;
import javax.net.ssl.SSLException;
import javax.net.ssl.SSLHandshakeException;
import org.apache.http.HeaderElement;
import org.apache.http.HeaderElementIterator;
import org.apache.http.HttpEntityEnclosingRequest;
import org.apache.http.HttpHost;
import org.apache.http.HttpRequest;
import org.apache.http.HttpResponse;
import org.apache.http.NoHttpResponseException;
import org.apache.http.client.HttpRequestRetryHandler;
import org.apache.http.client.protocol.HttpClientContext;
import org.apache.http.config.Registry;
import org.apache.http.config.RegistryBuilder;
import org.apache.http.conn.ConnectTimeoutException;
import org.apache.http.conn.ConnectionKeepAliveStrategy;
import org.apache.http.conn.routing.HttpRoute;
import org.apache.http.conn.socket.ConnectionSocketFactory;
import org.apache.http.conn.socket.LayeredConnectionSocketFactory;
import org.apache.http.conn.socket.PlainConnectionSocketFactory;
import org.apache.http.conn.ssl.SSLConnectionSocketFactory;
import org.apache.http.impl.client.CloseableHttpClient;
import org.apache.http.impl.client.HttpClientBuilder;
import org.apache.http.impl.client.LaxRedirectStrategy;
import org.apache.http.impl.conn.PoolingHttpClientConnectionManager;
import org.apache.http.message.BasicHeaderElementIterator;
import org.apache.http.protocol.HTTP;
import org.apache.http.protocol.HttpContext;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

/**
 * 线程连接池
 * 
 * @author ljw
 *
 */
public class HttpConnectionManager {

	private static Logger log = LoggerFactory.getLogger(HttpConnectionManager.class);

	static PoolingHttpClientConnectionManager cm = null;

	/*
	 * 初始化方法
	 */
	@PostConstruct
	public void init() {
		LayeredConnectionSocketFactory sslsf = null;
		
		try {
			sslsf = new SSLConnectionSocketFactory(SSLContext.getDefault());
		} catch (NoSuchAlgorithmException e) {
			log.error("算法错误");
			e.printStackTrace();
		}
		Registry<ConnectionSocketFactory> socketFactoryRegistry = RegistryBuilder.<ConnectionSocketFactory>create()
				.register("https", sslsf).register("http", new PlainConnectionSocketFactory()).build();
		cm = new PoolingHttpClientConnectionManager(socketFactoryRegistry);
		cm.setMaxTotal(500);// 最大连接数
		cm.setDefaultMaxPerRoute(40);// 将每个路由的默认最大连接数增加到20
		 // 将目标主机的最大连接数增加
		HttpHost localhost = new HttpHost("13.54.120.185",443);
        cm.setMaxPerRoute(new HttpRoute(localhost), 100);
      
        //HttpClientConnectionManager manager = new BasicHttpClientConnectionManager();  
		
		new IdleConnectionMonitorThread(cm).start();//启动线程，5秒钟清空一次失效连接  
	
	}
	
	 

	public static CloseableHttpClient getHttpClient() {
		
		//连接存活策略
		ConnectionKeepAliveStrategy keepAliveStrategy = 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 ("makeabooking.flyscoot.com".equalsIgnoreCase(target.getHostName())) {
	                // Keep alive for 5 seconds only
	                return 5 * 1000;
	            } else {
	                // otherwise keep alive for 30 seconds
	                return 30 * 1000;
	            }
	        }

	    };
	    
        // 请求重试处理
        HttpRequestRetryHandler httpRequestRetryHandler = new HttpRequestRetryHandler()
        {
            public boolean retryRequest(IOException exception,
                    int executionCount, HttpContext context) {
                if (executionCount >= 5) {// 如果已经重试了5次，就放弃
                   
                	log.error("已经重试了5次,放弃");
                	
                	return false;
                }
                if (exception instanceof NoHttpResponseException) {// 如果服务器丢掉了连接，那么就重试
                	
                	log.error("服务器丢掉连接");
                	
                	return true;
                }
                if (exception instanceof SSLHandshakeException) {// 不要重试SSL握手异常
                    
                	log.error("SSL握手异常");
                	
                	return false;
                }
                if (exception instanceof InterruptedIOException) {// 超时
                    
                	log.error("超时");
                	
                	return false;
                }
                if (exception instanceof UnknownHostException) {// 目标服务器不可达
                   
                	log.error("目标服务器不可达");
                	
                	return false;
                }
                if (exception instanceof ConnectTimeoutException) {// 连接被拒绝
                  
                	log.error("连接被拒绝");
                	
                	return false;
                }
                if (exception instanceof SSLException) {// SSL握手异常
                    
                	log.error("SSL异常");
                	
                	return false;
                }

                HttpClientContext clientContext = HttpClientContext
                        .adapt(context);
                HttpRequest request = clientContext.getRequest();
                // 如果请求是幂等的，就再次尝试
                if (!(request instanceof HttpEntityEnclosingRequest)) {
                    return true;
                }
                return false;
            }
        };
		
		// 创建一个httpclient实例
		HttpClientBuilder httpClientBuilder = HttpClientBuilder.create();
		// 自动处理重定向
		httpClientBuilder.disableAutomaticRetries().setRedirectStrategy(new LaxRedirectStrategy());

		HeadMessage.configureHttpClient(httpClientBuilder);// 忽略证书直接调用

		CloseableHttpClient httpclient = httpClientBuilder
				.setRetryHandler(httpRequestRetryHandler)
				.setConnectionManager(cm)
				.setKeepAliveStrategy(keepAliveStrategy)
				.build(); // 创建一个httpclient实例

		return httpclient;
	}  
}