HttpClientUtils 工具类

已于 2024-01-26 11:50:11 修改
阅读量2.1k 收藏 2
点赞数
分类专栏： 工具 文章标签： 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先僧
关注
专栏目录
get请求和post请求中用到的类、方法。【封装HttpClientUtils工具类】
weixin_43186788的博客
09-17 125
【代码】get请求和post请求中用到的类、方法。【封装HttpClientUtils工具类】
HttpClientUtils
01-09
一款基于HttpClient的工具类。 可二次开发 ，目前已集成文件上传 参数传递 Json传输 请求头添加等功能
发送http的get和post请求的工具类2
qq_41609775的博客
11-12 235
import java.io.IOException; import java.net.URI; import java.util.ArrayList; import java.util.List; import java.util.Map; import org.apache.http.NameValuePair; import org.apache.http.client.entity.Url...
java网络请求工具类（HttpUtils/HttpClientUtils）
最新发布
Flying_Fish_roe的博客
10-03 1080
Java网络请求工具类（HttpUtils/HttpClientUtils）是用来简化与服务器进行网络请求的过程。它是基于HttpClient库开发的。该工具类提供了一系列方法，可以方便地发送HTTP请求（GET、POST等）。它可以帮助我们完成以下操作：发送GET请求：通过传入URL和参数，发送GET请求并获取服务器返回的数据。发送POST请求：通过传入URL、参数和请求体，发送POST请求并获取服务器返回的数据。设置请求头：可以设置请求头，如User-Agent、Cookie等。
httpClientUtil 工具类
weixin_45447370的博客
02-23 362
package com.thsware.inner.service.home; import java.io.BufferedReader; import java.io.IOException; import java.io.InputStreamReader; import java.net.URI; import java.util.ArrayList; import java.util.List; import java.util.Map; import org.apache.commons.
<学习笔记> HttpClient工具类
Mars_Jiang的博客
07-06 1050
HttpClient工具类 HttpClient可忽略证书校验 package com.test.http; import java.io.IOException; import java.net.SocketTimeoutException; import java.security.GeneralSecurityException; import java.security.cert
HttpClientUtil工具类
ginger_mr的博客
09-15 711
public class HttpClientUtils { public static final int connTimeout=10000; public static final int readTimeout=10000; public static final String charset="UTF-8"; private static HttpClient client = null; static { PoolingHttpClientConne
java httpclient工具类_httpClientUtils工具类发送GET或POST请求完整案例
weixin_31261145的博客
02-16 1962
httpClient是javaEE语言中用于接口调用的框架，本案例封装好了httpClientUtils工具类，用于发送GET和POST请求，直接将此工具类复制到你的项目中就可以了。第一步：httpClient jar包可采用maven方式下载，version版本自己改，如下；javax.servlet.jspjsp-api2.2commons-httpclientcommons-httpclie...
httpclientutils 工具类
03-16
HttpClientUtils是一个Java HTTP客户端工具类，它基于Apache HttpComponents库构建，可以用于发送HTTP请求并处理响应。该工具类提供了多种方法，例如GET、POST、PUT和DELETE等HTTP方法，还支持设置请求头、请求体、...
HttpClient接口调用工具类(附带demo)
11-28
HttpClient是Apache基金会开发的一个HTTP客户端库，用于在Java应用程序中执行HTTP请求。...在这个工具类中，我们看到包括了Post、Get、Put...通过这个工具类，你无需深入了解HttpClient的底层实现，只需关注业务逻辑即可。
封装HttpClientUtils工具
weixin_30263073的博客
07-29 1455
封装HttpClientUtils工具 package cn.gzsxt.ego.base.utils; import java.io.IOException; import java.util.ArrayList; import java.util....
apache --- HttpClientUtils工具类
muguazhi的博客
04-11 389
【代码】apache --- HttpClientUtils工具类。详细介绍了如何在Java项目中使用ApacheHttpClient库进行HTTP的GET和POST请求，包括配置连接池、设置请求参数、处理URL编码、管理连接生命周期以及资源释放。
Java中HttpClientUtil工具类
listeningdu的博客
03-13 955
HttpClientUtil工具类是java 调用第三方接口时需要使用到的，例如：在系统之间交互时获取参数。HttpClientUtil 包含get和post方法。1、创建CloseableHttpClient对象，用于执行excute方法。2、创建HttpPost或者HttpGet请求对象。3、执行请求，判断返回状态，接收响应对象。
HttpClientUtill工具类
黑科技的专栏
11-02 227
HttpClientUtill工具类
*HttpClientUtil工具类*
lq845584463的博客
06-21 127
** HttpClientUtil工具类 ** 找了好久好到的接收Map<String,Object>类型的http请求工具类，亲测可用，供参考： import org.apache.commons.io.IOUtils; import org.apache.http.HttpEntity; import org.apache.http.HttpResponse; import org.apache.http.HttpStatus; import org.apache.http.NameValu
HttpClientUtil 工具类（http请求工具类）
清汉_CSDN
04-14 625
http 工具
HttpclientUtil
u011165335的博客
11-19 315
参考: import java.io.File; import java.io.IOException; import java.util.ArrayList; import java.util.Iterator; import java.util.List; import java.util.Map; import org.apache.http.HttpEntity; import org.apache.http.NameValuePair; import org.apache.http.client
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值