sdds

package com.pingan.ff.esb.proxy.common.http;

import java.io.IOException;
import java.security.KeyManagementException;
import java.security.KeyStoreException;
import java.security.NoSuchAlgorithmException;
import java.security.SecureRandom;
import java.security.cert.CertificateException;
import java.security.cert.X509Certificate;

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

import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.apache.http.client.config.RequestConfig;
import org.apache.http.config.Registry;
import org.apache.http.config.RegistryBuilder;
import org.apache.http.conn.socket.ConnectionSocketFactory;
import org.apache.http.conn.socket.LayeredConnectionSocketFactory;
import org.apache.http.conn.socket.PlainConnectionSocketFactory;
import org.apache.http.conn.ssl.SSLConnectionSocketFactory;
import org.apache.http.conn.ssl.SSLContexts;
import org.apache.http.conn.ssl.TrustStrategy;
import org.apache.http.conn.ssl.X509HostnameVerifier;
import org.apache.http.impl.client.CloseableHttpClient;
import org.apache.http.impl.client.HttpClientBuilder;
import org.apache.http.impl.client.HttpClients;
import org.apache.http.impl.conn.PoolingHttpClientConnectionManager;
import org.springframework.beans.factory.DisposableBean;
import org.springframework.beans.factory.InitializingBean;

import com.pingan.ff.esb.proxy.common.config.HttpConfig;

public class HttpClientUtil implements InitializingBean, DisposableBean {

    private Log logger = LogFactory.getLog(this.getClass());
    /***
     * 杩炴帴姹�
     */
    private PoolingHttpClientConnectionManager cm;

    /***
     * 閰嶇疆httpConfig
     */
    private HttpConfig httpConfig;

    private CloseableHttpClient httpclient;

    private RequestConfig requestConfig;

    public HttpClientUtil() {
    }

    public CloseableHttpClient getCloseableHttpClient() {
HttpClientBuilder httpClientBuilder = null;
if ("https".equals(httpConfig.getAgreement())) {
    LayeredConnectionSocketFactory sslsf = null;
    Registry<ConnectionSocketFactory> registry = null;

    TrustStrategy trustStrategy = new TrustStrategy() {
@Override
public boolean isTrusted(X509Certificate[] xcs, String authType) throws CertificateException {
    return true;
}
    };

    SSLContext sslContext = null;
    try {
sslContext = SSLContexts.custom().useSSL().loadTrustMaterial(null, trustStrategy).setSecureRandom(new SecureRandom()).build();

    } catch (KeyManagementException e) {
e.printStackTrace();
    } catch (NoSuchAlgorithmException e) {
e.printStackTrace();
    } catch (KeyStoreException e) {
e.printStackTrace();
    }

    X509HostnameVerifier x509HostnameVerifier = new HostnameVerifier();

    sslsf = new SSLConnectionSocketFactory(sslContext, new String[] { "TLSv1" }, null, x509HostnameVerifier);

    registry = RegistryBuilder.<ConnectionSocketFactory> create().register("http", PlainConnectionSocketFactory.getSocketFactory()).register("https", sslsf).build();

    cm = new PoolingHttpClientConnectionManager(registry);

    httpClientBuilder = HttpClients.custom().setSSLSocketFactory(sslsf).setDefaultRequestConfig(requestConfig);
} else {
    httpClientBuilder = HttpClients.custom().setDefaultRequestConfig(requestConfig);
}

// 鏄惁浣跨敤杩炴帴姹�
if (httpConfig.isUsePoolEnable()) {
    httpclient = httpClientBuilder.setConnectionManager(cm).build();
} else {
    httpclient = httpClientBuilder.build();
}

return httpclient;
    }

    public PoolingHttpClientConnectionManager getCm() {
return cm;
    }

    public void setCm(PoolingHttpClientConnectionManager cm) {
this.cm = cm;
    }

    public HttpConfig getHttpConfig() {
return httpConfig;
    }

    public void setHttpConfig(HttpConfig httpConfig) {
this.httpConfig = httpConfig;
    }

    public RequestConfig getRequestConfig() {
return requestConfig;
    }

    public void setRequestConfig(RequestConfig requestConfig) {
this.requestConfig = requestConfig;
    }

    @SuppressWarnings("unused")
    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 class HostnameVerifier implements X509HostnameVerifier {
@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 {
}

@Override
public boolean verify(String string, SSLSession ssls) {
    return true;
}
    }

    @Override
    public void afterPropertiesSet() throws Exception {
RequestConfig requestConfig = RequestConfig.custom().setSocketTimeout(httpConfig.getSocketTimeOut()).setConnectTimeout(httpConfig.getConnectionTimeOut()).setConnectionRequestTimeout(httpConfig.getConnectionTimeOut()).setStaleConnectionCheckEnabled(true).build();
this.requestConfig = requestConfig;

    }

    @Override
    public void destroy() throws Exception {

try {
    if (httpclient != null) {
httpclient.close();
logger.info("httpclient shutdown!");
    }
} catch (IOException e) {
    logger.error(" httpclient shutdown error,cause:" + e.getMessage(), e);
}

try {
    if (cm != null) {
cm.close();
logger.info("PoolingHttpClientConnectionManager shutdown!");
    }
} catch (Exception e) {
    logger.error(" PoolingHttpClientConnectionManager shutdown error,cause:" + e.getMessage(), e);
}

    }

}