HttpClient 信任站点,connet忽略证书直接访问https站点

最新推荐文章于 2024-08-12 11:34:51 发布
原创 最新推荐文章于 2024-08-12 11:34:51 发布 · 826 阅读 · 1 ·
本内容遵循CC 4.0 BY-SA版权协议
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
标签
#https #网络协议 #http #java
Python3.8

Python 是一种高级、解释型、通用的编程语言，以其简洁易读的语法而闻名，适用于广泛的应用，包括Web开发、数据分析、人工智能和自动化脚本

使用HttpClient访问https 站点时，如果Java没有导入该站点的证书的话，则会报如下错误：

javax.net.ssl.SSLHandshakeException: sun.security.validator.ValidatorException: PKIX path building failed: sun.security.provider.certpath.SunCertPathBuilderException: unable to find valid certification path to requested target
	at sun.security.ssl.Alerts.getSSLException(Alerts.java:192)
	at sun.security.ssl.SSLSocketImpl.fatal(SSLSocketImpl.java:1946)

因为Java在安装的时候，会默认导入某些根证书，所以有些网站不导入证书，也可以使用Java进行访问。

此外， Java的证书库和浏览器的证书管理是不同的机制， 所以即使在浏览器正常访问，使用Java语言的代码，比如HttpClient 进行访问时同样会出现上述的问题。

工具类


import org.apache.http.HttpEntity;
import org.apache.http.NameValuePair;
import org.apache.http.client.config.RequestConfig;
import org.apache.http.client.entity.UrlEncodedFormEntity;
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.conn.ssl.NoopHostnameVerifier;
import org.apache.http.conn.ssl.SSLConnectionSocketFactory;
import org.apache.http.entity.ContentType;
import org.apache.http.entity.StringEntity;
import org.apache.http.entity.mime.HttpMultipartMode;
import org.apache.http.entity.mime.MultipartEntityBuilder;
import org.apache.http.impl.client.CloseableHttpClient;
import org.apache.http.impl.client.HttpClients;
import org.apache.http.message.BasicNameValuePair;
import org.apache.http.ssl.SSLContextBuilder;
import org.apache.http.ssl.TrustStrategy;
import org.apache.http.util.EntityUtils;

import javax.net.ssl.*;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.net.HttpURLConnection;
import java.net.MalformedURLException;
import java.net.URL;
import java.security.KeyManagementException;
import java.security.NoSuchAlgorithmException;
import java.security.SecureRandom;
import java.security.cert.CertificateException;
import java.security.cert.X509Certificate;
import java.util.*;

public class HttpUtils2 {

    public static String postFile(String url, InputStream inputStream,String filename) throws Exception {
        CloseableHttpClient httpClient = null;
        CloseableHttpResponse response = null;
        try{
            HttpPost httpPost = new HttpPost(url);

            RequestConfig requestConfig = RequestConfig.custom()
                    .setConnectTimeout(60000)
                    .setSocketTimeout(60000)
                    .setConnectionRequestTimeout(60000)
                    .build();
            httpPost.setConfig(requestConfig);

            httpPost.setHeader("Content-Type",ContentType.MULTIPART_FORM_DATA.toString());

            MultipartEntityBuilder multipartEntityBuilder = MultipartEntityBuilder.create().setMode(HttpMultipartMode.RFC6532);
            multipartEntityBuilder.addBinaryBody("file",inputStream,ContentType.APPLICATION_OCTET_STREAM,filename);
            HttpEntity httpEntity = multipartEntityBuilder.build();
            httpPost.setEntity(httpEntity);

            httpClient = createHttpClient(url);
            response = httpClient.execute(httpPost);
            HttpEntity responseEntity = response.getEntity();

            return EntityUtils.toString(responseEntity,"UTF-8");
        }catch (Exception ex){
            throw ex;
        }finally {
            if(response != null){
                response.close();
            }
            if(httpClient != null){
                httpClient.close();
            }
        }
    }

    public static String postJson(String url,String jsonData) throws Exception {
        CloseableHttpClient httpClient = null;
        CloseableHttpResponse response = null;
        try{
            HttpPost httpPost = new HttpPost(url);
            RequestConfig requestConfig = RequestConfig.custom()
                    .setConnectTimeout(30000)
                    .setSocketTimeout(30000)
                    .setConnectionRequestTimeout(30000)
                    .build();
            httpPost.setConfig(requestConfig);

            StringEntity requestEntity = new StringEntity(jsonData,"UTF-8");
            //requestEntity.setContentEncoding("UTF-8");
            httpPost.setHeader("Content-type", "application/json");
            httpPost.setEntity(requestEntity);

            httpClient = createHttpClient(url);
            response = httpClient.execute(httpPost);
            HttpEntity responseEntity = response.getEntity();

            return EntityUtils.toString(responseEntity,"UTF-8");
        }catch (Exception ex){
            throw ex;
        }finally {
            if(response != null){
                response.close();
            }
            if(httpClient != null){
                httpClient.close();
            }
        }
    }

    public static String httpPost(String url, HashMap postData, HashMap header) throws Exception {
        CloseableHttpClient httpClient = null;
        CloseableHttpResponse response = null;
        try{
            HttpPost httpPost = new HttpPost(url);
            RequestConfig requestConfig = RequestConfig.custom()
                    .setConnectTimeout(30000)
                    .setSocketTimeout(30000)
                    .setConnectionRequestTimeout(30000)
                    .build();
            httpPost.setConfig(requestConfig);

            if(header != null){
                header.forEach(
                        (k,v) -> httpPost.setHeader(String.valueOf(k),String.valueOf(v))
                );
            }

            List<NameValuePair> params = new ArrayList<>();
            if(postData != null){
                postData.forEach(
                        (k,v)-> params.add(new BasicNameValuePair(String.valueOf(k),String.valueOf(v)))
                );
            }
            HttpEntity requestEntity = new UrlEncodedFormEntity(params,"UTF-8");
            httpPost.setEntity(requestEntity);

            httpClient = createHttpClient(url);
            response = httpClient.execute(httpPost);
            HttpEntity responseEntity = response.getEntity();

            return EntityUtils.toString(responseEntity,"UTF-8");
        }catch (Exception ex){
            throw ex;
        }finally {
            if(response != null){
                response.close();
            }
            if(httpClient != null){
                httpClient.close();
            }
        }
    }

    public static String httpPost(String url,HashMap postData) throws Exception{
        return httpPost(url,postData,null);
    }

    public static String httpPost(String url)throws Exception {
        return httpPost(url,null);
    }

    public static String httpGet(String url,HashMap header) throws Exception {
        CloseableHttpClient httpClient = null;
        CloseableHttpResponse response = null;
        try{
            HttpGet httpGet = new HttpGet(url);
            RequestConfig requestConfig = RequestConfig.custom()
                    .setConnectTimeout(30000)
                    .setSocketTimeout(30000)
                    .setConnectionRequestTimeout(30000)
                    .build();
            httpGet.setConfig(requestConfig);

            if(header != null){
                header.forEach(
                        (k,v) -> httpGet.setHeader(String.valueOf(k),String.valueOf(v))
                );
            }

            httpClient = createHttpClient(url);
            response = httpClient.execute(httpGet);
            HttpEntity responseEntity = response.getEntity();
            return EntityUtils.toString(responseEntity,"UTF-8");
        }catch (Exception ex){
            throw ex;
        }finally {
            if(response != null){
                response.close();
            }
            if(httpClient != null){
                httpClient.close();
            }
        }
    }

    public static String httpGet(String url) throws Exception{
        return httpGet(url,null);
    }

    /**
     * 发送https请求
     * @param url           url
     * @param requestMethod 请求方式
     * @param param         请求参数
     * @return 返回值
     */
    public static HttpsURLConnection sendHttpsRequest(String url, String requestMethod, String param) {
        StringBuilder result = new StringBuilder();
        HttpsURLConnection conn = null;
        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);
            conn = (HttpsURLConnection) console.openConnection();
            // GET/POST
            conn.setRequestMethod(requestMethod);
            conn.setRequestProperty("Content-Type", "application/json");
            conn.setDoOutput(true);
            conn.setDoInput(true);
            if (null != param) {
                OutputStream outputStream = conn.getOutputStream();
                // 注意编码格式
                outputStream.write(param.getBytes("UTF-8"));
                outputStream.close();
            }

            // 设置证书忽略相关操作
            conn.setSSLSocketFactory(sc.getSocketFactory());
            conn.setHostnameVerifier(new HostnameVerifier() {
                @Override
                public boolean verify(String s, SSLSession sslSession) {
                    return true;
                }
            });
            conn.connect();
            return conn;
        } catch (NoSuchAlgorithmException | KeyManagementException | MalformedURLException e) {
            e.printStackTrace();
        } catch (IOException ioException) {
            ioException.printStackTrace();
        }
        return null;
    }

    // http协议访问方法
    public static HttpURLConnection sendHttpRequest(String url, String requestMethod, String param) {
        StringBuilder result = new StringBuilder();
        HttpURLConnection conn = null;
        try {
            URL console = new URL(url);
            conn = (HttpURLConnection) console.openConnection();
            // GET/POST
            conn.setRequestMethod(requestMethod);
            conn.setRequestProperty("Content-Type", "application/json");
            conn.setDoOutput(true);
            conn.setDoInput(true);
            if (null != param) {
                OutputStream outputStream = conn.getOutputStream();
                // 注意编码格式
                outputStream.write(param.getBytes("UTF-8"));
                outputStream.close();
            }

            conn.connect();
//            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"));
//                }
//            }
//            conn.disconnect();
//            br.close();
        } catch (IOException ioException) {
            ioException.printStackTrace();
        }
        return conn;
    }

    /***
     * 获取httpUrl问号后面的参数
     * @param httpUrl
     * @return
     */
    public static Map<String,String> getUrlParam(String httpUrl){
        Map<String,String> paramMap = new LinkedHashMap<>();
        String[] urlParam = httpUrl.split("\\?");
        if (urlParam.length < 1){
            return paramMap;
        }
        String query = urlParam[1];
        for (String param : query.split("&")){
            String[] pair = param.split("=");
            String key = pair[0].toLowerCase(Locale.ROOT);
            String value = "";
            if (pair.length > 1) {
                value = pair[1];
            }
            paramMap.put(key,value);
        }
        return paramMap;
    }

    /**
     * HttpClient 信任所有的站点
     * @param url
     * @return
     * @throws Exception
     */
    public static CloseableHttpClient createHttpClient(String url) throws Exception {
        if(isHttpsUrl(url)) {
//创建SSL的上下文，类型是SSLContext，该上下文中设置信任策略，信任所有的站点
            SSLContext sslContext = new SSLContextBuilder().loadTrustMaterial(null, new TrustStrategy() {
                @Override
                public boolean isTrusted(java.security.cert.X509Certificate[] x509Certificates, String s) throws java.security.cert.CertificateException {
                    return true;
                }

            }).build();
//基于SSL的上下文，创建SSL连接的套接字工厂对象SSLConnectionSocketFactory
            SSLConnectionSocketFactory sslSocketFactory = new SSLConnectionSocketFactory(sslContext,
                    NoopHostnameVerifier.INSTANCE);

//使用SSLConnectionSocketFactory作为参数，来构建信任所有站点的HttpClient对象
            CloseableHttpClient httpclient = HttpClients.custom().setSSLSocketFactory(sslSocketFactory).build();
            return httpclient;
        }
        return HttpClients.createDefault();
    }

    /**
     * 判断是否https 开始的地址
     * @param val
     * @return
     */
    public static boolean isHttpsUrl(String val) {
        String regex = "^(https)://[a-zA-Z0-9.-]+(:\\d+)?(/.*)?$";
        return val.matches(regex);
    }
}

最后

您可能感兴趣的与本文相关的镜像

Python3.8

Python3.8

Conda
Python

Python 是一种高级、解释型、通用的编程语言，以其简洁易读的语法而闻名，适用于广泛的应用，包括Web开发、数据分析、人工智能和自动化脚本

JAVA使用HttpURLConnection请求HTTPS网站，不需要证书验证的DEMO教程
renkai721的专栏
07-27 5938
最近在爬取一个国外的购物网站商品，首先本地的VPN肯定是打开的，发现浏览器和postman每次都可以请求到内容，但是java代码尝试了各种方式都是Connection refused: connect，一开始以为是java代码的问题，后来突然意识到java是在虚拟机上运行的，可能需要使用代码进行代理，果然如此【虽然VPN打开的，但是java并不会自己去走VPN的那条通道】！ 无法连接的错误消息如下： java.net.ConnectException: Connection refused: con.
关于使用HttpClient进行访问https安全链接，双向认证核心部分讲解
u014411748的博客
07-26 6395
        在开文之前，首先了解几个问题 HTTPS（全称：Hyper Text Transfer Protocol over Secure Socket Layer），是以安全为目标的HTTP通道，简单讲是HTTP的安全版。即HTTP下加入SSL层，HTTPS的安全基础是SSL，因此加密的详细内容就需要SSL。 它是一个URI scheme（抽象标识符体系），句法类同http:体系。...
httpClient忽略https的证书认证
专搞技术的小兔子
01-24 4014
接口地址及参数：https://xxx.xxx.com/api/v3/technicians?input_data={“list_info”:{“search_fields”:{“email_id”:“wjjia@iflytek.com”}}}HttpClient工具类范例。
httpClient发送https请求
时光钟摆
05-22 1万+
前言        我们知道现在的http请求应用的越来越广泛，最常见的场景就是浏览器作为http请求的客户端，请求http服务端。在浏览器发送请求时，会封装请求行，请求头，请求体信息，那我们在用java代码模拟时，也需要带上http请求的这些相关信息。java自带的java.net包是关于java的网络方面的包，但是没有完全的封装好的方法，而org.apache.httpcomponents下的...
HttpClient 忽略证书直接访问https站点
oscar999的专栏
02-20 7172
使用HttpClient 访问https 站点，可以通过以下两种方式忽略证书的检查。 方式1. 信任所有的站点 方式2. 忽略证书认证
httpclient关于https的使用
09-22 3593
用了大半天时间才了解如何使用httpclient来进行https访问，现记录，已备后忘。  httpclient完全支持ssl连接方式。通常，如果不需要进行客户端认证和服务器端认证的ssl连接，httpclient的处理方式是和 http方式完全一样。  现在这里是讲的是需要
关于Https协议和HttpClient的实现详解
liweiminlining的专栏
02-14 3715
介绍了关于Https协议和HttpClient实现
HttpClient 调用https接口的三种方式
HYKung的博客
09-27 1万+
最近在工作过程中遇到使用httpClient去call https接口失败的问题， 所以就此做了个学习记录， 在这过程中可以通过一下三种方式中的任何一种都解决了上诉问题 1.ignore https certificate 通过在httpClient call https接口之前先调用如下代码即可忽略https认证 private static DefaultHttpClient httpClientTrustingAllSSLCerts() throws NoSuchAlgorithmException
httpClient发送https请求，忽略证书详解（亲测有效）
m0_53917137的博客
09-24 1万+
httpClient发送https请求，忽略证书详解（亲测有效）问题原因解决 问题 在项目上线前期。第三方接口的生产地址改用为 ip地址加端口号的形式（测试环境使用的是域名进行访问），导致项目上线后接口不能访问。 报错：doesn't match any of the subject alternative names: [...] 原因 https请求是需要对应的证书才能够进行访问，前面测试通过是因为解析的域名服务器上安装了证书，所以不需要客户端重新安装，而直接访问ip+端口号（直接目标机器）地址，
【httpClient忽略https的证书认证】
最新发布
weixin_45433218的博客
08-12 3817
有四种实现方式（指定SSL/TLS协议版本、指定加密算法和密码套件、自定义信任管理器、自定义主机名验证器），其中通过SSLConnectionSocketFactory指定自定义的主机名验证器（HostnameVerifier），以控制主机名验证的行为。主机名验证器用于验证SSL证书中的主机名与服务器实际的主机名是否匹配。NoopHostnameVerifier是一个空实现的主机名验证器，它绕过了主机名验证，即使主机名不匹配，也会继续进行SSL连接。有的时候为了方便调用，我们会绕过SSL认证。
httpclient来进行https访问
zhaokuner的专栏
06-09 1万+
引用：http://jimmyleeee.blog.163.com/blog/static/9309618200981032419802/ 用了大半天时间才了解如何使用httpclient来进行https访问，现记录，已备后忘。 httpclient完全支持ssl连接方式。通常，如果不需要进行客户端认证和服务器端认证的ssl连接，httpclient的处理方式是和http方式完全一
HttpClient访问https接口
rehjgjdk11的博客
10-24 1311
使用httpClient访问比如百度的首页时，这是一个https协议的地址，由于JDK内置了一些大型CA机构的公钥证书（根证书），所以httpClient会信任这些CA机构颁发的证书，程序能够正常访问。当访问自签证书的接口时，就需要客户端自己对服务器进行校验了。操作系统也有内置的证书，但是无法影响java程序。当使用连接池时，配置稍有不同。需要对证书认证有所了解。
http忽略ssl认证
weixin_54505261的博客
04-25 4996
httpclient证书忽略以及urlconnection证书忽略
HttpClient进行https请求
W_Ying_的博客
08-03 915
使用HttpClient调取第三方接口可能存在调取加密接口，使用https传输方式。本篇文章以具体例子演示调用过程。
java忽略证书验证(兼容http，https)
A1682234的博客
07-14 4284
HttpURLConnection是java的标准类，没有做封装，用起来比较原始，HttpURLConnection通常可以访问http/https协议，但是如果想忽略证书校验的话，需要使用HttpsURLConnection访问url，同时HttpsURLConnection只能访问https的协议。原文链接：https://blog.csdn.net/tianzhonghaoqing/article/details/128529358。java HttpsURLConnection忽略证书。
HttpClient可以直接请求https，为何要绕过ssl证书验证？
YHJ
06-06 6138
本程序使用的HttpClient版本：httpclient4.5.2 一个有意思的现象，看下面这段获取百度首页代码的HttpClient请求： importjava.io.IOException; importorg.apache.http.HttpEntity; importorg.apache.http.client.methods.CloseableHttpResponse; importorg.apache.http.client.methods.HttpGet; im...
httpclient 实现https请求
Cloud_July的专栏
06-15 2万+
httpclient 实现https请求，4.4版本之后，工具类如下：  package com.auth.verification; import java.io.IOException; import java.security.KeyManagementException; import java.security.KeyStoreException; import java.s
httpClient忽略https证书验证
热门推荐
qq_39486119的博客
09-08 6万+
直接上代码 public static String post(String url, String head, String body) throws Exception { // 创建httpClient的默认实例 CloseableHttpClient httpClient = HttpClients.createDefault(); // 忽略https证书验证 httpClient = (CloseableHttpClie
HttpClient详解及如何设置忽略SSL
lixinkuan的博客
07-24 7958
一、简介 HttpClient 是Apache Jakarta Common 下的子项目，可以用来提供高效的、最新的、功能丰富的支持 HTTP 协议的客户端编程工具包，并且它支持 HTTP 协议最新的版本和建议。 HttpClient 是 Apache Jakarta Common 下的子项目，用来提供高效的、最新的、功能丰富的支持 HTTP 协议的客户端编程工具包，并且它支持 HTTP 协议...
Java get/post的https请求忽略ssl证书认证
qq_37850230的博客
03-24 6696
Java get/post的https请求忽略ssl证书认证
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值