java发起http、https请求，并携带cookie、header，post参数放body并可选关闭ssl证书验证，高可用版

公司有个需求是发起https请求对接国家数据接口，需要带header、cookie，并关闭ssl证书验证，搜了很多文章，都说用HttpsURLConnection发起请求，但不知为啥在封装body参数的时候一直报400封装出错，也欢迎指出不足。遂找了这古代的方法，方法虽老但能解决实际问题且不用导包。

HttpsURLConnection报错方法示例（这是报错示例）：

			// 发起HTTPS POST请求
            URL url = new URL("https://example.com/api/resource");
            connection = (HttpsURLConnection) url.openConnection();

            // 设置请求方法为POST
            connection.setRequestMethod("POST");
            connection.setDoOutput(true); // 允许写入请求体
            connection.setRequestProperty("Content-Type", "application/json");

            // 封装请求体参数，这里假设参数是一个 JSON 对象
            String requestBody = "{\"param1\":\"value1\", \"param2\":\"value2\"}";
			//此处封装body参数一直报错
            try (OutputStream os = connection.getOutputStream()) {
                byte[] input = requestBody.getBytes("utf-8");
                os.write(input, 0, input.length);
            }

            // 获取响应
            int responseCode = connection.getResponseCode();
            System.out.println("Response Code: " + responseCode);

            BufferedReader reader = new BufferedReader(new InputStreamReader(connection.getInputStream()));
            String line;
            StringBuilder response = new StringBuilder();
            while ((line = reader.readLine()) != null) {
                response.append(line);
            }
            reader.close();

            System.out.println("Response: " + response.toString());

使用方法（其实cookie也是在header里面）：

<dependency>
<groupId>org.apache.httpcomponents</groupId>
<artifactId>httpasyncclient</artifactId>
<version>4.1.3</version>
</dependency>
<dependency>
<groupId>org.apache.httpcomponents</groupId>
<artifactId>httpcore-nio</artifactId>
<version>4.4.6</version>
</dependency>

1.创建默认证书（可选）

    /**
     * 创建默认证书
     *
     * @return
     */
    public static CloseableHttpClient createSSLClientDefault() {
        try {
            SSLContext sslContext = new SSLContextBuilder().loadTrustMaterial(null, new TrustStrategy() {
                // 信任所有
                public boolean isTrusted(X509Certificate[] chain, String authType) throws CertificateException {
                    return true;
                }
            }).build();
            HostnameVerifier hostnameVerifier = NoopHostnameVerifier.INSTANCE;
            SSLConnectionSocketFactory sslsf = new SSLConnectionSocketFactory(sslContext, hostnameVerifier);
            return HttpClients.custom().setSSLSocketFactory(sslsf).build();
        } catch (Exception e) {
            e.printStackTrace();
        }
        return HttpClients.createDefault();

    }

2.post请求：

   public static String dopost(String reqUrl, String json, Map<String, String> headerMap) {
        String strResult = "";
        CloseableHttpResponse response = null;
        CloseableHttpClient httpClient = null;
        if (reqUrl.startsWith("https")) {
        	//可选
            httpClient = createSSLClientDefault();
        } else {
            httpClient = HttpClients.custom()
                    .setDefaultRequestConfig(
                            RequestConfig.custom()
                                    .setSocketTimeout(1 * 60 * 1000)
                                    .setConnectTimeout(1000)
                                    .setConnectionRequestTimeout(1000)
                                    .build()
                    ).build();
        }

        HttpEntity httpEntity = null;
        try {
            HttpPost httpPost = new HttpPost(reqUrl);

            if (headerMap != null) {
                headerMap.forEach((k, v) -> httpPost.addHeader(k, v));
            }

            StringEntity entity = new StringEntity(json, "UTF-8");//解决中文乱码问题
            entity.setContentType("application/json");
            httpPost.setEntity(entity);
            response = httpClient.execute(httpPost, HttpClientContext.create());
            int status = response.getStatusLine().getStatusCode();
            httpEntity = response.getEntity();
            if (status == 200) {
                String string = EntityUtils.toString(httpEntity, StandardCharsets.UTF_8);
                return EntityUtils.toString(httpEntity, StandardCharsets.UTF_8);
            } else {
                log.error(reqUrl + " 请求错误：\r\t" + EntityUtils.toString(httpEntity, StandardCharsets.UTF_8));
            }
            return strResult;
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            try {
                if (httpEntity != null) {
                    EntityUtils.consume(httpEntity);
                }
                if (response != null) {
                    response.close();
                }
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
        return strResult;
    }

3.get请求：

    public static ResultVo sendHttpsRequest(String url, String requestMethod, String
            param, Map<String, String> headers, String cookieStr) {
        ResultVo vo = new ResultVo();
        StringBuilder result = new StringBuilder();
        try {
        	//屏蔽证书验证
            SSLContext sc = SSLContext.getInstance("SSL");
            sc.init(null, new TrustManager[]{
                    new X509TrustManager() {
                        @Override
                        public void checkClientTrusted(X509Certificate[] x509Certificates, String s) throws CertificateException {
                        }

                        @Override
                        public void checkServerTrusted(X509Certificate[] x509Certificates, String s) throws CertificateException {
                        }

                        @Override
                        public X509Certificate[] getAcceptedIssuers() {
                            return new X509Certificate[0];
                        }
                    }
            }, new SecureRandom());
            URL console = new URL(url);
            HttpsURLConnection conn = (HttpsURLConnection) console.openConnection();
            // GET/POST
            conn.setRequestMethod(requestMethod);
//            conn.setDoOutput(true);
            conn.setDoInput(true);
            if ("POST".equals(requestMethod)) {
                try (DataOutputStream wr = new DataOutputStream(conn.getOutputStream())) {
                    wr.writeBytes(param);
                    wr.flush();
                }
                conn.setRequestProperty("Content-Type", "application/json");
            } else {
                if (null != param) {
                    OutputStream outputStream = conn.getOutputStream();
                    // 注意编码格式
                    outputStream.write(param.getBytes("UTF-8"));
                    outputStream.close();
                }
            }
            if (ObjectUtil.isNotEmpty(headers)) {
                for (String s : headers.keySet()) {
                    conn.setRequestProperty(s, headers.get(s));
                }
            }
            conn.setRequestProperty("Cookie", cookieStr);


            // 设置证书忽略相关操作
            conn.setSSLSocketFactory(sc.getSocketFactory());
            conn.setHostnameVerifier(new HostnameVerifier() {
                @Override
                public boolean verify(String s, SSLSession sslSession) {
                    return true;
                }
            });
            conn.connect();
            int responseCode = conn.getResponseCode();
            if (responseCode == HttpURLConnection.HTTP_OK) {
                InputStream is = conn.getInputStream();
                BufferedReader br = new BufferedReader(new InputStreamReader(is));
                String ret = "";
                //输出响应信息
                while ((ret = br.readLine()) != null) {
                    if (ret != null && !ret.trim().equals("")) {
                        result.append(new String(ret.getBytes("utf-8"), "utf-8"));
                    }
                }
                List<String> cookies = conn.getHeaderFields().get("Set-Cookie");
                //这里返回了连接的cookie信息
                if (cookies != null) {
                    for (String cookie : cookies) {
                        if (cookie.contains(SyncInfoConfig.COOKIE_NAME)) {
                            // 找到目标Cookie
                            String sidCookie = cookie.split(";\\s*")[0];
                            vo.setCookieInfo(sidCookie);
                            break;
                        }
                    }
                }
                conn.disconnect();
                br.close();
            }
        } catch (NoSuchAlgorithmException | KeyManagementException | MalformedURLException e) {
            e.printStackTrace();
        } catch (IOException ioException) {
            ioException.printStackTrace();
        }
        if (ObjectUtil.isNotEmpty(result)) {
            vo.setResultStr(result.toString());
        }
        return vo;
    }