httpClient ignore SSL post https

/**

<dependency>
    <groupId>com.alibaba</groupId>
    <artifactId>fastjson</artifactId>
    <version>1.2.47</version>
</dependency>
<!-- HttpClient-->
<dependency>
    <groupId>org.apache.httpcomponents</groupId>
    <artifactId>httpclient</artifactId>
    <version>4.5.9</version>
</dependency>
<!--<dependency>
    <groupId>org.apache.httpcomponents</groupId>
    <artifactId>httpcore</artifactId>
    <version>4.4.6</version>
</dependency>-->
<dependency>
    <groupId>commons-lang</groupId>
    <artifactId>commons-lang</artifactId>
    <version>2.6</version>
</dependency>
<dependency>
    <groupId>org.projectlombok</groupId>
    <artifactId>lombok</artifactId>
    <version>1.16.18</version>
</dependency>

*/

import com.alibaba.fastjson.JSON;
import org.apache.http.HttpEntity;
import org.apache.http.client.config.RequestConfig;
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.config.Registry;
import org.apache.http.config.RegistryBuilder;
import org.apache.http.conn.HttpClientConnectionManager;
import org.apache.http.conn.socket.ConnectionSocketFactory;
import org.apache.http.conn.socket.PlainConnectionSocketFactory;
import org.apache.http.conn.ssl.NoopHostnameVerifier;
import org.apache.http.conn.ssl.SSLConnectionSocketFactory;
import org.apache.http.conn.ssl.TrustStrategy;
import org.apache.http.entity.StringEntity;
import org.apache.http.impl.client.CloseableHttpClient;
import org.apache.http.impl.client.HttpClients;
import org.apache.http.impl.conn.PoolingHttpClientConnectionManager;
import org.apache.http.ssl.SSLContexts;
import org.apache.http.util.EntityUtils;

import javax.net.ssl.*;
import java.security.KeyManagementException;
import java.security.NoSuchAlgorithmException;
import java.security.cert.CertificateException;
import java.security.cert.X509Certificate;
import java.util.HashMap;
import java.util.Map;

public class httpClientUtil {

//採用繞過驗證的方式處理https請求
   // SSLContext sslcontext = createIgnoreVerifySSL();
public static CloseableHttpClient getIgnoeSSLClient() throws Exception {
    SSLContext sslContext = SSLContexts.custom().loadTrustMaterial(null, new TrustStrategy() {

        public boolean isTrusted(X509Certificate[] x509Certificates, String s) throws CertificateException {
            return true;
        }
    }).build();



    //CloseableHttpClient client = HttpClients.createDefault();*/

    //設置協議http和https對應的處理socket連接工廠的對象

    Registry<ConnectionSocketFactory> socketFactoryRegistry = RegistryBuilder.<ConnectionSocketFactory>create()
            .register("http", PlainConnectionSocketFactory.INSTANCE)
            .register("https", new SSLConnectionSocketFactory(sslContext))
            .build();

    //HttpClientConnectionManager cm = new PoolingHttpClientConnectionManager(rrrr);

    PoolingHttpClientConnectionManager connManager = new PoolingHttpClientConnectionManager(socketFactoryRegistry);



    //建立httpClient
    CloseableHttpClient client = HttpClients.custom()
                                            .setSSLContext(sslContext).setConnectionManager(connManager).
                                            setSSLHostnameVerifier(new NoopHostnameVerifier()).build();
    return client;
}


public final static void main(String[] args) throws Exception {

    CloseableHttpClient httpClient =getIgnoeSSLClient();
    CloseableHttpClient httpClient1 = null;

   // try {

  /*      // 加載自定義的keystore
       // SSLContext sslContext = SSLContexts.custom().loadTrustMaterial(new File("D:/java/IdeaProjects/test/src/main/resources/certs/my.keystore"), "123456".toCharArray()).build();

        SSLContext sslContext = createIgnoreVerifySSL();
        // 默認的域名校驗類爲DefaultHostnameVerifier，比對服務器證書的AlternativeName和CN兩個屬性。
        // 若是服務器證書這二者不合法而咱們又必須讓其校驗經過，則能夠本身實現HostnameVerifier。
        SSLConnectionSocketFactory sslConnectionSocketFactory = new SSLConnectionSocketFactory(sslContext, new HostnameVerifier() {
            public boolean verify(String s, SSLSession sslSession) {
                // 咱們能夠重寫域名校驗邏輯
                return true;
            }
        });

        // 一個httpClient對象對於https僅會選用一個SSLConnectionSocketFactory
        // 至少在4.5.3和4.5.4中，若是給HttpClient對象設置ConnectionManager，咱們必須在PoolingHttpClientConnectionManager的構造方法中傳入Registry，
        // 並將https對應的工廠設置爲咱們本身的SSLConnectionSocketFactory對象，由於在DefaultHttpClientConnectionOperator.connect()中，邏輯是從這裏找SSLConnectionSocketFactory的。
        PoolingHttpClientConnectionManager connectionManager = new PoolingHttpClientConnectionManager(RegistryBuilder.<ConnectionSocketFactory>create()
                .register("http", PlainConnectionSocketFactory.getSocketFactory())
                .register("https", sslConnectionSocketFactory)
                .build());
        connectionManager.setMaxTotal(20);
        connectionManager.setDefaultMaxPerRoute(20);

        httpClient1 = HttpClients.custom()
                // 不在connectionManager中註冊，僅在這裏設置SSLConnectionSocketFactory是無效的，詳見build()內部邏輯，在connectionManager不爲null時，不會使用裏的SSLConnectionSocketFactory
                .setSSLSocketFactory(sslConnectionSocketFactory)
                .setConnectionManager(connectionManager)
                .build();*/

 /*       httpClient = getIgnoeSSLClient();


        HttpGet httpGet = new HttpGet("https://www.12306.cn");
        System.out.println("Executing request " + httpGet.getRequestLine());
        CloseableHttpResponse response = httpClient.execute(httpGet);
        System.out.println("----------------------------------------");
        System.out.println(response.getStatusLine());
        System.out.println(EntityUtils.toString(response.getEntity(), "UTF-8"));

    } catch (Exception e) {
        e.printStackTrace();
    } finally {
        try {
            if (null != httpClient) {
                httpClient.close();
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
    }*/



    String body = "";

  /*  //採用繞過驗證的方式處理https請求
    SSLContext sslcontext = createIgnoreVerifySSL();
    //設置協議http和https對應的處理socket連接工廠的對象
    Registry<ConnectionSocketFactory> socketFactoryRegistry = RegistryBuilder.<ConnectionSocketFactory>create()
            .register("http", PlainConnectionSocketFactory.INSTANCE)
            .register("https", new SSLConnectionSocketFactory(sslcontext))
            .build();
    PoolingHttpClientConnectionManager connManager = new PoolingHttpClientConnectionManager(socketFactoryRegistry);
    HttpClients.custom().setConnectionManager(connManager);

    //建立自定義的httpclient對象
    CloseableHttpClient client = HttpClients.custom().setConnectionManager(connManager).build();
    //CloseableHttpClient client = HttpClients.createDefault();*/

    try{
        //建立post方式請求對象
        HttpPost httpPost = new HttpPost("https://www.douban.com/service/apikey/apply");//https://api.douban.com/v2/book/1220562


        //指定報文頭Content-type、User-Agent
        httpPost.setHeader("Content-type", "application/x-www-form-urlencoded");

        httpPost.setHeader("User-Agent", "Mozilla/5.0 (Windows NT 6.1; rv:6.0.2) Gecko/20100101 Firefox/6.0.2");

        //setConnectTimeout：設置鏈接超時時間，單位毫秒。
        //setConnectionRequestTimeout：設置從connect Manager獲取Connection 超時時間，單位毫秒。這個屬性是新加的屬性，由於目前版本是能夠共享鏈接池的。
        //setSocketTimeout：請求獲取數據的超時時間，單位毫秒。 若是訪問一個接口，多少時間內沒法返回數據，就直接放棄這次調用。


        RequestConfig requestConfig = RequestConfig.custom().setConnectTimeout(5000).setConnectionRequestTimeout(5000).setSocketTimeout(5000).build();


        httpPost.setConfig( requestConfig);

        //apikey: "0b2bdeda43b5688921839c8ecb20399b"

        Map<String,String> params = new HashMap<String, String>();
        params.put("apikey","0b2bdeda43b5688921839c8ecb20399b");

        StringEntity stringEntity = new StringEntity(JSON.toJSONString(params),"utf-8");
        httpPost.setEntity(stringEntity);


        //執行請求操做，並拿到結果（同步阻塞）
        CloseableHttpResponse response = httpClient.execute(httpPost);

        //獲取結果實體
        HttpEntity entity = response.getEntity();
        if (entity != null) {
            //按指定編碼轉換結果實體爲String類型
            body = EntityUtils.toString(entity, "UTF-8");
        }

        EntityUtils.consume(entity);
        //釋放連接
        response.close();
        System.out.println("body:" + body);
    }finally{
        httpClient.close();
    }




}




public static SSLContext createIgnoreVerifySSL() throws NoSuchAlgorithmException, KeyManagementException {
    SSLContext sc = SSLContext.getInstance("SSLv3");

    // 實現一個X509TrustManager接口，用於繞過驗證，不用修改裏面的方法
    X509TrustManager trustManager = new X509TrustManager() {
        public void checkClientTrusted(
                java.security.cert.X509Certificate[] paramArrayOfX509Certificate,
                String paramString) throws CertificateException {
        }

        public void checkServerTrusted(
                java.security.cert.X509Certificate[] paramArrayOfX509Certificate,
                String paramString) throws CertificateException {
        }

        public java.security.cert.X509Certificate[] getAcceptedIssuers() {
            return null;
        }
    };
    sc.init(null, new TrustManager[] { trustManager }, null);
    return sc;
}

}