Java常用HttpClient工具类

置顶 已于 2022-05-16 17:16:04 修改
阅读量2k 收藏 15
点赞数 2
分类专栏： Java 文章标签： java http
于 2022-05-16 17:00:44 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_35341203/article/details/124802980
版权

HttpClient工具类

记录一个常用的HttpClient工具，还挺好用的，以前经常用，主要再次封装了httpcomponents。提供了一些上传功能，代理请求等不常见的方法！

当然hutool也比较好用，推荐大家使用。

主要功能：

上传视频

提交FormData

提交JSONBody

使用代理，发送请求

Pom文件

        <!-- http客户端 -->
        <dependency>
            <groupId>org.apache.httpcomponents</groupId>
            <artifactId>httpclient</artifactId>
            <version>4.5.12</version>
        </dependency>
        <!-- https://mvnrepository.com/artifact/org.apache.httpcomponents/httpmime -->
        <dependency>
            <groupId>org.apache.httpcomponents</groupId>
            <artifactId>httpmime</artifactId>
            <version>4.5.12</version>
        </dependency>
        <!-- https://mvnrepository.com/artifact/org.apache.httpcomponents/httpcore -->
        <dependency>
            <groupId>org.apache.httpcomponents</groupId>
            <artifactId>httpcore</artifactId>
            <version>4.4.13</version>
        </dependency>

工具类

先写一个异常类

public class HttpClientException extends RuntimeException{

    public HttpClientException() {
        super();
    }

    public HttpClientException(String message, Throwable cause) {
        super(message, cause);
    }

    public HttpClientException(String message) {
        super(message);
    }

    public HttpClientException(String message, Object... objects) {
        super(convertMessage(message,objects));
    }

    public HttpClientException(Throwable cause) {
        super(cause);
    }

    public static String convertMessage(String message,Object... objects) {
        if (message.indexOf("{}")>0){
            String s = message.replaceAll("\\{\\}", "%s");
            String format = null;
            try {
                format = String.format(s, objects);
            } catch (Exception e) {
                return message;
            }
            return format;
        }else {
            return message;
        }
    }
}

发出Http请求的工具类


/**
 * @Description: <p>通用http调用工具</p>
 */
public class HttpClient {

    private static final Logger log = LoggerFactory.getLogger(HttpClient.class);

    private static final RequestConfig requestConfig;

    private static final RequestConfig uploadConfig;

    static {
        requestConfig = RequestConfig.custom()
                // 客户端和服务器建立连接的timeout
                .setConnectTimeout(1000*60)
                // 指从连接池获取连接的timeout
                .setConnectionRequestTimeout(6000)
                // 客户端从服务器读取数据的timeout
                .setSocketTimeout(1000*60*3)
                .build();
        uploadConfig = RequestConfig.custom()
                // 客户端和服务器建立连接的timeout
                .setConnectTimeout(1000*60*20)
                // 指从连接池获取连接的timeout
                .setConnectionRequestTimeout(6000)
                // 客户端从服务器读取数据的timeout
                .setSocketTimeout(1000*60*20)
                .build();
    }

    /**
     * map转换
     */
    public static Map<String, String> convertMap(JSONObject jsonObject) throws Exception{
        Map<String, Object> innerMap = jsonObject.getInnerMap();
        Map<String, String> map = convertMap(innerMap);
        return map;
    }

    /**
     * map转换
     */
    public static Map<String, String> convertMap(Map<String, Object> objectMap) throws Exception{
        Map<String, String> map = new HashMap<>();
        for(Map.Entry<String, Object> entries : objectMap.entrySet()){
            map.put(entries.getKey(),null == entries.getValue() ? null : String.valueOf(entries.getValue()));
        }
        return map;
    }

    /**
     * 发送get请求，接收json响应数据
     * GET
     * @param url 访问地址，无query参数
     * @param param query参数
     * @return
     */
    public static JSONObject doGet(String url, Map<String, String> param) throws HttpClientException{

        // 创建Httpclient对象
        CloseableHttpClient httpClient = HttpClients.createDefault();

        String resultString = "";
        CloseableHttpResponse response = null;
        try {
            // 创建uri
            URIBuilder builder = new URIBuilder(url);
            if (param != null) {
                for (String key : param.keySet()) {
                    builder.addParameter(key, param.get(key));
                }
            }
            URI uri = builder.build();
            log.debug("-->>Http GET请求地址："+url);
            if(null != param){
                log.debug("-->>Http 请求参数："+param.toString());
            }

            // 创建http GET请求
            HttpGet httpGet = new HttpGet(uri);
            httpGet.setConfig(requestConfig);

            // 执行请求
            response = httpClient.execute(httpGet);
            // 判断返回状态是否为200
            if (response.getStatusLine().getStatusCode() == 200) {
                resultString = EntityUtils.toString(response.getEntity(), "UTF-8");
                log.debug("<<--Http 响应内容："+resultString);
            }else{
                log.error("<<--Http 响应状态码："+response.getStatusLine().getStatusCode());
                throw new HttpClientException("请求失败 状态码：{}",response.getStatusLine().getStatusCode());
            }

        } catch (IOException | URISyntaxException e) {
            log.error("Http 发送请求异常 url:{}",url,e);
            throw new HttpClientException("发送请求失败 url:{}",url);
        } finally {
            try {
                if (response != null) {
                    response.close();
                }
                httpClient.close();
            } catch (IOException e) {
                log.error("Http 关闭流异常",e);
            }
        }
        return JSONObject.parseObject(resultString);
    }

    /**
     * 发送post请求，上传byte
     * POST binary
     * @param url 请求地址，不拼接
     * @return
     */
    public static JSONObject doPostBinaryBody(String url,byte[] bytes,String fileName) throws HttpClientException{
        // 创建Httpclient对象
        CloseableHttpClient httpClient = HttpClients.createDefault();
        CloseableHttpResponse response = null;
        String resultString = "";
        try {
            // 创建Http Post请求
            log.debug("-->>Http POST请求地址："+url);

            HttpPost httpPost = new HttpPost(url);
            httpPost.setConfig(uploadConfig);
            // 创建参数列表

            MultipartEntityBuilder multipartEntityBuilder = MultipartEntityBuilder.create();
			// TODO:这个video自己填，因为这个方法非常少用，是我用来上传视频的，所以这里写死了
            multipartEntityBuilder.addBinaryBody("video", bytes, ContentType.MULTIPART_FORM_DATA,fileName );

            httpPost.setEntity(multipartEntityBuilder.build());
            // 执行http请求
            response = httpClient.execute(httpPost);
            // 判断返回状态是否为200
            if (response.getStatusLine().getStatusCode() == 200) {
                resultString = EntityUtils.toString(response.getEntity(), "UTF-8");
                log.debug("<<--Http 响应内容："+resultString);
            }else{
                log.error("<<--Http 响应状态码："+response.getStatusLine().getStatusCode());
                throw new HttpClientException("请求失败 状态码：{}",response.getStatusLine().getStatusCode());
            }
        } catch (Exception e) {
            log.error("Http 发送请求异常 url:{}",url,e);
            throw new HttpClientException("发送请求失败 url:{}",url);
        } finally {
            try {
                response.close();
            } catch (IOException e) {
                log.error("Http 关闭流异常",e);
            }
        }
        return JSONObject.parseObject(resultString);
    }

    /**
     * 发送post请求，form-data数据传输
     * POST multipart/form-data
     * @param url 请求地址
     * @return 返回json数据
     */
    public static JSONObject doPostFormData(String url,Map<String, String> formData) throws HttpClientException{
        // 创建Httpclient对象
        CloseableHttpClient httpClient = HttpClients.createDefault();
        CloseableHttpResponse response = null;
        String resultString = "";
        try {
            // 创建Http Post请求
            log.debug("-->>Http POST请求地址："+url);

            HttpPost httpPost = new HttpPost(url);
            httpPost.setConfig(requestConfig);
            // 创建参数列表
//            httpPost.setHeader("Content-Type", "multipart/form-data;charset=utf-8"); // 报错
            MultipartEntityBuilder multipartEntityBuilder = MultipartEntityBuilder.create();
            if (formData != null) {
                log.debug("-->>Http POST form-data内容："+ JSON.toJSONString(formData));
                for (String key : formData.keySet()) {
                    multipartEntityBuilder.addTextBody(key,formData.get(key), ContentType.MULTIPART_FORM_DATA);
                }
            }

            httpPost.setEntity(multipartEntityBuilder.build());
            // 执行http请求
            response = httpClient.execute(httpPost);
            // 判断返回状态是否为200
            if (response.getStatusLine().getStatusCode() == 200) {
                resultString = EntityUtils.toString(response.getEntity(), "UTF-8");
                log.debug("<<--Http 响应内容："+resultString);
            }else{
                log.error("<<--Http 响应状态码："+response.getStatusLine().getStatusCode());
                throw new HttpClientException("请求失败 状态码：{}",response.getStatusLine().getStatusCode());
            }
        } catch (Exception e) {
            log.error("Http 发送请求异常",e);
            throw new HttpClientException("发送请求失败 url:{}",url);
        } finally {
            try {
                response.close();
            } catch (IOException e) {
                log.error("Http 关闭流异常",e);
            }
        }
        return JSONObject.parseObject(resultString);
    }
    
    /**
     * 发送post请求，接收json响应数据
     * POST application/x-www-form-urlencoded
     * @param url 请求地址，不拼接
     * @param param 表单query参数
     * @return
     */
    public static JSONObject doPost(String url, Map<String, String> param) throws HttpClientException{
        // 创建Httpclient对象
        CloseableHttpClient httpClient = HttpClients.createDefault();
        CloseableHttpResponse response = null;
        String resultString = "";
        try {
            // 创建Http Post请求
            log.debug("-->>Http POST请求地址："+url);
            if (null != param){
                log.debug("-->>Http 请求参数："+param.toString());
            }

            HttpPost httpPost = new HttpPost(url);
            httpPost.setConfig(requestConfig);
            // 创建参数列表
            if (param != null) {
                List<NameValuePair> paramList = new ArrayList<>();
                for (String key : param.keySet()) {
                    paramList.add(new BasicNameValuePair(key, param.get(key)));
                }
                // 模拟表单
                UrlEncodedFormEntity entity = new UrlEncodedFormEntity(paramList);
                httpPost.setEntity(entity);
            }
            // 执行http请求
            response = httpClient.execute(httpPost);
            // 判断返回状态是否为200
            if (response.getStatusLine().getStatusCode() == 200) {
                resultString = EntityUtils.toString(response.getEntity(), "UTF-8");
                log.debug("<<--Http 响应内容："+resultString);
            }else{
                log.error("<<--Http 响应状态码："+response.getStatusLine().getStatusCode());
                throw new HttpClientException("请求失败 状态码：{}",response.getStatusLine().getStatusCode());
            }
        } catch (Exception e) {
            log.error("Http 发送请求异常 url:{}",url,e);
            throw new HttpClientException("发送请求失败 url:{}",url);
        } finally {
            try {
                response.close();
            } catch (IOException e) {
                log.error("Http 关闭流异常",e);
            }
        }
        return JSONObject.parseObject(resultString);
    }

    /**
     * 发送post请求，接收json响应数据
     *  POST application/json
     * @param url 请求地址
     * @param json json入参
     * @return
     */
    public static JSONObject doPostJson(String url, String json) throws HttpClientException {
        if(StringUtils.isBlank(json)){
            log.error("-->>Http POST发送json数据，json不能为空，url:"+url);
            return null;
        }
        // 创建Httpclient对象
        CloseableHttpClient httpClient = HttpClients.createDefault();
        CloseableHttpResponse response = null;
        String resultString = "";
        try {
            log.debug("-->>Http POST请求地址："+url);
            log.debug("-->>Http 请求参数："+json);
            // 创建Http Post请求
            HttpPost httpPost = new HttpPost(url);
            httpPost.setConfig(requestConfig);
            // 创建请求内容
            StringEntity entity = new StringEntity(json, ContentType.APPLICATION_JSON);
            httpPost.setEntity(entity);
            // 执行http请求
            response = httpClient.execute(httpPost);
            // 判断返回状态是否为200
            if (response.getStatusLine().getStatusCode() == 200) {
                resultString = EntityUtils.toString(response.getEntity(), "UTF-8");
                log.debug("<<--Http 响应内容："+resultString);
            }else{
                log.error("<<--Http 响应状态码："+response.getStatusLine().getStatusCode());
                throw new HttpClientException("请求失败 状态码：{}",response.getStatusLine().getStatusCode());
            }
        } catch (Exception e) {
            log.error("Http 发送请求异常 url:{}",url,e);
            throw new HttpClientException("发送请求失败 url:{}",url);
        } finally {
            try {
                if (response != null) {
                    response.close();
                }
                httpClient.close();
            } catch (IOException e) {
                log.error("Http 关闭流异常",e);
            }
        }
        return JSONObject.parseObject(resultString);
    }


	 /**
     * 发送get请求，接收json响应数据 [使用代理]
     *
     * @param url 访问地址，不拼接
     * @param params query参数
     * @param headers 请求头
     * @param proxyHost 代理服务器地址
     * @param proxyPort 代理服务器端口
     * @param proxyUser 认证用户名
     * @param proxyPassword 认证密码
     * @return
     * @throws HttpClientException
     */
    public static JSONObject doGetProxy(String url,
                                        Map<String, String > params,
                                        Map<String, String > headers,
                                        String proxyHost,Integer proxyPort,
                                        String proxyUser , String proxyPassword) throws HttpClientException{
        String resultString = "";
        CloseableHttpResponse response = null;
        CloseableHttpClient httpClient = null;
        try {
            // 设置代理HttpHost
            HttpHost proxy = new HttpHost(proxyHost, proxyPort);

            // 设置代理认证
            CredentialsProvider provider = new BasicCredentialsProvider();
            provider.setCredentials(new AuthScope(proxy), new UsernamePasswordCredentials(proxyUser, proxyPassword));

            httpClient = HttpClients.custom().setDefaultCredentialsProvider(provider).build();

            // 构建URI
            URIBuilder builder = new URIBuilder(url);
            if (params != null) {
                for (String key : params.keySet()) {
                    builder.addParameter(key, params.get(key));
                }
            }
            URI uri = builder.build();

            // 装配发送Get请求
            HttpGet httpGet = new HttpGet(uri);
            log.info("-->> ProxyHttp 请求内容："+uri.toString());

            // 请求设置时间
            RequestConfig requestConfig = RequestConfig.custom()
                    .setProxy(proxy)
                    .setConnectTimeout(10000)
                    .setSocketTimeout(10000)
                    .setConnectionRequestTimeout(3000)
                    .build();
            httpGet.setConfig(requestConfig);

            // 装配请求头
            if (null != headers){
                for(Map.Entry<String, String> entry : headers.entrySet()) {
                    httpGet.setHeader(entry.getKey(), entry.getValue());
                }
            }

            // 执行请求
            response = httpClient.execute(httpGet);

            // 判断返回状态是否为200
            if (response.getStatusLine().getStatusCode() == 200) {
                resultString = EntityUtils.toString(response.getEntity(), "UTF-8");
                log.info("<<--ProxyHttp 响应内容："+resultString);
            }else{
                log.error("<<--ProxyHttp 响应状态码："+response.getStatusLine().getStatusCode());
                throw new HttpClientException("请求失败");
            }
        } catch (IOException | URISyntaxException e) {
            log.error("ProxyHttp 发送请求异常",e);
            throw new HttpClientException("ProxyHttp 发送请求失败 url:{}",url);
        }  finally {
            try {
                if (response != null) {
                    response.close();
                }
                httpClient.close();
            } catch (IOException e) {
                log.error("ProxyHttp 关闭流异常",e);
            }
        }
        return JSONObject.parseObject(resultString);
    }
}
樱阙诗汀
关注
  • 2
    点赞
  • 踩
  • 15
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
httpclient工具类
qq_44077470的博客
05-27 433
【代码】httpclient工具类。
HTTPClient工具类
Planing & Design & Arrange & Do & willWinner
11-13 3223
HTTPClient 的实现工具类。
java中几种httpclient工具类
weixin_44263023的博客
05-06 1101
总结 java httpclient工具类
HttpClient Java工具类
小星星专栏
07-19 303
HttpClient
HttpClient常用操作及封装工具类
rqz__的博客
07-30 1562
HttpClient 是一个用于发送 HTTP 请求和接收 HTTP 响应的类库/模块，可以用于编写客户端应用程序，通过 HTTP 与服务器进行通信。 HttpClient 提供了一组方法和类，使得发送 HTTP 请求变得简单和方便。它支持各种 HTTP 方法，例如 GET、POST、PUT、DELETE 等，并可以设置请求的头部信息、请求参数、请求体等。
JavaHTTP请求工具类HTTPUtils
weixin_42077074的博客
03-17 3406
其中涉及 HTTP 请求相关的各种操作，关于这些方法详细的介绍可以查看这些博客。博客文章《Java发起HTTP请求并解析JSON返回数据》博客文章《JavaJSON处理工具类JSONUtils》博客文章《Java发起同异步HTTP请求和处理数据》HTTP 请求工具类。HTTP 请求工具类。
一些java常用的工具类
10-22
JUnit是Java中广泛使用的单元测试框架，它提供了断言、测试套件等功能，帮助开发者编写可测试的代码。 总之，Java工具类是提高开发效率的关键，它们封装了常见的操作，减少了代码重复，提高了代码可读性和维护性。...
Java Http工具类HttpClientUtil
11-24
多年积累，功能比较强大，可设置路由连接数，时间，请求类型包括get,post, 参数包括urlcode,map,json,xml。注释很清楚。
java工程常用代码工具类
10-16
在Java中，可以使用Spring框架的@RestController注解来创建RESTful服务，工具类可能包含一些辅助方法，如构建URL、处理HTTP响应等。 5. **HTTP工具**： 在Java中处理HTTP请求，我们可以利用HttpURLConnection或者...
Java常用工具类.zip
07-16
资源包括Java开发中经常使用到的一些工具类，源代码，亲测可直接使用。 工具类包括：CookieUtils；ExceptionUtil；FtpUtil；HttpClientUtil；IDUtils；JsonUtils；PictureResult；EasyUIResult
java常用的工具类实现
12-27
以下是一些Java中常用工具类的详细介绍： 1. **String**: `java.lang.String` 类是最基础的字符串处理工具类，提供了大量的静态方法，如 `concat()`、`substring()`、`indexOf()`、`replace()` 等，用于字符串的...
JAVA的http工具类
航仔的博客
11-17 2169
【代码】JAVA的http工具类。
java httpclient工具类_HttpClientUtils工具类
weixin_39773215的博客
02-13 336
import org.apache.http.Header;import org.apache.http.HttpEntity;import org.apache.http.NameValuePair;import org.apache.http.client.ClientProtocolException;import org.apache.http.client.config.RequestC...
【Java】HttpClientUtils（Apache HttpClient 工具类）
XKIND'S 博客
01-22 1346
文章目录HttpClientUtilsParameterizedTypeUtils HttpClientUtils import com.alibaba.fastjson.JSON; import com.alibaba.fastjson.TypeReference; import lombok.Data; import lombok.SneakyThrows; import org.apache.http.Header; import org.apache.http.HeaderIterator; imp
七大主流的HttpClient程序比较
Hanko的专栏
11-03 4059
在你还在纠结选择apache httpclient时，Android已经不用它了，改用okhttp了 当你还在纠结选择apache httpclient还是okhttp时，Square已经出了Retrofit，网友已经在说既然你都用了okhttp为何不直接使用Retrofit 1、HttpURLConnection： HttpURLConnection是java的标准类，什么都没封装，用起来太原始，不方便，比如重访问的自定义，以及一些高级功能等。 2、java.net.http.HttpCl.
基于HttpClient的http请求封装（含json格式）
niki_yang
11-22 2393
1.依赖 <dependency> <groupId>org.apache.httpcomponents</groupId> <artifactId>httpclient</artifactId> <version>4.5.5</version> </d...
HttpClientUtil发送Post/Get请求，使用fastjson解析json结果集
imVainiycos的博客
06-25 4984
由于经常需要通过后台服务端发起接口请求，在联调过程中借助HttpClientUtil工具类进行发送两位常见的网络请求，并且对返回的json结果集进行解析。作此文以方便后续查阅和学习，留个档。 一、HttpClientUtil pom依赖 <dependency> <groupId>org.wso2.apache.httpcomponents</group...
java httpclient工具类_Java开发小技巧（五）：HttpClient工具类
weixin_29002209的博客
02-13 809
前言大多数Java应用程序都会通过HTTP协议来调用接口访问各种网络资源，JDK也提供了相应的HTTP工具包，但是使用起来不够方便灵活，所以我们可以利用Apache的HttpClient来封装一个具有访问HTTP协议基本功能的高效工具类，为后续开发使用提供方便。文章要点：HttpClient使用流程工具类封装使用实例HttpClient使用流程1、导入Maven依赖org.apache.httpc...
在非WEB项目中用构建http强求来访问WEB资源 httpclient
香帅的博客
11-29 628
package com.xiangshuai; import java.io.FileNotFoundException; import java.util.HashMap; import java.util.Map; /*import org.apache.http.Header; import org.apache.http.client.HttpClient;*/ import com...
java常用httpclientutil
最新发布
11-21
Java常用的Httpclient工具是HttpclientUtil。...总的来说，HttpclientUtil是一个功能强大、使用简便的Httpclient工具类，它方便了Java开发者进行HTTP请求的发送和接收，并提供了丰富的功能和选项，以满足不同的需求。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值