深入理解Feign的负载均衡 失败重试 熔断
feign的组成
1.Hystri 将每一个fegin请求封装成一个命令 通过执行命令来控制请求hystrixCommand.execute()
2.Feign通过动态代理把最终请求的执行放在了SynchronousMethodHandler.invoke（同步的方法执行器）
3.Feign请求通过ribbon负载均衡，来获取注册在eureka上的服务的IP+端口
4.默认通过java自带的HttpURLConnection来发送http请求
逻辑上 Hystri + ribbon + HttpURLConnection = Feign
看一下调用的链路
feign的配置
我们已
#开启feign的熔断降级 默认为false是不开启熔断的
#feign.hystrix.enabled =
#hystrix熔断的超时时间（等待该时长未得到返回就执行降级的策略）
#hystrix.command.default.execution.isolation.thread.timeoutInMilliseconds =
#ribbon的读取超时时间
#ribbon.ReadTimeout =
#ribbon的连接超时时间
#ribbon.ConnectTimeout =
#feign的连接超时时间
#feign.client.config.default.connectTimeout =
#feign的读取超时时间
#feign.client.config.default.readTimeout =
feign时间的默认配置Request.Options 连接超时10s 读取超时60s
Ribbon的默认配置类 DefaultClientConfigImpl 读取超时时间5s 连接超时时间2s
我们来测试一下这个需要准备两个服务和一个注册中心，我只把两个服务里面的两个方法贴出来 A服务通过feign来调用B服务
A服务方法
@Autowired
private FeignClientProperties feignClientProperties;
@ApiOperation(value = "降级测试", httpMethod = "GET")
@RequestMapping("/normal")
public Object normal() {
long start = System.currentTimeMillis();
System.out.println("进入方法=====");
Result result = invoiceService.queryCloudEasyOrderInfo2("");
long end = System.currentTimeMillis();
System.out.println("花费的时间"+(end-start));
System.out.println("调用发票服务返回结果 result="+result);
return result;
}
B服务的方法 post请求（ribbon的重试自动屏蔽掉post请求）
public Result<OrderHistory> queryCloudEasyOrderInfo(String orderNo) {
try {
System.out.println("请求来了=====================");
//方法处理耗时是1s钟
Thread.sleep(1000);
}catch (Exception e){
return null;
}
}
1.fegin的所有配置都是默认的都不做配置（配置文件未做配置，代码里面配置了Retryer）
A服务日志
B服务的日志
因为有重试机制所以总共调用了5次。每次调用的的时间差大概就是1s多。
思考：1.方法耗时1s钟 feign读取超时时5s为什么还是没有成功呢？
2.调用失败重试了5次，每次这个时间间隔时哪里设置的（这个1s时谁的默认）？
答案：feign的读取超时时间时针对整个调用过程
每次的http请求，建立socket连接，等待响应 这个过程在HttpURLConnection内完成 的，它的默认读取超时时间时1s。所以只要1s内没有响应那么这一次的调用就是失败的。但是整个feign调用还没有结束，会继续重试。
2.只配置这两个值
feign.client.config.default.connectTimeout = 3000
feign.client.config.default.readTimeout = 3000
A服务日志
进入方法=====2021-04-16T15:45:41.658
2021-04-16 15:45:57.886 [http-nio-8081-exec-3] ERROR o.a.c.c.C.[.[localhost].[/].[dispatcherServlet] - Servlet.service() for servlet [dispatcherServlet] in context with path [] threw exception [Request processing failed; nested exception is feign.RetryableException: Read timed out executing POST http://broker-invoice-service/api/cloudeasy/order/operation/queryCloudEasyOrderInfo?orderNo] with root cause
java.net.SocketTimeoutException: Read timed out
at java.net.SocketInputStream.socketRead0(Native Method)
feign整个调用的时间是 3s*5=15s
B服务的日志
[broker-invoice-service] [TID: N/A] >> 2021-04-16 15:45:41.662 ERROR [,eaba7ae3a40b96b1,eaba7ae3a40b96b1,false] 29516 --- [nio-8857-exec-7] c.c.b.c.i.u.interceptor.RequestAop required
请求来了=====================时间2021-04-16T15:45:41.663
[broker-invoice-service] [TID: N/A] >> 2021-04-16 15:45:44.812 ERROR [,85234dd79c50cf69,85234dd79c50cf69,false] 29516 --- [nio-8857-exec-2] c.c.b.c.i.u.interceptor.RequestAop required
请求来了=====================时间2021-04-16T15:45:44.812
[broker-invoice-service] [TID: N/A] >> 2021-04-16 15:45:48.038 ERROR [,eef74f3d48abc37c,eef74f3d48abc37c,false] 29516 --- [nio-8857-exec-8] c.c.b.c.i.u.interceptor.RequestAop required
请求来了=====================时间2021-04-16T15:45:48.038
[broker-invoice-service] [TID: N/A] >> 2021-04-16 15:45:51.377 ERROR [,1eea8198257057a1,1eea8198257057a1,false] 29516 --- [nio-8857-exec-4] c.c.b.c.i.u.interceptor.RequestAop required
请求来了=====================时间2021-04-16T15:45:51.378
[broker-invoice-service] [TID: N/A] >> 2021-04-16 15:45:54.884 ERROR [,394f79e805f3602f,394f79e805f3602f,false] 29516 --- [io-8857-exec-10] c.c.b.c.i.u.interceptor.RequestAop required
请求来了=====================时间2021-04-16T15:45:54.884
每次重试的时间间隔是3s
重试机制
feign的重试机制默认试关闭的（在上面的demo我们试配置了feign的重试的）。
// feign 默认的重试
Retryer NEVER_RETRY = new Retryer() {
@Override
public void continueOrPropagate(RetryableException e) {
throw e;
}
@Override
public Retryer clone() {
return this;
}
};
feign的重试底层需要依赖spring-retry 开启需要做如下配置
引入依赖
<dependency>
<groupId>org.springframework.retry</groupId>
<artifactId>spring-retry</artifactId>
<version>1.2.4.RELEASE</version>
</dependency>
配置feign的重试
@Bean
public Retryer feignRetryer() {
return new Retryer.Default();
}
feign重试的部分代码
public Object invoke(Object[] argv) throws Throwable {
RequestTemplate template = buildTemplateFromArgs.create(argv);
//初始化重试的机制
Retryer retryer = this.retryer.clone();
while (true) {
try {
//不断的重试执行这个方法
return executeAndDecode(template);
} catch (RetryableException e) {
try {
//如果发生异常就执行continueOrPropagate方法
retryer.continueOrPropagate(e);
} catch (RetryableException th) {
Throwable cause = th.getCause();
if (propagationPolicy == UNWRAP && cause != null) {
throw cause;
} else {
throw th;
}
}
if (logLevel != Logger.Level.NONE) {
logger.logRetry(metadata.configKey(), logLevel);
}
continue;
}
}
}
public void continueOrPropagate(RetryableException e) {
//判断重试的次数是否到达上限
if (attempt++ >= maxAttempts) {
throw e;
}
long interval;
if (e.retryAfter() != null) {
interval = e.retryAfter().getTime() - currentTimeMillis();
//判断时间间隔
if (interval > maxPeriod) {
interval = maxPeriod;
}
if (interval < 0) {
return;
}
} else {
interval = nextMaxInterval();
}
try {
Thread.sleep(interval);
} catch (InterruptedException ignored) {
Thread.currentThread().interrupt();
throw e;
}
sleptForMillis += interval;
}
在上面的测试超时时间的时候我们feign的重试是配置了的。
ribbon的重试和feign的重试是完全分离开的，可以理解成feign是外面一层的重试，ribbon是里面一层的重试，ribbon的重试当前版本只对get请求有效默认开启。我们先看一下ribbon重试的几个配置
#对下一个实例的重试次数 默认1
ribbon.MaxAutoRetriesNextServer=1
#对当前实例的重试次数 默认0
ribbon.MaxAutoRetries=0
#对所有操作都重试（这个配置是无效的）
ribbon.OKToRetryOnAllOperations=true
我们把B服务的请求改成GET请求 所有的配置都是默认（不做任何配置）A服务请求B服务
B服务如果只有一个实例该请求在该实例只执行一次。
如果B服务有两个实例该请求在两个实例分别执行一次。
只配置这个
ribbon.MaxAutoRetries=1 查看两个实例的日志 实例a
实例b
两个实例各执行了两次。要理解这个配置ribbon.MaxAutoRetries 首先要理解当前实例
请求调用实例a当前实例就是a,第一次调用失败后就会有重试（重试的前提是调用失败），对当前的a实例重试1次，默认调用下一个实例1次，调用实例b,当前实例就是b,调用失败执行重试的策略，对当前实例的重试1次即对b重试一次。
为什么说 ribbon.OKToRetryOnAllOperations=true
这个配置是无效
DefaultLoadBalancerRetryHandler下面的方法就是用到我们配置的方法
public DefaultLoadBalancerRetryHandler(IClientConfig clientConfig) {
this.retrySameServer = clientConfig.get(CommonClientConfigKey.MaxAutoRetries, DefaultClientConfigImpl.DEFAULT_MAX_AUTO_RETRIES);
this.retryNextServer = clientConfig.get(CommonClientConfigKey.MaxAutoRetriesNextServer, DefaultClientConfigImpl.DEFAULT_MAX_AUTO_RETRIES_NEXT_SERVER);
// OkToRetryOnAllOperations 属性没有从配置里面取，直接默认false
this.retryEnabled = clientConfig.get(CommonClientConfigKey.OkToRetryOnAllOperations, false);
}
RibbonLoadBalancedRetryPolicy重试的策略
public boolean canRetry(LoadBalancedRetryContext context) {
HttpMethod method = context.getRequest().getMethod();
//GET方法 或者OkToRetryOnAllOperations为true
return HttpMethod.GET == method || lbContext.isOkToRetryOnAllOperations();
}
@Override
public boolean canRetrySameServer(LoadBalancedRetryContext context) {
return sameServerCount < lbContext.getRetryHandler().getMaxRetriesOnSameServer()
&& canRetry(context);
}
@Override
public boolean canRetryNextServer(LoadBalancedRetryContext context) {
// this will be called after a failure occurs and we increment the counter
// so we check that the count is less than or equals to too make sure
// we try the next server the right number of times
return nextServerCount <= lbContext.getRetryHandler().getMaxRetriesOnNextServer()
&& canRetry(context);
}
断点验证
我们的配置
前两个都生效了只有OKToRetryOnAllOperations还是false.
RetryableFeignLoadBalancer
@Override
public RibbonResponse execute(final RibbonRequest request,
IClientConfig configOverride) throws IOException {
final Request.Options options;
if (configOverride != null) {
RibbonProperties ribbon = RibbonProperties.from(configOverride);
options = new Request.Options(ribbon.connectTimeout(this.connectTimeout),
ribbon.readTimeout(this.readTimeout));
}
else {
options = new Request.Options(this.connectTimeout, this.readTimeout);
}
final LoadBalancedRetryPolicy retryPolicy = this.loadBalancedRetryFactory
.createRetryPolicy(this.getClientName(), this);
RetryTemplate retryTemplate = new RetryTemplate();
BackOffPolicy backOffPolicy = this.loadBalancedRetryFactory
.createBackOffPolicy(this.getClientName());
retryTemplate.setBackOffPolicy(
backOffPolicy == null ? new NoBackOffPolicy() : backOffPolicy);
RetryListener[] retryListeners = this.loadBalancedRetryFactory
.createRetryListeners(this.getClientName());
if (retryListeners != null && retryListeners.length != 0) {
retryTemplate.setListeners(retryListeners);
}
retryTemplate.setRetryPolicy(retryPolicy == null ? new NeverRetryPolicy()
: new FeignRetryPolicy(request.toHttpRequest(), retryPolicy, this,
this.getClientName()));
return retryTemplate.execute(new RetryCallback<RibbonResponse, IOException>() {
//这个方法的重试就是ribbon的重试
@Override
public RibbonResponse doWithRetry(RetryContext retryContext)
throws IOException {
Request feignRequest = null;
// on retries the policy will choose the server and set it in the context
// extract the server and update the request being made
if (retryContext instanceof LoadBalancedRetryContext) {
ServiceInstance service = ((LoadBalancedRetryContext) retryContext)
.getServiceInstance();
if (service != null) {
feignRequest = ((RibbonRequest) request
.replaceUri(reconstructURIWithServer(
new Server(service.getHost(), service.getPort()),
request.getUri()))).toRequest();
}
}
if (feignRequest == null) {
feignRequest = request.toRequest();
}
Response response = request.client().execute(feignRequest, options);
if (retryPolicy != null
&& retryPolicy.retryableStatusCode(response.status())) {
byte[] byteArray = response.body() == null ? new byte[] {}
: StreamUtils
.copyToByteArray(response.body().asInputStream());
response.close();
throw new RibbonResponseStatusCodeException(
RetryableFeignLoadBalancer.this.clientName, response,
byteArray, request.getUri());
}
return new RibbonResponse(request.getUri(), response);
}
}, new LoadBalancedRecoveryCallback<RibbonResponse, Response>() {
@Override
protected RibbonResponse createResponse(Response response, URI uri) {
return new RibbonResponse(uri, response);
}
});
}