HTTP调用工具类

package com.datalook.action.login.http;

import java.io.IOException;
import java.nio.charset.Charset;
import java.security.GeneralSecurityException;
import java.security.cert.CertificateException;
import java.security.cert.X509Certificate;
import java.util.ArrayList;
import java.util.List;
import java.util.Map;
import java.util.Set;

import javax.net.ssl.SSLContext;
import javax.net.ssl.SSLException;
import javax.net.ssl.SSLSession;
import javax.net.ssl.SSLSocket;

import net.sf.json.JSONObject;
import org.apache.http.HttpEntity;
import org.apache.http.HttpHost;
import org.apache.http.HttpResponse;
import org.apache.http.HttpStatus;
import org.apache.http.NameValuePair;
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.HttpPost;
import org.apache.http.conn.ssl.SSLConnectionSocketFactory;
import org.apache.http.conn.ssl.SSLContextBuilder;
import org.apache.http.conn.ssl.TrustStrategy;
import org.apache.http.conn.ssl.X509HostnameVerifier;
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 com.newcapec.http.HttpClientConnectionManager;
//import org.apache.log4j.Logger;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

public class HttpUlit {

private static PoolingHttpClientConnectionManager connMgr;
private static RequestConfig requestConfig;
private static final int MAX_TIMEOUT = 7000;

//public static Logger logger = Logger.getLogger(HttpUlit.class);
private static Logger log = LoggerFactory.getLogger(HttpUlit.class);
static {
    // 设置连接池
    connMgr = new PoolingHttpClientConnectionManager();
    // 设置连接池大小
    connMgr.setMaxTotal(100);
    
    connMgr.setDefaultMaxPerRoute(connMgr.getMaxTotal());

    RequestConfig.Builder configBuilder = RequestConfig.custom();
    // 设置连接超时
    configBuilder.setConnectTimeout(MAX_TIMEOUT);
    // 设置读取超时
    configBuilder.setSocketTimeout(MAX_TIMEOUT);
    // 设置从连接池获取连接实例的超时
    configBuilder.setConnectionRequestTimeout(MAX_TIMEOUT);
    // 在提交请求之前 测试连接是否可用
    configBuilder.setStaleConnectionCheckEnabled(true);
    requestConfig = configBuilder.build();
}  


/**
 * 创建SSL安全连接
 *
 * @return
 */
private static SSLConnectionSocketFactory createSSLConnSocketFactory() {
    SSLConnectionSocketFactory sslsf = null;
    try {
        SSLContext sslContext = new SSLContextBuilder().loadTrustMaterial(null, new TrustStrategy() {
            public boolean isTrusted(X509Certificate[] chain, String authType) throws CertificateException {
                return true;
            }
        }).build();
        sslsf = new SSLConnectionSocketFactory(sslContext, new X509HostnameVerifier() {

            @Override
            public boolean verify(String arg0, SSLSession arg1) {
                return true;
            }

            @Override
            public void verify(String host, SSLSocket ssl) throws IOException {
            }

            @Override
            public void verify(String host, X509Certificate cert) throws SSLException {
            }

            @Override
            public void verify(String host, String[] cns, String[] subjectAlts) throws SSLException {
            }
        });
    } catch (GeneralSecurityException e) {
        e.printStackTrace();
    }
    return sslsf;
}

/**
 * 发送 POST 请求（HTTP），K-V形式
 * @param apiUrl API接口URL
 * @param params 参数map
 * @return
 */
public static String doPost(String apiUrl, Map<String, Object> params) {
    CloseableHttpClient httpClient = HttpClients.createDefault();
    String httpStr = null;
    HttpPost httpPost = new HttpPost(apiUrl);
    CloseableHttpResponse response = null;

    try {
        httpPost.setConfig(requestConfig);
        List<NameValuePair> pairList = new ArrayList<NameValuePair>(params.size());
        for (Map.Entry<String, Object> entry : params.entrySet()) {
            NameValuePair pair = new BasicNameValuePair(entry.getKey(), entry
                    .getValue().toString());
            pairList.add(pair);
        }
        httpPost.setEntity(new UrlEncodedFormEntity(pairList, Charset.forName("UTF-8")));
        response = httpClient.execute(httpPost);
        System.out.println(response.toString());
        HttpEntity entity = response.getEntity();
        httpStr = EntityUtils.toString(entity, "UTF-8");
    } catch (IOException e) {
        e.printStackTrace();
    } finally {
        if (response != null) {
            try {
                EntityUtils.consume(response.getEntity());
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
    return httpStr;
}    


/**
 * 使用代理发送 POST 请求（HTTP），K-V形式
 * @param apiUrl API接口URL
 * @param params 参数map
 * @return
 */
public static String doPostByProxy(String apiUrl, Map<String, Object> params) {
	
	//配置华为现场的代理信息
	String proxyHost = "proxysys.huawei.com";
    Integer proxyPort = 8080;
    HttpHost proxy = new HttpHost(proxyHost, proxyPort, "http"); 
	
    CloseableHttpClient httpClient = HttpClients.createDefault();
    String httpStr = null;
    HttpPost httpPost = new HttpPost(apiUrl);
    CloseableHttpResponse response = null;
	
	try {
		httpPost.setConfig(requestConfig);
		List<NameValuePair> pairList = new ArrayList<NameValuePair>(params.size());
		for (Map.Entry<String, Object> entry : params.entrySet()) {
			NameValuePair pair = new BasicNameValuePair(entry.getKey(), entry
					.getValue().toString());
			pairList.add(pair);
		}
		httpPost.setEntity(new UrlEncodedFormEntity(pairList, Charset.forName("UTF-8")));
		response = httpClient.execute(proxy, httpPost);
		System.out.println(response.toString());
		HttpEntity entity = response.getEntity();
		httpStr = EntityUtils.toString(entity, "UTF-8");
	} catch (IOException e) {
		e.printStackTrace();
	} finally {
		if (response != null) {
			try {
				EntityUtils.consume(response.getEntity());
			} catch (IOException e) {
				e.printStackTrace();
			}
		}
	}
	return httpStr;
}    

/**
 * 发送 POST 请求（HTTP），JSON形式
 * @param apiUrl
 * @param json json对象
 * @return
 */
public static String doPost(String apiUrl, Object json) {
    CloseableHttpClient httpClient = HttpClients.createDefault();
    String httpStr = null;
    HttpPost httpPost = new HttpPost(apiUrl);
    CloseableHttpResponse response = null;

    try {
        httpPost.setConfig(requestConfig);
        StringEntity stringEntity = new StringEntity(json.toString(),"UTF-8");//解决中文乱码问题
        stringEntity.setContentEncoding("UTF-8");
        stringEntity.setContentType("application/json");
        httpPost.setEntity(stringEntity);
        response = httpClient.execute(httpPost);
        HttpEntity entity = response.getEntity();
        System.out.println(response.getStatusLine().getStatusCode());
        httpStr = EntityUtils.toString(entity, "UTF-8");
    } catch (IOException e) {
        e.printStackTrace();
    } finally {
        if (response != null) {
            try {
                EntityUtils.consume(response.getEntity());
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
    return httpStr;
}    

/**
 * 发送 SSL POST 请求（HTTPS），K-V形式
 * @param apiUrl API接口URL
 * @param params 参数map
 * @return
 */
public static String doPostSSL(String apiUrl, Map<String, Object> params) {
    CloseableHttpClient httpClient = HttpClients.custom().setSSLSocketFactory(createSSLConnSocketFactory())
    		.setConnectionManager(connMgr)
    		.setDefaultRequestConfig(requestConfig).build();
    HttpPost httpPost = new HttpPost(apiUrl);
    CloseableHttpResponse response = null;
    String httpStr = null;

    try {
        httpPost.setConfig(requestConfig);
        List<NameValuePair> pairList = new ArrayList<NameValuePair>(params.size());
        for (Map.Entry<String, Object> entry : params.entrySet()) {
            NameValuePair pair = new BasicNameValuePair(entry.getKey(), entry
                    .getValue().toString());
            pairList.add(pair);
        }
        httpPost.setEntity(new UrlEncodedFormEntity(pairList, Charset.forName("utf-8")));
        response = httpClient.execute(httpPost);
        int statusCode = response.getStatusLine().getStatusCode();
        if (statusCode != HttpStatus.SC_OK) {
            return null;
        }
        HttpEntity entity = response.getEntity();
        if (entity == null) {
            return null;
        }
        httpStr = EntityUtils.toString(entity, "utf-8");
    } catch (Exception e) {
        e.printStackTrace();
    } finally {
        if (response != null) {
            try {
                EntityUtils.consume(response.getEntity());
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
    return httpStr;
}    

/**
 * 发送 SSL POST 请求（HTTPS），JSON形式
 * @param apiUrl API接口URL
 * @param json JSON对象
 * @return
 */
public static String doPostSSL(String apiUrl, Object json) {
    CloseableHttpClient httpClient = HttpClients.custom().setSSLSocketFactory(createSSLConnSocketFactory())
    		.setConnectionManager(connMgr).setDefaultRequestConfig(requestConfig).build();
    HttpPost httpPost = new HttpPost(apiUrl);
    CloseableHttpResponse response = null;
    String httpStr = null;

    try {
        httpPost.setConfig(requestConfig);
        StringEntity stringEntity = new StringEntity(json.toString(),"UTF-8");//解决中文乱码问题
        stringEntity.setContentEncoding("UTF-8");
        stringEntity.setContentType("application/json");
        httpPost.setEntity(stringEntity);
        response = httpClient.execute(httpPost);
        int statusCode = response.getStatusLine().getStatusCode();
        if (statusCode != HttpStatus.SC_OK) {
            return null;
        }
        HttpEntity entity = response.getEntity();
        if (entity == null) {
            return null;
        }
        httpStr = EntityUtils.toString(entity, "utf-8");
    } catch (Exception e) {
        e.printStackTrace();
    } finally {
        if (response != null) {
            try {
                EntityUtils.consume(response.getEntity());
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
    return httpStr;
}    

public static String getResult(String url, String param) {

	CloseableHttpClient httpClient = HttpClients.createDefault();

	HttpPost httpost = HttpClientConnectionManager.getPostMethod(url);

	RequestConfig requestConfig = RequestConfig.custom()
			.setSocketTimeout(3000).setConnectTimeout(3000).build();
	httpost.setConfig(requestConfig);
	String result = "";

	try {
		httpost.setEntity(new StringEntity(param, "UTF-8"));
		HttpResponse response = httpClient.execute(httpost);
		result = EntityUtils.toString(response.getEntity(), "UTF-8");
	} catch (Exception e) {
		e.printStackTrace();
		return "";
	}

	return result;
}



/**
 * 发送 POST 请求（HTTP），JSON形式
 * @param apiUrl
 * @param json json对象
 * @return
 */
public static String sendHttpPost(String apiUrl, Object json, JSONObject header) {
    CloseableHttpClient httpClient = HttpClients.createDefault();
    String httpStr = null;
    HttpPost httpPost = new HttpPost(apiUrl);
    CloseableHttpResponse response = null;
    log.info("toString参数为："+json.toString());
    log.info("toJSONObjectString参数为："+JSONObject.fromObject(json).toString());
    try {
        httpPost.setConfig(requestConfig);
        StringEntity stringEntity = new StringEntity(json.toString(),"UTF-8");//解决中文乱码问题
        stringEntity.setContentEncoding("UTF-8");
        stringEntity.setContentType("application/json");
        httpPost.setEntity(stringEntity);
        Set<String> keys =header.keySet();
        for (String key : keys) {
            httpPost.setHeader(key,header.getString(key));
        }
        response = httpClient.execute(httpPost);
        HttpEntity entity = response.getEntity();
        System.out.println(response.getStatusLine().getStatusCode());
        httpStr = EntityUtils.toString(entity, "UTF-8");
    } catch (IOException e) {
        e.printStackTrace();
    } finally {
        if (response != null) {
            try {
                EntityUtils.consume(response.getEntity());
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
    return httpStr;
}

}