SpringCloud Feign使用ApacheHttpClient代替默认client方式

             org.springframework.cloud         spring-cloud-starter-openfeign                   org.apache.httpcomponents         httpclient         4.5.7                   io.github.openfeign         feign-httpclient         10.1.0     

feign:   httpclient:     enabled: true

import javax.net.ssl.SSLContext; import lombok.extern.slf4j.Slf4j; import org.apache.http.conn.ssl.SSLConnectionSocketFactory; import org.apache.http.impl.client.CloseableHttpClient; import org.apache.http.impl.client.HttpClients; import org.apache.http.ssl.SSLContextBuilder; import org.apache.http.ssl.SSLContexts; import org.springframework.util.ResourceUtils; import feign.httpclient.ApacheHttpClient; @Slf4j public class FeignClientBuilder {   private boolean enabled;   private String keyPassword;   private String keyStore;   private String keyStorePassword;   private String trustStore;   private String trustStorePassword;   private int maxConnTotal = 2048;   private int maxConnPerRoute = 512;   public FeignClientBuilder(boolean enabled, String keyPassword, String keyStore, String keyStorePassword, String trustStore, String trustStorePassword, int maxConnTotal, int maxConnPerRoute) {     this.enabled = enabled;     this.keyPassword = keyPassword;     this.keyStore = keyStore;     this.keyStorePassword = keyStorePassword;     this.trustStore = trustStore;     this.trustStorePassword = trustStorePassword;     /**      * maxConnTotal是同时间正在使用的最多的连接数      */     this.maxConnTotal = maxConnTotal;     /**      * maxConnPerRoute是针对一个域名同时间正在使用的最多的连接数      */     this.maxConnPerRoute = maxConnPerRoute;   }   public ApacheHttpClient apacheHttpClient() {     CloseableHttpClient defaultHttpClient = HttpClients.custom()             .setMaxConnTotal(maxConnTotal)             .setMaxConnPerRoute(maxConnPerRoute)             .build();     ApacheHttpClient defaultApacheHttpClient = new ApacheHttpClient(defaultHttpClient);     if (!enabled) {       return defaultApacheHttpClient;     }     SSLContextBuilder sslContextBuilder = SSLContexts.custom();     // 如果 服务端启用了 TLS 客户端验证，则需要指定 keyStore     if (keyStore == null || keyStore.isEmpty()) {       return new ApacheHttpClient();     } else {       try {         sslContextBuilder                 .loadKeyMaterial(                         ResourceUtils.getFile(keyStore),                         keyStorePassword.toCharArray(),                         keyPassword.toCharArray());       } catch (Exception e) {         e.printStackTrace();       }     }     // 如果 https 使用自签名证书，则需要指定 trustStore     if (trustStore == null || trustStore.isEmpty()) {     } else {       try {         sslContextBuilder //        .loadTrustMaterial(TrustAllStrategy.INSTANCE)                 .loadTrustMaterial(                         ResourceUtils.getFile(trustStore),                         trustStorePassword.toCharArray()                 );       } catch (Exception e) {         e.printStackTrace();       }     }     try {       SSLContext sslContext = sslContextBuilder.build();       SSLConnectionSocketFactory sslsf = new SSLConnectionSocketFactory(               sslContext,               SSLConnectionSocketFactory.getDefaultHostnameVerifier());       CloseableHttpClient httpClient = HttpClients.custom()               .setMaxConnTotal(maxConnTotal)               .setMaxConnPerRoute(maxConnPerRoute)               .setSSLSocketFactory(sslsf)               .build();       ApacheHttpClient apacheHttpClient = new ApacheHttpClient(httpClient);       log.info("feign Client load with ssl.");       return apacheHttpClient;     } catch (Exception e) {       e.printStackTrace();     }     return defaultApacheHttpClient;   }   public static FeignClientBuilderBuilder builder() {     return new FeignClientBuilderBuilder();   }   public static class FeignClientBuilderBuilder {     private boolean enabled;     private String keyPassword;     private String keyStore;     private String keyStorePassword;     private String trustStore;     private String trustStorePassword;     private int maxConnTotal = 2048;     private int maxConnPerRoute = 512;     public FeignClientBuilderBuilder enabled(boolean enabled) {       this.enabled = enabled;       return this;     }     public FeignClientBuilderBuilder keyPassword(String keyPassword) {       this.keyPassword = keyPassword;       return this;     }     public FeignClientBuilderBuilder keyStore(String keyStore) {       this.keyStore = keyStore;       return this;     }     public FeignClientBuilderBuilder keyStorePassword(String keyStorePassword) {       this.keyStorePassword = keyStorePassword;       return this;     }     public FeignClientBuilderBuilder trustStore(String trustStore) {       this.trustStore = trustStore;       return this;     }     public FeignClientBuilderBuilder trustStorePassword(String trustStorePassword) {       this.trustStorePassword = trustStorePassword;       return this;     }     public FeignClientBuilderBuilder maxConnTotal(int maxConnTotal) {       this.maxConnTotal = maxConnTotal;       return this;     }     public FeignClientBuilderBuilder maxConnPerRoute(int maxConnPerRoute) {       this.maxConnPerRoute = maxConnPerRoute;       return this;     }     public FeignClientBuilder build() {       return new FeignClientBuilder(               this.enabled,               this.keyPassword,               this.keyStore,               this.keyStorePassword,               this.trustStore,               this.trustStorePassword,               this.maxConnTotal,               this.maxConnPerRoute       );     }   } }

                     org.apache.httpcomponents             httpclient             4.5.2         

/**  * 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.  * 
  * Further responsibilities such as communication with the opposite  * endpoint is delegated to the next executor in the request execution  * chain.  * 
  *  * @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;                     }                 }             }         }     } }

/**  * 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> 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> clazzes) {         super();         this.retryCount = retryCount;         this.requestSentRetryEnabled = requestSentRetryEnabled;         this.nonRetriableClasses = new HashSet>();         for (final Class clazz: clazzes) {             this.nonRetriableClasses.add(clazz);         }     }     /**      * Create the request retry handler using the following list of      * non-retriable IOException classes: 
      * 
      * 
InterruptedIOException
      * 
UnknownHostException
      * 
ConnectException
      * 
SSLException
      * 
      * @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: 
      * 
      * 
InterruptedIOException
      * 
UnknownHostException
      * 
ConnectException
      * 
SSLException
      * 
      */     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 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());     } }