HttpClientUtils 工具类

已于 2024-01-26 11:50:11 修改
阅读量1.8k 收藏 1
点赞数
分类专栏： 工具 文章标签： java
于 2019-03-05 15:45:16 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/laihongming/article/details/88184997
版权

maven项目需要在pom文件中添加相关的包依赖 

 <dependency>
            <groupId>top.jfunc.json</groupId>
            <artifactId>Json-Gson</artifactId>
            <version>1.0</version>
 </dependency>

package com.laixh.utils;

import java.io.UnsupportedEncodingException;
import java.net.URLEncoder;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.Set;

import com.google.gson.Gson;
import org.apache.commons.io.IOUtils;
import org.apache.commons.lang.ObjectUtils;
import org.apache.http.Header;
import org.apache.http.HttpEntity;
import org.apache.http.HttpResponse;
import org.apache.http.NameValuePair;
import org.apache.http.client.entity.UrlEncodedFormEntity;
import org.apache.http.client.methods.CloseableHttpResponse;
import org.apache.http.client.methods.HttpEntityEnclosingRequestBase;
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.entity.StringEntity;
import org.apache.http.impl.client.CloseableHttpClient;
import org.apache.http.impl.client.HttpClients;
import org.apache.http.message.BasicNameValuePair;
import org.apache.http.util.EntityUtils;
import org.apache.log4j.Logger;


/**
 * HttpClientUtils 工具类
 */
public class HttpClientUtils {
    private static Logger logger = org.apache.log4j.Logger.getLogger(HttpClientUtils.class.getSimpleName());
    public static final String UTF8 = "UTF-8";
    public static final String GBK = "GBK";
    private final static String CONTENT_TYPE_TEXT_JSON = "text/json";

    public static String get(String url, String charset) {
        CloseableHttpClient httpClient = HttpClients.custom().build();
        HttpGet httpGet = new HttpGet(url);
        String result = null;
        try {
            HttpResponse response = httpClient.execute(httpGet);
            HttpEntity entity = response.getEntity();
            if (null != entity) {
                result = EntityUtils.toString(entity, charset);
            }
            EntityUtils.consume(entity);
        } catch (Exception e) {
            logger.error(url, e);
        } finally {
            IOUtils.closeQuietly(httpClient);
        }

        return result;
    }


    public static String get(String url, Map<String, String> headers, Map<String, String> data, String charset) {
        StringBuilder para = new StringBuilder();
        for (String item : data.keySet()) {
            para.append("&");
            para.append(item);
            para.append("=");
            para.append(URLEncoder.encode(data.get(item)));
        }

        if (para.length() > 0) {
            url = url.indexOf("?") > 0 ? url + para : url + "?" + para.substring(1);
        }
        return get(url, headers, charset);
    }


    public static String get(String url, Map<String, String> headers, String charset) {
        CloseableHttpClient httpClient = HttpClients.custom().build();
        HttpGet httpGet = new HttpGet(url);
        String result = null;
        try {
            if (headers != null) {
                for (String item : headers.keySet()) {
                    httpGet.addHeader(item, headers.get(item));
                }
            }
            HttpResponse response = httpClient.execute(httpGet);
            HttpEntity entity = response.getEntity();
            if (null != entity) {
                result = EntityUtils.toString(entity, charset);
            }
            EntityUtils.consume(entity);
        } catch (Exception e) {
            logger.error(url, e);
        } finally {
            IOUtils.closeQuietly(httpClient);
        }
        return result;
    }


    public static String post(String url, Map map, String charset) {
        return request(url, "post", null, map, charset);
    }


    public static String post(String url, Map<String, String> header, Map map, String charset) {
        return request(url, "post", header, map, charset);
    }

    public static String put(String url, Map<String, String> header, Map map, String charset) {
        return request(url, "put", header, map, charset);
    }

    public static String request(String url, String method, Map<String, String> header, Map map, String charset) {
        CloseableHttpClient httpClient = null;
        httpClient = HttpClients.custom().build();

        HttpEntityEnclosingRequestBase hp = null;
        String result = null;
        if ("put".equals(method)) {
            hp = new HttpPut(url);
        } else {
            hp = new HttpPost(url);

        }
        if (header != null) {
            for (String item : header.keySet()) {
                hp.addHeader(item, header.get(item));
            }
        }

        try {
            if (map != null && map.size() > 0) {
                List<NameValuePair> params = new ArrayList<NameValuePair>();
                Set keys = map.keySet();
                for (Iterator iterator = keys.iterator(); iterator.hasNext();) {
                    String name = ObjectUtils.toString(iterator.next());
                    String value =ObjectUtils.toString(map.get(name));
                    params.add(new BasicNameValuePair(name, value));
                }
                hp.setEntity(new UrlEncodedFormEntity(params, charset));
            }

            HttpResponse response = httpClient.execute(hp);
            HttpEntity entity = response.getEntity();
            if (null != entity) {
                result = EntityUtils.toString(entity, charset);
            }
            EntityUtils.consume(entity);
        } catch (Exception e) {
            logger.error(url, e);
        } finally {
            IOUtils.closeQuietly(httpClient);
        }
        return result;
    }

    public static String postContent(String url, Map map, String charset) {
        CloseableHttpClient httpclient = null;
        String ret = null;
        httpclient = HttpClients.custom().build();

        HttpPost httppost = new HttpPost(url);
        if (map != null && map.size() > 0) {
            List<NameValuePair> params = new ArrayList<NameValuePair>();
            Set keys = map.keySet();
            for (Iterator iterator = keys.iterator(); iterator.hasNext();) {
                String name = (String) iterator.next();
                String value = (String) map.get(name);
                params.add(new BasicNameValuePair(name, value));
            }
            try {
                httppost.setEntity(new UrlEncodedFormEntity(params, charset));
            } catch (UnsupportedEncodingException e) {
                e.printStackTrace();
            }
        }

        try {
            CloseableHttpResponse response = null;
            response = httpclient.execute(httppost);
            if (null != response) {
                HttpEntity entity = null;
                try {
                    entity = response.getEntity();
                    if (entity != null) {
                        ret = new String(IOUtils.toByteArray(entity.getContent()), getResCharset(response, charset));
                        logger.debug("解析后的数据: " + ret);
                    }
                    EntityUtils.consume(entity);
                } finally {
                    response.close();
                }
            }

        } catch (Exception e) {
            logger.error(url, e);
        } finally {
            IOUtils.closeQuietly(httpclient);
        }
        return ret;
    }

    public static String postContent(String url, String content, String charset) {
        String responseContent = "";
        CloseableHttpClient httpclient = HttpClients.custom().build();;

        HttpPost httppost = new HttpPost(url);
        HttpEntity postEntity = new StringEntity(content, charset);
        httppost.setEntity(postEntity);
        System.out.println("executing request" + httppost.getRequestLine());
        try {

            CloseableHttpResponse response = null;
            try {
                response = httpclient.execute(httppost);
            } catch (Exception e) {
                return "";
            }
            if (null != response) {
                try {
                    HttpEntity entity = response.getEntity();
                    if (entity != null) {
                        try {
                            responseContent = new String(IOUtils.toByteArray(entity.getContent()), getResCharset(response, charset));
                            logger.debug( responseContent);
                        } catch (Exception ee) {
                            logger.error(ee.getMessage());
                        }
                    }
                    EntityUtils.consume(entity);
                } finally {
                    response.close();
                }
            }

        } catch (Exception e) {
            logger.debug(e);
        }
        return responseContent;
    }

    public static String getResCharset(CloseableHttpResponse response, String charset) {
        Header[] contentTypes = response.getHeaders("Content-Type");
        String resCharset = charset;
        int totalTypes = null != contentTypes ? contentTypes.length : 0;
        for (int i = 0; i < totalTypes; i++) {
            String[] value = contentTypes[i].getValue().toLowerCase().split(";");
            for (int j = 0; j < value.length; j++) {
                if (value[j].startsWith("charset=")) {
                    resCharset = value[j].substring("charset=".length());
                }
            }

        }
        return resCharset;
    }

    /**
     * 参数 json格式
     * @param url
     * @param param
     * @return
     */
    public static String postJsonRequest(String url, Map<String, Object> param)   {

        CloseableHttpClient client = HttpClients.createDefault();
        CloseableHttpResponse response = null;
        String result = "";
        try {
            try {
                HttpPost httpPost = new HttpPost(url);
                httpPost.setHeader("Content-Type", "application/json;charset=UTF-8");
                Gson gson = new Gson();
                String parameter = gson.toJson(param);
                StringEntity se = new StringEntity(parameter);
                se.setContentType(CONTENT_TYPE_TEXT_JSON);
                httpPost.setEntity(se);
                response = client.execute(httpPost);
                HttpEntity entity = response.getEntity();
                result = EntityUtils.toString(entity, "UTF-8");
            }catch (Exception e){
                e.printStackTrace();
            }finally {
                response.close();
            }
        }catch (Exception e){
            e.printStackTrace();
        }
        return result;
    }
    public static void main(String[] args) {
        Map<String, Object> jsonObject = new HashMap<>();
        Map<String, Object> extras = new HashMap<>();
        jsonObject.put("title", "title");
        //jsonObject.put("noticeTitle",noticeTitle);
        jsonObject.put("shareRange","2");
        jsonObject.put("createTime","20180101");
        jsonObject.put("openType","3");
        jsonObject.put("jumpUrl","");
        //jsonObject.put("batchToUsers",batchToUsers);
        jsonObject.put("coverImgUrl","");
        jsonObject.put("summary","");
        extras.put("aa","er3");
        extras.put("bb","rqoutq");
        Gson gson = new Gson();
        String extrasJson = gson.toJson(extras);
        jsonObject.put("extras",extrasJson);
        jsonObject.put("mc_widget_identifier","");
        String urlN = "https://amobiletest.anta.com/mpm-api/api/tempmsg/create_temp_msg_and_push?appKey=55551f01&sourceType=todo&touser=2018019633&accessToken=aa584534-1e7c-47bf-b02d-7db853ff2630";
        System.out.println(postJsonRequest(urlN,jsonObject));
    }

}


package app.ext.utils;

import com.alibaba.fastjson.JSON;
import com.alibaba.fastjson.JSONObject;
import lombok.extern.slf4j.Slf4j;

import java.io.*;
import java.net.HttpURLConnection;
import java.net.URL;
import java.util.HashMap;
import java.util.Map;
import java.util.Set;

import org.apache.commons.codec.binary.Base64;
import org.apache.http.HttpEntity;
import org.apache.http.HttpResponse;
import org.apache.http.client.methods.HttpPost;
import org.apache.http.entity.StringEntity;
import org.apache.http.impl.client.CloseableHttpClient;
import org.apache.http.impl.client.HttpClients;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

@Slf4j
public class HttpClientMainExt {

    private final static Logger logger = LoggerFactory.getLogger(HttpClientMainExt.class);

    public static JSONObject httpPostJson(String url, Map<String, Object> params, Map<String, String> headers)
            throws Exception {
        // post请求返回结果
        logger.info("url:{},params:{},headers:{}",url,JSON.toJSONString(params),JSON.toJSONString(headers));
        CloseableHttpClient httpclient = HttpClients.createDefault();
        HttpPost method = new HttpPost(url);
        setPostHead(method, headers);
        JSONObject jsonObject = new JSONObject();
        try {
            String str = "";

            if (params == null) {
                params = new HashMap<String, Object>();
            }
            if (null != params) {
                // 解决中文乱码问题
                StringEntity entity = new StringEntity(JSON.toJSONString(params), "utf-8");// JSON请求字符串
                entity.setContentEncoding("UTF-8");
                entity.setContentType("application/json; charset=utf-8");
                method.setEntity(entity);
            }
            HttpResponse result = httpclient.execute(method);
            /** 读取服务器返回过来的json字符串数据 **/
            str = getRespString(result.getEntity());
            jsonObject = JSONObject.parseObject(str);
            logger.info("返回结果result:{}",url,JSON.toJSONString(params),JSON.toJSONString(headers),jsonObject);
        } catch (Exception e) {
            throw new Exception("调用接口url:" + url + "错误:" + e.getMessage(), e);
        } finally {
            try {
                httpclient.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
        return jsonObject;
    }
    public static void setPostHead(HttpPost httpPost, Map<String, String> headMap) {
        if (headMap != null && headMap.size() > 0) {
            Set<String> keySet = headMap.keySet();
            for (String key : keySet) {
                Object o = headMap.get(key);
                String value = (String) o;
                httpPost.addHeader(key, value);
            }
        }
    }

    private static String getRespString(HttpEntity entity) throws Exception {
        if (entity == null) {
            return null;
        }
        InputStream is = entity.getContent();
        StringBuffer strBuf = new StringBuffer();
        byte[] buffer = new byte[4096];
        int r = 0;
        while ((r = is.read(buffer)) > 0) {
            strBuf.append(new String(buffer, 0, r, "UTF-8"));
        }
        return strBuf.toString();
    }


    public static String sendPostWithBody(String url, com.alibaba.fastjson.JSONObject param) {
        BufferedReader reader = null;
        HttpURLConnection con = null;
        try {
            URL restUrl = new URL(url);
            // 打开和URL之间的连接
            con = (HttpURLConnection)restUrl.openConnection();
            //请求post方式
            con.setRequestMethod("POST");
            // Post请求不能使用缓存
            con.setUseCaches(false);
            // 设置是否从HttpURLConnection输入，默认值为 true
            con.setDoInput(true);
            // 设置是否使用HttpURLConnection进行输出，默认值为 false
            con.setDoOutput(true);

            //设置header内的参数 connection.setRequestProperty("健, "值");
            con.setRequestProperty("Content-Type", "application/x-www-form-urlencoded; charset=utf-8");
            con.setRequestProperty("Authorization","Basic " + Base64.encodeBase64String("aozhe:fda4a19a-b90d-40b0-a241-9ddece7f6f12".getBytes()));
            // 建立实际的连接
            con.connect();

            // 得到请求的输出流对象
            OutputStreamWriter writer = new OutputStreamWriter(con.getOutputStream(),"UTF-8");
            writer.write(param.toString());
            writer.flush();

            // 获取服务端响应，通过输入流来读取URL的响应
            InputStream is = con.getInputStream();
            reader = new BufferedReader(new InputStreamReader(is, "UTF-8"));
            StringBuffer sbf = new StringBuffer();
            String strRead;
            while ((strRead = reader.readLine()) != null) {
                sbf.append(strRead);
                sbf.append("\r\n");
            }
            // 打印读到的响应结果
            return sbf.toString();
        }catch (Exception e) {
            log.info("发送 POST 请求出现异常！url:{}", url, e);
        }finally {
            try {
                if(reader != null) {
                    reader.close();
                }
            }catch (IOException ex){


            }

            // 关闭连接
            if(con != null) {
                con.disconnect();
            }
        }
        return null;
    }
}

bug先僧
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
HttpClientUtils.java
10-14
httpclient工具类包含get,post,put,delete请求
HttpClient接口调用工具类(附带demo)
11-28
HttpClient接口调用工具类 (Post请求 get请求 put请求 delete请求 下载就可以用 )
HttpClientUtil工具类 里面包含GET POST 及返回值处理
10-19
代码经过测试 请放心使用 直接填入远程接口就可
HttpClientUtil-工具类
海恋北斗星
03-14 314
HttpClientUtil-工具类 代码 package cn.hlbdx; import java.io.IOException; import java.io.UnsupportedEncodingException; import java.net.URI; import java.net.URISyntaxExcep...
HttpClientUtils工具类封装，doGet()、doPost()、doPut()、doDelete()
Spring Boot-Common On With You
12-08 8788
概述 HttpClient 是 Apache Jakarta Common 下的子项目，可以用来提供高效的、最新的、功能丰富的支持 HTTP 协议的客户端编程工具包，并且它支持 HTTP 协议最新的版本。 HttpClientUtils工具类封装，doGet()、doPost()、doPut()、doDelete() 1、doGet不带参数示例 // 创建Httpcli...
HttpClientUtill工具类
黑科技的专栏
11-02 200
HttpClientUtill工具类
HTTPClient工具类，完整
08-07
HTTPClient工具类，完整，HTTPClient工具类，完整，HTTPClient工具类，完整HTTPClient工具类，完整，HTTPClient工具类，完整
Java中HttpClientUtil工具类
weixin_41769596的博客
02-22 4536
HttpClientUtil工具类是java 调用第三方接口时需要使用到的，例如：在系统之间交互时获取参数。HttpClientUtil 包含get和post方法。 发送HttpPost或HttpGet请求一共三个步骤： 1、创建CloseableHttpClient对象，用于执行excute方法 2、创建HttpPost或者HttpGet请求对象 3、执行请求，判断返回状态，接收响应对象 package com.*.utils; import java.io.IOException; import j
常用HttpClientUtil,拿来即用
weixin_41862314的博客
08-02 3274
最近项目中需要调用第三方接口,于是自己写了一个HttpClientUtil,拿来即用,封装了三个常用的get请求,Post表单请求和Post Json请求方法 如有不对,欢迎指正评论 1 pom.xmll导入依赖 2 上代码 package com.sunpeifu.http; import com.alibaba.fastjson.JSON; import com.sunpeifu.User;...
HttpClient工具类（完整版）
Boy_Martin的博客
12-21 3080
HttpClient工具类
http请求工具类-HttpClientUtils
12-19
http请求工具类-HttpClientUtils 还需要HttpClientResult类
HttpClientUtils
01-09
一款基于HttpClient的工具类。 可二次开发 ，目前已集成文件上传 参数传递 Json传输 请求头添加等功能
【1524】java投票管理系统Myeclipse开发mysql数据库web结构java编程计算机网页项目
qq_251836457的博客
04-18 662
2、开发环境为TOMCAT7.0,Myeclipse8.5开发，数据库为Mysql5.0，使用java语言开发。(5)投票选项管理：对投票选项信息进行添加、删除、修改和查看。(6)投票记录管理：对投票记录信息进行添加、删除、修改和查看。(1)管理员管理：对管理员信息进行添加、删除、修改和查看。(2)用户管理：对用户信息进行添加、删除、修改和查看。(3)公告管理：对公告信息进行添加、删除、修改和查看。(4)投票管理：对投票信息进行添加、删除、修改和查看。4）投票浏览查看、查看投票、投票记录。
2.8 构建gradle环境
蚊者逆袭的博客
04-18 2160
Gradle是一种现代化的构建工具，用于自动化地构建、测试和部署软件项目。它是一种基于JVM（Java虚拟机）的构建工具，最初是为了解决Apache Ant和Apache Maven等传统构建工具的一些限制而开发的。
Web前端 Javascript笔记5
cycyzh的博客
04-18 853
script>'console.log("哈哈哈佳人们好困")'}, 3000)​let t1 = setTimeout('console.log("你们看到这句话的时候我早已身价百万！！")', 4000)​</script>3秒，四秒后出来的东西，出现前会返回计时器编号。
JUC(java.util.concurrent) 的常见类
最新发布
weixin_43497876的博客
04-20 1179
Callable 是一个 interface（类似之前的 Runnable，用来描述一个任务，但是没有返回值）也是描述一个任务的，有返回值。方便程序猿借助多线程的方式计算结果.创建线程计算 1 + 2 + 3 + ... + 1000, 不使用 Callable。
Java中如何实现minio文件上传
Keep__Me的博客
04-19 1166
前面已经在docker中部署了minio服务，那么该如何在Java代码中使用？这篇说下minio在Java中的配置跟使用。
Java-常用API-2
2302_80362563的博客
04-17 898
Object类中提供的equals比较方法有空指针会直接报错，这时就需要用到Objects类中的方法。验证字符串的一种规则，或在文本中查找满足需要的内容，表达式类型为String。拥有非常高的上限，可以用来处理超过long long的整数。预定义字符（Java中，\\表示\）常用于小数的精确计算。
httpclientutils 工具类
03-16
HttpClientUtils是一个Java HTTP客户端工具类，它基于Apache HttpComponents库构建，可以用于发送HTTP请求并处理响应。该工具类提供了多种方法，例如GET、POST、PUT和DELETE等HTTP方法，还支持设置请求头、请求体、连接超时、读取超时和重试等参数。使用HttpClientUtils可以简化Java中使用HTTP客户端的复杂性，使得发送HTTP请求变得更加方便和高效。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值