使用Apache HttpClient 4.x进行异常重试

在进行http请求时，难免会遇到请求失败的情况，失败后需要重新请求，尝试再次获取数据。

Apache的HttpClient提供了异常重试机制，在该机制中，我们可以很灵活的定义在哪些异常情况下进行重试。

重试前提

被请求的方法必须是幂等的：就是多次请求服务端结果应该是准确且一致的。

适合的方法：比如根据ID，修改人员姓名，无论请求多次结果都是一样，这就是幂等。 

不适合的方法：比如减少账号50元，多次请求将多次扣减。

实现方式

想要实现异常重试，需要实现它提供的一个接口  HttpRequestRetryHandler ，并实现 retryRequest 方法。然后set到HttpClient中。该httpClient就具备了重试机制。

 

HttpClient自身提供了 StandardHttpRequestRetryHandler 和 DefaultHttpRequestRetryHandler 两个实现类。 DefaultHttpRequestRetryHandler 继承自 DefaultHttpRequestRetryHandler ， StandardHttpRequestRetryHandler 默认几个方法为幂等，如PUT、GET、HEAD等除POST外的方法，如果自定义可以参考它的实现方式。

 

代码如下：

 import java.io.IOException;
 import java.io.InterruptedIOException;
 import java.net.ConnectException;
 import java.net.UnknownHostException;

 import javax.net.ssl.SSLException;

 import org.apache.commons.lang3.ObjectUtils;
 import org.apache.commons.lang3.StringUtils;
 import org.apache.http.Consts;
 import org.apache.http.HttpEntityEnclosingRequest;
 import org.apache.http.HttpRequest;
 import org.apache.http.HttpStatus;
 import org.apache.http.ParseException;
 import org.apache.http.client.HttpRequestRetryHandler;
 import org.apache.http.client.config.RequestConfig;
 import org.apache.http.client.methods.CloseableHttpResponse;
 import org.apache.http.client.methods.HttpPost;
 import org.apache.http.client.protocol.HttpClientContext;
 import org.apache.http.entity.ContentType;
 import org.apache.http.entity.StringEntity;
 import org.apache.http.impl.client.CloseableHttpClient;
 import org.apache.http.impl.client.HttpClients;
 import org.apache.http.protocol.HttpContext;
 import org.apache.http.util.EntityUtils;

 /**
  * @author  *
  * @date 2017年5月18日 上午9:17:30
  *
  * @Description
  */
 public class HttpPostUtils {
     /**
      *
      * @param uri
      *            the request address
      * @param json
      *            the request data that must be a JSON string
      * @param retryCount
      *            the number of times this method has been unsuccessfully
      *            executed
      * @param connectTimeout
      *            the timeout in milliseconds until a connection is established
      * @param connectionRequestTimeout
      *            the timeout in milliseconds used when requesting a connection
      *            from the connection manager
      * @param socketTimeout
      *            the socket timeout in milliseconds, which is the timeout for
      *            waiting for data or, put differently, a maximum period
      *            inactivity between two consecutive data packets
      * @return null when method parameter is null, "", " "
      * @throws IOException
      *             if HTTP connection can not opened or closed successfully
      * @throws ParseException
      *             if response data can not be parsed successfully
      */
     public String retryPostJson(String uri, String json, int retryCount, int connectTimeout,
             int connectionRequestTimeout, int socketTimeout) throws IOException, ParseException {
         if (StringUtils.isAnyBlank(uri, json)) {
             return null;
         }

         HttpRequestRetryHandler httpRequestRetryHandler = new HttpRequestRetryHandler() {

             @Override
             public boolean retryRequest(IOException exception, int executionCount, HttpContext context) {
                 if (executionCount > retryCount) {
                     // Do not retry if over max retry count
                     return false;
                 }
                 if (exception instanceof InterruptedIOException) {
                     // An input or output transfer has been terminated
                     return false;
                 }
                 if (exception instanceof UnknownHostException) {
                     // Unknown host 修改代码让不识别主机时重试，实际业务当不识别的时候不应该重试，再次为了演示重试过程，执行会显示retryCount次下面的输出
                     System.out.println("不识别主机重试"); return true;
                 }
                 if (exception instanceof ConnectException) {
                     // Connection refused
                     return false;
                 }
                 if (exception instanceof SSLException) {
                     // SSL handshake exception
                     return false;
                 }
                 HttpClientContext clientContext = HttpClientContext.adapt(context);
                 HttpRequest request = clientContext.getRequest();
                 boolean idempotent = !(request instanceof HttpEntityEnclosingRequest);
                 if (idempotent) {
                     // Retry if the request is considered idempotent
                     return true;
                 }
                 return false;
             }
         };

         CloseableHttpClient client = HttpClients.custom().setRetryHandler(httpRequestRetryHandler).build();
         HttpPost post = new HttpPost(uri);
         // Create request data
         StringEntity entity = new StringEntity(json, ContentType.APPLICATION_JSON);
         // Set request body
         post.setEntity(entity);

         RequestConfig config = RequestConfig.custom().setConnectTimeout(connectTimeout)
                 .setConnectionRequestTimeout(connectionRequestTimeout).setSocketTimeout(socketTimeout).build();
         post.setConfig(config);
         // Response content
         String responseContent = null;
         CloseableHttpResponse response = null;
         try {
             response = client.execute(post, HttpClientContext.create());
             if (response.getStatusLine().getStatusCode() == HttpStatus.SC_OK) {
                 responseContent = EntityUtils.toString(response.getEntity(), Consts.UTF_8.name());
             }
         } finally {
             if (ObjectUtils.anyNotNull(response)) {
                 response.close();
             }
             if (ObjectUtils.anyNotNull(client)) {
                 client.close();
             }
         }
         return responseContent;
     }

在实现的 retryRequest 方法中，遇到不识别主机异常，返回 true ，请求将重试。最多重试请求retryCount次。