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

使用ApacheHttpClient代替默认client

ApacheHttpClient和默认实现的比较
ApacheHttpClient使用

apache的HttpClient默认重试机制

maven
异常重试log
RetryExec
DefaultHttpRequestRetryHandler

使用ApacheHttpClient代替默认client
ApacheHttpClient和默认实现的比较

Feign在默认情况下使用的是JDK原生的URLConnection发送HTTP请求，没有连接池，但是对每个地址会保持一个长连接，即利用HTTP的persistence connection。
ApacheHttpClient实现了连接池，同时它封装了访问http的请求头，参数，内容体，响应等等，使客户端发送 HTTP 请求变得容易。

ApacheHttpClient 使用
maven 依赖

org.springframework.cloudspring-cloud-starter-openfeignorg.apache.httpcomponentshttpclient4.5.7io.github.openfeignfeign-httpclient10.1.0

配置文件的修改

feign:httpclient:enabled: true

创建ApacheHttpClient客户端

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; @Slf4jpublic 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 客户端验证，则需要指定 keyStoreif (keyStore == null || keyStore.isEmpty()) {return new ApacheHttpClient(); } else {try {sslContextBuilder.loadKeyMaterial(ResourceUtils.getFile(keyStore),keyStorePassword.toCharArray(),keyPassword.toCharArray()); } catch (Exception e) {e.printStackTrace(); }}// 如果 https 使用自签名证书，则需要指定 trustStoreif (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); }}}

使用时可以直接使用builder来创建ApacheHttpClient。

apache的HttpClient默认重试机制
maven

org.apache.httpcomponentshttpclient4.5.2

异常重试log

2017-01-31 19:31:39.057INFO 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.058INFO 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. * * Further responsibilities such as communication with the opposite * endpoint is delegated to the next executor in the request execution * chain. *
* * @since 4.3 */@Immutablepublic 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; }@Overridepublic 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 */@Immutablepublic 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.*/@Overridepublic 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 countreturn 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 idempotentreturn 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 sentreturn true; }// otherwise do not retryreturn 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)*/@Deprecatedprotected boolean requestIsAborted(final HttpRequest request) {HttpRequest req = request; if (request instanceof RequestWrapper) { // does not forward request to originalreq = ((RequestWrapper) request).getOriginal(); }return (req instanceof HttpUriRequest && ((HttpUriRequest)req).isAborted()); }}