SpringCloud | OpenFeign原理

@Configuration
public class MyEurekaClientConfig {
    @Bean
    public Logger.Level feignLogLevel(){
        return Logger.Level.FULL;
    }
}

// 全局配置
@EnableFeignClients(defaultConfiguration = MyEurekaClientConfig.class)

//只针对当前的Feign配置
@FeignClient(value = "order", url = "http://127.0.0.1:81", configuration = MyEurekaClientConfig.class)

@Configuration  //如果加了这个注解 上述的配置类就不用加了
public class RetryerConfig implements Retryer {
    @Override
    public void continueOrPropagate(RetryableException e) {
        throw e;
    }

    /**
    *period：周期，重试间隔时间
    *maxPeriod：最大周期，重试间隔时间按照一定的规则逐渐增大，但不能超过最大周期
    *maxAttempts：最大尝试次数，重试次数
    **/
    @Override
    public Retryer clone() {
        return new Default(100, TimeUnit.SECONDS.toMillis(1), 5);
    }
}

Map<Method, MethodHandler> methodToHandler = new LinkedHashMap<Method, MethodHandler>();

//在创建代理对象前将方法和方法处理器之间的映射关系赋值给了ReflectiveFeign.FeignInvocationHandle对象
//再将该对象赋到代理对象中
InvocationHandler handler = factory.create(target, methodToHandler);
    T proxy = (T) Proxy.newProxyInstance(target.type().getClassLoader(),
        new Class<?>[] {target.type()}, handler);

 public InvocationHandler create(Target target, Map<Method, MethodHandler> dispatch) {
      return new ReflectiveFeign.FeignInvocationHandler(target, dispatch);
    }

//关注此处的dispatch，在后续执行的流程会使用到
FeignInvocationHandler(Target target, Map<Method, MethodHandler> dispatch) {
      this.target = checkNotNull(target, "target");
      this.dispatch = checkNotNull(dispatch, "dispatch for %s", target);
    }

public final class $Proxy81 extends Proxy implements OrderFeignClient {
    private static final Method m0;
    private static final Method m1;
    private static final Method m2;
    private static final Method m3;

    public $Proxy81(InvocationHandler var1) {
        super(var1);
    }

    //此处的h就是来自ReflectiveFeign.FeignInvocationHandler生成的对象，该静态类中的dispatch维护方法对象和方法处理器之间的     //映射关系，见2.2中的第六步
    public final OrderDTO getOrderById(String var1) {
        try {
            return (OrderDTO)super.h.invoke(this, m3, new Object[]{var1});
        } catch (RuntimeException | Error var2) {
            throw var2;
        } catch (Throwable var3) {
            throw new UndeclaredThrowableException(var3);
        }
    }

    static {
        try {
            m0 = Class.forName("java.lang.Object").getMethod("hashCode");
            m1 = Class.forName("java.lang.Object").getMethod("equals", Class.forName("java.lang.Object"));
            m2 = Class.forName("java.lang.Object").getMethod("toString");
            m3 = Class.forName("com.dev.wizard.feign.OrderFeignClient").getMethod("getOrderById", Class.forName("java.lang.String"));
        } catch (NoSuchMethodException var2) {
            throw new NoSuchMethodError(var2.getMessage());
        } catch (ClassNotFoundException var3) {
            throw new NoClassDefFoundError(var3.getMessage());
        }
    }
}

//上述通过代理对象调用时，实际上会调用ReflectiveFeign.FeignInvocationHandle中的invoke方法
//如果是开启了hystrix的fallback机制的话生成FeignCircuitBreakerInvocationHandler
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
      if ("equals".equals(method.getName())) {
        try {
          Object otherHandler =
              args.length > 0 && args[0] != null ? Proxy.getInvocationHandler(args[0]) : null;
          return equals(otherHandler);
        } catch (IllegalArgumentException e) {
          return false;
        }
      } else if ("hashCode".equals(method.getName())) {
        return hashCode();
      } else if ("toString".equals(method.getName())) {
        return toString();
      }
    //看到这里 基本上明白最终是根据method对象拿到SynchronousMethodHandler对象，所有的元数据都保存在这个对象中
      return dispatch.get(method).invoke(args);
    }

final class SynchronousMethodHandler implements MethodHandler
FeignCircuitBreakerInvocationHandler

public Object invoke(Object[] argv) throws Throwable {
    //根据参数构建请求模板，这些参数主要用于和请求参数之间绑定关系
    RequestTemplate template = buildTemplateFromArgs.create(argv);
    Options options = findOptions(argv);
    Retryer retryer = this.retryer.clone();
    //重试机制
    while (true) {
      try {
          //执行请求并对反序列化
        return executeAndDecode(template, options);
      } catch (RetryableException e) {
        try {
          //如果存在重试机制 并满足重试要求就会continue执行下一次调用
          //直到重试次数用完会抛出重试异常
          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;
      }
    }
  }