Https单双向认证

之前与某运营商渠道对接口，对方弄了一个https双向认证，项目非常着急，当时我对https一点概念都没有。

现在平安度过项目预运营期，特来总结。

首先什么是https，所谓Https说白了，就是加密，单向Https是，客户端保存着服务端的证书并信任该证书即可，而双向Https认证就麻烦了，服务器要存你的证书，你也要存服务器的证书。说白了这些都是概念，我们做软件开发的，如果有业余时间可以去研究研究，但实际上业务对接时间都非常紧

出这篇文章的目的在于，百度 + Google我都没有发现特别好的方案，要不就是很老的实现方式。虽然有部分可以用，但很多接口和实现都已经被弃用。未来可能被删除。

以下是我实现的方式，请各位大佬检验：

如果有着急的朋友，可以直接拿这份代码拷贝到你项目中，这是一个独立的工具类，依赖apache httpclient，应该就没有其他的了

       
            org.apache.httpcomponents
            httpclient
            4.5.6
        

import org.apache.http.HttpEntity;
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.socket.ConnectionSocketFactory;
import org.apache.http.conn.socket.LayeredConnectionSocketFactory;
import org.apache.http.conn.socket.PlainConnectionSocketFactory;
import org.apache.http.conn.ssl.SSLConnectionSocketFactory;
import javax.net.ssl.HostnameVerifier;
import org.apache.http.ssl.SSLContexts;
import org.apache.http.conn.ssl.TrustSelfSignedStrategy;
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.HttpClientBuilder;
import org.apache.http.impl.client.HttpClients;
import org.apache.http.impl.conn.PoolingHttpClientConnectionManager;
import org.apache.http.util.EntityUtils;

import javax.net.ssl.SSLContext;
import java.io.*;
import java.nio.charset.Charset;
import java.security.KeyManagementException;
import java.security.KeyStore;
import java.security.KeyStoreException;
import java.security.NoSuchAlgorithmException;
import java.util.Map;

/**

* Created with IntelliJ IDEA.

*

* @Author: eddie

* @Date: 2018-09-27

*/

public class HttpsClientUtil {

/**

* 获取文件流

* HttpsClientUtil.class.getClassLoader().getResource("cert/clients.jks").getFile()

*/

  private static final StringTRUST_STORE_FILE ="";

  public static StringHttpsPostRequest(String requestUrl,String requestBody, String charset)throws Exception{

StringBuffer resultsb =null;

      CloseableHttpClient httpClient = HttpClients.custom().setSSLSocketFactory(initConfig()).build();

      try {

HttpPost httpPost =new HttpPost(requestUrl);

        httpPost.addHeader("timestamp", "");

        StringEntity stringEntity =new StringEntity(requestBody, Charset.forName(charset));

        stringEntity.setContentType("application/json");

        httpPost.setEntity(stringEntity);

        CloseableHttpResponse response = httpClient.execute(httpPost);

        resultsb =send(response);

      }finally {

httpClient.close();

      }

return resultsb ==null ?null : resultsb.toString();

  }

public static StringHttpsGetRequest(String requestUrl, Map paramMap)throws Exception{

StringBuffer resultsb =null;

      CloseableHttpClient httpClient = HttpClients.custom().setSSLSocketFactory(initConfig()).build();

      try {

StringBuffer url =new StringBuffer().append(requestUrl);

          for (String key : paramMap.keySet()){

}

HttpGet httpGet =new HttpGet(requestUrl);

        CloseableHttpResponse response = httpClient.execute(httpGet);

            resultsb =send(response);

      }finally {

httpClient.close();

      }

return resultsb ==null ?null : resultsb.toString();

  }

public static StringHttpGetRequest(String requestUrl)throws Exception{

StringBuffer resultsb =null;

        CloseableHttpClient httpClient =getHttpClient();

        try {

HttpGet httpGet =new HttpGet(requestUrl);

            httpGet.addHeader("Content-Type", "application/json;encoding=utf-8");

            CloseableHttpResponse response = httpClient.execute(httpGet);

            resultsb =send(response);

        }finally {

httpClient.close();

        }

return resultsb ==null ?null : resultsb.toString();

    }

private static StringBuffersend(CloseableHttpResponse response)throws IOException {

try {

StringBuffer resultsb =null;

            HttpEntity entity = response.getEntity();

            if (entity !=null) {

resultsb =new StringBuffer();

                BufferedReader bufferedReader =new BufferedReader(new InputStreamReader(entity.getContent(),"UTF-8"));

                String text;

                while ((text = bufferedReader.readLine()) !=null) {

resultsb.append(text);

                }

}

EntityUtils.consume(entity);

            return resultsb;

        }finally {

response.close();

        }

}

private static SSLConnectionSocketFactoryinitConfig()throws Exception {

KeyStore keyStore = KeyStore.getInstance("jks");

      InputStream in =null;

      try {

in =new FileInputStream(TRUST_STORE_FILE);

        keyStore.load(in, "bld365".toCharArray());

        SSLContext sslcontext = SSLContexts.custom()

.loadTrustMaterial(keyStore, new TrustSelfSignedStrategy())

.loadKeyMaterial(keyStore, "bld365".toCharArray())

.build();

            HostnameVerifier verifier = (s, sslSession) ->true;

        return new SSLConnectionSocketFactory(

sslcontext,

              new String[]{"TLSv1", "TLSv1.1", "TLSv1.2"},

null,

                    verifier

);

      }catch (Exception e) {

e.printStackTrace();

        throw new Exception("初始化client keyStore 失败：" + e.getMessage());

      }finally {

if (null != in) {

in.close();

        }

}

}

private static CloseableHttpClientgetHttpClient() {

RegistryBuilder registryBuilder = RegistryBuilder.create();

        ConnectionSocketFactory plainSF =new PlainConnectionSocketFactory();

        registryBuilder.register("http", plainSF);

        //指定信任密钥存储对象和连接套接字工厂

        try {

KeyStore trustStore = KeyStore.getInstance(KeyStore.getDefaultType());

            TrustStrategy anyTrustStrategy = (x509Certificates, s) ->true;

            HostnameVerifier verifier = (s, sslSession) ->true;

            SSLContext sslContext = SSLContexts.custom().loadTrustMaterial(trustStore, anyTrustStrategy).build();

            LayeredConnectionSocketFactory sslSF =new SSLConnectionSocketFactory(sslContext, verifier);

            registryBuilder.register("https", sslSF);

        }catch (KeyStoreException e) {

throw new RuntimeException(e);

        }catch (KeyManagementException e) {

throw new RuntimeException(e);

        }catch (NoSuchAlgorithmException e) {

throw new RuntimeException(e);

        }

Registry registry = registryBuilder.build();

        //设置连接管理器

        PoolingHttpClientConnectionManager connManager =new PoolingHttpClientConnectionManager(registry);

        return HttpClientBuilder.create().setConnectionManager(connManager).build();

    }

}