个人中心
gpt4 book ai didi

spring集成httpclient配置的详细过程

转载 作者：qq735679552 更新时间：2022-09-29 22:32:09 26 4
gpt4 key购买 nike

CFSDN坚持开源创造价值，我们致力于搭建一个资源共享平台，让每一个IT人在这里找到属于你的精彩世界.

这篇CFSDN的博客文章spring集成httpclient配置的详细过程由作者收集整理，如果你对这篇文章有兴趣，记得点赞哟.

1、简介

HttpClient是Apache Jakarta Common下的子项目，用来提供高效的、最新的、功能丰富的支持HTTP协议的客户端编程工具包，并且它支持HTTP协议最新的版本和建议。HttpClient已经应用在很多的项目中，比如Apache Jakarta上很著名的另外两个开源项目Cactus和HTMLUnit都使用了HttpClient.

下载地址: http://hc.apache.org/downloads.cgi 。

2、特性

1. 基于标准、纯净的java语言。实现了Http1.0和Http1.1 。

2. 以可扩展的面向对象的结构实现了Http全部的方法（GET, POST, PUT, DELETE, HEAD, OPTIONS, and TRACE）.

3. 支持HTTPS协议.

4. 通过Http代理建立透明的连接.

5. 利用CONNECT方法通过Http代理建立隧道的https连接.

6. Basic, Digest, NTLMv1, NTLMv2, NTLM2 Session, SNPNEGO/Kerberos认证方案.

7. 插件式的自定义认证方案.

8. 便携可靠的套接字工厂使它更容易的使用第三方解决方案.

9. 连接管理器支持多线程应用。支持设置最大连接数，同时支持设置每个主机的最大连接数，发现并关闭过期的连接.

10. 自动处理Set-Cookie中的Cookie.

11. 插件式的自定义Cookie策略.

12. Request的输出流可以避免流中内容直接缓冲到socket服务器.

13. Response的输入流可以有效的从socket服务器直接读取相应内容.

14. 在http1.0和http1.1中利用KeepAlive保持持久连接.

15. 直接获取服务器发送的response code和 headers.

16. 设置连接超时的能力.

17. 实验性的支持http1.1 response caching.

18. 源代码基于Apache License 可免费获取.

spring httpclient

HTTP 协议可能是现在 Internet 上使用得最多、最重要的协议了，越来越多的 Java 应用程序需要直接通过 HTTP 协议来访问网络资源。虽然在 JDK 的 java.net 包中已经提供了访问 HTTP 协议的基本功能，但是对于大部分应用程序来说，JDK 库本身提供的功能还不够丰富和灵活。HttpClient 是 Apache Jakarta Common 下的子项目，用来提供高效的、最新的、功能丰富的支持 HTTP 协议的客户端编程工具包，并且它支持 HTTP 协议最新的版本和建议.

spring与httpclient集成方式如下:

引入jar包 。

?
1
2
3
4
5
<dependency>
     <groupId>org.apache.httpcomponents</groupId>
     <artifactId>httpclient</artifactId>
     <version> 4.5 . 2 </version>
</dependency>

2.编写执行get和post请求的java类 。

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
package com.wee.common.service;
 
import java.io.IOException;
import java.net.URISyntaxException;
import java.util.ArrayList;
import java.util.List;
import java.util.Map;
 
import org.apache.http.NameValuePair;
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.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.ContentType;
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 com.wee.common.bean.HttpResult;
 
@Service
public class HttpClientService {
 
     @Autowired
     private CloseableHttpClient httpClient;
     @Autowired
     private RequestConfig requestConfig;
 
     /**
      * 执行GET请求
      *
      * @param url
      * @return
      * @throws IOException
      * @throws ClientProtocolException
      */
     public String doGet(String url) throws ClientProtocolException, IOException {
         // 创建http GET请求
         HttpGet httpGet = new HttpGet(url);
         httpGet.setConfig( this .requestConfig);
 
         CloseableHttpResponse response = null ;
         try {
             // 执行请求
             response = httpClient.execute(httpGet);
             // 判断返回状态是否为200
             if (response.getStatusLine().getStatusCode() == 200 ) {
                 return EntityUtils.toString(response.getEntity(), "UTF-8" );
             }
         } finally {
             if (response != null ) {
                 response.close();
             }
         }
         return null ;
     }
 
     /**
      * 带有参数的GET请求
      *
      * @param url
      * @param params
      * @return
      * @throws URISyntaxException
      * @throws IOException
      * @throws ClientProtocolException
      */
     public String doGet(String url, Map<String, String> params)
             throws ClientProtocolException, IOException, URISyntaxException {
         URIBuilder uriBuilder = new URIBuilder(url);
         for (String key : params.keySet()) {
             uriBuilder.addParameter(key, params.get(key));
         }
         return this .doGet(uriBuilder.build().toString());
     }
 
     /**
      * 执行POST请求
      *
      * @param url
      * @param params
      * @return
      * @throws IOException
      */
     public HttpResult doPost(String url, Map<String, String> params) throws IOException {
         // 创建http POST请求
         HttpPost httpPost = new HttpPost(url);
         httpPost.setConfig( this .requestConfig);
         if (params != null ) {
             // 设置2个post参数，一个是scope、一个是q
             List<NameValuePair> parameters = new ArrayList<NameValuePair>();
             for (String key : params.keySet()) {
                 parameters.add( new BasicNameValuePair(key, params.get(key)));
             }
             // 构造一个form表单式的实体
             UrlEncodedFormEntity formEntity = new UrlEncodedFormEntity(parameters, "UTF-8" );
             // 将请求实体设置到httpPost对象中
             httpPost.setEntity(formEntity);
         }
 
         CloseableHttpResponse response = null ;
         try {
             // 执行请求
             response = httpClient.execute(httpPost);
             return new HttpResult(response.getStatusLine().getStatusCode(),
                     EntityUtils.toString(response.getEntity(), "UTF-8" ));
         } finally {
             if (response != null ) {
                 response.close();
             }
         }
     }
 
     /**
      * 执行POST请求
      *
      * @param url
      * @return
      * @throws IOException
      */
     public HttpResult doPost(String url) throws IOException {
         return this .doPost(url, null );
     }
 
     /**
      * 提交json数据
      *
      * @param url
      * @param json
      * @return
      * @throws ClientProtocolException
      * @throws IOException
      */
     public HttpResult doPostJson(String url, String json) throws ClientProtocolException, IOException {
         // 创建http POST请求
         HttpPost httpPost = new HttpPost(url);
         httpPost.setConfig( this .requestConfig);
 
         if (json != null ) {
             // 构造一个form表单式的实体
             StringEntity stringEntity = new StringEntity(json, ContentType.APPLICATION_JSON);
             // 将请求实体设置到httpPost对象中
             httpPost.setEntity(stringEntity);
         }
 
         CloseableHttpResponse response = null ;
         try {
             // 执行请求
             response = this .httpClient.execute(httpPost);
             return new HttpResult(response.getStatusLine().getStatusCode(),
                     EntityUtils.toString(response.getEntity(), "UTF-8" ));
         } finally {
             if (response != null ) {
                 response.close();
             }
         }
     }
 
}
?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
HttpResult.java
 
public class HttpResult {
 
     /**
      * 状态码
      */
     private Integer status;
     /**
      * 返回数据
      */
     private String data;
 
     public HttpResult() {
     }
 
     public HttpResult(Integer status, String data) {
         this .status = status;
         this .data = data;
     }
 
     public Integer getStatus() {
         return status;
     }
 
     public void setStatus(Integer status) {
         this .status = status;
     }
 
     public String getData() {
         return data;
     }
 
     public void setData(String data) {
         this .data = data;
     }
 
}

3.spring和httpClient整合配置文件 。

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
<!-- 定义连接管理器 -->
     <bean id= "httpClientConnectionManager"
         class = "org.apache.http.impl.conn.PoolingHttpClientConnectionManager"
         destroy-method= "close" >
         <!-- 最大连接数 -->
         <property name= "maxTotal" value= "${http.maxTotal}" />
 
         <!-- 设置每个主机地址的并发数 -->
         <property name= "defaultMaxPerRoute" value= "${http.defaultMaxPerRoute}" />
     </bean>
 
     <!-- httpclient对象构建器 -->
     <bean id= "httpClientBuilder" class = "org.apache.http.impl.client.HttpClientBuilder" >
         <!-- 设置连接管理器 -->
         <property name= "connectionManager" ref= "httpClientConnectionManager" />
     </bean>
 
     <!-- 定义Httpclient对象 -->
     <bean id= "httpClient" class = "org.apache.http.impl.client.CloseableHttpClient"
         factory-bean= "httpClientBuilder" factory-method= "build" scope= "prototype" >
     </bean>
 
     <!-- 定义清理无效连接 -->
     <bean class = "com.taotao.common.httpclient.IdleConnectionEvictor"
         destroy-method= "shutdown" >
         <constructor-arg index= "0" ref= "httpClientConnectionManager" />
     </bean>
 
     <bean id= "requestConfigBuilder" class = "org.apache.http.client.config.RequestConfig.Builder" >
         <!-- 创建连接的最长时间 -->
         <property name= "connectTimeout" value= "${http.connectTimeout}" />
         <!-- 从连接池中获取到连接的最长时间 -->
         <property name= "connectionRequestTimeout" value= "${http.connectionRequestTimeout}" />
         <!-- 数据传输的最长时间 -->
         <property name= "socketTimeout" value= "${http.socketTimeout}" />
         <!-- 提交请求前测试连接是否可用 -->
         <property name= "staleConnectionCheckEnabled" value= "${http.staleConnectionCheckEnabled}" />
     </bean>
     <!-- 定义请求参数 -->
     <bean id= "requestConfig" class = "org.apache.http.client.config.RequestConfig" factory-bean= "requestConfigBuilder" factory-method= "build" >
     </bean>

4.httpclient.properties 。

?
1
2
3
4
5
6
httpClient.maxTotal= 200
httpClient.defaultMaxPerRoute= 50
httpClient.connectTimeout= 1000
httpClient.connectionRequestTimeout= 500
httpClient.socketTimeout= 10000
httpClient.staleConnectionCheckEnabled= true

5.使用一个单独的线程完成连接池中的无效链接的清理 。

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
package com.wee.common.httpclient;
 
import org.apache.http.conn.HttpClientConnectionManager;
 
public class IdleConnectionEvictor extends Thread {
 
     private final HttpClientConnectionManager connMgr;
 
     private volatile boolean shutdown;
 
     public IdleConnectionEvictor(HttpClientConnectionManager connMgr) {
         this .connMgr = connMgr;
         // 启动当前线程
         this .start();
     }
 
     @Override
     public void run() {
         try {
             while (!shutdown) {
                 synchronized ( this ) {
                     wait( 5000 );
                     // 关闭失效的连接
                     connMgr.closeExpiredConnections();
                 }
             }
         } catch (InterruptedException ex) {
             // 结束
         }
     }
 
     public void shutdown() {
         shutdown = true ;
         synchronized ( this ) {
             notifyAll();
         }
     }
}

到此这篇关于spring集成httpclient配置的文章就介绍到这了,更多相关spring httpclient配置内容请搜索我以前的文章或继续浏览下面的相关文章希望大家以后多多支持我！ 。

原文链接：https://www.cnblogs.com/A-yes/p/9894176.html#4899710 。

最后此篇关于spring集成httpclient配置的详细过程的文章就讲到这里了,如果你想了解更多关于spring集成httpclient配置的详细过程的内容请搜索CFSDN的文章或继续浏览相关文章，希望大家以后支持我的博客！ 。

26 4 0
文章推荐： Python 安装第三方库 pip install 安装慢安装不上的解决办法
文章推荐： 利用C语言实现三子棋(井字棋)小游戏
文章推荐： PyQt编程之如何在屏幕中央显示窗体的实例
文章推荐： pycharm访问mysql数据库的方法步骤
qq735679552
个人简介

我是一名优秀的程序员,十分优秀！

滴滴打车优惠券免费领取
滴滴打车优惠券
全站热门文章
Copyright 2021 - 2024 cfsdn All Rights Reserved 蜀ICP备2022000587号
广告合作:1813099741@qq.com 6ren.com