Feign.builder().target()都做了什么操作！

Feign的执行流程

Weather weather = Feign.builder()
                    .client(new Client.Default(null,null))
                    .decoder(new Decoder.Default())
                    .encoder(new Encoder.Default())
                    .target(Weather.class, "http://t.weather.sojson.com/api/weather/city/101030100");

从上面可以看到Feign做完build之后通过调用target()方法直接就返回了我们想要的结果，接下来一点点探索各个方法都做了什么。

builder()

public static class Builder {
    // 请求拦截器
    private final List<RequestInterceptor> requestInterceptors =
        new ArrayList<RequestInterceptor>();
    // 日志级别
    private Logger.Level logLevel = Logger.Level.NONE;
    // 凭证信息
    private Contract contract = new Contract.Default();
    // 请求client
    private Client client = new Client.Default(null, null);
    // 重试器
    private Retryer retryer = new Retryer.Default();
    // 日志打印器
    private Logger logger = new NoOpLogger();
    // 编码器
    private Encoder encoder = new Encoder.Default();
    // 解码器
    private Decoder decoder = new Decoder.Default();
    // QueryMap编码器
    private QueryMapEncoder queryMapEncoder = new FieldQueryMapEncoder();
    // 错误解码器
    private ErrorDecoder errorDecoder = new ErrorDecoder.Default();
    // 请求参数（超时、连接时间等配置）
    private Options options = new Options();
    // 代理工厂
    private InvocationHandlerFactory invocationHandlerFactory =
        new InvocationHandlerFactory.Default();
    // 404是否处理
    private boolean decode404;
    // 解码后关闭连接
    private boolean closeAfterDecode = true;
    private ExceptionPropagationPolicy propagationPolicy = NONE;
    // 强制转换编码
    private boolean forceDecoding = false;
    // 增强解析器
    private List<Capability> capabilities = new ArrayList<>();
}

从上文中可以看到在builder中包含了基本上feign的所有核心的内容。

target()

public <T> T target(Class<T> apiType, String url) {
  // 创建硬编码Target对象
  return target(new HardCodedTarget<T>(apiType, url));
}

public <T> T target(Target<T> target) {
  // 构造并创建实例对象
  return build().newInstance(target);
}

public interface Target<T> {
  // 返回对象类型
  Class<T> type();
  // key名称
  String name();
  // 请求地址
  String url();
  // 构建Request
  public Request apply(RequestTemplate input);
}

上文中可以看到最终创建了一个HardCodedTarget,实现了Target接口。接下来看下build方法和newInstance方法都做了什么操作。

build()

public Feign build() {
      // 请求Client信息，默认HttpURLConnection
      Client client = Capability.enrich(this.client, capabilities);
      // 重试机制默认请求间隔100毫秒，最大重试间隔1秒，最多重试5次
      Retryer retryer = Capability.enrich(this.retryer, capabilities);
      // 请求拦截器
      List<RequestInterceptor> requestInterceptors = this.requestInterceptors.stream()
          .map(ri -> Capability.enrich(ri, capabilities))
          .collect(Collectors.toList());
      // 日志处理器
      Logger logger = Capability.enrich(this.logger, capabilities);
      // 契约信息，也就是定义了@Headers、@RequestLine、@Body、@Param等注解的处理器
      Contract contract = Capability.enrich(this.contract, capabilities);
      // 选项信息，配置Http请求的连接超时时间，读取超时时间
      Options options = Capability.enrich(this.options, capabilities);
      // 编码器
      Encoder encoder = Capability.enrich(this.encoder, capabilities);
      // 解码器
      Decoder decoder = Capability.enrich(this.decoder, capabilities);
      // 代理处理工厂
      InvocationHandlerFactory invocationHandlerFactory =
          Capability.enrich(this.invocationHandlerFactory, capabilities);
      // 查询Encoder
      QueryMapEncoder queryMapEncoder = Capability.enrich(this.queryMapEncoder, capabilities);
      // 同步方法是处理器
      SynchronousMethodHandler.Factory synchronousMethodHandlerFactory =
          new SynchronousMethodHandler.Factory(client, retryer, requestInterceptors, logger,
              logLevel, decode404, closeAfterDecode, propagationPolicy, forceDecoding);
      // 根据名称转换
      ParseHandlersByName handlersByName =
          new ParseHandlersByName(contract, options, encoder, decoder, queryMapEncoder,
              errorDecoder, synchronousMethodHandlerFactory);
      return new ReflectiveFeign(handlersByName, invocationHandlerFactory, queryMapEncoder);
}

build后，从Capability中再次解析，构建了代理处理工厂和同步处理器。最后创建了一个ReflectiveFeign实例对象。创建实例的时候传入了handlersByName，invocationHandlerFactory，queryMapEncoder三个参数。

ReflectiveFeign的newInstance方法

public <T> T newInstance(Target<T> target) {
    // 构建方法名和处理器的关系
    Map<String, MethodHandler> nameToHandler = targetToHandlersByName.apply(target);
    Map<Method, MethodHandler> methodToHandler = new LinkedHashMap<Method, MethodHandler>();
    List<DefaultMethodHandler> defaultMethodHandlers = new LinkedList<DefaultMethodHandler>();

    // 获取方法循环
    for (Method method : target.type().getMethods()) {
      if (method.getDeclaringClass() == Object.class) {
        continue;
      } else if (Util.isDefault(method)) {
        DefaultMethodHandler handler = new DefaultMethodHandler(method);
        defaultMethodHandlers.add(handler);
        methodToHandler.put(method, handler);
      } else {
        // 方法处理器
        methodToHandler.put(method, nameToHandler.get(Feign.configKey(target.type(), method)));
      }
    }
    // 创建代理处理器
    InvocationHandler handler = factory.create(target, methodToHandler);
    // 创建代理实例对象
    T proxy = (T) Proxy.newProxyInstance(target.type().getClassLoader(),
        new Class<?>[] {target.type()}, handler);
    // 循环绑定默认方法
    for (DefaultMethodHandler defaultMethodHandler : defaultMethodHandlers) {
      defaultMethodHandler.bindTo(proxy);
    }
    return proxy;
}

接下来看下Map<String, MethodHandler> nameToHandler = targetToHandlersByName.apply(target);处理器的获取方案是如何获取的。然后在看下工厂处理方法。

targetToHandlersByName.apply

public Map<String, MethodHandler> apply(Target target) {
      // 转换并且验证生成当前target的metadata
      List<MethodMetadata> metadata = contract.parseAndValidateMetadata(target.type());
      Map<String, MethodHandler> result = new LinkedHashMap<String, MethodHandler>();
      // 循环metadata
      for (MethodMetadata md : metadata) {
        BuildTemplateByResolvingArgs buildTemplate;
        if (!md.formParams().isEmpty() && md.template().bodyTemplate() == null) {
          // 构建模板信息
          buildTemplate =
              new BuildFormEncodedTemplateFromArgs(md, encoder, queryMapEncoder, target);
        } else if (md.bodyIndex() != null) {
          // 构建模板信息
          buildTemplate = new BuildEncodedTemplateFromArgs(md, encoder, queryMapEncoder, target);
        } else {
          // 构建模板信息
          buildTemplate = new BuildTemplateByResolvingArgs(md, queryMapEncoder, target);
        }
        if (md.isIgnored()) {
          result.put(md.configKey(), args -> {
            throw new IllegalStateException(md.configKey() + " is not a method handled by feign");
          });
        } else {
          result.put(md.configKey(),
              // 创建代理信息
              factory.create(target, md, buildTemplate, options, decoder, errorDecoder));
        }
      }
      return result;
}

public MethodHandler create(Target<?> target,
                                MethodMetadata md,
                                RequestTemplate.Factory buildTemplateFromArgs,
                                Options options,
                                Decoder decoder,
                                ErrorDecoder errorDecoder) {
  return new SynchronousMethodHandler(target, client, retryer, requestInterceptors, logger,
      logLevel, md, buildTemplateFromArgs, options, decoder,
      errorDecoder, decode404, closeAfterDecode, propagationPolicy, forceDecoding);
}

最终可以看到创建了key和SynchronousMethodHandler的实例关系的map进行返回。

factory.create

// 创建代理处理器
InvocationHandler handler = factory.create(target, methodToHandler);
// 创建代理实例对象
T proxy = (T) Proxy.newProxyInstance(target.type().getClassLoader(),
    new Class<?>[] {target.type()}, handler);

// 默认动态代理处理工程
static final class Default implements InvocationHandlerFactory {

    @Override
    public InvocationHandler create(Target target, Map<Method, MethodHandler> dispatch) {
      // 反射处理代理处理器
      return new ReflectiveFeign.FeignInvocationHandler(target, dispatch);
    }
}