spring boot封装HttpClient

最新推荐文章于 2024-06-27 17:27:08 发布

henghenghuo2690

最新推荐文章于 2024-06-27 17:27:08 发布

阅读量313

点赞数

本文链接：https://blog.csdn.net/henghenghuo2690/article/details/77160583

版权

最近使用到了HttpClient，看了一下官方文档：HttpClient实现是线程安全的。建议将这个类的实例重用于多个请求执行，翻译过来的意思就是：HttpClient的实现是线程安全的，可以重用相同的实例来执行多次请求。遇到这种描述的话，我们就应该想到，需要对HttpClient来进行封装了。由于是使用的spring boot，所以下面来结合spring boot来封装HttpClient。

一，请求重试处理

为了使自定义异常机制生效，实现需要HttpRequestRetryHandler接口，代码如下：

[java] 查看纯文本 
   
 import  java.io.IOException;  
 import  java.io.InterruptedIOException;  
 import  java.net.UnknownHostException;  
   
 import  javax.net.ssl.SSLException;  
 import  javax.net.ssl.SSLHandshakeException;  
   
 import  org.apache.http.HttpEntityEnclosingRequest;  
 import  org.apache.http.HttpRequest;  
 import  org.apache.http.NoHttpResponseException;  
 import  org.apache.http.client.HttpRequestRetryHandler;  
 import  org.apache.http.client.protocol.HttpClientContext;  
 import  org.apache.http.conn.ConnectTimeoutException;  
 import  org.apache.http.protocol.HttpContext;  
 import  org.springframework.beans.factory.annotation.Value;  
 import  org.springframework.context.annotation.Bean;  
 import  org.springframework.context.annotation.Configuration;  
   
 / ** 
  *描述：HttpClient的重试处理机制 
  * /  
 @组态  
 公共类 MyhttpRequestRetryHandler {   
   
     @Value （“$ {httpclient.config.retryTime}” ）//此处建议采用@ConfigurationProperties（prefix =“httpclient.config”）方式，方便复用  
     private int  retryTime;   
       
     @豆  
     public  HttpRequestRetryHandler httpRequestRetryHandler（）{  
         //请求重试  
         final int  retryTime =  this .retryTime;   
         返回新的 HttpRequestRetryHandler（）{   
             public boolean  retryRequest（IOException exception，  int  executionCount，HttpContext context）{   
                 //如果超过最大重试计数，请不要重试，如​​果重试次数超过了retryTime，则不再重试请求  
                 if  （executionCount> = retryTime）{  
                     返回假的;   
                 }  
                 //服务端断掉客户端的连接异常  
                 if  （exception  instanceof  NoHttpResponseException）{  
                     返回真;   
                 }  
                 // time out超时重试  
                 if  （异常  instanceof  InterruptedIOException）{  
                     返回真;   
                 }  
                 // 未知主机  
                 if  （exception  instanceof  UnknownHostException）{  
                     返回假的;   
                 }  
                 // 拒绝连接  
                 if  （异常  instanceof  ConnectTimeoutException）{  
                     返回假的;   
                 }  
                 // SSL握手异常  
                 if  （exception  instanceof  SSLException）{  
                     返回假的;   
                 }  
                 HttpClientContext clientContext = HttpClientContext.adapt（context）;  
                 HttpRequest request = clientContext.getRequest（）;  
                 if  （！（request  instanceof  HttpEntityEnclosingRequest））{  
                     返回真;   
                 }  
                 返回假的;   
             }  
         };  
     }  
 }  

二连池池管理

PoolingHttpClientConnectionManager用来管理客户端的连接池，并且可以为多个线程的请求提供，代码如下：

[java] 查看纯文本 
   
 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.conn.PoolingHttpClientConnectionManager;  
 import  org.springframework.beans.factory.annotation.Value;  
 import  org.springframework.context.annotation.Bean;  
 import  org.springframework.context.annotation.Configuration;  
   
 @组态  
 public class  MyPoolingHttpClientConnectionManager {   
     / ** 
      *连接池最大连接数 
      * /  
     @Value （“$ {httpclient.config.connMaxTotal}” ）  
     private int  connMaxTotal =  20 ;   
       
     / ** 
      *  
      * /  
     @Value （“$ {httpclient.config.maxPerRoute}” ）  
     private int  maxPerRoute =  20 ;   
   
         / ** 
      *连接存活时间，单位为s 
      * /  
      @Value （“$ {httpclient.config.timeToLive}” ）  
      private int  timeToLive =  60 ;   
   
        @豆  
     public  poolingHttpClientConnectionManager poolingClientConnectionManager（）{  
         PoolingHttpClientConnectionManager poolHttpcConnManager =  new  PoolingHttpClientConnectionManager（60 ，TimeUnit.SECONDS）;  
         //最大连接数  
         poolHttpcConnManager.setMaxTotal（this .connMaxTotal）;  
         //路由基数  
         poolHttpcConnManager.setDefaultMaxPerRoute（此.maxPerRoute）;  
         返回 poolHttpcConnManager;  
     }  
 }  

注意：当HttpClient的实例不再需要并且即将超出范围时，重要的是关闭其连接管理器，以确保管理器保持活动的所有连接都被关闭，并释放由这些连接分配的系统资源

上面PoolingHttpClientConnectionManager类的构造函数如下：

[java] 查看纯文本 
   
 public  PoolingHttpClientConnectionManager（final long  timeToLive，  final  TimeUnit tunit）{   
         this （getDefaultRegistry（），  null ，  null  ，null ，timeToLive，tunit）;  
     }  
   
 private static  Registry <ConnectionSocketFactory> getDefaultRegistry（）{   
         return  RegistryBuilder。<ConnectionSocketFactory> create（）  
                 .register（“http” ，PlainConnectionSocketFactory.getSocketFactory（））  
                 .register（“https” ，SSLConnectionSocketFactory.getSocketFactory（））  
                 。建立（）;  
     }  

在PoolingHttpClientConnectionManager的配置中有两个最大连接数量，分别控制着总的最大连接数量和每个路线的最大连接数量。如果没有显式设置，默认每个路径只允许最多2个连接，总的连接数量不超过20这个值对于很多并发度高的应用来说是不够的，必须根据实际的情况设置合适的值，思路和线程池的大小设置方式是类似的，如果所有的连接请求都是到同一个网址，那可以把MaxPerRoute的值设置成和MaxTotal一致，这样就能更高效地复用连接

特别注意：想要复用一个连接就必须要让它占有的系统资源得到正确释放，释放方法如下：

如果是使用outputStream就要保证整个实体都被写出，如果是inputStream，则再最后要记得调用inputStream.close（）。或者使用EntityUtils.consume（entity）或EntityUtils.consumeQuietly（entity）来让实体被完全耗尽（后者不抛异常）来做这一工作.EntityUtils中有个toString方法也很方便的（调用这个方法最后也会自动把inputStream close掉的，但是在实际的测试过程中，会导致连接没有释放的现象），不过只有在可以确定收到的实体不是特别大的情况下才能使用如果没有让整个实体被完全消费，则该连接是不能被复用的，很快就会因为在连接所以如果想要复用连接，一定一定要记得把实体完全消耗掉，只要检测到流的EOF，是会自动调用ConnectionHolder的releaseConnection方法行处理的

三，连接保持策略（保持连接策略）

HTTP规范没有指定持久连接可能和应该保持存活多久。一些HTTP服务器使用非标准的Keep-Alive标头来向客户端通信它们打算在服务器端保持连接的时间段（以秒为单位）HttpClient可以使用这些信息。如果响应中不存在保持活动头，HttpClient的会假定连接可以无限期地保持活动。然而，一般使用的许多HTTP服务器都配置为在一段不活动状态之后删除持久连接，以便节省系统资源，而不会通知客户端。如果默认策略过于乐观，则可能需要提供自定义的保持活动策略，代码如下：

[java] 查看纯文本 
   
 import  org.apache.http.HeaderElement;  
 import  org.apache.http.HeaderElementIterator;  
 import  org.apache.http.HttpResponse;  
 import  org.apache.http.conn.ConnectionKeepAliveStrategy;  
 import  org.apache.http.message.BasicHeaderElementIterator;  
 import  org.apache.http.protocol.HTTP;  
 import  org.apache.http.protocol.HttpContext;  
 import  org.springframework.beans.factory.annotation.Value;  
 import  org.springframework.context.annotation.Bean;  
 import  org.springframework.context.annotation.Configuration;  
   
 / ** 
  *描述：连接保持策略 
  * @author chhliu 
  * /  
 @组态  
 公共类 MyconnectionKeepAliveStrategy {   
       
     @Value （“$ {httpclient.config.keepAliveTime}” ）  
     private int  keepAliveTime =  30 ;   
       
     @Bean （“connectionKeepAliveStrategy” ）  
     public  ConnectionKeepAliveStrategy connectionKeepAliveStrategy（）{  
         返回新的 ConnectionKeepAliveStrategy（）{   
   
             public long  getKeepAliveDuration（HttpResponse response，HttpContext context）{   
                 // Honor'keep-alive'标题  
                 HeaderElementIterator it =  new  BasicHeaderElementIterator（  
                         response.headerIterator（HTTP.CONN_KEEP_ALIVE））;  
                 while  （it.hasNext（））{  
                     HeaderElement he = it.nextElement（）;  
                     String param = he.getName（）;  
                     String value = he.getValue（）;  
                     if  （value！=  null  && param.equalsIgnoreCase（“timeout” ））{  
                         尝试 {  
                             返回 Long.parseLong（value）*  1000 ;  
                         }  catch  （NumberFormatException ignore）{  
                         }  
                     }  
                 }  
                 返回30  *  1000 ;   
             }  
         };  
     }  
 }  

注意：长连接并不使用于所有的情况，尤其现在的系统，大都是部署在多台服务器上，且具有负载均衡的功能，如果我们在访问的时候，一直保持长连接，一旦那台服务器挂了，就会影响客户端，同时也不能充分的利用服务端的负载均衡的特性，反而短连接更有利一些，这些需要根据具体的需求来定，而不是一言概括。

四，HttpClient代理配置（代理配置）

用来配置代理，代码如下：

[java] 查看纯文本 
   
 import  org.apache.http.HttpHost;  
 import  org.apache.http.impl.conn.DefaultProxyRoutePlanner;  
 import  org.springframework.beans.factory.annotation.Value;  
 import  org.springframework.context.annotation.Bean;  
 import  org.springframework.context.annotation.Configuration;  
   
 / ** 
  *描述：HttpClient代理 
  * @author chhliu 
  * /  
 @组态  
 公共类 MyDefaultProxyRoutePlanner {   
     //代理的主机地址  
     @Value （“$ {httpclient.config.proxyhost}” ）  
     private  String proxyHost;  
       
     //代理的端口号  
     @Value （“$ {httpclient.config.proxyPort}” ）  
     private int  proxyPort =  8080 ;   
       
     @豆  
     public  DefaultProxyRoutePlanner defaultProxyRoutePlanner（）{  
         HttpHost proxy =  new  HttpHost（这个.proxyHost，  这个.proxyPort）;  
         返回新的 DefaultProxyRoutePlanner（代理）;   
     }  
 }  

HttpClient的不仅支持简单的直连，复杂的路由策略以及代理.HttpRoutePlanner是基于HTTP上下文情况下，客户端到服务器的路由计算策略，一般没有代理的话，就不用设置这个东西。这里有一个很关键的概念 - 路线指示运行环境机器

五，RequestConfig

用来设置请求的各种配置，代码如下：

[java] 查看纯文本 
   
 import  org.apache.http.client.config.RequestConfig;  
 import  org.springframework.beans.factory.annotation.Value;  
 import  org.springframework.context.annotation.Bean;  
 import  org.springframework.context.annotation.Configuration;  
   
 @组态  
 公共类 MyRequestConfig {   
     @Value （“$ {httpclient.config.connectTimeout}” ）  
     private int  connectTimeout =  2000 ;   
       
     @Value （“$ {httpclient.config.connectRequestTimeout}” ）  
     private int  connectRequestTimeout =  2000 ;   
       
     @Value （“$ {httpclient.config.socketTimeout}” ）  
     private int  socketTimeout =  2000 ;   
     @豆  
     public  RequestConfig config（）{  
         返回 RequestConfig.custom（）  
                 .setConnectionRequestTimeout（this .connectRequestTimeout）  
                 .setConnectTimeout（this .connectTimeout）  
                 .setSocketTimeout（this .socketTimeout）  
                 。建立（）;  
     }  
 }  

        RequestConfig是对请求的一些配置。里面比较重要的有三个超时时间，默认的情况下这三个超时时间都为0（如果不设置请求的配置，会在执行的过程中使用HttpClientParamConfig的getRequestConfig中用默认参数进行设置），这也就意味着无限等待，很容易导致所有的请求阻塞在这个地方无限期等待这三个超时时间为：
        a，connectionRequestTimeout-从连接池中取连接的超时时间
        这个时间定义的是从ConnectionManager管理的连接池中取出连接的超时时间，如果连接池中没有可用的连接，则请求被阻塞，最长等待connectionRequestTimeout的时间，如果还没有被服务，则抛出ConnectionPoolTimeoutException异常，不继续等待
        b
        连接等待时间定时时，会抛出ConnectionTimeoutException异常
        c，socketTimeout-请求超时时间
        这个时间定义了socket读数据的超时时间，也就是连接到服务器之后到从服务器获取响应数据需要等待的时间，或者说是连接上一个url之后到获取响应的返回等待时间。发生超时，会抛出SocketTimeoutException异常。

六，实例化的HttpClient

通过实现FactoryBean的来实例化HttpClient的，代码如下：

[java] 查看纯文本 
   
 import  org.apache.http.client.HttpRequestRetryHandler;  
 import  org.apache.http.client.config.RequestConfig;  
 import  org.apache.http.conn.ConnectionKeepAliveStrategy;  
 import  org.apache.http.impl.client.CloseableHttpClient;  
 import  org.apache.http.impl.client.HttpClients;  
 import  org.apache.http.impl.conn.DefaultProxyRoutePlanner;  
 import  org.apache.http.impl.conn.PoolingHttpClientConnectionManager;  
 import  org.springframework.beans.factory.DisposableBean;  
 import  org.springframework.beans.factory.FactoryBean;  
 import  org.springframework.beans.factory.InitializingBean;  
 import  org.springframework.beans.factory.annotation.Autowired;  
 import  org.springframework.stereotype.Service;  
   
 / ** 
  *描述：HttpClient客户端封装 
  * /  
 @Service （“httpClientManagerFactoryBen” ）  
 public class  HttpClientManagerFactoryBen  实现 FactoryBean <CloseableHttpClient>，InitializingBean，DisposableBean {   
   
     / ** 
      * FactoryBean生成的目标对象 
      * /  
     私人 CloseableHttpClient客户端;  
       
     @Autowired  
     私人 ConnectionKeepAliveStrategy connectionKeepAliveStrategy;  
       
     @Autowired  
     私人 HttpRequestRetryHandler httpRequestRetryHandler;  
       
     @Autowired  
     私人 DefaultProxyRoutePlanner proxyRoutePlanner;  
       
     @Autowired  
     private  PoolingHttpClientConnectionManager poolHttpcConnManager;  
       
     @Autowired  
     private  RequestConfig config;  
       
         //销毁上下文时，销毁HttpClient实例  
     @覆盖  
     public void  destroy（）  throws  Exception {   
                  / * 
            *调用httpClient.close（）会先关闭连接管理器，然后再释放该HttpClient所占用的所有资源， 
            *关闭所有在使用或者空闲的连接包括底层插座。由于这里把它所使用的连接管理器关闭了， 
            *所以在下次还要进行http请求的时候，要重新新一个连接管理器来构建一个HttpClient， 
            *也就是在需要关闭和新建客户的情况下，连接管理器不能是单例的。 
            * /  
                 if （null  ！=  this .client）{  
             这个.client.close（）;  
            }  
     }  
   
     @Override //初始化实例  
     public void  afterPropertiesSet（）  抛出 异常{   
                  / * 
          *建议此处使用HttpClient.custom的方式来创建HttpClientBuilder，而不要使用HttpClientBuilder.create（）方法来创建HttpClientBuilder 
          *从官方文档可以得出，HttpClientBuilder是非线程安全的，但是HttpClients确实Immutable的，immutable对象不仅能够保证对象的状态不被改变， 
          *而且还可以不使用锁机制就能被其他线程共享 
          * /  
                   这个.client = HttpClients.custom（）。setConnectionManager（poolHttpcConnManager）  
                 .setRetryHandler（httpRequestRetryHandler）  
                 .setKeepAliveStrategy（connectionKeepAliveStrategy）  
                 .setRoutePlanner（proxyRoutePlanner）  
                 .setDefaultRequestConfig（配置）  
                 。建立（）;  
     }  
   
         //返回实例的类型  
     @覆盖  
     public  CloseableHttpClient getObject（）  throws  Exception {  
         返回此.client;   
     }  
   
     @覆盖  
     public  class <？> getObjectType（）{  
         回 （这.client ==  空 CloseableHttpClient？类 ：  此.client.getClass（））;  
     }  
   
         //构建的实例为单例  
     @覆盖  
     public boolean  isSingleton（）{   
         返回真;   
     }  
   
 }  

七，增加配置文件

[java] 查看纯文本 
   
 ＃代理的主机  
 httpclient.config.proxyhost = xxx.xx.xx.xx  
 ＃代理端口  
 httpclient.config.proxyPort = 8080  
 ＃连接超时或异常重试次数  
 httpclient.config.retryTime = 3  
 ＃长连接保持时间，单位为s  
 httpclient.config.keepAliveTime = 30  
 ＃连接池最大连接数  
 httpclient.config.connMaxTotal = 20  
 httpclient.config.maxPerRoute = 20  
 ＃连接超时时间，单位ms  
 httpclient.config.connectTimeout = 2000  
 ＃请求超时时间  
 httpclient.config.connectRequestTimeout = 2000  
 ＃sock超时时间  
 httpclient.config.socketTimeout = 2000  
 ＃连接存活时间，单位  
 httpclient.config.timeToLive = 60  

八，测试

测试代码如下：

[java] 查看纯文本 
   
 import  java.io.IOException;  
 import  java.util.concurrent.ExecutorService;  
 import  java.util.concurrent.Executors;  
   
 import  javax.annotation.Resource;  
   
 import  org.apache.http.Consts;  
 import  org.apache.http.ParseException;  
 import  org.apache.http.client.ClientProtocolException;  
 import  org.apache.http.client.methods.CloseableHttpResponse;  
 import  org.apache.http.client.methods.HttpGet;  
 import  org.apache.http.impl.client.CloseableHttpClient;  
 import  org.apache.http.util.EntityUtils;  
 import  org.junit.Test;  
 import  org.junit.runner.RunWith;  
 import  org.springframework.boot.test.context.SpringBootTest;  
 import  org.springframework.test.context.junit4.SpringRunner;  
   
 @RunWith （SpringRunner。类）  
 @SpringBootTest  
 公共类 HttpClientManagerFactoryBenTest {   
         //注入HttpClient实例  
        @Resource （name =  “httpClientManagerFactoryBen” ）  
     私人 CloseableHttpClient客户端;  
       
     @测试  
     public void  test（）  throws  ClientProtocolException，IOException，InterruptedException {   
         ExecutorService service = Executors.newFixedThreadPool（2 ）;  
         for （int  i = 0 ; i < 10 ; i ++）{  
             service.submit（new  Runnable（）{  
                   
                 @覆盖  
                 public void  run（）{   
                     System.out.println（“当前线程是：” + Thread.currentThread（）。getName（））;  
                                         HttpEntity entity =  null ;  
                                        尝试 {  
                         HttpGet get =  new  HttpGet（“https：// localhost：8080 / testjson” ）;  
                         //通过httpclient的执行提交请求，并用CloseableHttpResponse接受返回信息  
                         CloseableHttpResponse response = client.execute（get）;  
                         System.out.println（“client object：” + client）;  
                                                 entity = response.getEntity（）;  
                                                System.out.println（“============” + EntityUtils.toString（entity，Consts.UTF_8）+“=============” ）;  
                                                 EntityUtils.consumeQuietly（实体）; //释放连接  
                                        }  catch  （ClientProtocolException e）{  
                         e.printStackTrace（）;  
                     }  catch  （ParseException e）{  
                         e.printStackTrace（）;  
                     }  catch  （IOException e）{  
                         e.printStackTrace（）;  
                     }  finally {  
                                                 if （null  ！= entity）{ //释放连接  
                                EntityUtils.consumeQuietly（实体）;  
                               }  
                                         }  
                                 }  
             }）;  
         }  
         Thread.sleep（60000 ）;  
     }  
 }  

通过上面的几个步骤，就基本上完成了对HttpClient的的封装，如果需要更细致的话，可以按照上面的思路，逐步完善，将HttpClient的封装成HttpClientTemplate，因为CloseableHttpClient内部使用了回调机制，和JdbcTemplate的，或者是RedisTemplate类似，直到可以以spring boot starter的方式提供服务。

henghenghuo2690

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
spring boot封装HttpClient

最近使用到了HttpClient，看了一下官方文档：HttpClient实现是线程安全的。建议将这个类的实例重用于多个请求执行，翻译过来的意思就是：HttpClient的实现是线程安全的，可以重用相同的实例来执行多次请求。遇到这种描述的话，我们就应该想到，需要对HttpClient来进行封装了。由于是使用的spring boot，所以下面来结合spring boot来封装HttpClient。
复制链接

扫一扫