Feign详解4- Retryer 源码分析

矫情吗；* 2022-11-20 06:00 262阅读 0赞

Retryer是重试器，主要负责Feign请求失败后的重试请求的发起. 它也要装配到Feign的Builder中.

public abstract class Feign {
        ....
       public static class Builder {
          private Retryer retryer = new Retryer.Default();
          ....
       }
    }

它也是一个接口，里面也提供了一个默认实现。 下面分析源码架构：

public interface Retryer extends Cloneable {
    
      //待实现的方法：  如果要重试，则return， 如果不能重试或指标超出阈值，则抛出异常。
      void continueOrPropagate(RetryableException e);
    
      Retryer clone();
    
      //默认的实现类
      class Default implements Retryer {
    
        private final int maxAttempts;  //最多尝试次数
        private final long period;      //时间间隔
        private final long maxPeriod;   //最大间隔
        int attempt;       //当前尝试次数
        long sleptForMillis;   //睡眠时间
    
       
      }
    
      //不发起重试的对象
      Retryer NEVER_RETRY = new Retryer() {
    
       ...
      };
    }

这其中   continueOrPropagate 非常重要：

public void continueOrPropagate(RetryableException e) {
          if (attempt++ >= maxAttempts) {  //判断是否已经重试了超过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);          //睡眠 interval .
          } catch (InterruptedException ignored) {
            Thread.currentThread().interrupt();
            throw e;
          }
          sleptForMillis += interval;
     }

那么这个Retryer是如何使用的呢，这就要看   SynchronousMethodHandler 这个类了. 前面我们已经介绍过了，它是实现了MethodHandler,并重写了invoke()方法，重点就在这里:

public Object invoke(Object[] argv) throws Throwable {
        RequestTemplate template = buildTemplateFromArgs.create(argv);
        Options options = findOptions(argv);
        Retryer retryer = this.retryer.clone();  //克隆一个  Retryer对象
        while (true) {   //循环发出请求，如果出错，则catch异常，再重试. 
          try {    //
            return executeAndDecode(template, options);
          } catch (RetryableException e) {    //注意: 只对 RetryableException异常重试
            try {
              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;   //可以重试，继续执行 executeAndDecode(). 
          }
        }
      }

在这个代码中，它catch的异常是  RetryableException,  这是由executeAndDecode中在客户端发出请求时抛出的异常. 我们查看一下  executeAndDecode

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);
        } catch (IOException e) {
          if (logLevel != Logger.Level.NONE) {
            logger.logIOException(metadata.configKey(), logLevel, e, elapsedTime(start));
          }
          throw errorExecuting(request, e);   // 抛出异常. 
        }
       ...
      }

请查看  throw errorExecuting(request, e);

static FeignException errorExecuting(Request request, IOException cause) {
        return new RetryableException(
            -1,
            format("%s executing %s %s", cause.getMessage(), request.httpMethod(), request.url()),
            request.httpMethod(),
            cause,
            null, request);
      }

这里就是异常对象的产生部分了.

好，到此，Retryer的源码分析结束，你看懂了吗!!!!!