对HttpClient的一些封装方法

最新推荐文章于 2024-08-18 15:12:53 发布
最新推荐文章于 2024-08-18 15:12:53 发布
阅读量1.8k 收藏 3
点赞数
分类专栏： httpclient 文章标签： httpclient get post 上传 下载
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/innerpeaceScorpio/article/details/70568883
版权

摘自项目中的util，利用httpclient发送get、post请求，上传、下载文件，可以直接拿去当作util类来使用。

import com.alibaba.fastjson.JSONObject;
import org.apache.commons.httpclient.HttpClient;
import org.apache.commons.httpclient.methods.PostMethod;
import org.apache.commons.io.IOUtils;
import org.apache.http.*;
import org.apache.http.client.config.RequestConfig;
import org.apache.http.client.methods.HttpGet;
import org.apache.http.client.methods.HttpPost;
import org.apache.http.entity.StringEntity;
import org.apache.http.entity.mime.MultipartEntityBuilder;
import org.apache.http.entity.mime.content.FileBody;
import org.apache.http.impl.client.CloseableHttpClient;
import org.apache.http.impl.client.HttpClientBuilder;
import org.apache.http.util.EntityUtils;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import java.io.*;
import java.net.URL;
import java.net.URLConnection;
import java.net.URLDecoder;
import java.util.Map;
import java.util.Set;
import java.util.UUID;

/**
 * HttpClient 封装
 * Created by Administrator on 2016/12/7.
 */
public class SimpleHttpClient {

    public static final Logger logger = LoggerFactory.getLogger(SimpleHttpClient.class);

    public static final Integer cache_size = 4096;

    public static InputStream invokePost4Stream(String url, Map<String, Object> params, Map<String, String> headers,int timeout) throws IOException {
        HttpClient hc = new HttpClient();
        PostMethod post = new PostMethod(url);
        if (headers != null) {
            Set<Map.Entry<String, String>> entrys = headers.entrySet();
            for (Map.Entry<String, String> entry : entrys) {
                post.addRequestHeader(entry.getKey(),String.valueOf(entry.getValue()));
            }
        }
        post.getParams().setContentCharset("UTF-8");
        if (params != null) {
            Set<Map.Entry<String, Object>> entrys = params.entrySet();
            for (Map.Entry<String, Object> entry : entrys) {
                post.addParameter(entry.getKey(),String.valueOf(entry.getValue()));
            }
        }
        try {
            hc.getParams().setSoTimeout(timeout);
            hc.executeMethod(post);
            return post.getResponseBodyAsStream();
        } finally {
//            post.releaseConnection();
        }
    }

    public static HttpResponse httpGetHttpResponse(String url) throws IOException {
        String uuid = UUID.randomUUID().toString();
        logger.info("http get request  uuid={},url={}", uuid, url);
        //get请求返回结果
        CloseableHttpClient client = HttpClientBuilder.create().build();
        HttpGet request = new HttpGet(url);
        try {
            HttpResponse response = client.execute(request);
            return response;
        } catch (IOException e) {
            throw e;
        } finally {
            request.releaseConnection();
            CloseUtil.close(client);
        }
    }

    public static JSONObject invokePost(String urlString, JSONObject json) throws IOException {
        // Configure and open a connection to the site you will send the request
        URL url = new URL(urlString);
        URLConnection urlConnection = url.openConnection();
        // 设置doOutput属性为true表示将使用此urlConnection写入数据
        urlConnection.setDoOutput(true);
        // 定义待写入数据的内容类型，我们设置为application/x-www-form-urlencoded类型
        urlConnection.setRequestProperty("content-type", "application/json");
        // 得到请求的输出流对象
        OutputStreamWriter out = new OutputStreamWriter(urlConnection.getOutputStream());
        // 把数据写入请求的Body
        out.write(json.toJSONString());
        out.flush();
        out.close();
        // 从服务器读取响应
        InputStream inputStream = urlConnection.getInputStream();
        String encoding = urlConnection.getContentEncoding();
        String body = IOUtils.toString(inputStream, encoding);
        JSONObject result = JSONObject.parseObject(body);
        return result;
    }

    public static JSONObject invokePost(String urlString, JSONObject json, Map<String, String> headers) throws IOException {

        // Configure and open a connection to the site you will send the request
        URL url = new URL(urlString);
        URLConnection urlConnection = url.openConnection();
        // 设置doOutput属性为true表示将使用此urlConnection写入数据
        urlConnection.setDoOutput(true);
        // 定义待写入数据的内容类型，我们设置为application/x-www-form-urlencoded类型
        urlConnection.setRequestProperty("content-type", "application/json");
        if(headers != null){
            Set<Map.Entry<String, String>> entrys = headers.entrySet();
            for (Map.Entry<String, String> entry : entrys) {
                urlConnection.setRequestProperty(entry.getKey(),String.valueOf(entry.getValue()));
            }
        }
        // 得到请求的输出流对象
        OutputStreamWriter out = new OutputStreamWriter(urlConnection.getOutputStream());
        // 把数据写入请求的Body
        out.write(json.toJSONString());
        out.flush();
        out.close();
        // 从服务器读取响应
        InputStream inputStream = urlConnection.getInputStream();
        String encoding = urlConnection.getContentEncoding();
        String body = IOUtils.toString(inputStream, encoding);
        JSONObject result = JSONObject.parseObject(body);
        return result;
    }


    public static InputStream httpGet4Stream(String url) throws IOException {
        return httpGet4Stream(url, null);
    }

    public static InputStream httpGet4Stream(String url, Map<String, String> headers) throws IOException {
        String uuid = UUID.randomUUID().toString();
        logger.info("http get request  uuid={},url={}", uuid, url);
        //get请求返回结果
        CloseableHttpClient client = HttpClientBuilder.create().build();
        HttpGet request = new HttpGet(url);
        try {
            if (headers != null) {
                Set<Map.Entry<String, String>> entrys = headers.entrySet();
                for (Map.Entry<String, String> entry : entrys) {
                    request.setHeader(entry.getKey(), String.valueOf(entry.getValue()));
                }
            }
            HttpResponse response = client.execute(request);
            HttpEntity entity = response.getEntity();
            return entity.getContent();
        } catch (IOException e) {
            throw e;
        } finally {
            request.releaseConnection();
            CloseUtil.close(client);
        }
    }


    /**
     * 下载文件
     *
     * @param url
     * @param bao
     * @return
     * @throws IOException
     */
    public static String httpGetFile(String url, ByteArrayOutputStream bao) throws IOException {
        String fileName = null;
        String uuid = UUID.randomUUID().toString();
        logger.info("http get request  uuid={},url={}", uuid, url);
        CloseableHttpClient client = HttpClientBuilder.create().build();
        HttpGet request = new HttpGet(url);
        try {
            HttpResponse response = client.execute(request);
            /**请求发送成功，并得到响应**/
            if (response.getStatusLine().getStatusCode() == 200) {
                HttpEntity entity = response.getEntity();
                InputStream in = entity.getContent();
                long length = entity.getContentLength();
                if (length <= 0) {
                    logger.error("下载文件不存在！");
                    return fileName;
                }
                byte[] buffer = new byte[cache_size];
                int readLength;
                while ((readLength = in.read(buffer)) > 0) {
                    byte[] bytes = new byte[readLength];
                    System.arraycopy(buffer, 0, bytes, 0, readLength);
                    bao.write(bytes);
                }
                bao.flush();
                fileName = getFileName(response);
            }
            return fileName;
        } catch (IOException e) {
            throw e;
        } finally {
            request.releaseConnection();
            CloseUtil.close(client);
        }
    }


    public static HttpResponse httpPostHttpResponse(String url, JSONObject jsonParam) throws IOException {
        String uuid = UUID.randomUUID().toString();
        logger.info("http post request  uuid={},url={},param={}", uuid, url, jsonParam);
        //post请求返回结果
        CloseableHttpClient client = HttpClientBuilder.create().build();
        HttpPost request = new HttpPost(url);
        try {
            checkJsonParam(jsonParam, request);
            HttpResponse response = client.execute(request);
            return response;
        } catch (IOException e) {
            throw e;
        } finally {
            request.releaseConnection();
            CloseUtil.close(client);
        }
    }

    private static void checkJsonParam(JSONObject jsonParam, HttpPost method) {
        if (null != jsonParam) {
            //解决中文乱码问题
            StringEntity entity = new StringEntity(jsonParam.toString(), "utf-8");
            entity.setContentEncoding("UTF-8");
            entity.setContentType("application/json");
            method.setEntity(entity);
        }
    }

    /**
     * post请求
     *
     * @param url
     * @param jsonParam
     * @param timeout
     * @return
     * @throws IOException
     */
    public static JSONObject httpPost(String url, JSONObject jsonParam, Integer timeout) throws IOException {
        String uuid = UUID.randomUUID().toString();
        logger.info("http post request  uuid={},url={},param={}", uuid, url, jsonParam);
        //post请求返回结果
        CloseableHttpClient httpClient = HttpClientBuilder.create().build();
        JSONObject jsonResult = null;
        HttpPost request = new HttpPost(url);
        try {
            if (timeout != null && timeout > 0) {
                RequestConfig requestConfig = RequestConfig.custom()
                        .setConnectionRequestTimeout(timeout)
                        .setConnectTimeout(timeout)
                        .setSocketTimeout(timeout).build();
                request.setConfig(requestConfig);
            }
            checkJsonParam(jsonParam, request);
            HttpResponse result = httpClient.execute(request);
            /**请求发送成功，并得到响应**/
            if (result.getStatusLine().getStatusCode() == 200) {
                /**读取服务器返回过来的json字符串数据**/
                String str = EntityUtils.toString(result.getEntity());
                /**把json字符串转换成json对象**/
                jsonResult = JSONObject.parseObject(str);
            }
        } catch (IOException e) {
            throw e;
        } finally {
            request.releaseConnection();
            CloseUtil.close(httpClient);
        }
        logger.info("http post response uuid={},response={}", uuid, jsonResult);
        return jsonResult;
    }

    /**
     * post请求
     *
     * @param url
     * @param jsonParam
     * @return
     * @throws IOException
     */
    public static JSONObject httpPost(String url, JSONObject jsonParam) throws IOException {
        return httpPost(url, jsonParam, null);
    }

    /**
     * 上传文件
     *
     * @param url
     * @param file
     * @return
     * @throws IOException
     */
    public static JSONObject httpPost(String url, File file) throws IOException {
        String uuid = UUID.randomUUID().toString();
        logger.info("http post request  uuid={},url={},file={}", uuid, url, file);
        //post请求返回结果
        CloseableHttpClient httpClient = HttpClientBuilder.create().build();
        JSONObject jsonResult = null;
        HttpPost request = new HttpPost(url);
        try {
            if (null != file) {
                FileBody binFileBody = new FileBody(file);
                MultipartEntityBuilder multipartEntityBuilder = MultipartEntityBuilder.create();
                multipartEntityBuilder.addPart(file.getName(), binFileBody);
                // 设置上传的其他参数
//                setUploadParams(multipartEntityBuilder, params);
                HttpEntity reqEntity = multipartEntityBuilder.build();
                request.setEntity(reqEntity);
            }
            HttpResponse result = httpClient.execute(request);
            /**请求发送成功，并得到响应**/
            if (result.getStatusLine().getStatusCode() == 200) {
                /**读取服务器返回过来的json字符串数据**/
                String str = EntityUtils.toString(result.getEntity());
                /**把json字符串转换成json对象**/
                jsonResult = JSONObject.parseObject(str);
            }
        } catch (IOException e) {
            httpClient.close();
            throw e;
        } finally {
            request.releaseConnection();
            CloseUtil.close(httpClient);
        }
        logger.info("http post response uuid={},response={}", uuid, jsonResult);
        return jsonResult;
    }

    /**
     * 发送get请求
     *
     * @param url 路径
     * @return
     */
    public static JSONObject httpGet(String url) throws IOException {
        String uuid = UUID.randomUUID().toString();
        logger.info("http get request  uuid={},url={}", uuid, url);
        //get请求返回结果
        JSONObject jsonResult = null;
        CloseableHttpClient client = HttpClientBuilder.create().build();
        HttpGet request = new HttpGet(url);
        try {
            HttpResponse response = client.execute(request);
            /**请求发送成功，并得到响应**/
            if (response.getStatusLine().getStatusCode() == HttpStatus.SC_OK) {
                logger.debug("response : " + response);
                /**读取服务器返回过来的json字符串数据**/
                String strResult = EntityUtils.toString(response.getEntity());
                /**把json字符串转换成json对象**/
                jsonResult = JSONObject.parseObject(strResult);
            }
        } catch (IOException e) {
            throw e;
        } finally {
            request.releaseConnection();
            CloseUtil.close(client);
        }
        logger.info("http get response uuid={},response={}", uuid, jsonResult);
        return jsonResult;
    }

    private static String getFileName(HttpResponse response) {
        Header contentHeader = response.getFirstHeader("Content-Disposition");
        String filename = null;
        if (contentHeader != null) {
            HeaderElement[] values = contentHeader.getElements();
            if (values.length == 1) {
                NameValuePair param = values[0].getParameterByName("filename");
                if (param != null) {
                    try {
                        filename = new String(param.getValue().toString().getBytes(), "utf-8");
                        filename = URLDecoder.decode(param.getValue(), "utf-8");
                        filename = param.getValue();
                    } catch (Exception e) {
                        e.printStackTrace();
                    }
                }
            }
        }
        return filename;
    }

}
innerpeaceScorpio
关注
专栏目录
httpclient4.3 封装工具类
09-16
httpclient4.3的二次封装，解决了代理问题、多线程问题、SSL问题、通用的get、post请求
angular项目的http请求代码如何封装合理
weixin_35755188的博客
01-04 347
在 Angular 中，你可以使用 HTTPClient 服务来封装 HTTP 请求代码。 首先，你需要在你的项目中安装 @angular/common/http 库，并在你的模块中导入 HttpClientModule。 然后，你可以在你的服务中注入 HttpClient，并使用它来发起 HTTP 请求。 例如，你可以使用 get() 方法来发起一个 GET 请求： import { HttpC...
Java封装httpClient
最新发布
promise524的博客
08-18 376
java封装httpClient（支持post、get、put、delete请求）
spring boot封装HttpClient
热门推荐
牛奋lch
03-29 3万+
最近使用到了HttpClient，看了一下官方文档：HttpClient implementations are expected to be thread safe. It is recommended that the same instance of this class is reused for multiple request executions，翻译过来的意思就是：HttpClie
angular7中httpClient封装get/post请求
yw00yw的博客
01-28 1089
login.component.ts import { HttpService } from 'src/app/services/http.service'; constructor(private http: HttpService) {} // ajax数据测试 get doGet() { const obj = { _userName: '...
HttpClient的使用与封装
憨憨小江的博客
01-25 623
封装httpclient
对于C#（HttpClient）方式网络请求的封装
06-28
标题中的“对于C#（HttpClient）方式网络请求的封装”是指使用C#编程语言，特别是通过HttpClient类来处理HTTP网络请求，并将这个过程进行抽象和封装，以便在多个地方重复使用。HttpClient是.NET Framework和.NET ...
httpclient4.3 封装工具类.zip
08-26
这个压缩包“httpclient4.3 封装工具类.zip”很可能包含了一些预先封装好的工具类，用于简化使用HttpClient进行网络请求的过程。以下是一些关于HttpClient 4.3以及如何封装工具类的关键知识点： 1. **HttpClient ...
HttpHelper:对HttpClient进行封装，简化getpost操作
06-30
#HttpHelper ####对HttpClient进行封装，简化get/post操作，使用...还有一个提取Cookie的方法，我对Cookie这边了解不是太多，可能一些网站上的Cookie会提取错（目前我还没碰到），这一点就要靠大家指教了，我会慢慢完
httpclient封装
04-25
封装了httpclient的get请求和post请求，包括传参数和和不传参数，以及请求头信息的设定。
HttpClient 框架的简单封装
gacmy的专栏
03-08 1609
package com.example.utilsdemo.utils;import java.util.ArrayList; import java.util.List;import org.apache.http.HttpResponse; import org.apache.http.HttpVersion; import org.apache.http.NameValuePair;
spring boot封装HttpClient的示例代码
08-28
主要介绍了spring boot封装HttpClient的示例代码，小编觉得挺不错的，现在分享给大家，也给大家做个参考。一起跟随小编过来看看吧
基于angular2 的 http服务封装的实例代码
08-30
主要介绍了基于angular2 的 http服务封装实例代码，
HttpClient4.5全部jar包＋简单实例
10-15
自身项目内的HttpClient4.5全部jar包＋简单实用实例。
Angular5 HttpService
01-10
Angular Http封装，对Http请求处理：https://plnkr.co/edit/2Wjw8RIOUylzomHlVB0p?p=info
httpclient get/post请求工具类（map参数封装）
06-17
httpclient get/post请求工具类（map参数封装）,方便调用
angular的httpClient
weixin_49343253的博客
07-04 575
angular使用httpClient模块发送网络请求，首先在app.module.ts中引入HttpClientModule、HttpClientJsonpModule相关模块，然后在下方imports中添加相关模块 1、http请求---get和post 在需要发送网络请求的组件中引入，注意post请求需要引入httpheaders;下方construuctor中定义变量 发送get/post请求 2、jsonp请求 3、axios请求 在service里封装一个发送ax
httpclient 包_Java工具分享——httpclient封装
weixin_28702105的博客
01-15 559
一。背景说明 在进行了java开发如此之久后，开始思考，自己写的代码质量到底如何，相信大部分朋友也有相同的想法，同时也对大批量的重复代码有相当的抵触，所以开始希望总结自己对于java开发中常用工具，api的封装，希望能在未来的工作生活中，简化自己的代码，提高工作效率。二。本节由来 现有工作中，主要任务为爬虫，不可避免的接触到了这个包，在熟悉的前提下，开始有了在此基础上进行封装简化的想法，故做出本代...
对HttpClient方法的封装
chpch的专栏
02-16 866
对HttpClient类使用的封装，方便使用，我觉得注释写的很清楚了，看着注释直接用
PHP HttpClient类封装与使用示例
以下是对文中HttpClient类的详细解析： 首先，我们看到`SinCookie`类，它用于表示Cookie对象。这个类包含Cookie的基本属性：`name`(名称)和`value`(值)，以及未在实例中实现的`expires`(过期时间)、`path`(路径)和`...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值