JavaHTTP请求工具类HTTPUtils

这篇具有很好参考价值的文章主要介绍了JavaHTTP请求工具类HTTPUtils。希望对大家有所帮助。如果存在错误或未考虑完全的地方,请大家不吝赐教,您也可以点击"举报违法"按钮提交疑问。

HTTP 请求工具类 HTTPUtils,其中涉及 HTTP 请求相关的各种操作,关于这些方法详细的介绍可以查看这些博客

💬相关

博客文章《Java发起HTTP请求并解析JSON返回数据》

https://blog.csdn.net/weixin_42077074/article/details/128672130

博客文章《Java发起同异步HTTP请求和处理数据》

https://blog.csdn.net/weixin_42077074/article/details/129601132

博客文章《JavaJSON处理工具类JSONUtils》

https://blog.csdn.net/weixin_42077074/article/details/129364274

HTTP 请求工具类 HTTPUtils 包含的属性和方法文章来源地址https://www.toymoban.com/news/detail-752511.html

  • headers:请求头示例
  • disableSSLVerification():禁用 SSL 验证
  • addHeadersToRequest():将请求头添加到 HTTP 请求中
  • concatParamsToURL():将请求参数拼接进 URL
  • requestHTTPContent():发起 HTTP 请求并获取响应内容
  • asyncHTTPRequest():异步 HTTP 请求
  • readResponseContent():读取响应内容
  • outputResponseContent():输出响应内容
  • printJSON():打印 JSON
  • printXML():打印 XML
  • viewImage():浏览图像
import com.alibaba.fastjson.JSON;
import com.alibaba.fastjson.JSONObject;
import org.w3c.dom.*;
import org.xml.sax.InputSource;

import javax.imageio.ImageIO;
import javax.net.ssl.*;
import javax.swing.*;
import javax.xml.parsers.DocumentBuilder;
import javax.xml.parsers.DocumentBuilderFactory;
import java.awt.*;
import java.awt.image.BufferedImage;
import java.io.*;
import java.net.HttpURLConnection;
import java.net.URL;
import java.net.URLEncoder;
import java.security.KeyManagementException;
import java.security.NoSuchAlgorithmException;
import java.security.cert.X509Certificate;
import java.util.Collections;
import java.util.HashMap;
import java.util.Map;
import java.util.concurrent.CompletableFuture;

public class HTTPUtils {

    // 请求头示例
    public static Map<String, String> headers = new HashMap<String, String>() {{
        // 设置接收内容类型
        put("Accept", "application/json");
        // 设置发送内容类型
        put("Content-Type", "application/json;charset=UTF-8");
        // 设置字符集
        put("charset", "UTF-8");
        // 设置访问者系统引擎版本、浏览器信息的字段信息,此处伪装成用户通过浏览器访问
        put("User-Agent", "Mozilla/4.0 (compatible; MSIE 5.0; Windows NT; DigExt)");
    }};

    // 禁用 SSL 验证
    public static void disableSSLVerification() {
        try {
            // 创建不验证证书链的 TrustManager
            TrustManager[] trustAllCerts = new TrustManager[]{new X509TrustManager() {
                public java.security.cert.X509Certificate[] getAcceptedIssuers() {
                    return null;
                }

                public void checkClientTrusted(X509Certificate[] certs, String authType) {
                }

                public void checkServerTrusted(X509Certificate[] certs, String authType) {
                }
            }
            };

            // 安装 TrustManager
            SSLContext sc = SSLContext.getInstance("SSL");
            sc.init(null, trustAllCerts, new java.security.SecureRandom());
            HttpsURLConnection.setDefaultSSLSocketFactory(sc.getSocketFactory());

            // 创建验证所有主机名的 HostnameVerifier
            HostnameVerifier allHostsValid = new HostnameVerifier() {
                public boolean verify(String hostname, SSLSession session) {
                    return true;
                }
            };

            // 安装 HostnameVerifier
            HttpsURLConnection.setDefaultHostnameVerifier(allHostsValid);
        } catch (NoSuchAlgorithmException e) {
            e.printStackTrace();
        } catch (KeyManagementException e) {
            e.printStackTrace();
        }
    }

    // 将请求头键值对添加到 HTTP 请求中
    public static void addHeadersToRequest(HttpURLConnection httpConn, Map<String, ?> headers) {
        if (headers != null) {
            for (Map.Entry<String, ?> entry : headers.entrySet()) {
                String key = entry.getKey();
                Object value = entry.getValue();

                if (value.getClass().isArray()) {
                    // 如果是数组类型,则遍历数组并添加请求头
                    for (Object v : (Object[]) value) {
                        httpConn.setRequestProperty(key, v.toString());
                    }
                } else {
                    // 如果不是数组类型,则直接添加请求头
                    httpConn.setRequestProperty(key, value.toString());
                }
            }
        }
    }


    // 将请求参数拼接进 URL
    public static String concatParamsToURL(String staticURL, String paramsStr){
        return staticURL + paramsStr;
    }

    public static String concatParamsToURL(String staticURL, Map<String, ?> params) throws Exception {
        // staticURL 是字符串形式的静态 URL
        // params 键与值分别是参数名与参数值,URL 有重复同名参数时将多个值放进数组

        // 判断参数是否为空
        if (params.isEmpty()) {
            return staticURL;
        }

        StringBuilder sb = new StringBuilder(staticURL);

        // 判断 URL 中是否已经包含参数
        boolean hasParams = staticURL.indexOf("?") != -1;

        // 遍历参数
        for (Map.Entry<String, ?> entry : params.entrySet()) {
            String key = entry.getKey(); // 参数名
            Object value = entry.getValue(); // 参数值

            // 判断参数值是否为数组
            if (value.getClass().isArray()) {
                // 如果是数组,遍历数组并添加参数
                for (Object v : (Object[]) value) {
                    sb.append(hasParams ? "&" : "?")
                            .append(URLEncoder.encode(key, "utf-8"))
                            .append("=")
                            .append(URLEncoder.encode(v.toString(), "utf-8"));
                    hasParams = true;
                }
            } else {
                // 如果不是数组,直接添加参数
                sb.append(hasParams ? "&" : "?")
                        .append(URLEncoder.encode(key, "utf-8"))
                        .append("=")
                        .append(URLEncoder.encode(value.toString(), "utf-8"));
                hasParams = true;
            }
        }

        return sb.toString();
    }

    // 发起 HTTP 请求并获取响应内容
    // 重载 requestHTTPContent(),相当于参数有默认值
    public static String requestHTTPContent(String strURL) throws Exception {
        return requestHTTPContent(strURL, "GET", null, null);
    }
    public static String requestHTTPContent(String strURL, String method) throws Exception {
        return requestHTTPContent(strURL, method, null, null);
    }
    public static String requestHTTPContent(String strURL, String method, Map<String, ?> headers) throws Exception {
        return requestHTTPContent(strURL, method, headers, null);
    }
    public static String requestHTTPContent(String strURL, String method, Map<String, ?> headers, Map<String, ?> params) throws Exception {
        // strURL 是 String 类型的 URL
        // method 是 String 类型的请求方法,为 "GET" 或 "POST"
        // headers 键与值分别是请求头名与请求头值,有重复同名请求头时将多个值放进数组
        // params 键与值分别是参数名与参数值,URL 有重复同名参数时将多个值放进数组

        // 忽略验证 https 中 SSL 证书
        disableSslVerification();

        // GET 方法下,query 参数拼接在 URL 字符串末尾
        if(method.equals("GET") && params != null) {
            strURL = concatParamsToURL(strURL, params);
        }

        System.out.println(strURL);

        URL url = new URL(strURL);
        HttpURLConnection httpConn = (HttpURLConnection) url.openConnection();
        httpConn.setRequestMethod(method);

        // 添加 HTTP 请求头
        addHeadersToRequest(httpConn, headers);

        // 请求时是否使用缓存
        httpConn.setUseCaches(false);

        // POST 方法请求必须设置下面两项
        // 设置是否从 HttpUrlConnection 的对象写
        httpConn.setDoOutput(true);
        // 设置是否从 HttpUrlConnection 的对象读入
        httpConn.setDoInput(true);

        // 此处默认 POST 方法发送的内容就是 JSON 形式的 body 参数,可以自行更改
        if(method.equals("POST") && params!=null) {
            // 发送请求
            OutputStream out = new DataOutputStream(httpConn.getOutputStream());
            // getBytes() 作用为根据参数给定的编码方式,将一个字符串转化为一个字节数组
            out.write(JSON.toJSONString(params).getBytes("UTF-8"));
            out.flush();
        }
        else{
            //发送请求
            httpConn.connect();
        }

        String contentType = httpConn.getContentType();
        String result = readResponseContent(httpConn);

        // 输出响应内容
        // outputResponseContent(result, contentType);

        return result;
    }

    // 异步 HTTP 请求
    public static CompletableFuture<String> asyncHTTPRequest(String strURL, String method, Map<String, ?> headers, Map<String, ?> params) {
        return CompletableFuture.supplyAsync(() -> {
            try {
                return requestHTTPContent(strURL, method, headers, params);
            } catch (Exception e) {
                e.printStackTrace();
                return null;
            }
        });
    }

    // 读取响应内容
    public static String readResponseContent(HttpURLConnection httpConn) throws Exception {
        try (BufferedReader reader = new BufferedReader(new InputStreamReader(httpConn.getInputStream()))) {
            // 此处不用 StringBuffer 而用 StringBuilder 是出于线程安全的考虑
            StringBuilder builder = new StringBuilder();
            String line;
            while ((line = reader.readLine()) != null) {
                builder.append(line);
            }
            return builder.toString();
        }
    }

    // 输出响应内容
    public static void outputResponseContent(String responseContent, String contentType) throws Exception {
        // contentType 是接收内容类型
        // 响应内容为 JSON 格式
        if (contentType.contains("application/json")) {
            // 解析 JSON 字符串为 JSON 对象
            JSONObject jsonObj = JSON.parseObject(responseContent);
            printJSON(jsonObj,0);
        }
        // 响应内容为 XML 格式
        else if (contentType.contains("application/xml")) {
            // 创建 DocumentBuilderFactory 对象
            DocumentBuilderFactory factory = DocumentBuilderFactory.newInstance();
            // 创建 DocumentBuilder 对象
            DocumentBuilder builder = factory.newDocumentBuilder();
            // 将 XML 解析成 Document 对象
            Document doc = builder.parse(new InputSource(new StringReader(responseContent)));
            printXML(doc);
        }
        // 响应内容为图像
        else if (contentType.contains("image/jpeg") || contentType.contains("image/png")) {
            // 将响应内容解码为图片
            byte[] imageBytes = responseContent.getBytes();
            ByteArrayInputStream bis = new ByteArrayInputStream(imageBytes);
            BufferedImage image = ImageIO.read(bis);
            viewImage(new ImageIcon(image));
        }
        // 响应内容为 PDF 文档
        else if (contentType.contains("application/pdf")) {
            System.out.println("[PDF document]");
        }
        // 响应内容为二进制数据流
        else if (contentType.contains("application/octet-stream")) {
            System.out.println("[Binary data]");
        }
        // 响应内容为 HTML 格式、纯文本格式
        else if (contentType.contains("text/html") || contentType.contains("text/plain")) {
            System.out.println(responseContent);
        }
        // 响应内容为其他格式
        else {
            System.out.println(responseContent);
        }

    }

    // 打印 JSON
    public static void printJSON(JSONObject jsonObj, int level) {
        if (jsonObj != null) {
            for (Map.Entry<String, Object> entry : jsonObj.entrySet()) {
                String key = entry.getKey();
                Object value = entry.getValue();
                String indent = String.join("", Collections.nCopies(level, "\t")); // 缩进
                if (value instanceof JSONObject) {
                    // 嵌套对象
                    System.out.println(indent + key + " = {");
                    printJSON((JSONObject) value, level + 1); // 增加嵌套层级
                    System.out.println(indent + "}");
                } else {
                    // 非嵌套对象
                    System.out.println(indent + key + " = " + value.toString());
                }
            }
        }
    }


    // 打印 XML
    public static void printXML(Document doc) {
        Element root = doc.getDocumentElement();
        printXML(System.out, root, 0);
    }

    // 打印 XML
    private static void printXML(PrintStream ps, Element element, int indent) {
        printTrunk(ps, indent);
        ps.printf("├─ 元素: %s\n", element.getNodeName());

        NamedNodeMap attributes = element.getAttributes();
        for (int i = 0; i < attributes.getLength(); i++) {
            Attr attribute = (Attr) attributes.item(i);
            printTrunk(ps, indent + 1);
            ps.printf("├─ 属性: %s = %s\n", attribute.getName(), attribute.getValue());
        }

        NodeList children = element.getChildNodes();
        for (int i = 0; i < children.getLength(); i++) {
            Node child = children.item(i);
            if (child.getNodeType() == Node.ELEMENT_NODE) {
                printXML(ps, (Element) child, indent + 1);
            } else if (child.getNodeType() == Node.TEXT_NODE) {
                String text = child.getNodeValue().trim();
                if (!text.isEmpty()) {
                    printTrunk(ps, indent + 1);
                    ps.printf("└─ 文本: %s\n", text);
                }
            }
        }
    }

    // 打印 XML
    private static void printTrunk(PrintStream ps, int indent) {
        for (int i = 0; i < indent; i++) {
            ps.print("|   ");
        }
    }

    // 浏览图像
    private static void viewImage(ImageIcon imageIcon) {
        JLabel label = new JLabel(imageIcon);
        JFrame frame = new JFrame("图片显示");
        frame.getContentPane().add(label, BorderLayout.CENTER);
        frame.pack();
        frame.setVisible(true);
    }
}

到了这里,关于JavaHTTP请求工具类HTTPUtils的文章就介绍完了。如果您还想了解更多内容,请在右上角搜索TOY模板网以前的文章或继续浏览下面的相关文章,希望大家以后多多支持TOY模板网!

本文来自互联网用户投稿,该文观点仅代表作者本人,不代表本站立场。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。如若转载,请注明出处: 如若内容造成侵权/违法违规/事实不符,请点击违法举报进行投诉反馈,一经查实,立即删除!

领支付宝红包 赞助服务器费用

相关文章

  • HTTP工具类封装与http请求响应

    一、前言 在Java web系统中经常需要与外部接口进行对接,比较多的方式就是是http的方式。在springboot中,我们可以直接使用封装的feign如:我们去请求微信的接口,定义一个client客户端,使用feign框架去请求就可以。但是也有很多系统没有使用feign的框架,那就需要使用http工具

    2024年04月25日
    浏览(27)
  • Android网络编程,HTTP请求和Json解析

    以下代码模拟了点击按钮请求百度的网页源码: 其中需要注意的是Android在API27之后不再支持明文访问HTTP,需要在manifest文件中配置属性允许使用明文访问, 并且Url需要使用https layout.xml 字节流转换字符串工具类: 主类.java: 配置manifest.xml文件: 将上述代码中的webview相关内容

    2023年04月09日
    浏览(38)
  • Qt 网络编程之美:探索 URL、HTTP、服务发现与请求响应

    Qt 网络编程是使用 Qt 框架进行网络应用开发的重要组成部分。Qt 是一个跨平台的 C++ 应用程序开发框架,广泛应用于各种领域,包括桌面应用、移动应用和嵌入式设备。在本文中,我们将探讨 Qt 网络编程的优势,以及本文涉及的主题,包括 URL、HTTP、服务发现和请求响应等。

    2023年04月23日
    浏览(52)
  • Nodejs基础6之HTTP模块的获取请求行和请求头、获取请求体、获取请求路径和查询字符串、http请求练习、设置HTTP响应报文、http响应练习

    含义 语法 重点掌握 请求方法 request.method * 请求版本 request.httpVersion 请求路径 request.url * URL 路径 require(‘url’).parse(request.url).pathname * URL 查询字符串 require(‘url’).parse(request.url, true).query * 请求头 request.headers * 请求体 request.on(‘data’, function(chunk){}),request.on(‘end’, functio

    2024年02月20日
    浏览(41)
  • Postman —— HTTP请求基础组成部分

    一般来说,所有的HTTP Request都有最基础的4个部分组成: URL 、  Method 、  Headers 和 body 。 (1)Method 要选择Request的Method是很简单的,Postman支持所有的请求方式。 (2)URL 要组装一条Request(请求), URL永远是你首先要填的内容。在Postman里面,你曾输入过的URL是可以通过下拉自

    2024年02月03日
    浏览(37)
  • 开源.NetCore通用工具库Xmtool使用连载 - HTTP请求篇

    《上一篇》 介绍了Xmtool工具库中的XML操作类库,今天我们继续为大家介绍其中的HTTP请求类库。 在现如今的软件需求场景中,HTTP网络请求几乎是开发过程中必然会使用的功能;而系统自带的HTTPClient对象使用起来并不是那么容易和友好,因此我们对其进行了二次封装成了一个

    2024年02月13日
    浏览(42)
  • hutool Http 工具发送POST请求的几种方式

            目录 依赖 🍊Maven 🍐Gradle 实践 hutool源码 hutool调用实践 其它自定义项         本质上,HttpUtil中的get和post工具方法都是HttpRequest对象的封装,因此如果想更加灵活操作Http请求,可以使用HttpRequest。今天咱们就列举一下hutool工具中常用的几种发送post请求的方式。

    2024年02月08日
    浏览(54)
  • hutool Http 工具发送POST请求的几种方式。

    Hutool是一个Java工具库,提供了丰富的功能模块,包括HTTP请求发送。以下是使用Hutool发送POST请求的几种方式: 使用HttpUtil.post方法: 使用HttpUtil.post方法可以发送简单的POST请求,示例如下: 使用HttpUtil.createPost方法: 使用HttpUtil.createPost方法可以创建一个HttpPost对象,然后设置

    2024年02月13日
    浏览(35)
  • 【雕爷学编程】MicroPython手册之内置模块 urequests:发送 HTTP 请求和处理响应

    MicroPython是为了在嵌入式系统中运行Python 3编程语言而设计的轻量级版本解释器。与常规Python相比,MicroPython解释器体积小(仅100KB左右),通过编译成二进制Executable文件运行,执行效率较高。它使用了轻量级的垃圾回收机制并移除了大部分Python标准库,以适应资源限制的微控制

    2024年01月17日
    浏览(37)
  • (Qt) Http之Get请求使用基础

    http的操作是网络通信中非常常见的操作,其中广泛使用get,post两种操作。 本文将对Qt中,http的get请求做简单应用,来进行展示。 这里不做排版了,不然篇幅过大 [1] QNetworkAccessManager 对于每个 reply 的 finish 都会发送 finished 的信号。 如果一个 manager 处理多个请求可能会出现先

    2024年02月12日
    浏览(40)

觉得文章有用就打赏一下文章作者

支付宝扫一扫打赏

博客赞助

微信扫一扫打赏

请作者喝杯咖啡吧~博客赞助

支付宝扫一扫领取红包,优惠每天领

二维码1

领取红包

二维码2

领红包