HttpClient工具类的使用

最新推荐文章于 2023-08-16 16:38:59 发布
最新推荐文章于 2023-08-16 16:38:59 发布
阅读量925 收藏 9
点赞数 1
分类专栏： SpringBoot 文章标签： http
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/DreamsArchitects/article/details/110129450
版权

文章目录

一、介绍

使用传统JDK自带的URLConnection是有些不方便的。所以我们使用HttpClient。
HttpClient 是 Apache Jakarta Common 下的子项目，可以用来提供高效的、最新的、功能丰富的支持 HTTP 协议的客户端编程工具包，并且它支持 HTTP 协议最新的版本和建议。

二、导入依赖

        <!--=============HttpUtils  Start=============-->
        <dependency>
            <groupId>org.apache.httpcomponents</groupId>
            <artifactId>httpclient</artifactId>
            <version>4.2.1</version>
        </dependency>
        <dependency>
            <groupId>org.apache.httpcomponents</groupId>
            <artifactId>httpcore</artifactId>
            <version>4.2.1</version>
        </dependency>
        <dependency>
            <groupId>commons-lang</groupId>
            <artifactId>commons-lang</artifactId>
            <version>2.6</version>
        </dependency>
        <!--=============HttpUtils  END=============-->

三、工具类

package com.wx.util;

/**
 * @author ：LiuShihao
 * @date ：Created in 2020/10/19 3:41 下午
 * @desc ：
 */

import org.apache.commons.lang.StringUtils;
import org.apache.http.HttpResponse;
import org.apache.http.NameValuePair;
import org.apache.http.client.HttpClient;
import org.apache.http.client.entity.UrlEncodedFormEntity;
import org.apache.http.client.methods.HttpDelete;
import org.apache.http.client.methods.HttpGet;
import org.apache.http.client.methods.HttpPost;
import org.apache.http.client.methods.HttpPut;
import org.apache.http.conn.ClientConnectionManager;
import org.apache.http.conn.scheme.Scheme;
import org.apache.http.conn.scheme.SchemeRegistry;
import org.apache.http.conn.ssl.SSLSocketFactory;
import org.apache.http.entity.ByteArrayEntity;
import org.apache.http.entity.StringEntity;
import org.apache.http.impl.client.DefaultHttpClient;
import org.apache.http.message.BasicNameValuePair;

import javax.net.ssl.SSLContext;
import javax.net.ssl.TrustManager;
import javax.net.ssl.X509TrustManager;
import java.io.UnsupportedEncodingException;
import java.net.URLEncoder;
import java.security.KeyManagementException;
import java.security.NoSuchAlgorithmException;
import java.security.cert.X509Certificate;
import java.util.ArrayList;
import java.util.List;
import java.util.Map;

public class HttpUtils {

    /**
     * get
     *
     * @param host
     * @param path
     * @param headers
     * @param querys
     * @return
     * @throws Exception
     */
    public static HttpResponse doGet(String host, String path,
                                     Map<String, String> headers,
                                     Map<String, String> querys)
            throws Exception {
        HttpClient httpClient = wrapClient(host);

        HttpGet request = new HttpGet(buildUrl(host, path, querys));
        for (Map.Entry<String, String> e : headers.entrySet()) {
            request.addHeader(e.getKey(), e.getValue());
        }

        return httpClient.execute(request);
    }

    /**
     * post form   表单形式
     *
     * @param host
     * @param path
     * @param headers
     * @param querys
     * @param bodys
     * @return
     * @throws Exception
     */
    public static HttpResponse doPost(String host, String path,
                                      Map<String, String> headers,
                                      Map<String, String> querys,
                                      Map<String, String> bodys)
            throws Exception {
        HttpClient httpClient = wrapClient(host);

        HttpPost request = new HttpPost(buildUrl(host, path, querys));
        for (Map.Entry<String, String> e : headers.entrySet()) {
            request.addHeader(e.getKey(), e.getValue());
        }

        if (bodys != null) {
            List<NameValuePair> nameValuePairList = new ArrayList<NameValuePair>();

            for (String key : bodys.keySet()) {
                nameValuePairList.add(new BasicNameValuePair(key, bodys.get(key)));
            }
            UrlEncodedFormEntity formEntity = new UrlEncodedFormEntity(nameValuePairList, "utf-8");
            formEntity.setContentType("application/x-www-form-urlencoded; charset=UTF-8");
            request.setEntity(formEntity);
        }

        return httpClient.execute(request);
    }

    /**
     * Post String   参数形式
     *
     * @param host
     * @param path
     * @param headers
     * @param querys
     * @param body
     * @return
     * @throws Exception
     */
    public static HttpResponse doPost(String host, String path,
                                      Map<String, String> headers,
                                      Map<String, String> querys,
                                      String body)
            throws Exception {
        HttpClient httpClient = wrapClient(host);

        HttpPost request = new HttpPost(buildUrl(host, path, querys));
        for (Map.Entry<String, String> e : headers.entrySet()) {
            request.addHeader(e.getKey(), e.getValue());
        }

        if (StringUtils.isNotBlank(body)) {
            request.setEntity(new StringEntity(body, "utf-8"));
        }

        return httpClient.execute(request);
    }

    /**
     * Post stream
     *
     * @param host
     * @param path
     * @param headers
     * @param querys
     * @param body
     * @return
     * @throws Exception
     */
    public static HttpResponse doPost(String host, String path,
                                      Map<String, String> headers,
                                      Map<String, String> querys,
                                      byte[] body)
            throws Exception {
        HttpClient httpClient = wrapClient(host);

        HttpPost request = new HttpPost(buildUrl(host, path, querys));
        for (Map.Entry<String, String> e : headers.entrySet()) {
            request.addHeader(e.getKey(), e.getValue());
        }

        if (body != null) {
            request.setEntity(new ByteArrayEntity(body));
        }

        return httpClient.execute(request);
    }

    /**
     * Put String
     * @param host
     * @param path
     * @param headers
     * @param querys
     * @param body
     * @return
     * @throws Exception
     */
    public static HttpResponse doPut(String host, String path,
                                     Map<String, String> headers,
                                     Map<String, String> querys,
                                     String body)
            throws Exception {
        HttpClient httpClient = wrapClient(host);

        HttpPut request = new HttpPut(buildUrl(host, path, querys));
        for (Map.Entry<String, String> e : headers.entrySet()) {
            request.addHeader(e.getKey(), e.getValue());
        }

        if (StringUtils.isNotBlank(body)) {
            request.setEntity(new StringEntity(body, "utf-8"));
        }

        return httpClient.execute(request);
    }

    /**
     * Put stream
     * @param host
     * @param path
     * @param headers
     * @param querys
     * @param body
     * @return
     * @throws Exception
     */
    public static HttpResponse doPut(String host, String path,
                                     Map<String, String> headers,
                                     Map<String, String> querys,
                                     byte[] body)
            throws Exception {
        HttpClient httpClient = wrapClient(host);

        HttpPut request = new HttpPut(buildUrl(host, path, querys));
        for (Map.Entry<String, String> e : headers.entrySet()) {
            request.addHeader(e.getKey(), e.getValue());
        }

        if (body != null) {
            request.setEntity(new ByteArrayEntity(body));
        }

        return httpClient.execute(request);
    }

    /**
     * Delete
     *
     * @param host
     * @param path
     * @param headers
     * @param querys
     * @return
     * @throws Exception
     */
    public static HttpResponse doDelete(String host, String path,
                                        Map<String, String> headers,
                                        Map<String, String> querys)
            throws Exception {
        HttpClient httpClient = wrapClient(host);

        HttpDelete request = new HttpDelete(buildUrl(host, path, querys));
        for (Map.Entry<String, String> e : headers.entrySet()) {
            request.addHeader(e.getKey(), e.getValue());
        }

        return httpClient.execute(request);
    }

    private static String buildUrl(String host, String path, Map<String, String> querys) throws UnsupportedEncodingException {
        StringBuilder sbUrl = new StringBuilder();
        sbUrl.append(host);
        if (!StringUtils.isBlank(path)) {
            sbUrl.append(path);
        }
        if (null != querys) {
            StringBuilder sbQuery = new StringBuilder();
            for (Map.Entry<String, String> query : querys.entrySet()) {
                if (0 < sbQuery.length()) {
                    sbQuery.append("&");
                }
                if (StringUtils.isBlank(query.getKey()) && !StringUtils.isBlank(query.getValue())) {
                    sbQuery.append(query.getValue());
                }
                if (!StringUtils.isBlank(query.getKey())) {
                    sbQuery.append(query.getKey());
                    if (!StringUtils.isBlank(query.getValue())) {
                        sbQuery.append("=");
                        sbQuery.append(URLEncoder.encode(query.getValue(), "utf-8"));
                    }
                }
            }
            if (0 < sbQuery.length()) {
                sbUrl.append("?").append(sbQuery);
            }
        }

        return sbUrl.toString();
    }

    private static HttpClient wrapClient(String host) {
        HttpClient httpClient = new DefaultHttpClient();
        if (host.startsWith("https://")) {
            sslClient(httpClient);
        }

        return httpClient;
    }

    private static void sslClient(HttpClient httpClient) {
        try {
            SSLContext ctx = SSLContext.getInstance("TLS");
            X509TrustManager tm = new X509TrustManager() {
                @Override
                public X509Certificate[] getAcceptedIssuers() {
                    return null;
                }
                @Override
                public void checkClientTrusted(X509Certificate[] xcs, String str) {

                }
                @Override
                public void checkServerTrusted(X509Certificate[] xcs, String str) {

                }
            };
            ctx.init(null, new TrustManager[] { tm }, null);
            SSLSocketFactory ssf = new SSLSocketFactory(ctx);
            ssf.setHostnameVerifier(SSLSocketFactory.ALLOW_ALL_HOSTNAME_VERIFIER);
            ClientConnectionManager ccm = httpClient.getConnectionManager();
            SchemeRegistry registry = ccm.getSchemeRegistry();
            registry.register(new Scheme("https", 443, ssf));
        } catch (KeyManagementException ex) {
            throw new RuntimeException(ex);
        } catch (NoSuchAlgorithmException ex) {
            throw new RuntimeException(ex);
        }
    }
}

四、使用方式

静态方法直接通过类名调用

GET方式

在这里插入图片描述

    /**
     * 获取acces_token
     * https请求方式: GET
     * https://api.weixin.qq.com/cgi-bin/token?grant_type=client_credential&appid=APPID&secret=APPSECRET
     * @return
     */
    public static String getWXToken() throws Exception {
        final String host = "https://api.weixin.qq.com";
        final String appID = "wx4959a20a2as31b3fc";
        final String appsecret = "d0e97bd7bse270bc400734e385eb1ad0e";
        final String path = "/cgi-bin/token";
        final String replace = path.replace("APPID", appID).replace("APPSECRET", appsecret);
        Map<String, String> headers = new HashMap<String, String>();
        Map<String, String> querys = new HashMap<String, String>();
        querys.put("grant_type","client_credential");
        querys.put("appid",appID);
        querys.put("secret",appsecret);
        HttpResponse httpResponse = HttpUtils.doGet(host, replace, headers, querys);
        String s = EntityUtils.toString(httpResponse.getEntity());
        JSONObject jsonObject = JSON.parseObject(s);
        String access_token = jsonObject.getString("access_token");
        return access_token;
    }

POST方式

JSON形式
在这里插入图片描述

/**
     * 获得二维码的ticket
     * 临时二维码请求说明
     * http请求方式: POST URL: https://api.weixin.qq.com/cgi-bin/qrcode/create?access_token=TOKEN
     * {"ticket":"gQGz8DwAAAAAAAAAAS5odHRwOi8vd2VpeGluLnFxLmNvbS9xLzAycUZUUGhsOXZmakUxUURhN052Y2gAAgSnD75fAwSAOgkA","expire_seconds":604800,"url":"http:\/\/weixin.qq.com\/q\/02qFTPhl9vfjE1QDa7Nvch"}
     * @return
     */
    public  String getQRCodeTicket() throws Exception {
        String host = "https://api.weixin.qq.com";
        String path = "/cgi-bin/qrcode/create";
        String token = WXServiceImpl.getWXToken();
        Map<String, String> headers = new HashMap<String, String>();
        Map<String, String> querys = new HashMap<String, String>();
        querys.put("access_token",token);
        String data= "{\"expire_seconds\": 604800, \"action_name\": \"QR_STR_SCENE\", \"action_info\": {\"scene\": {\"scene_str\": \"lsh\"}}}";
        HttpResponse httpResponse = HttpUtils.doPost(host, path, headers, querys, data);
        String respJsonStr = EntityUtils.toString(httpResponse.getEntity());
        JSONObject jsonObject = JSON.parseObject(respJsonStr);
        System.out.println("jsonObject:"+jsonObject);
        String ticket = (String)jsonObject.get("ticket");

        return ticket;
    }
Liu_Shihao
关注
  • 1
    点赞
  • 踩
  • 9
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 1
    评论
专栏目录
HttpClientHelper 工具类
08-13
C# HttpClientHelper（HttpClient工具类） 包含 同步/异步请求 返回 string/泛型类型/Xml 及一个单例模式 的 SingleHelper 适合做爬虫
Http调用外部接口工具类
sunshine8080的博客
12-19 1011
http调用外部接口的工具类HttpUtils import org.apache.http.conn.scheme.Scheme; import org.apache.commons.lang3.StringUtils; import org.apache.http.HttpResponse; import org.apache.http.NameValuePair; import org.ap...
SpringBoot案例 调用第三方接口传输数据
最新发布
小钟不想敲代码
08-16 4858
定时器任务调用第三方接口传输数据
HttpUtils工具类
Amelia_Liu的博客
06-02 2268
HttpUtils
HttpClient工具类（完整版）
Boy_Martin的博客
12-21 3078
HttpClient工具类
如何在项目中使用HttpClient工具包发送http请求
weixin_44879791的博客
05-05 506
在讲解如何使用HttpClient工具包之前，先简单介绍一下：HttpClient 是Apache Jakarta Common 下的子项目，是一个支持http协议的客户端编程工具包，使用它可以高效便捷的快速访问不同的网址，发送http请求。在搭建spring项目时，难免会使用到其他第三方已经实现的API服务，比如搭建微信小程序可能会使用到的微信支付功能，地图的定位功能等。这是我们就需要向其他服务器发送HTTP请求来获取我们需要的数据信息。下面将详细讲述一下如何发送最简单的http请求。
HttpClient工具类
05-23
HttpClient的工具类，用于发送get和post请求的工具类，数据类型可以使XML，JSON
httpClient 工具类
05-06
httpClient 工具类，简化请求开发，拿来即用，我用在SpringBoot框架；对于依赖，你可以根据包名导入。
httpClientUtil工具类
01-31
httpClientUtil工具类
httpclient 工具类
05-17
在日常开发中我们经常需要调用http接口，一个httpclient工具类，返回的对象可以自己写一个。
HTTPClient工具类，完整
08-07
HTTPClient工具类，完整，HTTPClient工具类，完整，HTTPClient工具类，完整HTTPClient工具类，完整，HTTPClient工具类，完整
HttpClient工具类及应用
小布1994的博客
08-23 1190
Content-Type类型： 常见的媒体格式类型如下： text/html ： HTML格式 text/plain ：纯文本格式 text/xml ： XML格式 image/gif ：gif图片格式 image/jpeg ：jpg图片格式 image/png：png图片格式 以application开头的媒体格式类型： application/xhtml+xml ：XHTML格式 ...
HttpClient
feir23的博客
05-05 386
HTTP 协议可能是现在 Internet 上使用得最多、最重要的协议了，越来越多的 Java 应用程序需要直接通过 HTTP 协议来访问网络资源。虽然在 JDK 的 java net包中已经提供了访问 HTTP 协议的基本功能，但是对于大部分应用程序来说，JDK 库本身提供的功能还不够丰富和灵活。HttpClient 是 Apache Jakarta Common 下的子项目，用来提供高效的、最新
HttpClient工具正确使用方式
热门推荐
Sam_Deep_Thinking
05-03 1万+
虽然现在微服务非常的流行，但是公司内部的蛮多系统仍然对外提供http接口。在调用http接口工具类中，apache httpclient工具用的比较多。下面列举一些正确使用httpclient的一些要点。设置socketTimeout可以在RequestConfig 中设置socketTimeout，表示数据传输处理时间，如下： RequestConfig requestConfig = Reque
Day04JavaWeb【Request】请求行
翁老师的教学团队
09-10 573
Http协议回顾 （1）Http协议是什么？ HTTP协议：超文本传输协议（HTTP，HyperText Transfer Protocol)是互联网上应用最为广泛的一种网络协议。用于定义WEB浏览器与WEB服务器之间交换数据的过程 （2）有什么特点？ 基于请求/响应模型的协议。请求和响应必须成对；先有请求后有响应。 HTTP协议默认的端口:80 Mysql 3306 Tomcat 8080 request-概述 （1）什么是request? 有两种含义 A：Http中的request B：Servle
认证服务------功能实现逻辑
骚戴的博客
12-05 766
认证服务------功能实现逻辑
httpclient工具类
07-27
Java HttpClient工具类是一个用于发送HTTP请求的Java类库。它提供了一种简单、灵活、可扩展的方式来发送HTTP请求和接收HTTP响应。该工具类可以用于访问Web服务、下载文件、上传文件等各种场景。它支持HTTP协议的各种方法，如GET、POST、PUT、DELETE等，并且可以设置请求头、请求参数、请求体等。使用Java HttpClient工具类可以方便地实现与Web服务的交互，提高开发效率。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

Liu_Shihao

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值