【Feign源码】解析方法的类--Contract

本篇文章介绍的是如何将方法中数据映射为请求数据，例如哪些是请求参数，哪些是请求体，哪些是请求头。。。

接口

该接口的作用就是解析类中的方法。每个方法解析为MethodMetadata。

public interface Contract {
   

  /**
   * Contract 提供接口，feign的原生实现是BaseContract，整合spring使用的是SpringMvcContract
   */
  // TODO: break this and correct spelling at some point
  List<MethodMetadata> parseAndValidatateMetadata(Class<?> targetType);
  
  }

该接口只有一个方法，传入的参数是开发者编写的接口的元信息；作用是将每个方法解析为一个MethodMetadata对象。

元信息MethodMetadata

  // 序列化
  private static final long serialVersionUID = 1L;
  // 每个方法的唯一标识
  private String configKey;
  // 方法的返回值
  private transient Type returnType;
  // 如果这个方法参数有URI类型的，记住这个索引
  private Integer urlIndex;
  // 记录方法体的索引值
  private Integer bodyIndex;
  // head中的数据使用map封装，记录索引值
  private Integer headerMapIndex;
  // 查询数据使用map封装，记录索引值
  private Integer queryMapIndex;
  // 是否编码查询map
  private boolean queryMapEncoded;
  private transient Type bodyType;
  // 请求数据模板。包含请求方法，请求参数，请求体和url
  private RequestTemplate template = new RequestTemplate();
  
  private List<String> formParams = new ArrayList<String>();
  // 每个方法参数的名称，key:参数的索引位置；value:注解中的value值
  private Map<Integer, Collection<String>> indexToName =
      new LinkedHashMap<Integer, Collection<String>>();
  // Expander类型，传入一个Object对象，返回一个String类型。。
  private Map<Integer, Class<? extends Expander>> indexToExpanderClass =
      new LinkedHashMap<Integer, Class<? extends Expander>>();
  private Map<Integer, Boolean> indexToEncoded = new LinkedHashMap<Integer, Boolean>();
  private transient Map<Integer, Expander> indexToExpander;

重要的是这些属性，剩下的就是get,set方法了，不同于JavaBean，这个类的方法和属性名一样，有参数就是set方法，没有参数就是get方法。其实是什么都行，没必要一个要按照JavaBean的格式。
这里介绍的解析过程是基于整合Spring的流程，如果你想让让feign解析自己的注解，只需要实现Contract接口，之后实现自己的逻辑即可。

实现类BaseContract

BaseContract#parseAndValidatateMetadata

    @Override
    // 类型class信息传入，该为开发者编写的接口class信息。
    public List<MethodMetadata> parseAndValidatateMetadata(Class<?> targetType) {
   
    	// 不能有泛型
      checkState(targetType.getTypeParameters().length == 0, "Parameterized types unsupported: %s",
          targetType.getSimpleName());
       // 继承的接口最多只能有一个
      checkState(targetType.getInterfaces().length <= 1, "Only single inheritance supported: %s",
          targetType.getSimpleName());
      if (targetType.getInterfaces().length == 1) {
   
        checkState(targetType.getInterfaces()[0].getInterfaces().length == 0,
            "Only single-level inheritance supported: %s",
            targetType.getSimpleName());
      }
      Map<String, MethodMetadata> result = new LinkedHashMap<String, MethodMetadata>();
      // 遍历方法，
      for (Method method : targetType.getMethods()) {
   
      	// 默认方法和静态方法都跳过
        if (method.getDeclaringClass() == Object.class ||
            (method.getModifiers() & Modifier.STATIC) != 0 ||
            Util.isDefault(method)) {
   
          continue;
        }
        // 解析出方法信息，放入缓存。
        MethodMetadata metadata = parseAndValidateMetadata(targetType, method);
        checkState(!result.containsKey(metadata.configKey()), "Overrides unsupported: %s",
            metadata.configKey());
        result.put(metadata.configKey(), metadata);
      }
      return new ArrayList<>(result.values());
    }

这里相当于Feign的规范了：

1. 接口不能有泛型
2. 继承的接口最多一个（继承的那个接口不能再继承接口了，也就是说最多有一个父接口，父接口不能再有父接口了）

遍历接口的所有Public方法，解析出MethodMetadata，放入集合返回。

解析方法

BaseContract#parseAndValidateMetadata
解析接口类中的方法。入参：targetType：接口类；method：接口类中的方法。

protected MethodMetadata parseAndValidateMetadata(Class<?> targetType, Method method) {
   
	  // 既然每个方法对应一个MethodMetadata,二话不说，直接创建对象。
      MethodMetadata data = new MethodMetadata();
      // 解析出返回值类型
      data.returnType(Types.resolve(targetType, targetType, method.getGenericReturnType()));
      // 创建唯一标识
      data.configKey(Feign.configKey(targetType, method));
	  // 有接口就先解析父接口的，之后再解析本接口的。
      if