HttpClient 发送 get、post 请求

已于 2023-06-29 14:42:11 修改
阅读量1.6w 收藏 102
点赞数 14
分类专栏： 日积月累 文章标签： http https
于 2022-04-24 14:49:34 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/LMGD_/article/details/124379183
版权

HttpClient 介绍

HttpClient 是Apache Jakarta Common 下的子项目，可以用来提供高效的、最新的、功能丰富的支持 HTTP 协议的客户端编程工具包，并且它支持 HTTP 协议最新的版本和建议。

HttpClient是客户端的http通信实现库，这个类库的作用是接收和发送http报文

 添加Maven依赖

       <!--****** httpclient start ******-->
       <dependency>
            <groupId>org.apache.httpcomponents</groupId>
            <artifactId>httpcore</artifactId>
            <version>4.4.10</version>
        </dependency>
        <dependency>
            <groupId>org.apache.httpcomponents</groupId>
            <artifactId>httpclient</artifactId>
            <version>4.5.6</version>
        </dependency>
        <!--****** httpclient end******-->

        <!--LMGD-注：这个依赖可选-->
	    <dependency>
			<groupId>org.apache.httpcomponents</groupId>
			<artifactId>httpasyncclient</artifactId>
			<version>4.0.1</version>
		 </dependency>
      <!-- fastjson json-->
		<dependency>
			<groupId>com.alibaba</groupId>
			<artifactId>fastjson</artifactId>
			<version>1.1.40</version>
		</dependency>

 HttpClient 发送 get、post 请求

注意：HttpClient 发送 post 请求时有三种格式报文的请求，分别是application/x-www-form-urlencoded、application/json、text/xml 格式报文的请求；本文例子写的是处理 application/json 格式报文的请求。

HttpclientUtils 工具类编写

package com.wondersgroup.hs.jw.jwxt.utils;


import org.apache.http.Header;
import org.apache.http.HttpEntity;
import org.apache.http.HttpResponse;
import org.apache.http.client.HttpClient;
import org.apache.http.client.config.RequestConfig;
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.HttpClients;
import org.apache.http.message.BasicHeader;
import org.apache.http.util.EntityUtils;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;

/**
 * @author 邓林妹
 * @date 2022/4/21
 */
public class HttpclientUtils {

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

    /**
     * get 方式调用
     *
     * @param url
     * @return
     */
    public static String get(String url) {
        logger.info("=====================HTTP GET 请求参数 url=" + url);
        InputStream is = null;
        String body = null;
        StringBuilder res = new StringBuilder();
        // 实例化CloseableHttpClient
        CloseableHttpClient client = HttpClients.createDefault();
        CloseableHttpResponse response = null;
        try {
            // 添加URL和请求参数
           //替换空格;get请求，url拼接参数时，参数值可能存在空格，需要对空格做处理，不然接口会调不通
            url = url.replaceAll(" ", "%20");
            URIBuilder ub = new URIBuilder(url);
            // 使用get方法添加URL
            HttpGet get = new HttpGet(ub.build());
            // 设置请求超时时间
            RequestConfig config = RequestConfig.custom().setConnectTimeout(5000).build();
            get.setConfig(config);
            //使用http调用远程，获取相应信息
            response = client.execute(get);
            // 获取响应状态码，可根据是否响应正常来判断是否需要进行下一步
            int statusCode = response.getStatusLine().getStatusCode();
            if (statusCode != 200) {
                return "请求失败 statusCode=" + statusCode;
            }
            // 获取响应实体
            HttpEntity entity = response.getEntity();
            // 读取响应内容
            if (entity != null) {
                is = entity.getContent();
                BufferedReader br = new BufferedReader(new InputStreamReader(is, "UTF-8"));
                while ((body = br.readLine()) != null) {
                    res.append(body);
                }
            }
        } catch (Exception e) {
            logger.info(e.getMessage());
        }
        logger.info("=====================HTTP GET 请求响应参数 result=" + res.toString());
        return res.toString();
    }

    /**
     * 通过post方式调用http接口
     *
     * @param url       url路径
     * @param jsonParam json格式的参数
     * @return
     * @throws Exception
     */
    public static String post(String url, String jsonParam) {
        logger.info("=====================HTTP POST 请求参数 【url=" + url + ",jsonParam=" + jsonParam + "】");
        //声明返回结果
        String result = "";
        //开始请求API接口时间
        long startTime = System.currentTimeMillis();
        HttpEntity httpEntity = null;
        HttpResponse httpResponse = null;
        HttpClient httpClient = null;
        try {
            // 创建连接
            httpClient = HttpClientFactory.getInstance().getHttpClient();
            // 设置请求头和报文
            HttpPost httpPost = HttpClientFactory.getInstance().httpPost(url);
            Header header = new BasicHeader("Accept-Encoding", null);
            httpPost.setHeader(header);
            // 设置报文和通讯格式
            StringEntity stringEntity = new StringEntity(jsonParam, HttpConstant.UTF8_ENCODE);
            stringEntity.setContentEncoding(HttpConstant.UTF8_ENCODE);
            stringEntity.setContentType(HttpConstant.APPLICATION_JSON);
            httpPost.setEntity(stringEntity);
            //log.info("请求{}接口的参数为{}", url, jsonParam);
            //执行发送，获取相应结果
            httpResponse = httpClient.execute(httpPost);
            httpEntity = httpResponse.getEntity();
            result = EntityUtils.toString(httpEntity);
            long endTime = System.currentTimeMillis();

            logger.info("HTTP POST 请求响应时间 httpResponse time=" + new java.util.Date(startTime - endTime));
        } catch (Exception e) {
            logger.info("http post 请求异常");
            e.printStackTrace();
        } finally {
            try {
                EntityUtils.consume(httpEntity);
            } catch (IOException e) {
                throw new RuntimeException("http请求释放资源异常");
            }
        }
        logger.info("=====================HTTP POST 请求响应参数 result=" + result);
        return result;
    }
}

HttpclientUtils 工具类 post 请求,用到的其他相关类编写：（如果只是使用get方式调用的话，不需要这些类,这两个都是 post 请求会用的类）

package com.wondersgroup.hs.jw.jwxt.utils;

import org.apache.http.client.HttpClient;
import org.apache.http.client.config.RequestConfig;
import org.apache.http.client.methods.HttpPost;
import org.apache.http.config.Registry;
import org.apache.http.config.RegistryBuilder;
import org.apache.http.conn.socket.ConnectionSocketFactory;
import org.apache.http.conn.socket.LayeredConnectionSocketFactory;
import org.apache.http.conn.socket.PlainConnectionSocketFactory;
import org.apache.http.conn.ssl.SSLConnectionSocketFactory;
import org.apache.http.impl.client.HttpClients;
import org.apache.http.impl.conn.PoolingHttpClientConnectionManager;

import javax.net.ssl.SSLContext;
import java.security.NoSuchAlgorithmException;

/**
 * @author 邓林妹
 * @date 2022/4/22
 */
public class HttpClientFactory {

    private static HttpClientFactory instance = null;

    private HttpClientFactory() {
    }

    public synchronized static HttpClientFactory getInstance() {
        if (instance == null) {
            instance = new HttpClientFactory();
        }
        return instance;
    }


    public synchronized HttpClient getHttpClient() {
        HttpClient httpClient = null;
        if (HttpConstant.IS_KEEP_ALIVE) {
            //获取长连接
            httpClient = new KeepAliveHttpClientBuilder().getKeepAliveHttpClient();
        } else {
            // 获取短连接
            httpClient = new HttpClientBuilder().getHttpClient();
        }
        return httpClient;
    }

    public HttpPost httpPost(String httpUrl) {
        HttpPost httpPost = null;
        httpPost = new HttpPost(httpUrl);
        if (HttpConstant.IS_KEEP_ALIVE) {
            // 设置为长连接，服务端判断有此参数就不关闭连接。
            httpPost.setHeader("Connection", "Keep-Alive");
        }
        return httpPost;
    }


    private static class KeepAliveHttpClientBuilder {

        private static HttpClient httpClient;

        /**
         * 获取http长连接
         */
        private synchronized HttpClient getKeepAliveHttpClient() {
            if (httpClient == null) {
                LayeredConnectionSocketFactory sslsf = null;
                try {
                    sslsf = new SSLConnectionSocketFactory(SSLContext.getDefault());
                } catch (NoSuchAlgorithmException e) {
                    e.printStackTrace();
                }

                Registry<ConnectionSocketFactory> socketFactoryRegistry = RegistryBuilder
                        .<ConnectionSocketFactory>create().register("https", sslsf)
                        .register("http", new PlainConnectionSocketFactory()).build();
                PoolingHttpClientConnectionManager cm = new PoolingHttpClientConnectionManager(socketFactoryRegistry);
                cm.setMaxTotal(HttpConstant.MAX_TOTAL);
                cm.setDefaultMaxPerRoute(HttpConstant.MAX_CONN_PER_ROUTE);

                RequestConfig requestConfig = RequestConfig.custom()
                        .setConnectTimeout(HttpConstant.CONNECT_TIMEOUT)
                        .setSocketTimeout(HttpConstant.SOCKET_TIMEOUT).build();
                // 创建连接
                httpClient = HttpClients.custom().setDefaultRequestConfig(requestConfig).setConnectionManager(cm).build();
            }

            return httpClient;
        }
    }


    private static class HttpClientBuilder {
        private HttpClient httpClient;

        /**
         * 获取http短连接
         */
        private synchronized HttpClient getHttpClient() {
            if (httpClient == null) {
                RequestConfig requestConfig = RequestConfig.custom()
                        // 设置请求超时时间
                        .setConnectTimeout(HttpConstant.CONNECT_TIMEOUT)
                        // 设置响应超时时间
                        .setSocketTimeout(HttpConstant.SOCKET_TIMEOUT).build();
                // 创建连接
                httpClient = HttpClients.custom().setDefaultRequestConfig(requestConfig).build();
            }
            return httpClient;
        }
    }
}

package com.wondersgroup.hs.jw.jwxt.utils;

/**
 * HttpClient请求常量类
 *
 * @author 邓林妹
 * @date 2022/4/22
 */
public class HttpConstant {

    /**
     * httpClient连接超时时间,单位毫秒
     */
    public static final int CONNECT_TIMEOUT = 3 * 1000;

    /**
     * httpClient请求获取数据的超时时间(即响应时间) 单位毫秒
     */
    public static final int SOCKET_TIMEOUT = 10 * 1000;

    /**
     * http连接池大小
     */
    public static final int MAX_TOTAL = 10;

    /**
     * 分配给同一个route(路由)最大的并发连接数
     */
    public static final int MAX_CONN_PER_ROUTE = 2;

    /**
     * http连接是否是长连接
     */
    public static final boolean IS_KEEP_ALIVE = true;

    /**
     * 调用接口失败默认重新调用次数
     */
    public static final int REQ_TIMES = 3;

    /**
     * utf-8编码
     */
    public static final String UTF8_ENCODE = "UTF-8";

    /**
     * application/json
     */
    public static final String APPLICATION_JSON = "application/json";

    /**
     * text/xml
     */
    public static final String TEXT_XML = "text/xml";

}

 Controller 层编写

/**
 * @author 邓林妹
 * @date 2022/4/24
 */
@RestController
@RequestMapping("/test")
public class HttpClientTest {

    @RequestMapping("/get")
    @ResponseBody
    public BaseResponse getRequest(@RequestBody RequestParamDto dto) {
        try {
            String message = HttpclientUtils.get(dto.getUrl());
            return BaseResponse.returnSuccess(message);
        } catch (Exception e) {
            return BaseResponse.returnFault(e.getMessage());
        }
    }

    @RequestMapping("/post")
    @ResponseBody
    public BaseResponse postRequest(@RequestBody RequestParamDto dto) {
        try {
            String message = HttpclientUtils.post(dto.getUrl(), JSON.toJSONString(dto.getPerson()));
            return BaseResponse.returnSuccess(message);
        } catch (Exception e) {
            return BaseResponse.returnFault(e.getMessage());
        }
    }
}

相关实体类编写： 

/**
 * @author 邓林妹
 * @date 2022/4/24
 */
public class RequestParamDto {

    private String url;
    private Person person;

    public String getUrl() {
        return url;
    }

    public void setUrl(String url) {
        this.url = url;
    }

    public Person getPerson() {
        return person;
    }

    public void setPerson(Person person) {
        this.person = person;
    }
}
/**
 * @author 邓林妹
 * @date 2022/4/24
 */
public class Person {

    private String idCardNo;
    private String examCode;

    public String getIdCardNo() {
        return idCardNo;
    }

    public void setIdCardNo(String idCardNo) {
        this.idCardNo = idCardNo;
    }

    public String getExamCode() {
        return examCode;
    }

    public void setExamCode(String examCode) {
        this.examCode = examCode;
    }
}

测试- HttpClient 发送get、post请求

调用Controller层的接口地址（可以是get/post请求），传入 url （get、post 请求的url），通过 url  ，HttpClient 向服务器端发送 get、post请求。

高德地图-IP定位-get 请求接口地址：

https://restapi.amap.com/v3/ip?ip=114.247.50.2&output=xml&key=<用户的key>

HttpClient发送post请求
x_15710079125的博客
07-24 705
首先创建一个HttpClientPost类 package com.xzz.HttpClient; import com.google.gson.Gson; import com.xzz.FileText.Student; import lombok.extern.slf4j.Slf4j; import org.apache.commons.collections.CollectionUtils; import org.apache.http.HttpStatus; import org.apache
HttpClient 发送 GET 和 POST 请求深度解析
xycxycooo的博客
08-06 5073
Apache HttpClient 是一个开源的 HTTP 客户端库，提供了对 HTTP 协议的全面支持。它简化了 HTTP 请求的创建和处理，使得开发者可以方便地与 Web 服务器进行交互。HttpClient 支持 HTTP/1.1 和 HTTP/2 协议，并且提供了丰富的功能，如连接管理、请求重试、认证和代理支持等。
httpclient发送post请求
01-02
其中包含项目post-demo定义接口；包含另一个项目httpclient-demo使用工具类发送post请求调用接口。详细内容查看博客 httpclient发送post请求
Java 的 HttpClient 中使用 POST 请求传递参数
最新发布
qq_63553317的博客
02-23 1310
由于你提到的是 RPC POST 请求，我假设你想知道如何在 POST 请求中传递参数，尤其是结合 RPC 的场景。下面我将分别讲解这两种方式，并提供示例代码。
HttpClient 发送get和post请求
12-20
一个简单的易学的 基于HttpClient 4.3发送psot及get请求，返回数据，适合初学者,适合初学者
httpclient 发送post请求
qq_29086535的博客
11-13 4735
HttpClient相比于jdk自带的URLConnection更加灵活，用起来也比较方便，它使客户端发送http请求更加方便，提高了开发效率。 使用HttpClient发送请求接受返回参数，其步骤大致如下 1、创建HttpClient对象       // 创建默认的httpClient实例       CloseableHttpClient httpclient = Http
httpclient发送get请求和post请求demo
02-26
同时，通过阅读如"HttpClient发送get请求和post请求"这样的博客，你可以获取更多关于HttpClient实战中的技巧和最佳实践。在提供的压缩包文件中，`test-demo`和`httpclient-demo`可能包含了这些示例的源码，供你...
HttpClient模拟get，post请求并发送请求参数（json等）
08-07
// 执行POST请求 // 返回响应对象 } } ``` 通过以上介绍，我们可以看出HttpClient是一个强大的工具，可以帮助开发者轻松地进行HTTP请求。无论是在测试API接口，还是在集成外部服务，HttpClient都是一个值得信赖...
Java HttpClient 实战 GET 与 POST 请求一网打尽
安迪的专栏
09-10 659
通过本文，我们深入了解了如何使用Java的HttpClient库执行GET和POST请求。这只是HttpClient功能的冰山一角，你可以根据实际需求使用更多功能，例如处理响应状态、处理重定向、设置超时等。希望这篇博文能帮助你更好地利用Java进行HTTP通信。如果有任何问题或建议，请随时留言。
使用HttpClient发送Post Http请求
nodeblog的专栏
07-29 914
最近需要使用java对Rest接口进行调用，也就是直接使用java直接发送Post, Get, Put, Delete等请求。 印象中可以使用Apache Common下的HttpClient来做，结果HttpClient已经独立成了HttpComponent，编码方式也有所改变。 Google出来的很多文章多数是common-httpclient的方式，在新版本中不怎么适用。经过一番研究自己...
HttpClient发送Post请求
热门推荐
weixin_42408447的博客
09-17 1万+
一.HttpClientUtil类，提供三个方法，分别是sendPostByForm，sendPostByJson，sendPostByXml （1）sendPostByForm 处理 application/x-www-form-urlencoded格式报文的请求 （2）sendPostByJson 处理 application/json 格式报文的请求 （3）sendPostByXml 处理 text/xml 格式报文的请求 1. package com.harara.fund.util.http;
HttpClient 发送get和post请求的使用方法
m0_63216787的博客
07-23 2203
HttpClient 是Apache Jakarta Common 下的子项目，可以用来提供高效的，最新的，功能丰富的支持HTTP协议的客户端变成工具包，并且他支持HTTP协议最新的版本和建议。核心API:HttpClientHttpGetHttpPost。
使用httpclient发送get请求
风吹草动
07-27 2669
HttpClient 发送get请求
使用httpClient发送get\post请求
DN金猿的博客
12-15 244
maven依赖 <dependency> <groupId>org.apache.httpcomponents</groupId> <artifactId>httpclient</artifactId> <version>4.5.2</version> </dependency> GET请求： 1、参数直接拼接到URL后面，即http://test.com?a=1&
Java使用httpclient发送POST请求
宁好的博客
05-11 1870
声明：实习时接到一个送餐机器人项目 涉及到httpclient。
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值