HttpClient连接池工具类

工作中有时需要调用http接口，自然而然的会使用HttpClient客户端来实现：

    public static void doHttpPost(String pin) throws IOException {
        CloseableHttpClient httpClient = null;
        String url = "http://192.168.88.12:1234/userService/getUserByPin";
        HttpPost httpPost = new HttpPost(url);
        String jsonStr = "[" +
			     " \"test\", " +
			     " \""+ pin + "\"" +   
		         "]";
        try {
            httpClient = HttpClients.createDefault();
            StringEntity entity = new StringEntity(jsonStr, "utf-8");
            entity.setContentType("application/json");
            httpPost.setEntity(entity);
            
            HttpResponse httpResponse = httpClient.execute(httpPost);
            int respCode = httpResponse.getStatusLine().getStatusCode();
            LOGGER.info("The respCode is: " + respCode);
            
            if ( respCode == 200) {
                HttpEntity httpEntity = httpResponse.getEntity();
                String response = EntityUtils.toString(httpEntity);
                LOGGER.info(response);
            }
            httpPost.abort();
        } catch (Exception e) {
            LOGGER.error("Errors: " + e.getMessage());
        } finally {
        	httpClient.close();
        }
    }

但是，当调用量频繁的时候，利用HttpClients.createDefault()这种方式每次创建一个连接，比较耗时且消耗服务器资源。能不能采用连接池的方式，事先建立好一批连接，需要使用时从池子里拿一个就行，直接上代码：

import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.apache.http.client.config.RequestConfig;
import org.apache.http.impl.client.CloseableHttpClient;
import org.apache.http.impl.client.HttpClientBuilder;
import org.apache.http.impl.client.HttpClients;
import org.apache.http.impl.conn.PoolingHttpClientConnectionManager;

/**
 * 连接池工具类
 */
public class HttpPoolUtil {
	private static Log logger = LogFactory.getLog(HttpPoolUtil.class);
	
	public static final String UTF8 = "UTF-8";
	public static volatile boolean isClosed = false;
	
	public static final int maxTotalPool = 150;
	public static final int MAX_TIMEOUT = 5000;
	public static final int RequestTimeout = 2000;
	
	private static RequestConfig requestConfig;
	private static HttpClientBuilder httpClientBuilder;
	private static PoolingHttpClientConnectionManager poolConnManager;
    
    static {
        // 设置连接池  
    	poolConnManager = new PoolingHttpClientConnectionManager();  
    	poolConnManager.setMaxTotal(maxTotalPool);//设置连接池大小
    	poolConnManager.setDefaultMaxPerRoute(maxTotalPool);  
        
        RequestConfig.Builder configBuilder = RequestConfig.custom();  
        // 设置连接超时
        configBuilder.setConnectTimeout(MAX_TIMEOUT);  
        // 设置读取超时
        configBuilder.setSocketTimeout(MAX_TIMEOUT);  
        // 设置从连接池获取连接实例的超时
        configBuilder.setConnectionRequestTimeout(RequestTimeout);  
        // 在提交请求之前 测试连接是否可用 
        //configBuilder.setStaleConnectionCheckEnabled(true);  
        requestConfig = configBuilder.build();
        //
        httpClientBuilder = HttpClients.custom().setConnectionManager(poolConnManager).setDefaultRequestConfig(requestConfig);
        System.out.println(">>>>>>>>>>> PoolingHttpClientConnectionManager初始化成功 >>>>>>>>>>>");
    }  
    
    /**
     * 获取HttpClient客户端
     * @return httpClient
     */
    public static CloseableHttpClient getClient() {   
        CloseableHttpClient httpClient = HttpClients.custom()  
                .setConnectionManager(poolConnManager)
                .setDefaultRequestConfig(requestConfig)
                .build();
        if( null == httpClient){
        	httpClient = HttpClients.createDefault();
        }
        
        return httpClient;
    }
    
    /**
     * 从http连接池里获取客户端实例
     * @return httpClient
     */
    public static CloseableHttpClient getHttpClient() {   
        CloseableHttpClient httpClient = httpClientBuilder.build(); 
        if( null == httpClient ){
        	logger.info("---------HttpClients.createDefault()---------");
        	httpClient = HttpClients.createDefault();
        }
        
        return httpClient;  
    }
    
    /**
     * 关闭连接池资源
     */
    public static void closePool() {
    	if( !isClosed ){
    		isClosed = true;
    		poolConnManager.close();
    	}
    }
    
}

每次使用完要记得释放连接：httpPost.abort();

经过对比测试，使用相同机器的情况下，使用连接池方式接口调用量相较之前提升了6倍，十分明显。

转载于:https://my.oschina.net/yzuzhang/blog/1498681