HttpClientUtil工具類，發送get請求和post請求

代碼以下：

import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.io.UnsupportedEncodingException;
import java.net.HttpURLConnection;
import java.net.URL;
import java.security.KeyManagementException;
import java.security.NoSuchAlgorithmException;
import java.security.cert.CertificateException;
import java.security.cert.X509Certificate;
import java.util.ArrayList;
import java.util.List;
import java.util.Map;

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

import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.apache.http.Consts;
import org.apache.http.HttpEntity;
import org.apache.http.HttpResponse;
import org.apache.http.HttpStatus;
import org.apache.http.NameValuePair;
import org.apache.http.ParseException;
import org.apache.http.client.ClientProtocolException;
import org.apache.http.client.HttpClient;
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.client.utils.URLEncodedUtils;
import org.apache.http.conn.scheme.Scheme;
import org.apache.http.conn.ssl.SSLSocketFactory;
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.DefaultHttpClient;
import org.apache.http.impl.client.HttpClients;
import org.apache.http.message.BasicNameValuePair;
import org.apache.http.protocol.HTTP;
import org.apache.http.util.EntityUtils;
 
/**
 * 封裝了一些採用HttpClient發送HTTP請求的方法
 * @see 本工具所採用的是最新的HttpComponents-Client-4.2.1
 */
public class HttpClientUtil {
    private HttpClientUtil(){}
     
    private static Log logger = LogFactory.getLog(HttpClientUtil.class);
    
    
    /**
     * 發送HTTP_GET請求
     * @see 該方法會自動關閉鏈接,釋放資源
     * @param requestURL    請求地址(含參數)
     * @param decodeCharset 解碼字符集,解析響應數據時用之,其爲null時默認採用UTF-8解碼
     * @return 遠程主機響應正文
     */
    public static String sendGetRequest(String reqURL, String decodeCharset){
        long responseLength = 0;       //響應長度
        String responseContent = null; //響應內容
        HttpClient httpClient = new DefaultHttpClient(); //建立默認的httpClient實例
        HttpGet httpGet = new HttpGet(reqURL);           //建立org.apache.http.client.methods.HttpGet
        try{
            HttpResponse response = httpClient.execute(httpGet); //執行GET請求
            HttpEntity entity = response.getEntity();            //獲取響應實體
            if(null != entity){
                responseLength = entity.getContentLength();
                responseContent = EntityUtils.toString(entity, decodeCharset==null ? "UTF-8" : decodeCharset);
                EntityUtils.consume(entity); //Consume response content
            }
            System.out.println("請求地址: " + httpGet.getURI());
            System.out.println("響應狀態: " + response.getStatusLine());
            System.out.println("響應長度: " + responseLength);
            System.out.println("響應內容: " + responseContent);
        }catch(ClientProtocolException e){
        	logger.debug("該異常一般是協議錯誤致使,好比構造HttpGet對象時傳入的協議不對(將'http'寫成'htp')或者服務器端返回的內容不符合HTTP協議要求等,堆棧信息以下", e);
        }catch(ParseException e){
        	logger.debug(e.getMessage(), e);
        }catch(IOException e){
        	logger.debug("該異常一般是網絡緣由引發的,如HTTP服務器未啓動等,堆棧信息以下", e);
        }finally{
            httpClient.getConnectionManager().shutdown(); //關閉鏈接,釋放資源
        }
        return responseContent;
    }
     
     
    /**
     * 發送HTTP_POST請求
     * @see 該方法爲<code>sendPostRequest(String,String,boolean,String,String)</code>的簡化方法
     * @see 該方法在對請求數據的編碼和響應數據的解碼時,所採用的字符集均爲UTF-8
     * @see 當<code>isEncoder=true</code>時,其會自動對<code>sendData</code>中的[中文][|][ ]等特殊字符進行<code>URLEncoder.encode(string,"UTF-8")</code>
     * @param isEncoder 用於指明請求數據是否須要UTF-8編碼,true爲須要
     */
    public static String sendPostRequest(String reqURL, String sendData, boolean isEncoder){
        return sendPostRequest(reqURL, sendData, isEncoder, null, null);
    }
     
     
    /**
     * 發送HTTP_POST請求
     * @see 該方法會自動關閉鏈接,釋放資源
     * @see 當<code>isEncoder=true</code>時,其會自動對<code>sendData</code>中的[中文][|][ ]等特殊字符進行<code>URLEncoder.encode(string,encodeCharset)</code>
     * @param reqURL        請求地址
     * @param sendData      請求參數,如有多個參數則應拼接成param11=value11&22=value22&33=value33的形式後,傳入該參數中
     * @param isEncoder     請求數據是否須要encodeCharset編碼,true爲須要
     * @param encodeCharset 編碼字符集,編碼請求數據時用之,其爲null時默認採用UTF-8解碼
     * @param decodeCharset 解碼字符集,解析響應數據時用之,其爲null時默認採用UTF-8解碼
     * @return 遠程主機響應正文
     */
    public static String sendPostRequest(String reqURL, String sendData, boolean isEncoder, String encodeCharset, String decodeCharset){
        String responseContent = null;
        HttpClient httpClient = new DefaultHttpClient();
         
        HttpPost httpPost = new HttpPost(reqURL);
        //httpPost.setHeader(HTTP.CONTENT_TYPE, "application/x-www-form-urlencoded; charset=UTF-8");
        httpPost.setHeader(HTTP.CONTENT_TYPE, "application/x-www-form-urlencoded");
        try{
            if(isEncoder){
                List<NameValuePair> formParams = new ArrayList<NameValuePair>();
                for(String str : sendData.split("&")){
                    formParams.add(new BasicNameValuePair(str.substring(0,str.indexOf("=")), str.substring(str.indexOf("=")+1)));
                }
                httpPost.setEntity(new StringEntity(URLEncodedUtils.format(formParams, encodeCharset==null ? "UTF-8" : encodeCharset)));
            }else{
                httpPost.setEntity(new StringEntity(sendData));
            }
             
            HttpResponse response = httpClient.execute(httpPost);
            HttpEntity entity = response.getEntity();
            if (null != entity) {
                responseContent = EntityUtils.toString(entity, decodeCharset==null ? "UTF-8" : decodeCharset);
                EntityUtils.consume(entity);
            }
        }catch(Exception e){
            logger.debug("與[" + reqURL + "]通訊過程當中發生異常,堆棧信息以下", e);
        }finally{
            httpClient.getConnectionManager().shutdown();
        }
        return responseContent;
    }
     
     
    /**
     * 發送HTTP_POST請求
     * @see 該方法會自動關閉鏈接,釋放資源
     * @see 該方法會自動對<code>params</code>中的[中文][|][ ]等特殊字符進行<code>URLEncoder.encode(string,encodeCharset)</code>
     * @param reqURL        請求地址
     * @param params        請求參數
     * @param encodeCharset 編碼字符集,編碼請求數據時用之,其爲null時默認採用UTF-8解碼
     * @param decodeCharset 解碼字符集,解析響應數據時用之,其爲null時默認採用UTF-8解碼
     * @return 遠程主機響應正文
     */
    public static String sendPostRequest(String reqURL, Map<String, String> params, String encodeCharset, String decodeCharset){
        String responseContent = null;
        HttpClient httpClient = new DefaultHttpClient();
         
        HttpPost httpPost = new HttpPost(reqURL);
        List<NameValuePair> formParams = new ArrayList<NameValuePair>(); //建立參數隊列
        for(Map.Entry<String,String> entry : params.entrySet()){
            formParams.add(new BasicNameValuePair(entry.getKey(), entry.getValue()));
        }
        try{
            httpPost.setEntity(new UrlEncodedFormEntity(formParams, encodeCharset==null ? "UTF-8" : encodeCharset));
             
            HttpResponse response = httpClient.execute(httpPost);
            HttpEntity entity = response.getEntity();
            if (null != entity) {
                responseContent = EntityUtils.toString(entity, decodeCharset==null ? "UTF-8" : decodeCharset);
                EntityUtils.consume(entity);
            }
        }catch(Exception e){
            logger.debug("與[" + reqURL + "]通訊過程當中發生異常,堆棧信息以下", e);
        }finally{
            httpClient.getConnectionManager().shutdown();
        }
        return responseContent;
    }
     
     
    /**
     * 發送HTTPS_POST請求
     * @see 該方法爲<code>sendPostSSLRequest(String,Map<String,String>,String,String)</code>方法的簡化方法
     * @see 該方法在對請求數據的編碼和響應數據的解碼時,所採用的字符集均爲UTF-8
     * @see 該方法會自動對<code>params</code>中的[中文][|][ ]等特殊字符進行<code>URLEncoder.encode(string,"UTF-8")</code>
     */
    public static String sendPostSSLRequest(String reqURL, Map<String, String> params){
        return sendPostSSLRequest(reqURL, params, null, null);
    }
     
     
    /**
     * 發送HTTPS_POST請求
     * @see 該方法會自動關閉鏈接,釋放資源
     * @see 該方法會自動對<code>params</code>中的[中文][|][ ]等特殊字符進行<code>URLEncoder.encode(string,encodeCharset)</code>
     * @param reqURL        請求地址
     * @param params        請求參數
     * @param encodeCharset 編碼字符集,編碼請求數據時用之,其爲null時默認採用UTF-8解碼
     * @param decodeCharset 解碼字符集,解析響應數據時用之,其爲null時默認採用UTF-8解碼
     * @return 遠程主機響應正文
     */
    public static String sendPostSSLRequest(String reqURL, Map<String, String> params, String encodeCharset, String decodeCharset){
        String responseContent = "";
        HttpClient httpClient = new DefaultHttpClient();
        X509TrustManager xtm = new X509TrustManager(){
            public void checkClientTrusted(X509Certificate[] chain, String authType) throws CertificateException {}
            public void checkServerTrusted(X509Certificate[] chain, String authType) throws CertificateException {}
            public X509Certificate[] getAcceptedIssuers() {return null;}
        };
        try {
            SSLContext ctx = SSLContext.getInstance("TLS");
            ctx.init(null, new TrustManager[]{xtm}, null);
            SSLSocketFactory socketFactory = new SSLSocketFactory(ctx);
            httpClient.getConnectionManager().getSchemeRegistry().register(new Scheme("https", 443, socketFactory));
             
            HttpPost httpPost = new HttpPost(reqURL);
            List<NameValuePair> formParams = new ArrayList<NameValuePair>();
            for(Map.Entry<String,String> entry : params.entrySet()){
                formParams.add(new BasicNameValuePair(entry.getKey(), entry.getValue()));
            }
            httpPost.setEntity(new UrlEncodedFormEntity(formParams, encodeCharset==null ? "UTF-8" : encodeCharset));
             
            HttpResponse response = httpClient.execute(httpPost);
            HttpEntity entity = response.getEntity();
            if (null != entity) {
                responseContent = EntityUtils.toString(entity, decodeCharset==null ? "UTF-8" : decodeCharset);
                EntityUtils.consume(entity);
            }
        } catch (Exception e) {
            logger.debug("與[" + reqURL + "]通訊過程當中發生異常,堆棧信息爲", e);
        } finally {
            httpClient.getConnectionManager().shutdown();
        }
        return responseContent;
    }
     
     
    /**
     * 發送HTTP_POST請求
     * @see 若發送的<code>params</code>中含有中文,記得按照雙方約定的字符集將中文<code>URLEncoder.encode(string,encodeCharset)</code>
     * @see 本方法默認的鏈接超時時間爲30秒,默認的讀取超時時間爲30秒
     * @param reqURL 請求地址
     * @param params 發送到遠程主機的正文數據,其數據類型爲<code>java.util.Map<String, String></code>
     * @return 遠程主機響應正文`HTTP狀態碼,如<code>"SUCCESS`200"</code><br>若通訊過程當中發生異常則返回"Failed`HTTP狀態碼",如<code>"Failed`500"</code>
     */
    public static String sendPostRequestByJava(String reqURL, Map<String, String> params){
        StringBuilder sendData = new StringBuilder();
        for(Map.Entry<String, String> entry : params.entrySet()){
            sendData.append(entry.getKey()).append("=").append(entry.getValue()).append("&");
        }
        if(sendData.length() > 0){
            sendData.setLength(sendData.length() - 1); //刪除最後一個&符號
        }
        return sendPostRequestByJava(reqURL, sendData.toString());
    }
     
     
    /**
     * 發送HTTP_POST請求
     * @see 若發送的<code>sendData</code>中含有中文,記得按照雙方約定的字符集將中文<code>URLEncoder.encode(string,encodeCharset)</code>
     * @see 本方法默認的鏈接超時時間爲30秒,默認的讀取超時時間爲30秒
     * @param reqURL   請求地址
     * @param sendData 發送到遠程主機的正文數據
     * @return 遠程主機響應正文`HTTP狀態碼,如<code>"SUCCESS`200"</code><br>若通訊過程當中發生異常則返回"Failed`HTTP狀態碼",如<code>"Failed`500"</code>
     */
    public static String sendPostRequestByJava(String reqURL, String sendData){
        HttpURLConnection httpURLConnection = null;
        OutputStream out = null; //寫
        InputStream in = null;   //讀
        int httpStatusCode = 0;  //遠程主機響應的HTTP狀態碼
        try{
            URL sendUrl = new URL(reqURL);
            httpURLConnection = (HttpURLConnection)sendUrl.openConnection();
            httpURLConnection.setRequestMethod("POST");
            httpURLConnection.setDoOutput(true);        //指示應用程序要將數據寫入URL鏈接,其值默認爲false
            httpURLConnection.setUseCaches(false);
            httpURLConnection.setConnectTimeout(30000); //30秒鏈接超時
            httpURLConnection.setReadTimeout(30000);    //30秒讀取超時
             
            out = httpURLConnection.getOutputStream();
            out.write(sendData.toString().getBytes());
             
            //清空緩衝區,發送數據
            out.flush();
             
            //獲取HTTP狀態碼
            httpStatusCode = httpURLConnection.getResponseCode();
             
            in = httpURLConnection.getInputStream();            
            byte[] byteDatas = new byte[in.available()];
            in.read(byteDatas);
            return new String(byteDatas) + "`" + httpStatusCode;
        }catch(Exception e){
            logger.debug(e.getMessage());
            return "Failed`" + httpStatusCode;
        }finally{
            if(out != null){
                try{
                    out.close();
                }catch (Exception e){
                    logger.debug("關閉輸出流時發生異常,堆棧信息以下", e);
                }
            }
            if(in != null){
                try{
                    in.close();
                }catch(Exception e){
                    logger.debug("關閉輸入流時發生異常,堆棧信息以下", e);
                }
            }
            if(httpURLConnection != null){
                httpURLConnection.disconnect();
                httpURLConnection = null;
            }
        }
    }
    
    /**
     * https posp請求，能夠繞過證書校驗
     * @param url
     * @param params
     * @return
     */
    public static final String sendHttpsRequestByPost(String url, Map<String, String> params) {
		String responseContent = null;
		HttpClient httpClient = new DefaultHttpClient();
		//建立TrustManager
		X509TrustManager xtm = new X509TrustManager() {
			public void checkClientTrusted(X509Certificate[] chain, String authType) throws CertificateException {}
			public void checkServerTrusted(X509Certificate[] chain, String authType) throws CertificateException {}
			public X509Certificate[] getAcceptedIssuers() {
				return null;
			}
		};
		//這個好像是HOST驗證
		X509HostnameVerifier hostnameVerifier = new X509HostnameVerifier() {
			public boolean verify(String arg0, SSLSession arg1) {
				return true;
			}
			public void verify(String arg0, SSLSocket arg1) throws IOException {}
			public void verify(String arg0, String[] arg1, String[] arg2) throws SSLException {}
			public void verify(String arg0, X509Certificate arg1) throws SSLException {}
		};
		try {
			//TLS1.0與SSL3.0基本上沒有太大的差異，可粗略理解爲TLS是SSL的繼承者，但它們使用的是相同的SSLContext
			SSLContext ctx = SSLContext.getInstance("TLS");
			//使用TrustManager來初始化該上下文，TrustManager只是被SSL的Socket所使用
			ctx.init(null, new TrustManager[] { xtm }, null);
			//建立SSLSocketFactory
			SSLSocketFactory socketFactory = new SSLSocketFactory(ctx);
			socketFactory.setHostnameVerifier(hostnameVerifier);
			//經過SchemeRegistry將SSLSocketFactory註冊到咱們的HttpClient上
			httpClient.getConnectionManager().getSchemeRegistry().register(new Scheme("https", socketFactory, 443));
			HttpPost httpPost = new HttpPost(url);
			List<NameValuePair> formParams = new ArrayList<NameValuePair>(); // 構建POST請求的表單參數
			for (Map.Entry<String, String> entry : params.entrySet()) {
				formParams.add(new BasicNameValuePair(entry.getKey(), entry.getValue()));
			}
			httpPost.setEntity(new UrlEncodedFormEntity(formParams, "UTF-8"));
			HttpResponse response = httpClient.execute(httpPost);
			HttpEntity entity = response.getEntity(); // 獲取響應實體
			if (entity != null) {
				responseContent = EntityUtils.toString(entity, "UTF-8");
			}
		} catch (KeyManagementException e) {
			e.printStackTrace();
		} catch (NoSuchAlgorithmException e) {
			e.printStackTrace();
		} catch (UnsupportedEncodingException e) {
			e.printStackTrace();
		} catch (ClientProtocolException e) {
			e.printStackTrace();
		} catch (ParseException e) {
			e.printStackTrace();
		} catch (IOException e) {
			e.printStackTrace();
		} finally {
			// 關閉鏈接,釋放資源
			httpClient.getConnectionManager().shutdown();
		}
		return responseContent;
	}
    
    
    /**
     * 發送HTTP_POST請求,json格式數據
     * @param url
     * @param body
     * @return
     * @throws Exception
     */
    public static String sendPostByJson(String url, String body) throws Exception {
		CloseableHttpClient httpclient = HttpClients.custom().build();
		HttpPost post = null;
		String resData = null;
		CloseableHttpResponse result = null;
		try {
			post = new HttpPost(url);
			HttpEntity entity2 = new StringEntity(body, Consts.UTF_8);
			post.setConfig(RequestConfig.custom().setConnectTimeout(30000).setSocketTimeout(30000).build());
			post.setHeader("Content-Type", "application/json");
			post.setEntity(entity2);
			result = httpclient.execute(post);
			if (HttpStatus.SC_OK == result.getStatusLine().getStatusCode()) {
				resData = EntityUtils.toString(result.getEntity());
			}
		} finally {
			if (result != null) {
				result.close();
			}
			if (post != null) {
				post.releaseConnection();
			}
			httpclient.close();
		}
		return resData;
	}
	 
    
}