SpringBoot整合HttpClient

已于 2022-07-19 17:10:20 修改
阅读量2.2k 收藏 7
点赞数 3
分类专栏： springboot 文章标签： spring boot
于 2021-10-18 14:32:28 首次发布
原文链接：https://blog.csdn.net/wsywb111/article/details/80311716
版权

SpringBoot HttpClient 连接池 配置参数 HTTP请求
关键词由CSDN通过智能技术生成

参考 SpringBoot整合HttpClient

  1. 引入依赖
 <!-- HttpClient  -->
        <dependency>
            <groupId>org.apache.httpcomponents</groupId>
            <artifactId>httpclient</artifactId>
            <version>4.3.1</version>
        </dependency>
  1. 在配置文件中加入httpclient需要的一些配置参数
#最大连接数
http.maxTotal = 100
#并发数
http.defaultMaxPerRoute = 20
#创建连接的最长时间
http.connectTimeout=1000
#从连接池中获取到连接的最长时间
http.connectionRequestTimeout=500
#数据传输的最长时间
http.socketTimeout=10000
#提交请求前测试连接是否可用
http.staleConnectionCheckEnabled=true
  1. 注入连接池等，用于在service层获取httpclient
import org.apache.http.client.config.RequestConfig;
import org.apache.http.impl.client.CloseableHttpClient;
import org.apache.http.impl.client.HttpClientBuilder;
import org.apache.http.impl.conn.PoolingHttpClientConnectionManager;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

@Configuration
public class HttpClient {

    @Value("${http.maxTotal}")
    private Integer maxTotal;

    @Value("${http.defaultMaxPerRoute}")
    private Integer defaultMaxPerRoute;

    @Value("${http.connectTimeout}")
    private Integer connectTimeout;

    @Value("${http.connectionRequestTimeout}")
    private Integer connectionRequestTimeout;

    @Value("${http.socketTimeout}")
    private Integer socketTimeout;

    @Value("${http.staleConnectionCheckEnabled}")
    private boolean staleConnectionCheckEnabled;

    /**
     * 首先实例化一个连接池管理器，设置最大连接数、并发连接数
     * @return
     */
    @Bean(name = "httpClientConnectionManager")
    public PoolingHttpClientConnectionManager getHttpClientConnectionManager(){
        PoolingHttpClientConnectionManager httpClientConnectionManager = new PoolingHttpClientConnectionManager();
        //最大连接数
        httpClientConnectionManager.setMaxTotal(maxTotal);
        //并发数
        httpClientConnectionManager.setDefaultMaxPerRoute(defaultMaxPerRoute);
        return httpClientConnectionManager;
    }

    /**
     * 实例化连接池，设置连接池管理器。
     * 这里需要以参数形式注入上面实例化的连接池管理器
     * @param httpClientConnectionManager
     * @return
     */
    @Bean(name = "httpClientBuilder")
    public HttpClientBuilder getHttpClientBuilder(@Qualifier("httpClientConnectionManager")PoolingHttpClientConnectionManager httpClientConnectionManager){

        //HttpClientBuilder中的构造方法被protected修饰，所以这里不能直接使用new来实例化一个HttpClientBuilder，可以使用HttpClientBuilder提供的静态方法create()来获取HttpClientBuilder对象
        HttpClientBuilder httpClientBuilder = HttpClientBuilder.create();

        httpClientBuilder.setConnectionManager(httpClientConnectionManager);

        return httpClientBuilder;
    }

    /**
     * 注入连接池，用于获取httpClient
     * @param httpClientBuilder
     * @return
     */
    @Bean
    public CloseableHttpClient getCloseableHttpClient(@Qualifier("httpClientBuilder") HttpClientBuilder httpClientBuilder){
        return httpClientBuilder.build();
    }

    /**
     * Builder是RequestConfig的一个内部类
     * 通过RequestConfig的custom方法来获取到一个Builder对象
     * 设置builder的连接信息
     * 这里还可以设置proxy，cookieSpec等属性。有需要的话可以在此设置
     * @return
     */
    @Bean(name = "builder")
    public RequestConfig.Builder getBuilder(){
        RequestConfig.Builder builder = RequestConfig.custom();
        return builder.setConnectTimeout(connectTimeout)
                .setConnectionRequestTimeout(connectionRequestTimeout)
                .setSocketTimeout(socketTimeout)
                .setStaleConnectionCheckEnabled(staleConnectionCheckEnabled);
    }

    /**
     * 使用builder构建一个RequestConfig对象
     * @param builder
     * @return
     */
    @Bean
    public RequestConfig getRequestConfig(@Qualifier("builder") RequestConfig.Builder builder){
        return builder.build();
    }

}
  1. 新建 HttpResult
import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;

@Data
@AllArgsConstructor
@NoArgsConstructor
public class HttpResult {

    // 响应的状态码
    private int code;

    // 响应的响应体
    private String body;
    
}
  1. 新建 HttpAPIService

import com.csjbot.scan.util.newutil.HttpResult;
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.impl.client.CloseableHttpClient;
import org.apache.http.message.BasicNameValuePair;
import org.apache.http.util.EntityUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import java.util.ArrayList;
import java.util.List;
import java.util.Map;

@Service
public class HttpAPIService {

    @Autowired
    private CloseableHttpClient httpClient;

    @Autowired
    private RequestConfig config;


    /**
     * 不带参数的get请求，如果状态码为200，则返回body，如果不为200，则返回null
     *
     * @param url
     * @return
     * @throws Exception
     */
    public String doGet(String url) throws Exception {
        // 声明 http get 请求
        HttpGet httpGet = new HttpGet(url);

        // 装载配置信息
        httpGet.setConfig(config);

        // 发起请求
        CloseableHttpResponse response = this.httpClient.execute(httpGet);

        // 判断状态码是否为200
        if (response.getStatusLine().getStatusCode() == 200) {
            // 返回响应体的内容
            return EntityUtils.toString(response.getEntity(), "UTF-8");
        }
        return null;
    }

    /**
     * 带参数的get请求，如果状态码为200，则返回body，如果不为200，则返回null
     *
     * @param url
     * @return
     * @throws Exception
     */
    public String doGet(String url, Map<String, Object> map) throws Exception {
        URIBuilder uriBuilder = new URIBuilder(url);

        if (map != null) {
            // 遍历map,拼接请求参数
            for (Map.Entry<String, Object> entry : map.entrySet()) {
                uriBuilder.setParameter(entry.getKey(), entry.getValue().toString());
            }
        }

        // 调用不带参数的get请求
        return this.doGet(uriBuilder.build().toString());

    }

    /**
     * 带参数的post请求
     *
     * @param url
     * @param map
     * @return
     * @throws Exception
     */
    public HttpResult doPost(String url, Map<String, Object> map) throws Exception {
        // 声明httpPost请求
        HttpPost httpPost = new HttpPost(url);
        // 加入配置信息
        httpPost.setConfig(config);

        // 判断map是否为空，不为空则进行遍历，封装from表单对象
        if (map != null) {
            List<NameValuePair> list = new ArrayList<NameValuePair>();
            for (Map.Entry<String, Object> entry : map.entrySet()) {
                list.add(new BasicNameValuePair(entry.getKey(), entry.getValue().toString()));
            }
            // 构造from表单对象
            UrlEncodedFormEntity urlEncodedFormEntity = new UrlEncodedFormEntity(list, "UTF-8");

            // 把表单放到post里
            httpPost.setEntity(urlEncodedFormEntity);
        }

        // 发起请求
        CloseableHttpResponse response = this.httpClient.execute(httpPost);
        return new HttpResult(response.getStatusLine().getStatusCode(), EntityUtils.toString(
                response.getEntity(), "UTF-8"));
    }

    /**
     * 不带参数post请求
     *
     * @param url
     * @return
     * @throws Exception
     */
    public HttpResult doPost(String url) throws Exception {
        return this.doPost(url, null);
    }
}

由于上个httpclient 的功能不全，因此在后期又添加了一个新的 httpclient、

import org.apache.http.HttpEntity;
import org.apache.http.NameValuePair;
import org.apache.http.ParseException;
import org.apache.http.client.ClientProtocolException;
import org.apache.http.client.config.RequestConfig;
import org.apache.http.client.entity.UrlEncodedFormEntity;
import org.apache.http.client.methods.*;
import org.apache.http.client.utils.URIBuilder;
import org.apache.http.entity.StringEntity;
import org.apache.http.impl.client.CloseableHttpClient;
import org.apache.http.message.BasicNameValuePair;
import org.apache.http.util.EntityUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import java.io.IOException;
import java.io.UnsupportedEncodingException;
import java.net.URISyntaxException;
import java.util.*;

@Service
public class HttpAPIServiceClient {

    @Autowired
    private CloseableHttpClient httpClient;

    @Autowired
    private RequestConfig config;

    // 编码格式。发送编码格式统一用UTF-8
    private static final String ENCODING = "UTF-8";


    /**
     * 不带参数的get请求，如果状态码为200，则返回body，如果不为200，则返回null
     *
     * @param url
     * @return
     * @throws Exception
     */
    public String doGet(String url) throws Exception {
        // 声明 http get 请求
        HttpGet httpGet = new HttpGet(url);

        // 装载配置信息
        httpGet.setConfig(config);

        // 发起请求
        CloseableHttpResponse response = this.httpClient.execute(httpGet);

        // 判断状态码是否为200
        if (response.getStatusLine().getStatusCode() == 200) {
            // 返回响应体的内容
            return EntityUtils.toString(response.getEntity(), "UTF-8");
        }
        return null;
    }

    /**
     * 带参数的get请求，如果状态码为200，则返回body，如果不为200，则返回null
     *
     * @param url
     * @return
     * @throws Exception
     */
    public String doGet(String url, Map<String, Object> map) throws Exception {
        URIBuilder uriBuilder = new URIBuilder(url);

        if (map != null) {
            // 遍历map,拼接请求参数
            for (Map.Entry<String, Object> entry : map.entrySet()) {
                uriBuilder.setParameter(entry.getKey(), entry.getValue().toString());
            }
        }

        // 调用不带参数的get请求
        return this.doGet(uriBuilder.build().toString());

    }

    /**
     * Post请求
     * @param url 地址
     * @param headers  请求头
     * @param params  请求参数
     * @param params  url请求参数
     * @return
     */
    public String doPost(String url, Map<String, String> headers, Map<String, String> params,Map<String, String> UrlParams){
        // 获得Http客户端(可以理解为:你得先有一个浏览器;注意:实际上HttpClient与浏览器是不一样的)
        // 创建访问的地址
        HttpPost httpPost = postUrlParam(url,UrlParams);
        httpPost.setConfig(config);

        packageHeader(headers, httpPost);
        packageParam(headers, httpPost);

        // 响应模型
        CloseableHttpResponse response = null;
        try {
            // 由客户端执行(发送)Get请求
            response = httpClient.execute(httpPost);
            // 从响应模型中获取响应实体
            HttpEntity responseEntity = response.getEntity();
            return EntityUtils.toString(responseEntity);
        } catch (ClientProtocolException e) {
            e.printStackTrace();
        } catch (ParseException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            //5.回收链接到连接池
            if (null != response) {
                try {
                    EntityUtils.consume(response.getEntity());
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
        return null;
    }

    /**
     * Post请求
     * @param url 地址
     * @param headers 请求头
     * @param urlParams url请求参数
     * @return
     */
    public String doPost(String url, Map<String,String> headers,Map<String, String> urlParams){
        return doPost(url,headers,null,urlParams);
    }

    /**
     * Post请求
     * @param url 地址
     * @param urlParams url请求参数
     * @return
     */
    public String doPost(String url, Map<String, String> urlParams){
        return doPost(url,null,null,urlParams);
    }

    /**
     * Post请求
     * @param url 地址
     * @return
     */
    public String doPost(String url){
        return doPost(url,new HashMap<>());
    }

    /**
     * Post请求
     * @param url 地址
     * @param headers  请求头
     * @param params  url请求参数
     * @param json  json请求体
     * @return
     */
    public String doPost(String url, Map<String, String> headers, Map<String, String> params,String json){
        // 获得Http客户端(可以理解为:你得先有一个浏览器;注意:实际上HttpClient与浏览器是不一样的)
        // 创建访问的地址
        HttpPost httpPost = postUrlParam(url,params);
        httpPost.setConfig(config);
        if(headers==null){
            headers=new HashMap<>();
        }



        headers.put("Content-Type", "application/json;charset=utf8");

        packageHeader(headers, httpPost);
        // post请求是将参数放在请求体里面传过去的;这里将entity放入post请求体中
        try {
            StringEntity s = new StringEntity(json,"UTF-8");
            s.setContentEncoding("UTF-8");
            s.setContentType("application/json");
            httpPost.setEntity(s);
//            httpPost.setEntity(new StringEntity(json));
        } catch (Exception e) {
            e.printStackTrace();
        }

        // 响应模型
        CloseableHttpResponse response = null;
        try {
            // 由客户端执行(发送)Get请求
            response = httpClient.execute(httpPost);
            // 从响应模型中获取响应实体
            HttpEntity responseEntity = response.getEntity();
            return EntityUtils.toString(responseEntity);
        } catch (ClientProtocolException e) {
            e.printStackTrace();
        } catch (ParseException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            //5.回收链接到连接池
            if (null != response) {
                try {
                    EntityUtils.consume(response.getEntity());
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
        return null;
    }

    /**
     * 简单json请求
     * @param url 地址
     * @param json  json请求体
     * @return
     */
    public String doPost(String url, String json){
        Map<String, String> headers=new HashMap<>();
        headers.put("Content-Type", "application/json;charset=utf8");
        return doPost(url,headers,null,json);
    }

    private HttpGet getUrlParam(String url, Map<String, String> params) {
        try{
            URIBuilder uriBuilder = new URIBuilder(url);
            if (params != null) {
                Set<Map.Entry<String, String>> entrySet = params.entrySet();
                for (Map.Entry<String, String> entry : entrySet) {
                    uriBuilder.setParameter(entry.getKey(), entry.getValue());
                }
            }
            // 创建Get请求
            return new HttpGet(uriBuilder.build());
        }catch (URISyntaxException e){
            throw new RuntimeException("url语法错误！");
        }
    }

    private HttpPost postUrlParam(String url, Map<String, String> params) {
        try{
            URIBuilder uriBuilder = new URIBuilder(url);
            if (params != null) {
                Set<Map.Entry<String, String>> entrySet = params.entrySet();
                for (Map.Entry<String, String> entry : entrySet) {
                    uriBuilder.setParameter(entry.getKey(), entry.getValue());
                }
            }
            // 创建Get请求
            return new HttpPost(uriBuilder.build());
        }catch (URISyntaxException e){
            throw new RuntimeException("url语法错误！");
        }
    }

    /**
     * Description: 封装请求头
     * @param params
     * @param httpMethod
     */
    private void packageHeader(Map<String, String> params, HttpRequestBase httpMethod) {
        // 封装请求头
        if (params != null) {
            Set<Map.Entry<String, String>> entrySet = params.entrySet();
            for (Map.Entry<String, String> entry : entrySet) {
                // 设置到请求头到HttpRequestBase对象中
                httpMethod.setHeader(entry.getKey(), entry.getValue());
            }
        }
    }

    /**
     * Description: 封装请求参数
     *
     * @param params
     * @param httpMethod
     * @throws UnsupportedEncodingException
     */
    private void packageParam(Map<String, String> params, HttpEntityEnclosingRequestBase httpMethod) {
        // 封装请求参数
        if (params != null) {
            List<NameValuePair> nvps = new ArrayList<NameValuePair>();
            Set<Map.Entry<String, String>> entrySet = params.entrySet();
            for (Map.Entry<String, String> entry : entrySet) {
                nvps.add(new BasicNameValuePair(entry.getKey(), entry.getValue()));
            }

            // 设置到请求的http对象中
            try {
                httpMethod.setEntity(new UrlEncodedFormEntity(nvps, ENCODING));
            } catch (UnsupportedEncodingException e) {
                throw new RuntimeException("不支持的地址格式！");
            }
        }
    }

}
  1. 新建 HttpClientController

import com.csjbot.scan.module.test.service.HttpAPIService;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
import javax.annotation.Resource;

@RestController
@RequestMapping("/HttpClientController")
public class HttpClientController {

    @Resource
    private HttpAPIService httpAPIService;

    @RequestMapping("httpclient")
    public String test() throws Exception {
        String str = httpAPIService.doGet("http://www.baidu.com");
        System.out.println(str);
        return "hello";
    }
}
  1. 测试结果
    在这里插入图片描述
    在这里插入图片描述
秋叶清风
关注
  • 3
    点赞
  • 踩
  • 7
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
HttpClient常用操作及封装工具类
rqz__的博客
07-30 1936
HttpClient 是一个用于发送 HTTP 请求和接收 HTTP 响应的类库/模块，可以用于编写客户端应用程序，通过 HTTP 与服务器进行通信。 HttpClient 提供了一组方法和类，使得发送 HTTP 请求变得简单和方便。它支持各种 HTTP 方法，例如 GET、POST、PUT、DELETE 等，并可以设置请求的头部信息、请求参数、请求体等。
springboot整合httpclient
yaoct的博客
12-04 2532
HttpClientConfig： package com.demo1.config; import org.apache.http.client.config.RequestConfig; import org.apache.http.impl.client.CloseableHttpClient; import org.apache.http.impl.client.HttpClientBuilder; import org.apache.http.impl.conn.PoolingHttpCli
基于SpringBoot的httpclient实现
最新发布
dashalen的博客
07-24 370
基于springboot的httpclient实现(RestTemplate)
「HttpClient」在 SpringBoot 中使用 HttpClient 实现 HTTP 请求
wdj0311的博客
11-29 1128
越来越多的 Java 应用程序需要直接通过 HTTP 协议来访问网络资源。虽然在 JDK 的 java.net 包中已经提供了访问 HTTP 协议的基本功能，但是对于大部分应用程序来说，JDK 库本身提供的功能还不够丰富和灵活。 HttpClient 是 Apache Jakarta Common 下的子项目，用来提供高效的、最新的、功能丰富的支持 HTTP 协议的客户端编程工具包，并且它支持 HTTP 协议最新的版本和建议。 新建一个SpringBoot工程，引入httpclient的 POM...
springboot中的httpclient
weixin_41645721的博客
09-21 1116
经纬度转行政地理位置这里调用高德地图 逆地理编码API服务地址 URL https://restapi.amap.com/v3/geocode/regeo?parameters 请求方式 GET 一开始使用conn非常复杂繁琐 public static String sendPost(String url, String param) throws IOException { PrintWriter o...
springboot整合httpClient代码实例
08-25
主要介绍了springboot整合httpClient代码实例,文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下
SpringBoot 整合 httpclient http请求发送工具类HttpUtils
NeverGiveUp
09-07 4907
SpringBoot 整合 httpclient http请求发送工具类HttpUtils 导入依赖 <dependency> <groupId>org.apache.httpcomponents</groupId> <artifactId>httpcore</artifactId> <version>4.4.12</version> </dependency> <dependenc
HttpClient与SpringBoot整合
qq_44509920的博客
08-13 1333
文章目录 SpringBoot官方并没有对HttpClient的启动器。 SpringBoot虽然没有提供启动器，但是却提供了一个统一的对Restful服务进行调用的模板类：RestTemplate，底层可以使用HttpClient来实现。有了这个我们就无需自己定义APIService了。 1、导入maven坐标 <dependency> <groupId>org.apache.httpcomponents</groupId> <artifact
Spring Boot 整合httpClient
weixin_38982591的博客
03-21 548
老套路 ，引入maven 依赖 <!-- httpclient --> <dependency> <groupId>org.apache.httpcomponents</groupId> <artifactId>httpclient</artifactId> <version>4.3.1&...
springboot使用httpclient(PostMethod，RequestEntity等)使用笔记
enthan809882的博客
12-19 7923
所需jar包如下： commons-codec-1.7.jar commons-logging-1.1.1.jar commons-httpclient.jar httpclient-4.2.2.jar httpcore-4.2.2.jar 如果有spring-boot-starter-parent ，下面2个默认会带： commons-codec-1.7.jar commons-loggin...
httpclient(springboot)demo
05-06
基于springboot+httpClient无缝整合在一起的demo例子（资源分享）！
HttpClient—与SpringBoot整合
mo念的博客
03-26 1万+
一、HttpClient 两个系统间如何互相访问？两个tomcat上的项目如何互相访问 采用HttpClient实现跨系统的接口调用。 1.2、 什么是HttpClient 官网：http://hc.apache.org/index.html 特点： HttpClient别名：HttpComponents HttpClient可以发送get、post、put、delete、…等请求 ...
Spring 或 SpringBoot 整合HttpClient
weixin_42545531的博客
05-24 3846
------------------------------------httpclient ------------------------ 1.引入jar包 <!--httpclient--> <dependency> <groupId>org.apache.httpcomponents</groupId> <arti...
Spring Boot入门教程(五十): httpclient
人不风流枉少年
10-12 4152
引入依赖 &amp;amp;lt;dependency&amp;amp;gt; &amp;amp;lt;groupId&amp;amp;gt;org.apache.httpcomponents&amp;amp;lt;/groupId&amp;amp;gt; &amp;amp;lt;artifactId&amp;amp;gt;httpclient&amp;amp;lt;/artifactId&amp;amp;g
springboot-httpclient
myz的博客
07-23 562
https://github.com/li5454yong/springboot-httpclient
spring boot 整合 HttpClient
一代键客的博客
10-12 1971
第一步：引入HttpClient 的jar包 1、httpClient 5.0 开始支持异步（Async）请求； 2、httpclient 版本过低上传文件会出，原因是org.apache.http.entity.ContentType 没有方法withParameters(final NameValuePair... params)； <dependency> &lt...
Spring Boot 之httpClient使用
热门推荐
二营长
04-27 1万+
两个系统间交互有很多方式，今天记一下Http的交互方式，以便代码复用。 &amp;lt;!-- http所需包 --&amp;gt; &amp;lt;dependency&amp;gt; &amp;lt;groupId&amp;gt;org.apache.httpcomponents&amp;lt;/groupId&amp;gt; &amp;lt;art
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值