apache的HttpClient的默认重试机制

傷城~ 2021-06-24 15:58 1354阅读 0赞

## maven ##

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

## 异常重试log ##

2017-01-31 19:31:39.057  INFO 3873 --- [askScheduler-13] o.apache.http.impl.execchain.RetryExec   : I/O exception (org.apache.http.NoHttpResponseException) caught when processing request to {}->http://192.168.99.100:8080: The target server failed to respond
    2017-01-31 19:31:39.058  INFO 3873 --- [askScheduler-13] o.apache.http.impl.execchain.RetryExec   : Retrying request to {}->http://192.168.99.100:8080

## RetryExec ##

org/apache/http/impl/execchain/RetryExec.java

/** * Request executor in the request execution chain that is responsible * for making a decision whether a request failed due to an I/O error * should be re-executed. * <p> * Further responsibilities such as communication with the opposite * endpoint is delegated to the next executor in the request execution * chain. * </p> * * @since 4.3 */
    @Immutable
    public class RetryExec implements ClientExecChain {
    
        private final Log log = LogFactory.getLog(getClass());
    
        private final ClientExecChain requestExecutor;
        private final HttpRequestRetryHandler retryHandler;
    
        public RetryExec(
                final ClientExecChain requestExecutor,
                final HttpRequestRetryHandler retryHandler) {
            Args.notNull(requestExecutor, "HTTP request executor");
            Args.notNull(retryHandler, "HTTP request retry handler");
            this.requestExecutor = requestExecutor;
            this.retryHandler = retryHandler;
        }
    
        @Override
        public CloseableHttpResponse execute(
                final HttpRoute route,
                final HttpRequestWrapper request,
                final HttpClientContext context,
                final HttpExecutionAware execAware) throws IOException, HttpException {
            Args.notNull(route, "HTTP route");
            Args.notNull(request, "HTTP request");
            Args.notNull(context, "HTTP context");
            final Header[] origheaders = request.getAllHeaders();
            for (int execCount = 1;; execCount++) {
                try {
                    return this.requestExecutor.execute(route, request, context, execAware);
                } catch (final IOException ex) {
                    if (execAware != null && execAware.isAborted()) {
                        this.log.debug("Request has been aborted");
                        throw ex;
                    }
                    if (retryHandler.retryRequest(ex, execCount, context)) {
                        if (this.log.isInfoEnabled()) {
                            this.log.info("I/O exception ("+ ex.getClass().getName() +
                                    ") caught when processing request to "
                                    + route +
                                    ": "
                                    + ex.getMessage());
                        }
                        if (this.log.isDebugEnabled()) {
                            this.log.debug(ex.getMessage(), ex);
                        }
                        if (!RequestEntityProxy.isRepeatable(request)) {
                            this.log.debug("Cannot retry non-repeatable request");
                            throw new NonRepeatableRequestException("Cannot retry request " +
                                    "with a non-repeatable request entity", ex);
                        }
                        request.setHeaders(origheaders);
                        if (this.log.isInfoEnabled()) {
                            this.log.info("Retrying request to " + route);
                        }
                    } else {
                        if (ex instanceof NoHttpResponseException) {
                            final NoHttpResponseException updatedex = new NoHttpResponseException(
                                    route.getTargetHost().toHostString() + " failed to respond");
                            updatedex.setStackTrace(ex.getStackTrace());
                            throw updatedex;
                        } else {
                            throw ex;
                        }
                    }
                }
            }
        }
    
    }

## DefaultHttpRequestRetryHandler ##

org/apache/http/impl/client/DefaultHttpRequestRetryHandler.java

/** * The default { @link HttpRequestRetryHandler} used by request executors. * * @since 4.0 */
    @Immutable
    public class DefaultHttpRequestRetryHandler implements HttpRequestRetryHandler {
    
        public static final DefaultHttpRequestRetryHandler INSTANCE = new DefaultHttpRequestRetryHandler();
    
        /** the number of times a method will be retried */
        private final int retryCount;
    
        /** Whether or not methods that have successfully sent their request will be retried */
        private final boolean requestSentRetryEnabled;
    
        private final Set<Class<? extends IOException>> nonRetriableClasses;
    
        /** * Create the request retry handler using the specified IOException classes * * @param retryCount how many times to retry; 0 means no retries * @param requestSentRetryEnabled true if it's OK to retry requests that have been sent * @param clazzes the IOException types that should not be retried * @since 4.3 */
        protected DefaultHttpRequestRetryHandler( final int retryCount, final boolean requestSentRetryEnabled, final Collection<Class<? extends IOException>> clazzes) {
            super();
            this.retryCount = retryCount;
            this.requestSentRetryEnabled = requestSentRetryEnabled;
            this.nonRetriableClasses = new HashSet<Class<? extends IOException>>();
            for (final Class<? extends IOException> clazz: clazzes) {
                this.nonRetriableClasses.add(clazz);
            }
        }
    
        /** * Create the request retry handler using the following list of * non-retriable IOException classes: <br> * <ul> * <li>InterruptedIOException</li> * <li>UnknownHostException</li> * <li>ConnectException</li> * <li>SSLException</li> * </ul> * @param retryCount how many times to retry; 0 means no retries * @param requestSentRetryEnabled true if it's OK to retry non-idempotent requests that have been sent */
        @SuppressWarnings("unchecked")
        public DefaultHttpRequestRetryHandler(final int retryCount, final boolean requestSentRetryEnabled) {
            this(retryCount, requestSentRetryEnabled, Arrays.asList(
                    InterruptedIOException.class,
                    UnknownHostException.class,
                    ConnectException.class,
                    SSLException.class));
        }
    
        /** * Create the request retry handler with a retry count of 3, requestSentRetryEnabled false * and using the following list of non-retriable IOException classes: <br> * <ul> * <li>InterruptedIOException</li> * <li>UnknownHostException</li> * <li>ConnectException</li> * <li>SSLException</li> * </ul> */
        public DefaultHttpRequestRetryHandler() {
            this(3, false);
        }
        /** * Used { @code retryCount} and { @code requestSentRetryEnabled} to determine * if the given method should be retried. */
        @Override
        public boolean retryRequest( final IOException exception, final int executionCount, final HttpContext context) {
            Args.notNull(exception, "Exception parameter");
            Args.notNull(context, "HTTP context");
            if (executionCount > this.retryCount) {
                // Do not retry if over max retry count
                return false;
            }
            if (this.nonRetriableClasses.contains(exception.getClass())) {
                return false;
            } else {
                for (final Class<? extends IOException> rejectException : this.nonRetriableClasses) {
                    if (rejectException.isInstance(exception)) {
                        return false;
                    }
                }
            }
            final HttpClientContext clientContext = HttpClientContext.adapt(context);
            final HttpRequest request = clientContext.getRequest();
    
            if(requestIsAborted(request)){
                return false;
            }
    
            if (handleAsIdempotent(request)) {
                // Retry if the request is considered idempotent
                return true;
            }
    
            if (!clientContext.isRequestSent() || this.requestSentRetryEnabled) {
                // Retry if the request has not been sent fully or
                // if it's OK to retry methods that have been sent
                return true;
            }
            // otherwise do not retry
            return false;
        }
    
        /** * @return { @code true} if this handler will retry methods that have * successfully sent their request, { @code false} otherwise */
        public boolean isRequestSentRetryEnabled() {
            return requestSentRetryEnabled;
        }
    
        /** * @return the maximum number of times a method will be retried */
        public int getRetryCount() {
            return retryCount;
        }
    
        /** * @since 4.2 */
        protected boolean handleAsIdempotent(final HttpRequest request) {
            return !(request instanceof HttpEntityEnclosingRequest);
        }
    
        /** * @since 4.2 * * @deprecated (4.3) */
        @Deprecated
        protected boolean requestIsAborted(final HttpRequest request) {
            HttpRequest req = request;
            if (request instanceof RequestWrapper) { // does not forward request to original
                req = ((RequestWrapper) request).getOriginal();
            }
            return (req instanceof HttpUriRequest && ((HttpUriRequest)req).isAborted());
        }
    
    }

> 默认重试3次，三次都失败则抛出NoHttpResponseException或其他异常

## doc ##

*  [Apache HttpComponents][]

[Apache HttpComponents]: http://hc.apache.org/