httpclient pool使用工具类

package com.aisino.common.util;

import java.io.UnsupportedEncodingException;
import java.net.URLEncoder;
import java.nio.charset.CodingErrorAction;
import java.security.KeyManagementException;
import java.security.NoSuchAlgorithmException;
import java.security.cert.X509Certificate;
import java.util.ArrayList;
import java.util.List;
import java.util.Map;
import java.util.Map.Entry;

import javax.net.ssl.SSLContext;
import javax.net.ssl.TrustManager;
import javax.net.ssl.X509TrustManager;

import org.apache.http.Consts;
import org.apache.http.HttpEntity;
import org.apache.http.NameValuePair;
import org.apache.http.client.config.CookieSpecs;
import org.apache.http.client.config.RequestConfig;
import org.apache.http.client.entity.UrlEncodedFormEntity;
import org.apache.http.client.methods.CloseableHttpResponse;
import org.apache.http.client.methods.HttpGet;
import org.apache.http.client.methods.HttpPost;
import org.apache.http.config.ConnectionConfig;
import org.apache.http.config.MessageConstraints;
import org.apache.http.config.Registry;
import org.apache.http.config.RegistryBuilder;
import org.apache.http.config.SocketConfig;
import org.apache.http.conn.socket.ConnectionSocketFactory;
import org.apache.http.conn.socket.PlainConnectionSocketFactory;
import org.apache.http.conn.ssl.SSLConnectionSocketFactory;
import org.apache.http.conn.ssl.SSLContexts;
import org.apache.http.entity.StringEntity;
import org.apache.http.impl.client.CloseableHttpClient;
import org.apache.http.impl.client.HttpClients;
import org.apache.http.impl.conn.PoolingHttpClientConnectionManager;
import org.apache.http.message.BasicNameValuePair;
import org.apache.http.util.EntityUtils;
import org.apache.log4j.Logger;

import com.alibaba.fastjson.JSON;

public class HttpClientUtil {

private final static Logger logger = Logger.getLogger(HttpClientUtil.class);

private static PoolingHttpClientConnectionManager connManager = null;
private static CloseableHttpClient httpclient = null;
private static RequestConfig globalConfig = null;

static {
try {
globalConfig = RequestConfig.custom().setCookieSpec(CookieSpecs.BEST_MATCH).build();
SSLContext sslContext = SSLContexts.custom().useTLS().build();
sslContext.init(null,
new TrustManager[] { new X509TrustManager() {
public X509Certificate[] getAcceptedIssuers() {
return null;
}
public void checkClientTrusted(
X509Certificate[] certs, String authType) {
}
public void checkServerTrusted(
X509Certificate[] certs, String authType) {
}
}}, null);
Registry<ConnectionSocketFactory> socketFactoryRegistry = RegistryBuilder.<ConnectionSocketFactory>create()
.register("http", PlainConnectionSocketFactory.INSTANCE)
.register("https", new SSLConnectionSocketFactory(sslContext))
.build();

connManager = new PoolingHttpClientConnectionManager(socketFactoryRegistry);
httpclient = HttpClients.custom().setConnectionManager(connManager).build();
// Create socket configuration
SocketConfig socketConfig = SocketConfig.custom().setTcpNoDelay(true).build();
connManager.setDefaultSocketConfig(socketConfig);
// Create message constraints
MessageConstraints messageConstraints = MessageConstraints.custom()
.setMaxHeaderCount(200)
.setMaxLineLength(2000)
.build();
// Create connection configuration
ConnectionConfig connectionConfig = ConnectionConfig.custom()
.setMalformedInputAction(CodingErrorAction.IGNORE)
.setUnmappableInputAction(CodingErrorAction.IGNORE)
.setCharset(Consts.UTF_8)
.setMessageConstraints(messageConstraints)
.build();
connManager.setDefaultConnectionConfig(connectionConfig);
connManager.setMaxTotal(200);
connManager.setDefaultMaxPerRoute(20);
} catch (KeyManagementException e) {
logger.error("KeyManagementException", e);
} catch (NoSuchAlgorithmException e) {
logger.error("NoSuchAlgorithmException", e);
}
}

public static String postMapBody(String url, int timeout, Map<String, Object> map){
HttpPost post = new HttpPost(url);
try {
post.setHeader("Content-type", "application/json");
RequestConfig requestConfig = RequestConfig.custom()
.setSocketTimeout(timeout)
.setConnectTimeout(timeout)
.setConnectionRequestTimeout(timeout)
.setExpectContinueEnabled(false).build();
post.setConfig(requestConfig);

//String str1 = JsonUtil.objectToJson(map).replace("\\", "");
String str1 = JSON.toJSONString(map,false);
post.setEntity(new StringEntity(str1, Consts.UTF_8));
//logger.info("[HttpUtils Post] begin invoke url:" + url + " , params:"+str1);
CloseableHttpResponse response = httpclient.execute(post);
try {
HttpEntity entity = response.getEntity();
try {
if(entity != null){
String str = EntityUtils.toString(entity, Consts.UTF_8);
return str;
}
} finally {
if(entity != null){
entity.getContent().close();
}
}
} finally {
if(response != null){
response.close();
}
}
}catch (Exception e) {
//logger.error("Exception", e);
logger.error("[HttpUtils postMapBody], url :" + url+","+e.getClass().getName());
} finally {
post.releaseConnection();
}
return "";
}

public static String postJsonBody(String url, int timeout, String json){
HttpPost post = new HttpPost(url);
try {
post.setHeader("Content-type", "application/json");
RequestConfig requestConfig = RequestConfig.custom()
.setSocketTimeout(timeout)
.setConnectTimeout(timeout)
.setConnectionRequestTimeout(timeout)
.setExpectContinueEnabled(false).build();
post.setConfig(requestConfig);

//String str1 = JsonUtil.objectToJson(map).replace("\\", "");
post.setEntity(new StringEntity(json, Consts.UTF_8));
CloseableHttpResponse response = httpclient.execute(post);
try {
HttpEntity entity = response.getEntity();
try {
if(entity != null){
String str = EntityUtils.toString(entity, Consts.UTF_8);
return str;
}
} finally {
if(entity != null){
entity.getContent().close();
}
}
} finally {
if(response != null){
response.close();
}
}
}catch (Exception e) {
//logger.error("Exception", e);
logger.error("[HttpUtils postMapBody], url :" + url+","+e.getClass().getName());
} finally {
post.releaseConnection();
}
return "";
}

public static String executeGet(String url,int connectTimeout, int soTimeout) {
String responseString = null;
RequestConfig requestConfig = RequestConfig.custom().setSocketTimeout(connectTimeout).setConnectTimeout(connectTimeout).setConnectionRequestTimeout(connectTimeout).build();
//logger.info("[HttpUtils Get] begin invoke:" + url);
HttpGet get = new HttpGet(url);
get.setConfig(requestConfig);
try {
CloseableHttpResponse response = httpclient.execute(get);
try {
HttpEntity entity = response.getEntity();
try {
if(entity != null){
responseString = EntityUtils.toString(entity, Consts.UTF_8);
return responseString;
}
} finally {
if(entity != null){
entity.getContent().close();
}
}
} catch (Exception e) {
//logger.error(String.format("[HttpUtils Get]get response error, url:%s", url), e);
//logger.error("[HttpUtils Get] begin invoke url:" + url);
logger.error("[HttpUtils executeGet], url :" + url+","+e.getClass().getName());
} finally {
if(response != null){
response.close();
}
}
//logger.info(String.format("[HttpUtils Get]Debug url:%s , response string %s:", sb.toString(), responseString));
}catch (Exception e) {
//logger.error(String.format("[HttpUtils Get]invoke get error, url:%s", url), e);
logger.error("[HttpUtils executeGet], url :" + url+","+e.getClass().getName());
} finally {
get.releaseConnection();
}
return "";
}

public static String cookieGet(String url) {
String responseString = null;
RequestConfig requestConfig = RequestConfig
.copy(globalConfig)
.setSocketTimeout(connectTimeout)
.setConnectTimeout(connectTimeout)
.setConnectionRequestTimeout(connectTimeout)
.setCookieSpec(CookieSpecs.BROWSER_COMPATIBILITY)
.build();
//logger.info("[HttpUtils Get] begin invoke:" + url);
HttpGet get = new HttpGet(url);
get.setConfig(requestConfig);
try {
CloseableHttpResponse response = httpclient.execute(get);
try {
HttpEntity entity = response.getEntity();
try {
if(entity != null){
responseString = EntityUtils.toString(entity, Consts.UTF_8);
return responseString;
}
} finally {
if(entity != null){
entity.getContent().close();
}
}
} catch (Exception e) {
logger.error("[HttpUtils cookieGet], url :" + url+","+e.getClass().getName());
//logger.error(String.format("[HttpUtils Get]get response error, url:%s", url), e);
} finally {
if(response != null){
response.close();
}
}
//logger.info(String.format("[HttpUtils Get]Debug url:%s , response string %s:", sb.toString(), responseString));
} catch (Exception e) {
logger.error("[HttpUtils cookieGet], url :" + url+","+e.getClass().getName());
} finally {
get.releaseConnection();
}
return "";
}

@SuppressWarnings("deprecation")
public static String invokeGet(String url, Map<String, String> params, int connectTimeout, int soTimeout) {
String responseString = null;
RequestConfig requestConfig = RequestConfig.custom()
.setSocketTimeout(connectTimeout)
.setConnectTimeout(connectTimeout)
.setConnectionRequestTimeout(connectTimeout).build();

StringBuilder sb = new StringBuilder();
sb.append(url);
int i = 0;
for (Entry<String, String> entry : params.entrySet()) {
String value = entry.getValue();
if (value==null){
continue;
}
if (i == 0 && !url.contains("?")) {
sb.append("?");
} else {
sb.append("&");
}
sb.append(entry.getKey());
sb.append("=");
try {
sb.append(URLEncoder.encode(value, "UTF-8"));
} catch (UnsupportedEncodingException e) {
logger.warn("encode http get params error, value is "+value, e);
sb.append(URLEncoder.encode(value));
}
i++;
}
//logger.info("[HttpUtils Get] begin invoke:" + sb.toString());
HttpGet get = new HttpGet(sb.toString());
get.setConfig(requestConfig);

try {
CloseableHttpResponse response = httpclient.execute(get);
try {
HttpEntity entity = response.getEntity();
try {
if(entity != null){
responseString = EntityUtils.toString(entity, Consts.UTF_8);
return responseString;
}
} finally {
if(entity != null){
entity.getContent().close();
}
}
} catch (Exception e) {
logger.error("[HttpUtils invokeGet], url :" + url+","+e.getClass().getName());
} finally {
if(response != null){
response.close();
}
}
//logger.info(String.format("[HttpUtils Get]Debug url:%s , response string %s:", sb.toString(), responseString));
} catch (Exception e) {
logger.error("[HttpUtils invokeGet], url :" + url+","+e.getClass().getName());
} finally {
get.releaseConnection();
}
return "";
}

public final static int connectTimeout = 5000;
/**
* HTTPS请求，默认超时为5S
* @param reqURL
* @param params
* @return
*/
public static String connectPostHttps(String reqURL, Map<String, String> params) {

String responseContent = null;

HttpPost httpPost = new HttpPost(reqURL);
try {
RequestConfig requestConfig = RequestConfig.custom()
.setSocketTimeout(connectTimeout)
.setConnectTimeout(connectTimeout)
.setConnectionRequestTimeout(connectTimeout).build();

List<NameValuePair> formParams = new ArrayList<NameValuePair>();
// 绑定到请求 Entry
for (Map.Entry<String, String> entry : params.entrySet()) {
formParams.add(new BasicNameValuePair(entry.getKey(), entry.getValue()));
}
httpPost.setEntity(new UrlEncodedFormEntity(formParams, Consts.UTF_8));
httpPost.setConfig(requestConfig);
CloseableHttpResponse response = httpclient.execute(httpPost);
try {
// 执行POST请求
HttpEntity entity = response.getEntity(); // 获取响应实体
try {
if (null != entity) {
responseContent = EntityUtils.toString(entity, Consts.UTF_8);
return responseContent;
}
} finally {
if(entity != null){
entity.getContent().close();
}
}
} finally {
if(response != null){
response.close();
}
}
//logger.info("requestURI : "+httpPost.getURI()+", responseContent: " + responseContent);
} catch (Exception e) {
logger.error("[HttpUtils connectPostHttps], url :" + reqURL+","+e.getClass().getName());
} finally {
httpPost.releaseConnection();
}
return "";
}
}