基于java net包实现HTTPS http 的httputils

已于 2022-04-19 16:27:22 修改
阅读量883 收藏
点赞数 1
分类专栏： java 文章标签： java http net
于 2021-02-26 22:40:32 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_39355187/article/details/114155919
版权

   目前大多数项目中为了实现http 、https调用 大家会引入大量的第三方jar包，但对里面的参数设置又模棱两可，导致有的项目上线后，时间一长就会出现资源耗尽的情况。但大部分人却对jdk的net包进行忽视。

package com.vivo.es;


import com.fasterxml.jackson.core.JsonGenerator;
import com.fasterxml.jackson.core.JsonParser;
import com.fasterxml.jackson.databind.DeserializationFeature;
import com.fasterxml.jackson.databind.MapperFeature;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.fasterxml.jackson.databind.SerializationFeature;
import org.apache.commons.io.IOUtils;

import javax.net.ssl.*;
import java.io.*;
import java.net.HttpURLConnection;
import java.net.URL;
import java.nio.charset.StandardCharsets;
import java.security.SecureRandom;
import java.security.cert.CertificateException;
import java.security.cert.X509Certificate;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

public class JavaOriginalHttpClientUtil {

    public static final ObjectMapper objectMapper = new ObjectMapper();
    public static final String END = "\r\n";
    public static final String TWOHYPHENS = "--";
    public static final String BOUNDARY = "******";
    private static int CONNECT_TIMEOUT = 5000;
    private static int READ_TIMEOUT = 5000;
    private static int CHUNK_LENGTH = 128 * 1024;
    static {
        objectMapper.configure(JsonParser.Feature.ALLOW_COMMENTS, true);
        objectMapper.configure(JsonParser.Feature.ALLOW_SINGLE_QUOTES, true);
        objectMapper.configure(JsonParser.Feature.ALLOW_UNQUOTED_FIELD_NAMES, true);
        objectMapper.configure(JsonParser.Feature.ALLOW_YAML_COMMENTS, true);
        objectMapper.configure(JsonParser.Feature.AUTO_CLOSE_SOURCE, true);
        objectMapper.configure(JsonParser.Feature.IGNORE_UNDEFINED, true);
        objectMapper.configure(JsonParser.Feature.INCLUDE_SOURCE_IN_LOCATION, true);
        objectMapper.configure(JsonParser.Feature.STRICT_DUPLICATE_DETECTION, false);
        objectMapper.configure(JsonGenerator.Feature.STRICT_DUPLICATE_DETECTION, false);
        objectMapper.configure(JsonGenerator.Feature.IGNORE_UNKNOWN, true);
        objectMapper.configure(JsonGenerator.Feature.AUTO_CLOSE_JSON_CONTENT, true);
        objectMapper.configure(JsonGenerator.Feature.AUTO_CLOSE_TARGET, true);
        objectMapper.configure(JsonGenerator.Feature.WRITE_BIGDECIMAL_AS_PLAIN, false);
        objectMapper.configure(MapperFeature.ACCEPT_CASE_INSENSITIVE_ENUMS, false);
        objectMapper.configure(MapperFeature.ACCEPT_CASE_INSENSITIVE_PROPERTIES, false);
        objectMapper.configure(MapperFeature.ACCEPT_CASE_INSENSITIVE_ENUMS, false);
        objectMapper.configure(MapperFeature.ACCEPT_CASE_INSENSITIVE_VALUES, false);
        objectMapper.configure(MapperFeature.USE_WRAPPER_NAME_AS_PROPERTY_NAME, false);
        objectMapper.configure(MapperFeature.USE_STD_BEAN_NAMING, false);
        objectMapper.configure(MapperFeature.ALLOW_EXPLICIT_PROPERTY_RENAMING, false);
        objectMapper.configure(MapperFeature.ALLOW_COERCION_OF_SCALARS, true);
        objectMapper.configure(MapperFeature.IGNORE_DUPLICATE_MODULE_REGISTRATIONS, true);
        objectMapper.configure(MapperFeature.IGNORE_MERGE_FOR_UNMERGEABLE, true);
        objectMapper.configure(MapperFeature.BLOCK_UNSAFE_POLYMORPHIC_BASE_TYPES, false);
        objectMapper.configure(DeserializationFeature.USE_BIG_DECIMAL_FOR_FLOATS, false);
        objectMapper.configure(DeserializationFeature.USE_BIG_INTEGER_FOR_INTS, false);
        objectMapper.configure(DeserializationFeature.USE_LONG_FOR_INTS, false);
        objectMapper.configure(DeserializationFeature.USE_JAVA_ARRAY_FOR_JSON_ARRAY, false);
        objectMapper.configure(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES, true);
        objectMapper.configure(DeserializationFeature.FAIL_ON_NULL_FOR_PRIMITIVES, false);
        objectMapper.configure(DeserializationFeature.FAIL_ON_INVALID_SUBTYPE, true);
        objectMapper.configure(DeserializationFeature.FAIL_ON_MISSING_CREATOR_PROPERTIES, false);
        objectMapper.configure(DeserializationFeature.FAIL_ON_NULL_CREATOR_PROPERTIES, false);
        objectMapper.configure(DeserializationFeature.FAIL_ON_MISSING_EXTERNAL_TYPE_ID_PROPERTY, true);
        objectMapper.configure(DeserializationFeature.FAIL_ON_TRAILING_TOKENS, false);
        objectMapper.configure(DeserializationFeature.WRAP_EXCEPTIONS, true);
        objectMapper.configure(DeserializationFeature.ACCEPT_SINGLE_VALUE_AS_ARRAY, false);
        objectMapper.configure(DeserializationFeature.UNWRAP_SINGLE_VALUE_ARRAYS, false);
        objectMapper.configure(DeserializationFeature.UNWRAP_ROOT_VALUE, false);
        objectMapper.configure(DeserializationFeature.ACCEPT_EMPTY_STRING_AS_NULL_OBJECT, false);
        objectMapper.configure(DeserializationFeature.READ_ENUMS_USING_TO_STRING, false);
        objectMapper.configure(DeserializationFeature.READ_UNKNOWN_ENUM_VALUES_AS_NULL, false);
        objectMapper.configure(DeserializationFeature.READ_UNKNOWN_ENUM_VALUES_USING_DEFAULT_VALUE, false);
        objectMapper.configure(DeserializationFeature.READ_DATE_TIMESTAMPS_AS_NANOSECONDS, true);
        objectMapper.configure(DeserializationFeature.ADJUST_DATES_TO_CONTEXT_TIME_ZONE, true);
        objectMapper.configure(DeserializationFeature.EAGER_DESERIALIZER_FETCH, true);
        objectMapper.configure(SerializationFeature.WRAP_ROOT_VALUE, false);
        objectMapper.configure(SerializationFeature.INDENT_OUTPUT, false);
        objectMapper.configure(SerializationFeature.FAIL_ON_EMPTY_BEANS, true);
        objectMapper.configure(SerializationFeature.FAIL_ON_SELF_REFERENCES, true);
        objectMapper.configure(SerializationFeature.WRAP_EXCEPTIONS, true);
        objectMapper.configure(SerializationFeature.FAIL_ON_UNWRAPPED_TYPE_IDENTIFIERS, true);
        objectMapper.configure(SerializationFeature.WRITE_SELF_REFERENCES_AS_NULL, false);
        objectMapper.configure(SerializationFeature.CLOSE_CLOSEABLE, false);
        objectMapper.configure(SerializationFeature.FLUSH_AFTER_WRITE_VALUE, true);
        objectMapper.configure(SerializationFeature.WRITE_DATES_AS_TIMESTAMPS, true);
        objectMapper.configure(SerializationFeature.WRITE_DATE_KEYS_AS_TIMESTAMPS, false);
        objectMapper.configure(SerializationFeature.WRITE_DATES_WITH_ZONE_ID, false);
        objectMapper.configure(SerializationFeature.WRITE_DURATIONS_AS_TIMESTAMPS, true);
        objectMapper.configure(SerializationFeature.WRITE_CHAR_ARRAYS_AS_JSON_ARRAYS, false);
        objectMapper.configure(SerializationFeature.WRITE_ENUMS_USING_TO_STRING, false);
        objectMapper.configure(SerializationFeature.WRITE_ENUMS_USING_INDEX, false);
        objectMapper.configure(SerializationFeature.WRITE_ENUM_KEYS_USING_INDEX, false);
        objectMapper.configure(SerializationFeature.WRITE_SINGLE_ELEM_ARRAYS_UNWRAPPED, false);
        objectMapper.configure(SerializationFeature.WRITE_DATE_TIMESTAMPS_AS_NANOSECONDS, true);
        objectMapper.configure(SerializationFeature.ORDER_MAP_ENTRIES_BY_KEYS, false);
        objectMapper.configure(SerializationFeature.EAGER_SERIALIZER_FETCH, true);
        objectMapper.configure(SerializationFeature.USE_EQUALITY_FOR_OBJECT_ID, false);
    }

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

//        Data o = doGet("http://cis-test.vivo.xyz/cis-admin/health", null, Data.class);
//        System.out.println(o);
        HashMap<String, String> headers = new HashMap<>();
        headers.put("token", "eyJ0eXAiOiJKV1QiLCJhbGciOiJIUzI1NiJ9.eyJhY2NvdW50SWQiOiIxZmRlNjgwMmQ1YjM0NzU4ODcyYjg1YzExODhlMjUxNSIsInRlbmFudElkIjoiMmY4YWE1Y2I3NDQ3NDcwOGE2Yjg5NWRlMjVmNjRjNDkiLCJjaGFubmVsIjpudWxsLCJpc3MiOiJvM3VrVlpMa2tyQWM1SVgyazk4NEUwZG96U2ZEWlFzcSIsInBhcmFtcyI6eyJuaWNrbmFtZSI6IuadjuW6miIsImFkbWluIjpmYWxzZSwidXNlcklkIjoyOTA4fSwiZXhwIjoxNjQ4NDQ1MzY3LCJpYXQiOjE2NDg0MzgxNjd9.YLhM2lNnesyKMdCTxLoQUuisKeTlWfoB5ButOrq17yQ");
        String o1 = doGet("https://devops.vivo.xyz", headers, String.class);
        System.out.println(o1);
//        HashMap<String, String> param = new HashMap<>();
//        param.put("lg", "lg");
//        HashMap<String, List<File>> files = new HashMap<>();
        ArrayList<File> objects = new ArrayList<>();
        objects.add(new File("E:\\workspace\\spring-es\\src\\main\\java\\com\\vivo\\es\\SpringEsApplication.java"));
        objects.add(new File("E:\\workspace\\spring-es\\src\\main\\java\\com\\vivo\\es\\SpringEsApplication.java"));
        objects.add(new File("E:\\workspace\\spring-es\\src\\main\\java\\com\\vivo\\es\\SpringEsApplication.java"));
        files.put("files", objects);

        String s = doPostUploadFile("http://127.0.0.1:9998/web/uploadsinglefile", headers, param, files, String.class);
        System.out.println(s);
//
//
//        String s = doPostForm("http://127.0.0.1:9998/web/add", headers, param, String.class);
//        System.out.println(s);


    }


    public static <T> T doGet(String urlStr, Map<String, String> headers, Class<T> tClass) throws Exception {
        HttpURLConnection httpURLConnection = getConnection(urlStr);
        httpURLConnection.setRequestMethod("GET");
        if (headers != null) {
            for (Map.Entry<String, String> entry : headers.entrySet()) {
                httpURLConnection.setRequestProperty(entry.getKey(), entry.getValue());
            }
        }
        httpURLConnection.connect();
        return getResponse(tClass, httpURLConnection);
    }


    public static <T> T doPostJson(String urlStr, Map<String, String> headers, Object param, Class<T> tClass) throws Exception {

        HttpURLConnection httpURLConnection = getConnection(urlStr);
        // 设置连接请求方式
        httpURLConnection.setRequestMethod("POST");
        // 默认值为：false，当向远程服务器传送数据/写数据时，需要设置为true
        httpURLConnection.setDoOutput(true);
        // 默认值为：true，当前向远程服务读取数据时，设置为true，该参数可有可无
        httpURLConnection.setDoInput(true);
        httpURLConnection.setRequestProperty("Content-Type", "application/json");
        if (headers != null) {
            for (Map.Entry<String, String> entry : headers.entrySet()) {
                httpURLConnection.setRequestProperty(entry.getKey(), entry.getValue());
            }
        }
        httpURLConnection.connect();
        try (OutputStream os = httpURLConnection.getOutputStream();) {
            os.write(param instanceof String ? ((String) param).getBytes(StandardCharsets.UTF_8) : objectMapper.writeValueAsBytes(param));
            return getResponse(tClass, httpURLConnection);
        }
    }

    public static <T> T doPostForm(String urlStr, Map<String, String> headers, Map<String, String> param, Class<T> tClass) throws Exception {
        HttpURLConnection httpURLConnection = getConnection(urlStr);
        // 设置连接请求方式
        httpURLConnection.setRequestMethod("POST");
        // 默认值为：false，当向远程服务器传送数据/写数据时，需要设置为true
        httpURLConnection.setDoOutput(true);
        // 默认值为：true，当前向远程服务读取数据时，设置为true，该参数可有可无
        httpURLConnection.setDoInput(true);
        // 设置传入参数的格式:请求参数应该是 name1=value1&name2=value2 的形式。
        httpURLConnection.setRequestProperty("Content-Type", "application/x-www-form-urlencoded");
        if (headers != null) {
            for (Map.Entry<String, String> entry : headers.entrySet()) {
                httpURLConnection.setRequestProperty(entry.getKey(), entry.getValue());
            }
        }
        httpURLConnection.connect();
        try (OutputStream os = httpURLConnection.getOutputStream();) {
            os.write(createLinkString(param).getBytes(StandardCharsets.UTF_8));
            return getResponse(tClass, httpURLConnection);
        }

    }



    public static <T> T doPostUploadFile(String urlStr, Map<String, String> headers, Map<String, String> param, Map<String, List<File>> uploadFiles, Class<T> tClass) throws Exception {
        OutputStream outputStream = null;
        try {

            HttpURLConnection urlConnection = getConnection(urlStr);
            urlConnection.setChunkedStreamingMode(CHUNK_LENGTH);
            urlConnection.setDoInput(true);
            urlConnection.setDoOutput(true);
            urlConnection.setUseCaches(true);
            urlConnection.setRequestMethod("POST");
            urlConnection.setRequestProperty("Connection", "close");
            urlConnection.setRequestProperty("Charset", "UTF-8");
            urlConnection.setRequestProperty("Content-Type", "multipart/form-data;boundary=" + BOUNDARY);
            if (headers != null) {
                for (Map.Entry<String, String> entry : headers.entrySet()) {
                    urlConnection.setRequestProperty(entry.getKey(), entry.getValue());
                }
            }
            outputStream = urlConnection.getOutputStream();
            // 处理文本==============================
            if (param != null) {
                for (Map.Entry<String, String> entry : param.entrySet()) {
                    String name = entry.getKey();
                    String value = entry.getValue();
                    if (value == null) {
                        continue;
                    }
                    value = new String(value.getBytes("utf-8"));
                    String strData = END + TWOHYPHENS + BOUNDARY + END;
                    outputStream.write(strData.getBytes(StandardCharsets.UTF_8));
                    strData = "Content-Disposition: form-data; name=\"" + name + "\"" + END + END + value;
                    outputStream.write(strData.getBytes(StandardCharsets.UTF_8));
                }
            }
// 处理文件上传==============================
            if (uploadFiles != null) {
                for (Map.Entry<String, List<File>> entry : uploadFiles.entrySet()) {
                    String name = entry.getKey();
                    List<File> files = entry.getValue();
                    if (files == null || files.isEmpty()) {
                        continue;
                    }
                    for (File file : files) {
                        outputStream.write((END + TWOHYPHENS + BOUNDARY + END).getBytes(StandardCharsets.UTF_8));
                        outputStream.write(("Content-Disposition: form-data; name=\"" + name + "\"; filename=\""
                                + file.getName() + "\"" + END).getBytes(StandardCharsets.UTF_8));
                        outputStream.write(END.getBytes(StandardCharsets.UTF_8));
                        try (InputStream inputStream = new FileInputStream(file)) {
                            IOUtils.copy(inputStream,outputStream,1024*1024);
                        }
                    }

                }
            }
            outputStream.write(END.getBytes(StandardCharsets.UTF_8));
            outputStream.write((TWOHYPHENS + BOUNDARY + TWOHYPHENS + END).getBytes(StandardCharsets.UTF_8));
            outputStream.flush();
            return getResponse(tClass, urlConnection);
        } finally {
            IOUtils.close(outputStream);
        }
    }

    private static <T> T getResponse(Class<T> tClass, HttpURLConnection urlConnection) throws IOException {
        try (InputStream inputStream = urlConnection.getInputStream();
             ByteArrayOutputStream byteArrayOutputStream = new ByteArrayOutputStream()) {
            IOUtils.copy(inputStream, byteArrayOutputStream);
            String message = new String(byteArrayOutputStream.toByteArray());
            if (urlConnection.getResponseCode() == 200) {
                if (tClass.isAssignableFrom(String.class)) {
                    return (T) message;
                }
                return objectMapper.readValue(message, tClass);
            } else {
                throw new HttpException(urlConnection.getResponseCode(), message);
            }
        }
    }


    /**
     * 把数组所有元素排序，并按照“参数=参数值”的模式用“&”字符拼接成字符串
     *
     * @param params 需要排序并参与字符拼接的参数组
     * @return 拼接后字符串
     */
    public static String createLinkString(Map<String, String> params) {
        StringBuilder prestr = new StringBuilder();
        if (params != null && !params.isEmpty()) {
            int i = 0;
            for (Map.Entry<String, String> entry : params.entrySet()) {
                String key = entry.getKey();
                String value = entry.getValue();
                if (i == params.size() - 1) {// 拼接时，不包括最后一个&字符
                    prestr.append(key).append("=").append(value);
                } else {
                    prestr.append(key).append("=").append(value).append("&");
                }
            }
        }
        return prestr.toString();
    }

    private static HttpURLConnection getConnection(String urlStr) throws Exception {
        URL url = new URL(urlStr);
        HttpURLConnection connection = (HttpURLConnection) url.openConnection();
        if (connection instanceof HttpsURLConnection) {
            HttpsURLConnection sCon = (HttpsURLConnection) connection;
            SSLContext instance = SSLContext.getInstance("TLSv1.2");
            instance.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 null;
                        }
                    }
            },new SecureRandom());
            sCon.setSSLSocketFactory(instance.getSocketFactory());
            sCon.setHostnameVerifier(new HostnameVerifier() {

                @Override
                public boolean verify(String arg0, SSLSession arg1) {
                    // TODO Auto-generated method stub
                    return true;
                }
            });

        }
        connection.setUseCaches(true);
        connection.setInstanceFollowRedirects(true);
        connection.setConnectTimeout(CONNECT_TIMEOUT);
        connection.setReadTimeout(READ_TIMEOUT);
        return connection;
    }


}

一把青龙湾月刀
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
HttpsUtils.java
06-21
为了应付在web项目中调用其他http或https接口的需求，配合https、http、本地 路径转换 InputStream 使用
java使用common-httpclient包实现post请求方法示例
08-27
在这个例子中，我们将关注如何使用Apache Commons HttpClient包来实现POST请求，特别针对发送JSON类型的数据。 首先，让我们了解`common-httpclient`包。Apache Commons HttpClient是一个Java库，它提供了对HTTP...
SpringBatch 使用过程中遇到的问题
z2431435的博客
09-14 903
这个往往是某个jar包没导入，可以把这一行错误往后拉，找到最后的那个报错，我这显示java.lang.NoClassDefFoundError: javax/batch/runtime/JobInstance，说明pom.xml没有导入，去导入就能解决。，可以通过pom.xml直接通过dependency导入下载，也可以下载bundle文件（即jar，利用本地导入）。
java里面封装https请求工具类2
最新发布
sunsiny
06-08 338
encodeJson 是请求参数的密文格式（大公司都是要对请求参数加密的）ResponseBean 是自己或者对方定义的返回内容参数。
java.net.http包_java11教程--包java.net.http 介绍
weixin_39777967的博客
02-28 1671
java.net.httpHTTP客户端和WebSocket API提供HTTP(版本1.1和2)的高级客户端接口和WebSocket的低级客户端接口。 定义的主要类型是：HttpClientHttpRequestHttpResponseWebSocket协议特定的要求在限定Hypertext Transfer Protocol Version 2 (HTTP/2) ，所述Hypertext Tr...
JDK原生java.net.HttpURLConnection & Apache提供的通信池化客户端org.apache.http.impl.client.CloseableHttpClient
noob_can的博客
06-02 3553
一文搞懂 JDK原生HttpURLConnection 和 Apache提供的通信池化客户端.CloseableHttpClient！
java之net.http.HttpClient详解
weixin_44233295的博客
06-30 2905
java HttpClient详解 特点、使用、优化
HttpUtils_java_
09-29
在Java编程语言中，网络通信是应用程序与远程服务器交互的重要组成部分。`HttpUtils` 是一个常用的工具类，它封装了HTTP协议的相关操作，为...通过阅读`HttpUtils.java`源代码，我们可以深入了解其内部实现和优化技巧。
HTTPUtils_HTTP上传下载_
10-01
下面我们将深入探讨HTTP上传和下载的基本概念以及可能在`HTTPUtils.java`中实现的关键技术。 首先，HTTP（超文本传输协议）是互联网上应用最为广泛的一种网络协议，用于从万维网服务器传输超文本到本地浏览器的传输...
HttpUtils.rar_Java_
08-10
在Java编程领域，`HttpUtils`通常是指一个用于处理HTTP请求的工具类。这个压缩包文件`HttpUtils.rar_Java_`很可能包含了这样一个工具类，方便开发者进行HTTP通信。在这个类中，通常会封装常见的HTTP请求方法，如GET...
java 发送https 请求 证书
11-21
在Java编程中，HTTPS（Hypertext Transfer Protocol Secure）是一种基于HTTP协议的安全通信方式，它通过SSL/TLS协议加密传输数据，确保了网络通信的安全性。当你需要在Java程序中发送HTTPS请求时，可能会遇到证书...
Java 实现HTTP请求的方式总结
weixin_43543654的博客
10-31 2418
Java中用于进行HTTP通信的类，它预先定义了一些方法，如 setRequestMethod()、setRequestProperty() 和 getResponseCode()，方便开发者自由地控制请求和响应。
java有关的HttpsUtils工具类 https请求工具类
billionyearsbo的博客
12-07 597
java的Http或者Https有关的工具类
jdk1.4java.net.url包_JDK9上的“包java.net.http不存在”错误
weixin_32285357的博客
02-13 470
我在从HttpRequest JavaDoc编译简单的阻塞GET示例时遇到问题：package org.example;import java.io.IOException;import java.net.URI;import java.net.URISyntaxException;import java.net.http.HttpRequest;import java.net.http.Http...
http通信（二）java发送https与http请求
w_t_y_y的博客
09-03 1万+
post、get请求一般出现在前端调用后端接口的时候，现在如果希望java代码(非controller，controller调另一个controller可以redirect重定向)去调用controller接口，比如在job定时器中，达到某一条件需要返回给前端一条提示消息（如订单30分钟内未付款，已被自动取消），而前端只能调controler接口，所以这时可以用job去调controller接口，......
httpsutil java_HttpsUtils
weixin_42134168的博客
02-27 186
packageio.renren.modules.jqr.util;importjava.io.BufferedReader;importjava.io.InputStream;importjava.io.InputStreamReader;importjava.io.OutputStream;importjava.net.HttpURLConnection;importjava.n...
JAVA实现发送HTTPS请求（SSL双向认证）
热门推荐
qq_36313856的博客
12-20 2万+
一、项目背景 Java项目需要作为客户端发起HTTPS请求访问服务端，并且需要携带证书进行SSL双向认证，当前提供的证书相关文件有：ca.crt、ca.key、client.crt、client.key、server.crt、server.key 二、实现步骤 1、对客户端证书和私钥进行打包处理(需要输入密码,之后在代码中需要用到该密码） openssl pkcs12 -export clcerts -in client.crt -inkey client.key -out client.p12 2、.p
JAVA实现http/https的Post、Get、代理访问请求
M1mory的博客
08-08 1万+
前言平时测试的时候可能会遇到使用Java发送http或者https请求的需求.网上找了一圈暂时没有发现比较称心方便能够直接使用的代码.所以就借鉴别人的代码按自己需求改造了一下.主要实现http/https的get和post请求,并支持设置代理抓包.只需要一个Java文件就搞定,不需要第三方库支持.
工具类-----Java实现HTTPS请求
small_emotion的博客
03-27 2206
1、创建证书信任管理器 /** * 证书信任管理器（用于https请求） * */ public class MyX509TrustManager implements X509TrustManager{ @Override public void checkClientTrusted(X509Certificate[] x509Certificates, String s...
https get httputils
07-16
https get和httputils是两个不同的概念。 首先，https是一种安全的网络协议，它在http的基础上增加了加密机制，用于保护网站访问的安全性。https使用SSL（Secure Sockets Layer）或TLS（Transport Layer Security）...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值