public class PoolHttpsClientService {


    // 日誌
    private static final SimpleLogger LOGGER = SimpleLogger.getLogger(PoolHttpsClientService.class);


    private static final String CHAR_SET = "UTF-8";


    // 代理IP
    @Value("${InetAddressStr}")
    private String InetAddressStr;


    // 代理埠
    @Value("${InetPort}")
    private int InetPort;


    /**
     * 最大連線數400
     */
    private static int MAX_CONNECTION_NUM = 400;


    /**
     * 單路由最大連線數80
     */
    private static int MAX_PER_ROUTE = 80;


    /**
     * 向服務端請求超時時間設定(單位:毫秒)
     */
    private static int SERVER_REQUEST_TIME_OUT = 2000;


    /**
     * 服務端響應超時時間設定(單位:毫秒)
     */
    private static int SERVER_RESPONSE_TIME_OUT = 2000;


    /**
     * 建構函式
     */
    private PoolHttpsClientService() {
    }


    private static Object LOCAL_LOCK = new Object();
    
    /**
     * 連線池管理物件
     */
    PoolingHttpClientConnectionManager cm = null;


    /**
     * 
     * 功能描述: <br>
     * 初始化連線池管理物件
     *
     * @see [相關類/方法](可選)
     * @since [產品/模組版本](可選)
     */
    private PoolingHttpClientConnectionManager getPoolManager() {
        final String methodName = "getPoolManager";
        LOGGER.enter(methodName, "initPoolManager");
        if (null == cm) {
            synchronized (LOCAL_LOCK) {
                if (null == cm) {
                    SSLContextBuilder sslContextBuilder = new SSLContextBuilder();
                    try {
                        sslContextBuilder.loadTrustMaterial(null, new TrustSelfSignedStrategy());
                        SSLConnectionSocketFactory socketFactory = new SSLConnectionSocketFactory(
                                sslContextBuilder.build());
                        Registry<ConnectionSocketFactory> socketFactoryRegistry = RegistryBuilder.<ConnectionSocketFactory> create()
                                .register("https", socketFactory)
                                .register("http", new PlainConnectionSocketFactory())
                                .build();
                        cm = new PoolingHttpClientConnectionManager(socketFactoryRegistry);
                        cm.setMaxTotal(MAX_CONNECTION_NUM);
                        cm.setDefaultMaxPerRoute(MAX_PER_ROUTE);
                    } catch (Exception e) {
                        LOGGER.error(methodName, "init PoolingHttpClientConnectionManager Error" + e);
                    }


                }
            }
        }
        LOGGER.exit(methodName, "initPoolManager");
        return cm;
    }


    /**
     * 建立執行緒安全的HttpClient
     * 
     * @param config 客戶端超時設定
     * 
     * @return
     */
    public CloseableHttpClient getHttpsClient(RequestConfig config) {
        final String methodName = "getHttpsClient";
        LOGGER.enter(methodName, "initHttpsClient");
        CloseableHttpClient httpClient = HttpClients.custom().setDefaultRequestConfig(config)
                .setConnectionManager(this.getPoolManager())
                .build();
        LOGGER.exit(methodName, "initHttpsClient");
        return httpClient;
    }


    /**
     * Https post請求
     * 
     * @param url 請求地址
     * @param json 請求引數(如果為null,則表示不請求引數) return 返回結果
     */
    public String poolHttpsPost(String url, JSONObject json) {
        final String methodName = "poolHttpsPost";
        LOGGER.enter(methodName, json);
        CloseableHttpResponse response = null;
 

            HttpPost post = null;
        try {
            // 設定代理
            HttpHost proxy = new HttpHost(InetAddressStr, InetPort);
            // connectTimeout設定伺服器請求超時時間
            // socketTimeout設定伺服器響應超時時間
            RequestConfig requestConfig = RequestConfig.custom().setProxy(proxy)
                    .setSocketTimeout(SERVER_REQUEST_TIME_OUT).setConnectTimeout(SERVER_RESPONSE_TIME_OUT).build();
            post = new HttpPost(url);
            post.setConfig(requestConfig);


            if (json != null) {
                StringEntity se = new StringEntity(json.toString(), CHAR_SET);
                se.setContentEncoding(new BasicHeader(HTTP.CONTENT_TYPE, "application/json;"));
                post.setEntity(se);
            }


            LOGGER.info(methodName, "start post to weixin");
            response = getHttpsClient(requestConfig).execute(post);
            LOGGER.info(methodName, "end post to weixin");
            int status = response.getStatusLine().getStatusCode();
            LOGGER.info(methodName, "return status:" + status);


            String result = null;
            if (status == 200) {
                result = EntityUtils.toString(response.getEntity(), CHAR_SET);
            }
            EntityUtils.consume(response.getEntity());
            response.close();
            LOGGER.exit(methodName);
            return result;
        } catch (Exception e) {
            if (e instanceof SocketTimeoutException) {
                // 伺服器請求超時
                LOGGER.error(methodName, "server request time out");
            } else if (e instanceof ConnectTimeoutException) {
                // 伺服器響應超時(已經請求了)
                LOGGER.error(methodName, "server response time out");
            }
            LOGGER.error(methodName, e.getMessage());
        } finally {
 

                  post.releaseConnection();
            if (response != null) {
                try {
                    EntityUtils.consume(response.getEntity());
                    response.close();
                } catch (IOException e) {
                    LOGGER.error(methodName, e.getMessage());
                }
            }
        }
        LOGGER.exit(methodName);
        // 超時或者網路不通時返回值
        return null;
    }