Java HttpUtils 请求工具类

已于 2022-04-26 19:35:46 修改
阅读量2.6k 收藏 3
点赞数 1
分类专栏： java 文章标签： java httpUtils
于 2021-07-19 17:38:36 首次发布
原文链接：https://blog.csdn.net/github_39083395/article/details/86636488
版权

 引入jar包

        <dependency>
            <groupId>org.apache.commons</groupId>
            <artifactId>commons-lang3</artifactId>
            <version>3.9</version>
        </dependency>

        <dependency>
            <groupId>org.apache.httpcomponents</groupId>
            <artifactId>httpclient</artifactId>
            <version>4.5.13</version>
        </dependency>

import org.apache.commons.lang3.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 method
     * @param headers
     * @param querys
     * @return
     * @throws Exception
     */
    public static HttpResponse doGet(String host, String path, String method,
                                     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 method
     * @param headers
     * @param querys
     * @param bodys
     * @return
     * @throws Exception
     */
    public static HttpResponse doPost(String host, String path, String method,
                                      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 method
     * @param headers
     * @param querys
     * @param body
     * @return
     * @throws Exception
     */
    public static HttpResponse doPost(String host, String path, String method,
                                      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 method
     * @param headers
     * @param querys
     * @param body
     * @return
     * @throws Exception
     */
    public static HttpResponse doPost(String host, String path, String method,
                                      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 method
     * @param headers
     * @param querys
     * @param body
     * @return
     * @throws Exception
     */
    public static HttpResponse doPut(String host, String path, String method,
                                     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 method
     * @param headers
     * @param querys
     * @param body
     * @return
     * @throws Exception
     */
    public static HttpResponse doPut(String host, String path, String method,
                                     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 method
     * @param headers
     * @param querys
     * @return
     * @throws Exception
     */
    public static HttpResponse doDelete(String host, String path, String method,
                                        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() {
                public X509Certificate[] getAcceptedIssuers() {
                    return null;
                }
                public void checkClientTrusted(X509Certificate[] xcs, String str) {
                }
                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);
        }
    }

}

测试

@Test
    public void aaa(){
        //请求的域名
        String host = "https://staging.xxx.com";
        //请求域名后的 uri接口地址
        String path = "/users/login";
        //请求方式
        String method = "POST";

        Map<String, String> headers = new HashMap<String, String>();
        // 设置请求头信息
          headers.put("Content-Type", "application/json");
          headers.put("ESBDate", "xxxxxx");

        Map<String, String> querys = new HashMap<String, String>();
        // 设置请求参数信息
        querys.put("userName", "法外狂徒");
        querys.put("password", "123456");


//        querys.put("BusiTokenCode", "Bearer 126ec2ea-ae8f-49ea-bdf1-e9f4072209f1");


        try {
            /**
             * 重要提示如下:
             * HttpUtils请从
             * https://github.com/aliyun/api-gateway-demo-sign-java/blob/master/src/main/java/com/aliyun/api/gateway/demo/util/HttpUtils.java
             * 下载
             *
             * 相应的依赖请参照
             * https://github.com/aliyun/api-gateway-demo-sign-java/blob/master/pom.xml
             */
            HttpResponse response = HttpUtils.doGet(host, path, method, headers, querys);
            System.out.println(response.toString());
            String res = EntityUtils.toString(response.getEntity());
            JSONObject res_obj = JSON.parseObject(res);
            String a =  res_obj.toJSONString();

            System.out.println(a);
            //获取response的body
            System.out.println(EntityUtils.toString(response.getEntity()));
        } catch (Exception e) {
//            return e.toString();
        }

NatChan
关注
专栏目录
httpclient封装
04-25
封装了httpclient的get请求和post请求，包括传参数和和不传参数，以及请求头信息的设定。
HTTPClient 的一个封装
06-11
HttpClient的一个封装， HttpClient的一个封装
java网络请求工具类（HttpUtils/HttpClientUtils）
最新发布
Flying_Fish_roe的博客
10-03 1064
Java网络请求工具类（HttpUtils/HttpClientUtils）是用来简化与服务器进行网络请求的过程。它是基于HttpClient库开发的。该工具类提供了一系列方法，可以方便地发送HTTP请求（GET、POST等）。它可以帮助我们完成以下操作：发送GET请求：通过传入URL和参数，发送GET请求并获取服务器返回的数据。发送POST请求：通过传入URL、参数和请求体，发送POST请求并获取服务器返回的数据。设置请求头：可以设置请求头，如User-Agent、Cookie等。
Java访问https接口实现
mno2330的博客
03-05 355
用两种方式分别实现了，第一种是jdk原生的，代码稍微多点，第二种是基于httpclient4版本的。在我的机器上，访问同一个接口原生的性能要好很多（前者900ms，后者5.7s左右），httpclient主要性能消耗在"HttpResponse res = client.execute(post);"，大约占总执行时间的90%。     Java代码   private...
httpclient 简单封装
baidu_21349635的专栏
10-23 1374
文章目录项目目录get测试get带参数post测试post带参数测试封装httpclient工具类测试类itheima-activemq的pom.xmlparent的pom.xml 项目目录 get测试 public class DoGET { public static void main(String[] args) throws Exception { // ...
Httpclient封装
java_study_的博客
10-27 365
​ 在做一个项目的过程中，发现调用HttpClients请求时，传参五花八门，有的用map，有的用流。代码重复量巨大，虽然在spring对应的框架已经封装，但对于没有依赖类似的jar包时，我考虑调用的问题，将请求封装为两个方法，post方法 和 get方法，方法参数为地址，和map参数，返回类型 为map字符串。代码如下，需要的时候直接传参获取返回参数。 package com.hb.kfcenter.kfSSO.test; import java.util.ArrayList; import java.
【转】httpclient封装
xieqi5200的博客
07-13 175
package com.util; import java.io.IOException; import java.io.UnsupportedEncodingException; import java.security.cert.CertificateException; import java.security.cert.X509Certificate; import java.util.ArrayList; import java.util.HashMap; import java.util.L.
HttpUtils 请求工具类
09-17
自己写的基于Java自带URL请求 处理get,post 不明白的，里面直接运行可以跑,
httpUtils请求工具类
10-11
"httpUtils请求工具类"是一个常见的Java库，用于简化HTTP请求操作，特别是GET和POST方法。这个工具类使得开发者无需深入了解底层HTTP协议，就能轻松地发送数据到服务器并获取响应。下面我们将深入探讨这个工具类以及...
HttpUtils 发送http请求工具类(实例讲解)
08-30
HttpUtils 发送 HTTP 请求工具类详解 HTTP 请求工具类是 Java 语言中一个常用的工具类，用于发送 HTTP 请求并处理响应结果。本文将对 HttpUtils 发送 HTTP 请求工具类进行详细的讲解，包括其实现原理、关键代码分析...
httpclient4 封装
11-26
httpclient4 封装实例 apache httpclient4.2jar包
HttpUtils.java工具类（附注释）
08-06
此为调用http请求的java工具类，基于springframework的RestTemplate，有注释
HttpUtils Java get post 工具类
04-01
"HttpUtils Java get post 工具类" 提供了便捷的方法来发送GET和POST请求，简化了网络请求的操作。以下是对这两个主要HTTP方法的详细解释以及如何在Java中实现它们。 **1. GET方法** GET是HTTP中最常见的请求方法，...
httpclient工具类封装
dream_xin2013的专栏
11-09 554
分享基于apache的httpclient工具类封装，可以在项目中直接引入HttpUtils当做工具类使用
Java封装httpClient
promise524的博客
08-18 377
java封装httpClient（支持post、get、put、delete请求）
通用HttpClient封装
今天又是充满希望的一天
09-10 3138
通用HttpClient
java httpclient封装类_HttpClient 4.0 封装工具类
weixin_36486277的博客
02-24 594
以下为本人在实际开发过程中封装的HttpClient工具类，HttpClient 4 较之 HttpClient 3 的变动较大，尤其是在SSL方面，包结构已经改得面目全非, 不过使用HttpClient 4 的SSL 及数字证书的双向认证方面更为清晰及简单了。[@more@]/** @{#} HttpclientUtil.java** Pingzonglangji.com Inc.** Copy...
java httpclient封装类_HttpClientUtils封装（详细版本）
weixin_33656445的博客
02-24 466
//// Source code recreated from a .class file by IntelliJIDEA// (powered by Fernflower decompiler)//package com.tree.ztree_demo.httpclient;import java.io.IOException;import java.io.InputStream;import ...
HttpUtils工具类和post请求List 数据
06-06
您好，关于您的问题，HttpUtils是一个HTTP请求工具类，可以用于发送HTTP请求，并获取响应结果。下面是一个使用HttpUtils进行POST请求发送List数据的示例代码： ```java public static void postListData(String url, List<String> dataList) { HttpUtils httpUtils = new HttpUtils(); RequestParams params = new RequestParams(); StringBuilder stringBuilder = new StringBuilder(); for (String data : dataList) { stringBuilder.append(data).append(","); } params.addBodyParameter("dataList", stringBuilder.toString()); httpUtils.send(HttpMethod.POST, url, params, new RequestCallBack<String>() { @Override public void onSuccess(ResponseInfo<String> responseInfo) { // 处理成功回调 } @Override public void onFailure(HttpException error, String msg) { // 处理失败回调 } }); } ``` 在上述代码中，我们使用了HttpUtils发送POST请求，并通过RequestParams添加了一个名为"dataList"的请求参数，并将List数据转换成了逗号分隔的字符串。 希望对您有所帮助。
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值