HttpClient实现HTTP请求

其他 2020-06-27 10:08:16 阅读次数: 0

1：开发环境

JDK1.8、Springboot

2：项目依赖

"org.apache.httpcomponents:httpclient:4.5.10"

3：代码详细

package com.nobody.utils;

import java.net.URI;
import java.net.URLEncoder;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.Set;

import org.apache.http.HttpEntity;
import org.apache.http.NameValuePair;
import org.apache.http.client.config.RequestConfig;
import org.apache.http.client.entity.UrlEncodedFormEntity;
import org.apache.http.client.methods.CloseableHttpResponse;
import org.apache.http.client.methods.HttpGet;
import org.apache.http.client.methods.HttpPost;
import org.apache.http.client.utils.URIBuilder;
import org.apache.http.entity.StringEntity;
import org.apache.http.impl.client.CloseableHttpClient;
import org.apache.http.impl.client.HttpClientBuilder;
import org.apache.http.message.BasicNameValuePair;
import org.apache.http.util.EntityUtils;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.util.CollectionUtils;
import org.springframework.util.StringUtils;

public class HttpClientUtil {

    private static final Logger LOGGER = LoggerFactory.getLogger(HttpClientUtil.class);

    private static final String STANDARD_CHARSET = "UTF-8";

    /**
     * GET 若有参则直接拼接URL
     * 
     * @param headers 请求头参数
     * @param params 请求参数
     * @param url 请求地址
     * @param timeOutInMillis 超时时间(毫秒)
     * @return
     */
    public static String doGet(Map<String, Object> headers, Map<String, Object> params, String url,
            int timeOutInMillis) {

        // 返回结果
        String result = null;

        // 创建Http客户端
        CloseableHttpClient httpClient = HttpClientBuilder.create().build();
        // 创建Get请求
        HttpGet httpGet = null;

        try {
            // 请求参数处理(拼接前先将请求参数值encoding,处理一些特殊字符)
            if (!CollectionUtils.isEmpty(params)) {
                StringBuffer sb = new StringBuffer();
                for (String key : params.keySet()) {
                    sb.append(key).append("=")
                            .append(URLEncoder.encode(params.get(key).toString(), STANDARD_CHARSET))
                            .append("&");
                }
                String handledParams = sb.substring(0, sb.length() - 1).toString();
                httpGet = new HttpGet(url + "?" + handledParams);
            } else {
                httpGet = new HttpGet(url);
            }

            // 请求头处理
            if (!CollectionUtils.isEmpty(headers)) {
                Set<String> set = headers.keySet();
                Iterator<String> it = set.iterator();
                while (it.hasNext()) {
                    String key = it.next();
                    if (null != headers.get(key)) {
                        httpGet.addHeader(key, headers.get(key).toString());
                    }
                }
            }

            // 设置数据读取超时时间,传输超时时间,链接请求超时时间
            if (timeOutInMillis > 0) {
                RequestConfig requestConfig = RequestConfig.custom()
                        .setSocketTimeout(timeOutInMillis).setConnectTimeout(timeOutInMillis)
                        .setConnectionRequestTimeout(timeOutInMillis).build();
                httpGet.setConfig(requestConfig);
            }

            // 客户端发送请求并获得响应模型
            CloseableHttpResponse response = httpClient.execute(httpGet);
            // 从响应模型中获取响应实体
            HttpEntity responseEntity = response.getEntity();
            if (null != responseEntity) {
                result = EntityUtils.toString(responseEntity, STANDARD_CHARSET);
            }
        } catch (

        Exception ex) {
            LOGGER.error("doGet error:", ex);
        } finally {
            // 释放资源
            httpGet.abort();
            if (null != httpClient) {
                try {
                    httpClient.close();
                } catch (Exception ex) {
                    LOGGER.error("doGet httpClient close error:", ex);
                }
            }
        }

        return result;
    }

    /**
     * GET 若有参形式(使用URI获得HttpGet)
     * 
     * @param headers 请求头参数
     * @param params 请求参数
     * @param scheme 请求协议
     * @param host 请求IP
     * @param port 请求端口
     * @param path 请求路径
     * @param timeOutInMillis 超时时间(毫秒)
     * @return
     */
    public static String doGet(Map<String, Object> headers, Map<String, Object> params,
            final String scheme, final String host, final int port, final String path,
            int timeOutInMillis) {

        // 返回结果
        String result = null;

        // 创建Http客户端
        CloseableHttpClient httpClient = HttpClientBuilder.create().build();
        // 创建Get请求
        HttpGet httpGet = null;

        try {
            URI uri = null;
            URIBuilder ub =
                    new URIBuilder().setScheme(scheme).setHost(host).setPort(port).setPath(path);
            // 请求参数处理
            if (!CollectionUtils.isEmpty(params)) {
                List<NameValuePair> nvps = new ArrayList<>();
                for (String key : params.keySet()) {
                    nvps.add(new BasicNameValuePair(key, params.get(key).toString()));
                }
                ub.setParameters(nvps);
            }
            uri = ub.build();

            httpGet = new HttpGet(uri);

            if (!CollectionUtils.isEmpty(headers)) {
                Set<String> set = headers.keySet();
                Iterator<String> it = set.iterator();
                while (it.hasNext()) {
                    String key = it.next();
                    if (null != headers.get(key)) {
                        httpGet.addHeader(key, headers.get(key).toString());
                    }
                }
            }

            // 设置数据读取超时时间,传输超时时间,链接请求超时时间
            if (timeOutInMillis > 0) {
                RequestConfig requestConfig = RequestConfig.custom()
                        .setSocketTimeout(timeOutInMillis).setConnectTimeout(timeOutInMillis)
                        .setConnectionRequestTimeout(timeOutInMillis).build();
                httpGet.setConfig(requestConfig);
            }

            // 客户端发送请求并获得响应模型
            CloseableHttpResponse response = httpClient.execute(httpGet);
            // 从响应模型中获取响应实体
            HttpEntity responseEntity = response.getEntity();
            if (null != responseEntity) {
                result = EntityUtils.toString(responseEntity, STANDARD_CHARSET);
            }
        } catch (Exception ex) {
            LOGGER.error("doGet error:", ex);
        } finally {
            // 释放资源
            httpGet.abort();
            if (null != httpClient) {
                try {
                    httpClient.close();
                } catch (Exception ex) {
                    LOGGER.error("doGet httpClient close error:", ex);
                }
            }
        }

        return result;
    }

    /**
     * POST application/x-www-form-urlencoded形式
     * 
     * @param headers 请求头参数
     * @param params 请求参数
     * @param url 请求地址
     * @param timeOutInMillis 超时时间(毫秒)
     * @return
     */
    public static String doPost(String url, Map<String, Object> headers, Map<String, Object> params,
            int timeOutInMillis) {

        // 返回结果
        String result = null;

        // 创建Http客户端
        CloseableHttpClient httpClient = HttpClientBuilder.create().build();
        // 创建Get请求
        HttpPost httpPost = null;

        try {
            // 请求参数处理(拼接前先将请求参数值encoding,处理一些特殊字符)
            if (!CollectionUtils.isEmpty(params)) {
                StringBuffer sb = new StringBuffer();
                for (String key : params.keySet()) {
                    sb.append(key).append("=")
                            .append(URLEncoder.encode(params.get(key).toString(), STANDARD_CHARSET))
                            .append("&");
                }
                String handledParams = sb.substring(0, sb.length() - 1).toString();
                httpPost = new HttpPost(url + "?" + handledParams);
            } else {
                httpPost = new HttpPost(url);
            }

            // 请求头处理
            if (!CollectionUtils.isEmpty(headers)) {
                Set<String> set = headers.keySet();
                Iterator<String> it = set.iterator();
                while (it.hasNext()) {
                    String key = it.next();
                    if (null != headers.get(key)) {
                        httpPost.addHeader(key, headers.get(key).toString());
                    }
                }
            }

            // 设置数据读取超时时间,传输超时时间,链接请求超时时间
            if (timeOutInMillis > 0) {
                RequestConfig requestConfig = RequestConfig.custom()
                        .setSocketTimeout(timeOutInMillis).setConnectTimeout(timeOutInMillis)
                        .setConnectionRequestTimeout(timeOutInMillis).build();
                httpPost.setConfig(requestConfig);
            }

            // 客户端发送请求并获得响应模型
            CloseableHttpResponse response = httpClient.execute(httpPost);
            // 从响应模型中获取响应实体
            HttpEntity responseEntity = response.getEntity();
            if (null != responseEntity) {
                result = EntityUtils.toString(responseEntity, STANDARD_CHARSET);
            }
        } catch (Exception ex) {
            LOGGER.error("doPost error:", ex);
        } finally {
            // 释放资源
            httpPost.abort();
            if (null != httpClient) {
                try {
                    httpClient.close();
                } catch (Exception ex) {
                    LOGGER.error("doPost httpClient close error:", ex);
                }
            }
        }

        return result;
    }

    /**
     * POST application/x-www-form-urlencoded形式(NameValuePair参数形式)
     * 
     * @param headers 请求头参数
     * @param params 请求参数
     * @param url 请求地址
     * @param timeOutInMillis 超时时间(毫秒)
     * @return
     */
    public static String doPostByNvp(String url, Map<String, Object> headers,
            Map<String, Object> params, int timeOutInMillis) {

        // 返回结果
        String result = null;

        // 创建Http客户端
        CloseableHttpClient httpClient = HttpClientBuilder.create().build();
        // 创建Get请求
        HttpPost httpPost = null;

        try {

            httpPost = new HttpPost(url);

            // 请求参数处理
            if (!CollectionUtils.isEmpty(params)) {
                List<NameValuePair> nvps = new ArrayList<>();
                for (String key : params.keySet()) {
                    nvps.add(new BasicNameValuePair(key, params.get(key).toString()));
                }
                httpPost.setEntity(new UrlEncodedFormEntity(nvps, STANDARD_CHARSET));
            }

            // 请求头处理
            if (!CollectionUtils.isEmpty(headers)) {
                Set<String> set = headers.keySet();
                Iterator<String> it = set.iterator();
                while (it.hasNext()) {
                    String key = it.next();
                    if (null != headers.get(key)) {
                        httpPost.addHeader(key, headers.get(key).toString());
                    }
                }
            }

            // 设置数据读取超时时间,传输超时时间,链接请求超时时间
            if (timeOutInMillis > 0) {
                RequestConfig requestConfig = RequestConfig.custom()
                        .setSocketTimeout(timeOutInMillis).setConnectTimeout(timeOutInMillis)
                        .setConnectionRequestTimeout(timeOutInMillis).build();
                httpPost.setConfig(requestConfig);
            }

            // 客户端发送请求并获得响应模型
            CloseableHttpResponse response = httpClient.execute(httpPost);
            // 从响应模型中获取响应实体
            HttpEntity responseEntity = response.getEntity();
            if (null != responseEntity) {
                result = EntityUtils.toString(responseEntity, STANDARD_CHARSET);
            }
        } catch (Exception ex) {
            LOGGER.error("doPost error:", ex);
        } finally {
            // 释放资源
            httpPost.abort();
            if (null != httpClient) {
                try {
                    httpClient.close();
                } catch (Exception ex) {
                    LOGGER.error("doPost httpClient close error:", ex);
                }
            }
        }

        return result;
    }

    /**
     * POST application/json形式
     * 
     * @param headers 请求头参数
     * @param jsonObject 请求对象参数
     * @param url 请求地址
     * @param timeOutInMillis 超时时间(毫秒)
     * @return
     */
    public static String doPost(Map<String, Object> headers, String jsonObject, String url,
            int timeOutInMillis) {

        // 返回结果
        String result = null;

        // 创建Http客户端
        CloseableHttpClient httpClient = HttpClientBuilder.create().build();
        // 创建Get请求
        HttpPost httpPost = null;

        try {

            httpPost = new HttpPost(url);

            // 请求参数处理
            if (!StringUtils.isEmpty(jsonObject)) {
                StringEntity entity = new StringEntity(jsonObject, STANDARD_CHARSET);
                httpPost.setEntity(entity);
                // httpPost.addHeader("Content-Type", ContentType.APPLICATION_JSON.getMimeType());
            }

            // 请求头处理
            if (!CollectionUtils.isEmpty(headers)) {
                Set<String> set = headers.keySet();
                Iterator<String> it = set.iterator();
                while (it.hasNext()) {
                    String key = it.next();
                    if (null != headers.get(key)) {
                        httpPost.addHeader(key, headers.get(key).toString());
                    }
                }
            }

            // 设置数据读取超时时间,传输超时时间,链接请求超时时间
            if (timeOutInMillis > 0) {
                RequestConfig requestConfig = RequestConfig.custom()
                        .setSocketTimeout(timeOutInMillis).setConnectTimeout(timeOutInMillis)
                        .setConnectionRequestTimeout(timeOutInMillis).build();
                httpPost.setConfig(requestConfig);
            }

            // 客户端发送请求并获得响应模型
            CloseableHttpResponse response = httpClient.execute(httpPost);
            // 从响应模型中获取响应实体
            HttpEntity responseEntity = response.getEntity();
            if (null != responseEntity) {
                result = EntityUtils.toString(responseEntity, STANDARD_CHARSET);
            }
        } catch (Exception ex) {
            LOGGER.error("doPost error:", ex);
        } finally {
            // 释放资源
            httpPost.abort();
            if (null != httpClient) {
                try {
                    httpClient.close();
                } catch (Exception ex) {
                    LOGGER.error("doPost httpClient close error:", ex);
                }
            }
        }

        return result;
    }

}

猜你喜欢

转载自blog.csdn.net/chenlixiao007/article/details/103975057
今日推荐
火速冲上 GitHub 热榜 —— 开源编程语言、框架哪有这么可爱？
北京人形机器人创新中心发布全球首个纯电驱拟人奔跑的全尺寸人形机器人“天工”
LFOSSA 源来如此公开课 | 掌握云原生未来：CNCF 认证全面攻略与备考秘籍
国产云输入法——仅华为无云端数据上传安全问题
开源日报 | 工业开源项目OGG 1.0；姐姐，你要和我一起配置火狐吗；苹果AI遥遥落后？Fedora 40
开放签电子签章：停止新增，优化体验，前进更进（五一假期前工作）
开源日报 | 中学生开源前端动画引擎；全球首个Llama3 8B中文版开源模型；联想电脑恐出局；Linus讽刺AI炒作
周排行
浏览器对同一域名进行请求的最大并发连接数
React Hook之自定义Hook
【转】MyBatis缓存机制
-Java-泛型
自动化测试常用脚本-发送邮件
LeetCode#859: Buddy Strings
java、Python处理字符串
第二篇の博客
Hadoop伪分布式环境安装
SQL Server进阶（十一）临时表、表变量
每日归档
更多
2024-04-27(56)
2024-04-26(39)
2024-04-25(22)
2024-04-24(36)
2024-04-23(26)
2024-04-22(39)
2024-04-21(0)
2024-04-20(6)
2024-04-19(5)
2024-04-18(0)

代码天地 © 2018 codetd.com

境外服务器   最新电视剧2022