HttpURLConnection--支持忽略ssl验证

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import javax.net.ssl.HostnameVerifier;
import javax.net.ssl.HttpsURLConnection;
import javax.net.ssl.SSLSession;
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.Reader;
import java.net.HttpURLConnection;
import java.net.URL;
import java.util.Map;
import java.util.Set;

/**
 * @Description: httpclient
 * @Author: hw
 * @CreateDate: 2019/6/4
 */
public class HttpClientUtil {
    /**
     * 日志
     */
    private static final Logger LOG = LoggerFactory.getLogger(HttpClientUtil.class);

    /**
     * 发送HttpPost请求
     * @param uri 服务地址
     * @param params 请求参数
     * @param headers 请求头
     * @param ignoreSSL 是否忽略ssl验证
     * @return
     * @throws Exception
     * @author hw
     * @date 2019/3/7 16:19
     */
    public static String jsonPost(String uri, String params, Map<String,String> headers, boolean ignoreSSL)throws Exception{
        LOG.info("HTTP POST请求, uri={}, params={}", uri, params);

        //访问准备
        URL url = new URL(uri);
        byte[] postDataBytes = params.getBytes("UTF-8");
        Reader in = null;
        try {
            //https请求忽略ssl证书，该部分必须在获取connection前调用
            if(ignoreSSL){
                trustAllHttpsCertificates();
                HostnameVerifier hv = new HostnameVerifier() {
                    @Override
                    public boolean verify(String urlHostName, SSLSession session) {
                        LOG.info("Warning: URL Host: " + urlHostName + " vs. " + session.getPeerHost());
                        return true;
                    }
                };
                HttpsURLConnection.setDefaultHostnameVerifier(hv);
            }

            HttpURLConnection conn = (HttpURLConnection)url.openConnection();
            conn.setRequestMethod("POST");
            conn.setRequestProperty("Content-Type", "application/json");
            conn.setRequestProperty("Content-Length", String.valueOf(postDataBytes.length));
            conn.setDoOutput(true);
            conn.setConnectTimeout(1000);
            conn.setReadTimeout(1000);
            // 检测请求头
            if(!headers.isEmpty()){
                Set<String> keys = headers.keySet();
                for (String key:keys){
                    conn.setRequestProperty(key, headers.get(key));
                }
            }
            conn.getOutputStream().write(postDataBytes);

            int code = conn.getResponseCode();
            if (code == 200) {
                // 得到网络返回的正确输入流
                in = new BufferedReader(new InputStreamReader(conn.getInputStream(), "UTF-8"));
            } else {
                // 得到网络返回的错误输入流
                in = new BufferedReader(new InputStreamReader(conn.getErrorStream(), "UTF-8"));
            }

            StringBuilder sb = new StringBuilder();
            for (int c; (c = in.read()) >= 0;) {
                sb.append((char) c);
            }
            String response = sb.toString();
            LOG.info(response);
            return response;
        }catch (Exception e){
            LOG.error("执行HTTP POST异常, uri={}, \r参数为:{}, \r异常消息:{}",
                    uri, params, StringUtil.getExceptionStackTrace(e));
        }finally {
            try {
                if(in!=null) {
                    in.close();
                }
            } catch (IOException e) {
                LOG.error("执行HTTP POST关闭Response流异常,uri={}, \rparam={}, \r异常消息:{}",
                        uri, params, StringUtil.getExceptionStackTrace(e));
            }
        }
        return null;
    }

    private static void trustAllHttpsCertificates() throws Exception {
        javax.net.ssl.TrustManager[] trustAllCerts = new javax.net.ssl.TrustManager[1];
        javax.net.ssl.TrustManager tm = new miTM();
        trustAllCerts[0] = tm;
        javax.net.ssl.SSLContext sc = javax.net.ssl.SSLContext.getInstance("SSL");
        sc.init(null, trustAllCerts, null);
        javax.net.ssl.HttpsURLConnection.setDefaultSSLSocketFactory(sc.getSocketFactory());
    }

    static class miTM implements javax.net.ssl.TrustManager, javax.net.ssl.X509TrustManager {
        @Override
        public java.security.cert.X509Certificate[] getAcceptedIssuers() {
            return null;
        }

        public boolean isServerTrusted(java.security.cert.X509Certificate[] certs) {
            return true;
        }

        public boolean isClientTrusted(java.security.cert.X509Certificate[] certs) {
            return true;
        }

        @Override
        public void checkServerTrusted(java.security.cert.X509Certificate[] certs, String authType)
                throws java.security.cert.CertificateException {
            return;
        }

        @Override
        public void checkClientTrusted(java.security.cert.X509Certificate[] certs, String authType)
                throws java.security.cert.CertificateException {
            return;
        }
    }
}