https請求核心代碼實現，包括證書認證

直接上代碼，如下：

package com.mischen.pay.common.core.utils.httpclient;

import org.apache.commons.io.output.ByteArrayOutputStream;
import org.apache.log4j.Logger;

import javax.net.ssl.*;
import java.io.*;
import java.lang.reflect.Array;
import java.net.HttpURLConnection;
import java.net.URL;
import java.net.URLDecoder;
import java.net.URLEncoder;
import java.nio.charset.Charset;
import java.security.KeyStore;
import java.security.cert.CertificateException;
import java.security.cert.X509Certificate;
import java.util.*;
import java.util.Map.Entry;


public class SimpleHttpUtils {
	private static final Logger logger = Logger.getLogger(SimpleHttpUtils.class);

	/**
	 * 默認字符編碼
	 */
	public static final String DEFAULT_CHARSET = "utf-8";

	public static final String HTTP_METHOD_POST = "POST";

	public static final String HTTP_METHOD_GET = "GET";
	
	public static final String HTTP_ERROR_MESSAGE = "http_error_message";

	/**
	 * 默認超時設置(20秒)
	 */
	public static final int DEFAULT_READ_TIMEOUT = 20000;
	
	public static final int DEFAULT_CONNECT_TIMEOUT = 10000;


	public static final String HTTP_PREFIX = "http://";

	public static final String HTTPS_PREFIX = "https://";

	//最多隻讀取5000字節
	public static final int MAX_FETCHSIZE = 5000;
	
	private static TrustManager[] trustAnyManagers = new TrustManager[]{new TrustAnyTrustManager()};
	
	static {
		System.setProperty("sun.net.inetaddr.ttl", "3600");
	}

	public static String httpPost(String url, Map params) {
		return httpRequest(url, params, HTTP_METHOD_POST, DEFAULT_CHARSET, null);
	}

	public static String httpGet(String url, Map params) {
		return httpRequest(url, params, HTTP_METHOD_GET, DEFAULT_CHARSET, null);
	}

	/**
	 * 以建立HttpURLConnection方式發送請求
	 * 
	 * @param url
	 *            請求地址
	 * @param params
	 *            請求參數
	 * @param method
	 *            請求方式
	 * @param charSet
	 * @return 通訊失敗返回null, 否則返回服務端輸出
	 */
	public static String httpRequest(String url, Map<String,String> params, String method,
			String charSet, Map<String,String> headers) {
		SimpleHttpParam param = new SimpleHttpParam(url);
		if(null != param){
			param.setParameters(params);
		}
		if(null != headers){
			param.setHeaders(headers);
		}
		param.setCharSet(charSet);
		param.setMethod(method);
		SimpleHttpResult result = httpRequest(param);
		if(result==null || !result.isSuccess()){
			return null;
		}else{
			return result.getContent();
		}
	}

	/**
	 *
	 * @param httpParam
	 * @return
	 */
	public static SimpleHttpResult httpRequest(SimpleHttpParam httpParam) {
		String url = httpParam.getUrl();
		Map<String,Object> parameters = httpParam.getParameters();
		String sMethod = httpParam.getMethod();
		String charSet = httpParam.getCharSet();
		boolean sslVerify = httpParam.isSslVerify();
		int maxResultSize = httpParam.getMaxResultSize();
		Map<String,Object> headers = httpParam.getHeaders();
		int readTimeout = httpParam.getReadTimeout();
		int connectTimeout = httpParam.getConnectTimeout();
		boolean ignoreContentIfUnsuccess = httpParam.isIgnoreContentIfUnsuccess();
		boolean hostnameVerify = httpParam.isHostnameVerify();
		TrustKeyStore trustKeyStore = httpParam.getTrustKeyStore();
		ClientKeyStore clientKeyStore = httpParam.getClientKeyStore();
		
		if (url == null || url.trim().length() == 0) {
			throw new IllegalArgumentException("invalid url : " + url);
		}
		if(maxResultSize<=0){
			throw new IllegalArgumentException("maxResultSize must be positive : "+maxResultSize);
		}
		Charset.forName(charSet);
		HttpURLConnection urlConn = null;
		URL destURL = null;
		
		String baseUrl = url.trim();
		if (!baseUrl.toLowerCase().startsWith(HTTPS_PREFIX) && !baseUrl.toLowerCase().startsWith(HTTP_PREFIX)) {
			baseUrl = HTTP_PREFIX + baseUrl;
		}

		String method = null;
		if (sMethod != null) {
			method = sMethod.toUpperCase();
		}
		if (method == null
				|| !(method.equals(HTTP_METHOD_POST) || method
						.equals(HTTP_METHOD_GET))) {
			throw new IllegalArgumentException("invalid http method : "
					+ method);
		}
		
		int index = baseUrl.indexOf("?");
		if (index>0){
			baseUrl = urlEncode(baseUrl, charSet);
		}else if(index==0){
			throw new IllegalArgumentException("invalid url : " + url);
		}
		
		String queryString = mapToQueryString(parameters, charSet);
		String targetUrl = "";
		if (method.equals(HTTP_METHOD_POST)) {
			targetUrl = baseUrl;
		} else {
			if(index>0){
				targetUrl = baseUrl +"&" + queryString;
			}else{
				targetUrl = baseUrl +"?" + queryString;
			}
		}
		try {
			destURL = new URL(targetUrl);
			urlConn = (HttpURLConnection)destURL.openConnection();
			
			setSSLSocketFactory(urlConn, sslVerify, hostnameVerify, trustKeyStore, clientKeyStore);
			       
			
			boolean hasContentType = false;
			boolean hasUserAgent = false;
			for(String key : headers.keySet()){
				if("Content-Type".equalsIgnoreCase(key)){
					hasContentType = true;
				}
				if("user-agent".equalsIgnoreCase(key)){
					hasUserAgent = true;
				}
			}
			if(!hasContentType){
				headers.put("Content-Type", "application/x-www-form-urlencoded; charset=" + charSet);
			}
			if(!hasUserAgent){
				headers.put("user-agent", "PlatSystem");
			}
			
			if(headers!=null && !headers.isEmpty()){
				for(Entry<String, Object> entry : headers.entrySet()){
					String key = entry.getKey();
					Object value = entry.getValue();
					List<String> values = makeStringList(value);
					for(String v : values){
						urlConn.addRequestProperty(key, v);
					}
				}
			}
			urlConn.setDoOutput(true);
			urlConn.setDoInput(true);
			urlConn.setAllowUserInteraction(false);
			urlConn.setUseCaches(false);
			urlConn.setRequestMethod(method);
			urlConn.setConnectTimeout(connectTimeout);
			urlConn.setReadTimeout(readTimeout);
			
			
			
			if (method.equals(HTTP_METHOD_POST)) {
				String postData = queryString.length()==0?httpParam.getPostData():queryString;
				if(postData!=null && postData.trim().length()>0){
					OutputStream os = urlConn.getOutputStream();
					OutputStreamWriter osw = new OutputStreamWriter(os, charSet);
					osw.write(postData);
					osw.flush();
					osw.close();
				}
			}

			int responseCode = urlConn.getResponseCode();
			Map<String, List<String>> responseHeaders = urlConn.getHeaderFields();
			String contentType = urlConn.getContentType();
				
			SimpleHttpResult result = new SimpleHttpResult(responseCode);
			result.setHeaders(responseHeaders);
			result.setContentType(contentType);
			
			if(responseCode!=200 && ignoreContentIfUnsuccess){
				return result;
			}
			
			InputStream is = urlConn.getInputStream();
			byte[] temp = new byte[1024];
			ByteArrayOutputStream baos = new ByteArrayOutputStream();
			int readBytes = is.read(temp);
			while(readBytes>0){
				baos.write(temp, 0, readBytes);
				readBytes =  is.read(temp);
			}
			String resultString = new String(baos.toByteArray(), charSet); //new String(buffer.array(), charSet);
			baos.close();
			result.setContent(resultString);
			return result;
		} catch (Exception e) {
			logger.warn("connection error : " + e.getMessage());
			return new SimpleHttpResult(e);
		} finally {
			if (urlConn != null) {
				urlConn.disconnect();
			}
		}
	}

	/**
	 *
	 * @param url
	 * @param charSet
	 * @return
	 */
	public static String urlEncode(String url, String charSet){
		if(url==null || url.trim().length()==0){
			return url;
		}
		int splitIndex = url.indexOf("?");
		if(splitIndex <= 0){
			return url;
		}
		String serviceUrl = url.substring(0, splitIndex);
		String queryString = url.substring(splitIndex+1, url.length());
		String newQueryString = "";
		if(queryString.length()>0){
			String[] nameValues = queryString.split("&");
			for(String nameValue : nameValues){
				int index = nameValue.indexOf("=");
				String pname = null;
				String pvalue = null;
				if(index<0){
					pname = nameValue;
					pvalue = "";
				}
				else{
					pname = nameValue.substring(0, index);
					pvalue = nameValue.substring(index+1, nameValue.length());
					try {
						pvalue = URLEncoder.encode(pvalue, charSet);
					} catch (UnsupportedEncodingException e) {
						throw new IllegalArgumentException("invalid charset : "+charSet);
					}
				}
				newQueryString += pname +"=" + pvalue + "&";
			}
			newQueryString = newQueryString.substring(0, newQueryString.length()-1);
		}
		return serviceUrl + "?" + newQueryString;
	}

	/**
	 *
	 * @param parameters
	 * @param charSet
	 * @return
	 */
	public static String mapToQueryString(Map parameters, String charSet) {
		String queryString = "";
		if (parameters!=null && !parameters.isEmpty()) {
			Set<Entry> entrySet = parameters.entrySet();
			for(Entry entry : entrySet){
				try {
					String key = entry.getKey().toString();
					Object value = entry.getValue();
					List values = makeStringList(value);
					for(Object v : values){
						queryString += key + "=" + URLEncoder.encode(v==null?"":v.toString(), charSet) + "&";
					}
				} catch (UnsupportedEncodingException e) {
					throw new IllegalArgumentException("invalid charset : " + charSet);
				}
			}
			if (queryString.length() > 0) {
				queryString = queryString.substring(0, queryString.length()-1);
			}
		}
		return queryString;
	}

	/**
	 *
	 * @param queryString
	 * @param charSet
	 * @return
	 */
	public static Map queryStringToMap(String queryString, String charSet) {
		if (queryString == null) {
			throw new IllegalArgumentException("queryString must be specified");
		}

		int index = queryString.indexOf("?");
		if (index > 0) {
			queryString = queryString.substring(index + 1);
		}
		String[] keyValuePairs = queryString.split("&");
		Map <String, String>map = new HashMap<String, String>();
		for (String keyValue : keyValuePairs) {
			if (keyValue.indexOf("=") == -1) {
				continue;
			}
			String[] args = keyValue.split("=");
			if (args.length == 2) {
				try {
					map.put(args[0], URLDecoder.decode(args[1], charSet));
				} catch (UnsupportedEncodingException e) {
					throw new IllegalArgumentException("invalid charset : " + charSet);
				}
			}
			if (args.length == 1) {
				map.put(args[0], "");
			}
		}
		return map;
	}

	/**
	 *
	 * @param urlConn
	 * @param sslVerify
	 * @param hostnameVerify
	 * @param trustCertFactory
	 * @param clientKeyFactory
	 */
	private static void setSSLSocketFactory(HttpURLConnection urlConn, boolean sslVerify, boolean hostnameVerify, TrustKeyStore trustCertFactory, ClientKeyStore clientKeyFactory){
		try{
			SSLSocketFactory socketFactory = null;
			if(trustCertFactory!=null || clientKeyFactory!=null || !sslVerify){
				SSLContext sc = SSLContext.getInstance("SSL");
				TrustManager[] trustManagers = null;
				KeyManager[] keyManagers = null;
				if(trustCertFactory!=null){
					trustManagers = trustCertFactory.getTrustManagerFactory().getTrustManagers();
				}
				if(clientKeyFactory!=null){
					keyManagers = clientKeyFactory.getKeyManagerFactory().getKeyManagers();
				}
				if(!sslVerify){
					trustManagers = trustAnyManagers;
					hostnameVerify = false;
				}
				sc.init(keyManagers, trustManagers, new java.security.SecureRandom());
				socketFactory = sc.getSocketFactory();
			}
		
			if(urlConn instanceof HttpsURLConnection){
				HttpsURLConnection httpsUrlCon = (HttpsURLConnection)urlConn;
				if(socketFactory!=null){
					httpsUrlCon.setSSLSocketFactory(socketFactory);
				}
				//設置是否驗證hostname
				if(!hostnameVerify){
					httpsUrlCon.setHostnameVerifier(new TrustAnyHostnameVerifier());
				}
			}
			if(urlConn instanceof com.sun.net.ssl.HttpsURLConnection){
				com.sun.net.ssl.HttpsURLConnection httpsUrlCon = (com.sun.net.ssl.HttpsURLConnection)urlConn;
				if(socketFactory!=null){
					httpsUrlCon.setSSLSocketFactory(socketFactory);
				}
				//設置是否驗證hostname
				if(!hostnameVerify){
					httpsUrlCon.setHostnameVerifier(new TrustAnyHostnameVerifierOld());
				}
			}
		}catch(Exception e){
			logger.error(e.getMessage(), e);
		}
	}

	/**
	 *
	 * @param value
	 * @return
	 */
	private static List<String> makeStringList(Object value){
    	if (value == null) {
    		value = "";
        }
    	List<String> result = new ArrayList<String>();
    	if (value.getClass().isArray()) {
            for (int j = 0; j < Array.getLength(value); j++) {
            	Object obj = Array.get(value, j);
            	result.add(obj!=null?obj.toString():"");
            }
            return result;
        }
    	
        if (value instanceof Iterator) {
            Iterator it = (Iterator)value;
            while(it.hasNext()){
            	Object obj = it.next();
            	result.add(obj!=null?obj.toString():"");
            }
            return result;
        }
        
        if(value instanceof Collection){
        	for(Object obj : (Collection)value){
        		result.add(obj!=null?obj.toString():"");
        	}
        	return result;
        }

        if (value instanceof Enumeration) {
            Enumeration enumeration = (Enumeration) value;
            while (enumeration.hasMoreElements()) {
            	Object obj = enumeration.nextElement();
            	result.add(obj!=null?obj.toString():"");
            }
            return result;
        }
        result.add(value.toString());
        return result;
    }

	/**
	 *
	 */
	private static class TrustAnyTrustManager implements X509TrustManager {
	    
        public void checkClientTrusted(X509Certificate[] chain, String authType) throws CertificateException {
        }
    
        public void checkServerTrusted(X509Certificate[] chain, String authType) throws CertificateException {
        }
    
        public X509Certificate[] getAcceptedIssuers() {
            return new X509Certificate[]{};
        }
    }
    
    private static class TrustAnyHostnameVerifier implements HostnameVerifier {
        public boolean verify(String hostname, SSLSession session) {
            return true;
        }
    }
    
    private static class  TrustAnyHostnameVerifierOld implements com.sun.net.ssl.HostnameVerifier{
		public boolean verify(String arg0, String arg1) {
			return true;
		}
    }
    
    public static ClientKeyStore loadClientKeyStore(String keyStorePath, String keyStorePass, String privateKeyPass){
    	try{
    		return loadClientKeyStore(new FileInputStream(keyStorePath), keyStorePass, privateKeyPass);
    	}catch(Exception e){
    		logger.error("loadClientKeyFactory fail : "+e.getMessage(), e);
    		return null;
    	}
    }
    
    public static ClientKeyStore loadClientKeyStore(InputStream keyStoreStream, String keyStorePass, String privateKeyPass){
    	try{
    		KeyManagerFactory kmf = KeyManagerFactory.getInstance("SunX509");
    		KeyStore ks = KeyStore.getInstance("JKS");
    		ks.load(keyStoreStream, keyStorePass.toCharArray());
    		kmf.init(ks, privateKeyPass.toCharArray());
    		return new ClientKeyStore(kmf);
    	}catch(Exception e){
    		logger.error("loadClientKeyFactory fail : "+e.getMessage(), e);
    		return null;
    	}
    }
    
    public static TrustKeyStore loadTrustKeyStore(String keyStorePath, String keyStorePass){
    	try{
    		return loadTrustKeyStore(new FileInputStream(keyStorePath), keyStorePass);
    	}catch(Exception e){
    		logger.error("loadTrustCertFactory fail : "+e.getMessage(), e);
    		return null;
    	}
    }
    
    public static TrustKeyStore loadTrustKeyStore(InputStream keyStoreStream, String keyStorePass){
    	try{
    		TrustManagerFactory tmf = TrustManagerFactory.getInstance("SunX509");
    		KeyStore ks = KeyStore.getInstance("JKS");
    		ks.load(keyStoreStream, keyStorePass.toCharArray());
    		tmf.init(ks);
    		return new TrustKeyStore(tmf);
    	}catch(Exception e){
    		logger.error("loadTrustCertFactory fail : "+e.getMessage(), e);
    		return null;
    	}
    }

}