Java HttpClient中的三种超时设置区别

秒速五厘米 2021-11-23 00:44 344阅读 0赞

最近项目中在使用HttpClient有三个超时(connectionRequestTimeout,connectTimeout,socketTimeout)时间理解得不是很透彻，API文档不是很理解，专门写Demo理解了一下。

API的描述如下：

/** 
 * Returns the timeout in milliseconds used when requesting a connection 
 * from the connection manager. A timeout value of zero is interpreted 
 * as an infinite timeout. 
 * 
 * A timeout value of zero is interpreted as an infinite timeout. 
 * A negative value is interpreted as undefined (system default). 
 * 
 * 
 * Default: { @code -1} 
 * 
 */ 
 public int getConnectionRequestTimeout () { 
 return connectionRequestTimeout ; 
 } 
 
 /** 
 * Determines the timeout in milliseconds until a connection is established. 
 * A timeout value of zero is interpreted as an infinite timeout. 
 * 
 * A timeout value of zero is interpreted as an infinite timeout. 
 * A negative value is interpreted as undefined (system default). 
 * 
 * 
 * Default: { @code -1} 
 * 
 */ 
 public int getConnectTimeout () { 
 return connectTimeout ; 
 } 
 
 /** 
 * Defines the socket timeout ({ @code SO_TIMEOUT}) in milliseconds, 
 * which is the timeout for waiting for data or, put differently, 
 * a maximum period inactivity between two consecutive data packets). 
 * 
 * A timeout value of zero is interpreted as an infinite timeout. 
 * A negative value is interpreted as undefined (system default). 
 * 
 * 
 * Default: { @code -1} 
 * 
 */ 
 public int getSocketTimeout () { 
 return socketTimeout ; 
 }

### 正确解读一下 ###

API中不能看出正式的含义是什么，经过demo之后，终于知道了各自含义

#### 1. connectTimeOut：指建立连接的超时时间，比较容易理解 ####

#### 2. connectionRequestTimeOut：指从连接池获取到连接的超时时间，如果是非连接池的话，该参数暂时没有发现有什么用处 ####

#### 3. socketTimeOut：指客户端和服务进行数据交互的时间，是指两者之间如果两个数据包之间的时间大于该时间则认为超时，而不是整个交互的整体时间，比如如果设置1秒超时，如果每隔0.8秒传输一次数据，传输10次，总共8秒，这样是不超时的。而如果任意两个数据包之间的时间超过了1秒，则超时。 ####

### 代码 ###

首先是为这次demo写的服务代码，包含几个controller方法（Spring MVC）

package me . nabil . demo . springbootdemo ; 
 
 import org.slf4j.Logger ; 
 import org.slf4j.LoggerFactory ; 
 import org.springframework.boot.SpringApplication ; 
 import org.springframework.boot.autoconfigure.EnableAutoConfiguration ; 
 import org.springframework.stereotype.Controller ; 
 import org.springframework.web.bind.annotation.RequestMapping ; 
 import org.springframework.web.bind.annotation.RequestMethod ; 
 import org.springframework.web.bind.annotation.ResponseBody ; 
 
 import javax.servlet.http.HttpServletRequest ; 
 import javax.servlet.http.HttpServletResponse ; 
 import java.io.IOException ; 
 
 /** 
 * 超时测试 
 * 
 * @author nabilzhang 
 */ 
 @Controller 
 @EnableAutoConfiguration 
 @RequestMapping ( value = { "/test" }, method = { RequestMethod . GET }) 
 public class TimeoutTestController { 
 
 private static final Logger logger = LoggerFactory . getLogger ( TimeoutTestController . class ); 
 
 /** 
 * main方法 
 * 
 * @param args 参数数组 
 */ 
 public static void main ( String args []) { 
 SpringApplication . run ( TimeoutTestController . class , args ); 
 } 
 
 /** 
 * 1.测试socketOutTimeout，三秒后返回数据 
 * 
 * @return 
 * @throws InterruptedException 
 */ 
 @RequestMapping ( value = { "/socket_timeout" }, method = { RequestMethod . GET }) 
 @ResponseBody 
 String socketTimeout () throws InterruptedException { 
 logger . info ( "socket_timeout" ); 
 Thread . sleep ( 3000 ); 
 return "socket_timeout" ; 
 } 
 
 /** 
 * 2.测试socketOutTimeout，每隔0.8秒返回数据 
 * 
 * @return 
 * @throws InterruptedException 
 */ 
 @RequestMapping ( value = { "/socket_timeout_2" }, method = { RequestMethod . GET }) 
 void socketTimeout2 ( HttpServletResponse response ) throws InterruptedException , IOException { 
 logger . info ( "socket_timeout_2" ); 
 for ( int i = 0 ; i < 10 ; i ++) { 
 logger . info ( "{}" , i ); 
 response . getWriter (). println ( "" + i ); 
 response . flushBuffer (); 
 Thread . sleep ( 800 ); 
 } 
 } 
 
 /** 
 * 3.测试connectionRequestTimeout用的服务，三秒后返回数据 
 * 
 * @param request 
 * @return 
 * @throws InterruptedException 
 */ 
 @RequestMapping ( value = { "/connection_request_timeout" }, method = { RequestMethod . GET }) 
 @ResponseBody 
 String connectionRequestTimeout ( HttpServletRequest request ) throws InterruptedException { 
 logger . info ( "{}" , request . getRequestURI ()); 
 Thread . sleep ( 3000 ); 
 return "connectionRequestTimeout" ; 
 } 
 }

如下是客户端的测试Case，下面几个Case分别测试了几个超时时间的各种情况，Case全部通过才可以

package me . nabil . demo . springbootdemo ; 
 
 import org.apache.http.client.ClientProtocolException ; 
 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.conn.ConnectTimeoutException ; 
 import org.apache.http.impl.client.CloseableHttpClient ; 
 import org.apache.http.impl.client.HttpClients ; 
 import org.apache.http.impl.conn.BasicHttpClientConnectionManager ; 
 import org.apache.http.impl.conn.PoolingHttpClientConnectionManager ; 
 import org.apache.http.util.EntityUtils ; 
 import org.junit.Assert ; 
 import org.junit.Test ; 
 
 import java.io.IOException ; 
 import java.net.SocketTimeoutException ; 
 import java.util.Date ; 
 import java.util.concurrent.ExecutorService ; 
 import java.util.concurrent.Executors ; 
 
 /** 
 * 测试HttpClient超时参数 
 * 
 * @author nabilzhang 
 */ 
 public class TimeoutTestControllerTest { 
 
 /** 
 * 1.connectionTimeout测试：IP无法链接，链接超时 
 * 
 * @throws Exception 
 */ 
 @Test 
 public void connectionTimeout () throws Exception { 
 CloseableHttpClient httpclient = HttpClients . createDefault (); 
 HttpGet httpGet = new HttpGet ( "http://74.125.203.100" ); 
 RequestConfig requestConfig = RequestConfig . custom (). setConnectionRequestTimeout ( 1000 ) 
 . setSocketTimeout ( 1000 ). setConnectTimeout ( 1000 ). build (); 
 httpGet . setConfig ( requestConfig ); 
 try { 
 httpclient . execute ( httpGet ); 
 } catch ( ConnectTimeoutException exception ) { 
 Assert . assertTrue ( exception . getMessage (). contains ( "connect timed out" )); 
 } 
 
 } 
 
 /** 
 * 2.socketTimeout测试，服务端没有指定时间内任何响应，会超时 
 * 
 * @throws Exception 
 */ 
 @Test 
 public void socketTimeout () throws Exception { 
 CloseableHttpClient httpclient = HttpClients . createDefault (); 
 HttpGet httpGet = new HttpGet ( "http://127.0.0.1:8080/test/socket_timeout" ); 
 RequestConfig requestConfig = RequestConfig . custom () 
 . setSocketTimeout ( 1000 ). build (); 
 httpGet . setConfig ( requestConfig ); 
 try { 
 httpclient . execute ( httpGet ); 
 } catch ( SocketTimeoutException exception ) { 
 Assert . assertEquals ( "Read timed out" , exception . getMessage ()); 
 } 
 } 
 
 /** 
 * 3.socketTimeout测试：服务端隔800ms返回一点数据,不会超时 
 * 
 * @throws Exception 
 */ 
 @Test 
 public void socketTimeoutNo () { 
 CloseableHttpClient httpclient = HttpClients . createDefault (); 
 HttpGet httpGet = new HttpGet ( "http://127.0.0.1:8080/test/socket_timeout_2" ); 
 RequestConfig requestConfig = RequestConfig . custom (). setConnectionRequestTimeout ( 1000 ) 
 . setSocketTimeout ( 1000 ). setConnectTimeout ( 1000 ). build (); 
 httpGet . setConfig ( requestConfig ); 
 
 try { 
 httpclient . execute ( httpGet ); 
 CloseableHttpResponse response = httpclient . execute ( httpGet ); 
 System . out . println ( String . format ( "socketTimeoutNo, %s" , EntityUtils . toString ( response . getEntity ()))); 
 } catch ( Exception e ) { 
 Assert . fail ( "服务端隔800ms返回一点数据,不会超时" ); 
 } 
 
 
 } 
 
 /** 
 * 4.connectionRequestTimeout测试:指从连接管理器(例如连接池)中拿到连接的超时时间 
 * 
 * @throws Exception 
 */ 
 @Test 
 public void connectionRequestTimeoutWithPoolingConnectionManager () throws Exception { 
 PoolingHttpClientConnectionManager conMgr = new PoolingHttpClientConnectionManager (); 
 conMgr . setMaxTotal ( 2 ); 
 
 final CloseableHttpClient httpclient = HttpClients . custom (). setConnectionManager ( conMgr ). build (); 
 final HttpGet httpGet = new HttpGet ( "http://127.0.0.1:8080/test/connection_request_timeout" ); 
 
 RequestConfig requestConfig = RequestConfig . custom (). setConnectTimeout ( 1000 ) 
 . setConnectionRequestTimeout ( 1000 ). setSocketTimeout ( 1000 ). build (); 
 httpGet . setConfig ( requestConfig ); 
 
 // 如下多线程占满连接池 
 ExecutorService executorService = Executors . newFixedThreadPool ( 10 ); 
 for ( int i = 0 ; i < 10 ; i ++) { 
 executorService . submit ( new Runnable () { 
 @Override 
 public void run () { 
 try { 
 CloseableHttpResponse response = httpclient . execute ( httpGet ); 
 System . out . println ( String . format ( "connectionRequestTimeoutTest: %s" , 
 EntityUtils . toString ( response . getEntity ()))); 
 } catch ( SocketTimeoutException exception ) { 
 System . out . println ( exception . getMessage ()); 
 } catch ( ClientProtocolException e ) { 
 e . printStackTrace (); 
 } catch ( IOException e ) { 
 e . printStackTrace (); 
 } 
 } 
 }); 
 } 
 
 // 在连接池占满的情况下，拿不到就会抛异常 
 try { 
 CloseableHttpResponse response = httpclient . execute ( httpGet ); 
 System . out . println ( String . format ( "connectionRequestTimeoutTest: %s" , 
 EntityUtils . toString ( response . getEntity ()))); 
 Assert . fail (); 
 } catch ( Exception exception ) { 
 // 异常是从连接池拿到连接超时 
 Assert . assertEquals ( "Timeout waiting for connection from pool" , exception . getMessage ()); 
 System . out . println ( exception . getMessage ()); 
 } 
 
 } 
 
 /** 
 * 5.connectionRequestTimeout测试，指从连接管理器中拿到连接的超时时间，由于使用基本的连接管理器，链接被占用时，直接无法分配链接 
 * connectionRequestTimeout并未生效，目前看来该参数只在连接池奏效. 
 * 该链接管理器(BasicHttpClientConnectionManager)是单线程情况下可以使用，多线程情况下不要使用。 
 * 
 * @throws Exception 
 */ 
 @Test 
 public void connectionRequestTimeoutWithBasicConnectionManager () throws Exception { 
 
 BasicHttpClientConnectionManager connManager = new BasicHttpClientConnectionManager (); 
 final CloseableHttpClient httpclient = HttpClients . custom () 
 . setConnectionManager ( connManager ). setMaxConnPerRoute ( 1 ). build (); 
 final HttpGet httpGet = new HttpGet ( "http://127.0.0.1:8080/test/connection_request_timeout" ); 
 
 RequestConfig requestConfig = RequestConfig . custom (). setConnectTimeout ( 100000 ) 
 . setConnectionRequestTimeout ( 1000000 ). setSocketTimeout ( 1000000 ). build (); 
 httpGet . setConfig ( requestConfig ); 
 
 // 如下多线程占满连接 
 ExecutorService executorService = Executors . newFixedThreadPool ( 10 ); 
 for ( int i = 0 ; i < 10 ; i ++) { 
 executorService . submit ( new Runnable () { 
 @Override 
 public void run () { 
 CloseableHttpResponse response = null ; 
 try { 
 response = httpclient . execute ( httpGet ); 
 System . out . println ( String . format ( "connectionRequestTimeoutTest: %s" , 
 EntityUtils . toString ( response . getEntity ()))); 
 } catch ( Exception exception ) { 
 exception . printStackTrace (); 
 } finally { 
 if ( response != null ) { 
 try { 
 response . close (); 
 httpclient . close (); 
 } catch ( IOException e ) { 
 e . printStackTrace (); 
 } 
 } 
 
 } 
 } 
 }); 
 } 
 System . out . println ( new Date ()); 
 
 // 在连接池占满的情况下，拿不到就会抛异常 
 try { 
 CloseableHttpResponse response = httpclient . execute ( httpGet ); 
 System . out . println ( String . format ( "connectionRequestTimeoutTest: %s" , 
 EntityUtils . toString ( response . getEntity ()))); 
 Assert . fail (); 
 } catch ( Exception exception ) { 
 System . out . println ( new Date ()); 
 exception . printStackTrace (); 
 // 异常是从连接池拿到连接超时 
 Assert . assertEquals ( "Connection is still allocated" , exception . getMessage ()); 
 System . out . println ( exception . getMessage ()); 
 } 
 
 } 
 
 }

注：上面Case是使用httpclient版本4.5.2测试所得。

<dependency> 
 <groupId>org.apache.httpcomponents </groupId> 
 <artifactId>httpclient </artifactId> 
 <version>4.5.2 </version> 
 <type>jar </type> 
 </dependency>

更深理解可以参照:[http://www.baeldung.com/httpclient-connection-management][http_www.baeldung.com_httpclient-connection-management]

[http_www.baeldung.com_httpclient-connection-management]: http://www.baeldung.com/httpclient-connection-management