ErrorDecoder Spring Cloud OpenFeign 重试机制及其源码分析

文章目录

Retryer接口OpenFeign中提供的Retryer接口的两个实现Retryer.Default

重试的源码分析asyncResponseHandler.handleResponse源码解析

ErrorDecoder源码分析OpenFeign默认使用的ErrorDecoder是ErrorDecoder.Default

总结

Retryer接口

Retryer接口的实现主要是continueOrPropagate方法，该方法主要用于判断是否可以重试，具体的判断逻辑，我们在下面介绍

void continueOrPropagate(RetryableException e);

Retryer clone(); //Retryer继承了Cloneable接口

OpenFeign中提供的Retryer接口的两个实现

Retryer.Default：OpenFeign中提供的默认的重试实现Retryer.NEVER_RETRY：在无任何自定义配置的情况下，OpenFeign使用该重试配置，表示不重试。其配置在FeignClientsConfiguration中：

@Bean

@ConditionalOnMissingBean

public Retryer feignRetryer() {

return Retryer.NEVER_RETRY;

}

我们可以自定义覆盖该配置，来设置重试接口。

Retryer.Default

源码如下，我们做了一些基本的说明

class Default implements Retryer {

private final int maxAttempts; // 最大尝试次数

private final long period; // 间隔时间

private final long maxPeriod; // 最大间隔时间

int attempt; // 当前尝试了多少次

long sleptForMillis; // 已休眠了多久

public Default() {

this(100, SECONDS.toMillis(1), 5);

}

public Default(long period, long maxPeriod, int maxAttempts) {

this.period = period;

this.maxPeriod = maxPeriod;

this.maxAttempts = maxAttempts;

this.attempt = 1;

}

protected long currentTimeMillis() {

return System.currentTimeMillis();

}

public void continueOrPropagate(RetryableException e) {

if (attempt++ >= maxAttempts) { // 超过最大尝试次数，则直接抛出异常e

throw e;

}

long interval;// 实际的间隔时间

if (e.retryAfter() != null) {

// retryAfter是RetryableException抛出时设置的，这个我们在将ErrorEncoder的时候再说

interval = e.retryAfter().getTime() - currentTimeMillis();

if (interval > maxPeriod) {

interval = maxPeriod;

}

if (interval < 0) {

return;

}

} else {

// retryAfter 为null将使用period 来计算间隔时间

interval = nextMaxInterval();

}

try {

Thread.sleep(interval);// 休眠interval毫秒

} catch (InterruptedException ignored) {

Thread.currentThread().interrupt();

throw e;

}

sleptForMillis += interval;

}

long nextMaxInterval() {

long interval = (long) (period * Math.pow(1.5, attempt - 1));

return interval > maxPeriod ? maxPeriod : interval;

}

@Override

public Retryer clone() {

return new Default(period, maxPeriod, maxAttempts);

}

}

Retryer.Default的continueOrPropagate方法，主要就是计算实际的间隔时间，然后线程休眠对应的时间，如果达到重试次数，则把RetryableException抛出

重试的源码分析

我们在前文中已经提到，每次的FeignClient调用，主要就是SynchronousMethodHandler的invoke和executeAndDecode方法，我们再次来看看这两个方法

public Object invoke(Object[] argv) throws Throwable {

RequestTemplate template = buildTemplateFromArgs.create(argv);

Options options = findOptions(argv);

Retryer retryer = this.retryer.clone(); // 克隆Retryer

while (true) {// 重试循环

try {

// 执行并decode

return executeAndDecode(template, options);

} catch (RetryableException e) {// catch RetryableException异常

try {

// 执行retryery接口的continueOrPropagate方法

retryer.continueOrPropagate(e);

} catch (RetryableException th) {

// 如果continueOrPropagate接着抛出RetryableException 异常，则不再重试

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;

}

}

}

Object executeAndDecode(RequestTemplate template, Options options) throws Throwable {

Request request = targetRequest(template);

if (logLevel != Logger.Level.NONE) {

logger.logRequest(metadata.configKey(), logLevel, request);

}

Response response;

long start = System.nanoTime();

try {

response = client.execute(request, options);

// ensure the request is set. TODO: remove in Feign 12

response = response.toBuilder()

.request(request)

.requestTemplate(template)

.build();

} catch (IOException e) {

if (logLevel != Logger.Level.NONE) {

logger.logIOException(metadata.configKey(), logLevel, e, elapsedTime(start));

}

// 执行请求时，如果出现IOException，则认为是请求时网络波动等问题影响了请求，尝试重试

// errorExecuting方法是FeignException类下静态方法

// import static feign.FeignException.errorExecuting;

// 该方法直接抛出RetryableException

throw errorExecuting(request, e);

}

long elapsedTime = TimeUnit.NANOSECONDS.toMillis(System.nanoTime() - start);

if (decoder != null)

return decoder.decode(response, metadata.returnType());

CompletableFuture