http 請求報文

package com.common.utils;


import java.io.*;

import java.net.*;
import java.security.KeyManagementException;
import java.security.KeyStore;
import java.security.KeyStoreException;
import java.security.NoSuchAlgorithmException;
import java.security.UnrecoverableKeyException;
import java.security.cert.CertificateException;
import java.security.cert.X509Certificate;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.Map.Entry;
import java.util.Set;

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

import org.apache.commons.httpclient.HttpException;
import org.apache.commons.lang3.StringUtils;
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.apache.http.*;
import org.apache.http.auth.AuthScope;
import org.apache.http.auth.UsernamePasswordCredentials;
import org.apache.http.client.ClientProtocolException;
import org.apache.http.client.config.RequestConfig;
import org.apache.http.client.entity.UrlEncodedFormEntity;
import org.apache.http.client.methods.HttpGet;
import org.apache.http.client.methods.HttpPost;
import org.apache.http.conn.ClientConnectionManager;
import org.apache.http.conn.params.ConnRoutePNames;
import org.apache.http.conn.scheme.PlainSocketFactory;
import org.apache.http.conn.scheme.Scheme;
import org.apache.http.conn.scheme.SchemeRegistry;
import org.apache.http.conn.ssl.*;
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.impl.conn.tsccm.ThreadSafeClientConnManager;
import org.apache.http.params.BasicHttpParams;
import org.apache.http.params.CoreConnectionPNames;
import org.apache.http.params.HttpParams;
import org.apache.http.params.HttpProtocolParams;
import org.apache.http.protocol.HTTP;
import org.apache.http.util.EntityUtils;

@SuppressWarnings("deprecation")
public class HttpUtil {

    //註冊端口
    //private static int port = 443;
    //超時時間（毫秒）
    private final static int CONNECTION_TIME_OUT = 10000;

    public static final int READDATA_TIMEOUT = 10000;// 數據讀取等待超時

    protected static Log log = LogFactory.getLog(HttpUtil.class);

    public synchronized static String sendDataByGet(String url,
                                                    Map<String, String> params, boolean enableProxy, int timeout) {

        if (params != null && params.size() > 0) {
            StringBuffer sb = new StringBuffer();
            Set<Entry<String, String>> set = params.entrySet();
            for (Iterator<Entry<String, String>> iterator = set.iterator(); iterator.hasNext(); ) {
                Entry<String, String> entry = (Entry<String, String>) iterator.next();
                sb.append("&" + entry.getKey() + "=" + URLEncoder.encode(entry.getValue()));
            }
            if (url.indexOf("?") == -1) {
                sb.deleteCharAt(0);
                url = url + "?" + sb.toString();
            } else {
                url = url + sb.toString();
            }
        }

        DefaultHttpClient client = null;

        if (client == null) {
            client = createHttpClient(timeout);
        }

        if (enableProxy) {
            HttpHost host = new HttpHost("10.37.84.16", 80);
            client.getParams().setParameter(ConnRoutePNames.DEFAULT_PROXY, host);
            client.getCredentialsProvider().setCredentials(new AuthScope("10.37.84.16", 80), new UsernamePasswordCredentials("um", "密碼"));
        }
        HttpGet get = new HttpGet(url);
        HttpResponse resp = null;
        String result = null;
        try {
            resp = client.execute(get);
            if (resp.getStatusLine().getStatusCode() == HttpStatus.SC_OK
                    || resp.getStatusLine().getStatusCode() == 400) {
                result = EntityUtils.toString(resp.getEntity(), HTTP.UTF_8);
                System.out.println(result);
            }
        } catch (UnsupportedEncodingException e) {
            e.printStackTrace();
        } catch (ClientProtocolException e) {
            e.printStackTrace();
        } catch (IOException e) {

            e.printStackTrace();
        } catch (Exception e) {

            e.printStackTrace();
        }
        return result;
    }

    public synchronized static String sendDataByPost(String url,
                                                     List<NameValuePair> datas, boolean enableProxy, int timeout) {
        DefaultHttpClient client = null;

        if (client == null) {
            client = createHttpClient(timeout);
        }
        if (enableProxy) {
            HttpHost host = new HttpHost("10.37.84.16", 80);
            client.getParams().setParameter(ConnRoutePNames.DEFAULT_PROXY, host);
            client.getCredentialsProvider().setCredentials(new AuthScope("10.37.84.16", 80), new UsernamePasswordCredentials("gengqian499", "gq1234!@#$"));
        }
        HttpPost post = new HttpPost(url);

        HttpResponse resp = null;
        String result = null;
        try {
            post.setEntity(new UrlEncodedFormEntity(datas, HTTP.UTF_8));
            resp = client.execute(post);
            if (resp.getStatusLine().getStatusCode() == HttpStatus.SC_OK
                    || resp.getStatusLine().getStatusCode() == 400) {
                result = EntityUtils.toString(resp.getEntity(), HTTP.UTF_8);
                System.out.println(result);
            }
        } catch (UnsupportedEncodingException e) {
            e.printStackTrace();
        } catch (ClientProtocolException e) {
            e.printStackTrace();
        } catch (IOException e) {

            e.printStackTrace();
        } catch (Exception e) {

            e.printStackTrace();
        }
        return result;
    }
    public static String doGet(String url) throws IOException {
        CloseableHttpClient httpClient = HttpClients.createDefault();
        HttpGet httpGet = new HttpGet(url);
        RequestConfig requestConfig = RequestConfig.custom().setSocketTimeout(CONNECTION_TIME_OUT).setConnectTimeout(CONNECTION_TIME_OUT).build();
        httpGet.setConfig(requestConfig);
        try {
            HttpResponse resp = httpClient.execute(httpGet);
            String result = EntityUtils.toString(resp.getEntity(), HTTP.UTF_8);
            int statusCode = resp.getStatusLine().getStatusCode();
            if (statusCode == HttpStatus.SC_OK) {
                return result;
            } else {
                throw new HttpException("Unsuccessful request -------->  The response is statusCode= " + statusCode + " and message= " + result);
            }
        } finally {
            httpClient.close();
        }
    }

    private static DefaultHttpClient createHttpClient(int soTimeout) {
        if (soTimeout == 0) {
            soTimeout = CONNECTION_TIME_OUT;
        }
        try {
            HttpParams params = new BasicHttpParams();
            HttpProtocolParams.setVersion(params, HttpVersion.HTTP_1_1);
            HttpProtocolParams.setContentCharset(params, HTTP.DEFAULT_CONTENT_CHARSET);
            HttpProtocolParams.setUseExpectContinue(params, true);
            // 設置超時時間
            params.setParameter(CoreConnectionPNames.CONNECTION_TIMEOUT, soTimeout);
            // 讀取超時
            params.setParameter(CoreConnectionPNames.SO_TIMEOUT, soTimeout);
            params.setParameter("Connection", "Keep-Alive");
            params.setParameter("Content-Length", " 12");

            KeyStore trustStore = KeyStore.getInstance(KeyStore.getDefaultType());
            trustStore.load(null, null);
            MySSLSocketFactory sf = new MySSLSocketFactory(trustStore);
            sf.setHostnameVerifier(MySSLSocketFactory.ALLOW_ALL_HOSTNAME_VERIFIER);

            SchemeRegistry registry = new SchemeRegistry();
            registry.register(new Scheme("http", PlainSocketFactory.getSocketFactory(), 80));
            registry.register(new Scheme("https", sf, 443));
            ClientConnectionManager conMgr = new ThreadSafeClientConnManager(params, registry);

            return new DefaultHttpClient(conMgr, params);
        } catch (Exception e) {
            e.printStackTrace();
            return null;
        }
    }

    public static String sendHttpsPost(String url, String requestBody, String contentType, String hostName) throws Exception {
        log.info("httpsClient訪問開始..." + url);
        CloseableHttpClient httpClient = null;
        try {
            SSLContext sslContext = new SSLContextBuilder().loadTrustMaterial(null, new TrustStrategy() {
                // 默認信任全部證書
                public boolean isTrusted(X509Certificate[] arg0, String arg1) {
                    return true;
                }
            }).build();
            SSLConnectionSocketFactory ssf = new SSLConnectionSocketFactory(sslContext, SSLConnectionSocketFactory.ALLOW_ALL_HOSTNAME_VERIFIER);
            httpClient = HttpClients.custom().setSSLSocketFactory(ssf).build();

            HttpPost httpPost = new HttpPost(url);

            RequestConfig requestConfig = RequestConfig.custom().setConnectTimeout(CONNECTION_TIME_OUT).setSocketTimeout(READDATA_TIMEOUT)
//                    .setProxy(new HttpHost("10.37.84.36", 8080))
                    .build();
            httpPost.setConfig(requestConfig);
            httpPost.setEntity(new StringEntity(requestBody, "UTF-8"));
            if (StringUtils.isNotBlank(hostName)) {
                httpPost.setHeader("HOST", hostName);
            }
            if (StringUtils.isNotBlank(contentType)) {
                httpPost.setHeader("Content-Type", contentType);
            }
            HttpResponse resp = httpClient.execute(httpPost);
            String result = EntityUtils.toString(resp.getEntity(), HTTP.UTF_8);
            int statusCode = resp.getStatusLine().getStatusCode();
            if (statusCode == HttpStatus.SC_OK) {
                return result;
            } else {
                throw new HttpException("HTTP REQUEST FAIL ---- statusCode: " + statusCode + " and result: " + result);
            }
        } catch (Exception e) {
            log.error(e.getMessage(), e);
            throw new RuntimeException("通信未知系統異常", e);
        } finally {
            if (httpClient != null) {
                httpClient.close();
            }
        }
    }
}


/**
 * 過濾證書
 * 
 */
@SuppressWarnings("deprecation")
class MySSLSocketFactory extends SSLSocketFactory {
    SSLContext sslContext = SSLContext.getInstance("TLS");

    public MySSLSocketFactory(KeyStore truststore)
            throws NoSuchAlgorithmException, KeyManagementException,
            KeyStoreException, UnrecoverableKeyException {
        super(truststore);
        TrustManager tm = 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;
            }
        };
        sslContext.init(null, new TrustManager[]{tm}, null);
    }

    @Override
    public Socket createSocket(Socket socket, String host, int port,
                               boolean autoClose) throws IOException, UnknownHostException {
        return sslContext.getSocketFactory().createSocket(socket, host, port,
                autoClose);
    }

    @Override
    public Socket createSocket() throws IOException {
        return sslContext.getSocketFactory().createSocket();
    }
}