Open Feign 源码解析(四) --- 请求对象构造(上)

Open Feign 源码解析四 请求对象的构造（上）

源码前三篇文章写了这个图的过程

源码前三篇文章的内容归纳起来就是讲了这样的问题：

如何把接口转换为具有发送http请求能力的feign client对象以及如何整合到Spring容器中？

如何构造请求对象?

思路分析

Http请求对象的分析（目标）

URL: http://127.0.0.1:9000/consumer/feign/order/{1}?name=xxx&age=18

​ 协议: http

​ IP端口: 127.0.0.1:9000 -> 注册中心获取

​ URI: /consumer/feign/order/{id}

​ 路径参: {1} (path variable)

​ 请求参：name=xxx, age=18 (query)

请求头: headers

请求体： body

请求方法: Get/Post/Put/Delete …

public final class Request {
  private final HttpMethod httpMethod;
  private final String url;
  private final Map<String, Collection<String>> headers;
  private final Body body;
}

接口方法的分析（数据源）

方法本身的要素是否能表达所有Http请求的要素？

方法的要素：

​ 方法名 ×

​ 参数(名称与类型) √

​ 返回值类型 ×

URI -> 注解 或 Java对象（URI对象）表示

请求方法 -> 注解

路径参、请求参、请求头、请求体 -> 方法的入参 + 注解

问题一：注解如何设计？

1）URI 和 请求方法可以合并在一个注解中

2）对路径参、请求参、请求头、请求体分别设置对应的注解

feign：

@RequestLine/@Param/@QueryMap/@HeaderMap/@Body

open feign：

@RequestMapping/@PathVariable/@RequestParam/@SpringQueryMap/@RequestHeader/@RequestBody

URI: 类的@RequestMapping + 方法的@RequestMapping

请求方法： 方法的@RequestMapping

路径参：参数的@PathVariable

请求参：参数的@RequestParam + @SpringQueryMap

请求头: 类的@RequestMapping(produce/consume/header)

​ 方法的@RequestMapping(produce/consume/header)

​ 参数的@RequestHeader

问题二：为什么选择SpringMVC注解？

SpringMVC： http 请求 -> Java 对象

open feign：Java 对象 -> http 请求

对于方法和注解信息，可以封装在新的对象中 -> 方法元数据

方法元数据的分析

1）各种参数的位置（索引）

2）参数名称，类型

3）参数类型转换器

4）编码信息

public final class MethodMetadata implements Serializable {

  private static final long serialVersionUID = 1L;
  private String configKey;
  private transient Type returnType;
  private Integer urlIndex;
  private Integer bodyIndex;
  private Integer headerMapIndex;
  private Integer queryMapIndex;
  private boolean queryMapEncoded;
  private transient Type bodyType;
  private RequestTemplate template = new RequestTemplate();
  private List<String> formParams = new ArrayList<String>();
  private Map<Integer, Collection<String>> indexToName =
      new LinkedHashMap<Integer, Collection<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;
}

构造请求对象整体思路：

构建请求对象分两步走：

1）解析方法和注解（类、方法、参数），并把信息封装到方法元数据中 -> 应用启动

2）结合方法元数据和实际参数，构建请求对象 -> 方法调用

实参的类型转换，编码，填充

问题三：如何转换成方法元数据？

1）做成一个组件（Contract）

public interface Contract {
    // 解析接口的注解信息并封装为方法元数据的集合
  	List<MethodMetadata> parseAndValidatateMetadata(Class<?> targetType);
}

模板方法的设计模式

​ 接口 + 抽象实现 + 默认实现

​ 接口：提供扩展性 -> Contract

​ 抽象实现： 抽取公共逻辑 -> BaseContract

​ 默认实现：提供基本功能的使用 -> Default, SpringMvcContract

2）Contract组件从何获得？

Springboot自动装配 + 从FeignContext获取

@Configuration(proxyBeanMethods = false)
public class FeignClientsConfiguration {

    @Bean
	@ConditionalOnMissingBean
	public Contract feignContract(ConversionService feignConversionService) {
		return new SpringMvcContract(this.parameterProcessors, feignConversionService);
	}
}

源码解读

BaseContract

解析注解的顺序：类 -> 方法 -> 参数

abstract class BaseContract implements Contract {

    /** 解析接口的注解信息并封装为方法元数据的集合 */
    @Override
    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>();
          // 获取所有public方法，包括从父接口继承而来的  
          for (Method method : targetType.getMethods()) {
            // 排除掉从Object继承的方法，static方法，接口中的default方法
            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());
    }

    /** 解析方法的注解并封装为方法元数据对象 */
    protected MethodMetadata parseAndValidateMetadata(Class<?> targetType, Method method) {
          // 创建MethodMetadata对象
          MethodMetadata data = new MethodMetadata();

          // 设置返回值
          data.returnType(Types.resolve(targetType, targetType, method.getGenericReturnType()));

          // 设置configKey,方法的唯一标识: 接口名#方法名(参数类型名称1,参数类型名称2)
          data.configKey(Feign.configKey(targetType, method));

          // 如果有父接口先处理父接口
          if (targetType.getInterfaces().length == 1) {
            processAnnotationOnClass(data, targetType.getInterfaces()[0]);
          }
          // 再处理当前接口 【关键代码】
          processAnnotationOnClass(data, targetType);

          // 处理方法的注解 【关键代码】
          for (Annotation methodAnnotation : method.getAnnotations()) {
            processAnnotationOnMethod(data, methodAnnotation, method);
          }

          // 只支持GET POST等http方法
          checkState(data.template().method() != null,
              "Method %s not annotated with HTTP method type (ex. GET, POST)",
              method.getName());

		  // 获取参数原始类型
          Class<?>[] parameterTypes = method.getParameterTypes();
          // 获取参数通用类型
          Type[] genericParameterTypes = method.getGenericParameterTypes();
          // 获取参数注解 二维数组:因为可以有多个参数 每个参数有多个注解
          Annotation[][] parameterAnnotations = method.getParameterAnnotations();
        
          int count = parameterAnnotations.length;
          for (int i = 0; i < count; i++) {
            boolean isHttpAnnotation = false;
            if (parameterAnnotations[i] != null) {
               // 处理每个参数的注解 如果其中有一个注解属于http注解 则isHttpAnnotation为true 
               // 哪些属于http注解？如SpringMVC的@RequestHeader @PathVariable @RequestParam @SpringQueryMap
               //【关键代码】
               isHttpAnnotation = processAnnotationsOnParameter(data, parameterAnnotations[i], i);
            }
              
            if (parameterTypes[i] == URI.class) {
               data.urlIndex(i);
            } else if (!isHttpAnnotation && parameterTypes[i] != Request.Options.class) {
               // 参数类型不是URI或Options 也没有加http注解 则该参数判定为body 
               checkState(data.formParams().isEmpty(),
                  "Body parameters cannot be used with form parameters.");
               checkState(data.bodyIndex() == null, "Method has too many Body parameters: %s", method);
               // 设置body的位置和类型【关键代码】
               data.bodyIndex(i);
               data.bodyType(Types.resolve(targetType, targetType, genericParameterTypes[i]));
            }
          }

          // ...

          return data;
    }

	/** 处理类上的注解 */
    protected abstract void processAnnotationOnClass(MethodMetadata data, Class<?> clz);

    /** 处理方法上的注解 */
    protected abstract void processAnnotationOnMethod(MethodMetadata data, Annotation annotation, Method method);

	/** 处理参数上的注解 */
    protected abstract boolean processAnnotationsOnParameter(MethodMetadata data, Annotation[] annotations, int paramIndex);
  }

SpringMvcContract

类：@RequestMapping

方法：@RequestMapping

参数：@PathVariable @SpringQueryMap @RequestHeader @RequestParam

@RequestMapping

@Target({ElementType.TYPE, ElementType.METHOD})
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Mapping
public @interface RequestMapping {

   @AliasFor("path")
   String[] value() default {};

   @AliasFor("value")
   String[] path() default {};

   /**
    * The HTTP request methods to map to, narrowing the primary mapping:
    * GET, POST, HEAD, OPTIONS, PUT, PATCH, DELETE, TRACE.
    */
   RequestMethod[] method() default {};

   String[] params() default {};

   String[] headers() default {};

   /**
    * header的Content-Type
    */
   String[] consumes() default {};

   /**
	* header的Accept
    */
   String[] produces() default {};

}

public class SpringMvcContract extends Contract.BaseContract implements ResourceLoaderAware {

	private static final String ACCEPT = "Accept";

	private static final String CONTENT_TYPE = "Content-Type";

	private static final TypeDescriptor STRING_TYPE_DESCRIPTOR = TypeDescriptor
			.valueOf(String.class);

	private static final TypeDescriptor ITERABLE_TYPE_DESCRIPTOR = TypeDescriptor
			.valueOf(Iterable.class);

	private static final ParameterNameDiscoverer PARAMETER_NAME_DISCOVERER = new DefaultParameterNameDiscoverer();

    // 参数处理器 可以自动装配也可以使用默认的处理器
	private final Map<Class<? extends Annotation>, AnnotatedParameterProcessor> annotatedArgumentProcessors;

	private final Map<String, Method> processedMethods = new HashMap<>();

	private final ConversionService conversionService;

	private final ConvertingExpanderFactory convertingExpanderFactory;

	private ResourceLoader resourceLoader = new DefaultResourceLoader();

	public SpringMvcContract(
			List<AnnotatedParameterProcessor> annotatedParameterProcessors,
			ConversionService conversionService) {
		Assert.notNull(annotatedParameterProcessors,
				"Parameter processors can not be null.");
		Assert.notNull(conversionService, "ConversionService can not be null.");

        // 初始化参数处理器
		List<AnnotatedParameterProcessor> processors;
		if (!annotatedParameterProcessors.isEmpty()) {
			processors = new ArrayList<>(annotatedParameterProcessors);
		}
		else {
			processors = getDefaultAnnotatedArgumentsProcessors();
		}
		this.annotatedArgumentProcessors = toAnnotatedArgumentProcessorMap(processors);
        
        // 创建参数转换器工厂 真正的转换功能来自conversionService
		this.conversionService = conversionService;
		this.convertingExpanderFactory = new ConvertingExpanderFactory(conversionService);
	}

    /** 获取默认处理器 */
	private List<AnnotatedParameterProcessor> getDefaultAnnotatedArgumentsProcessors() {

		List<AnnotatedParameterProcessor> annotatedArgumentResolvers = new ArrayList<>();
        annotatedArgumentResolvers.add(new MatrixVariableParameterProcessor()); // 处理@MatrixVariable
		annotatedArgumentResolvers.add(new PathVariableParameterProcessor()); // 处理@PathVavirable
		annotatedArgumentResolvers.add(new RequestParamParameterProcessor()); // 处理@RequestParam
		annotatedArgumentResolvers.add(new RequestHeaderParameterProcessor()); // 处理@RequestHeader
		annotatedArgumentResolvers.add(new QueryMapParameterProcessor()); // 处理@SpringQueryMap
		annotatedArgumentResolvers.add(new RequestPartParameterProcessor()); // 处理@RequestPart
        
		return annotatedArgumentResolvers;
	}
    
    @Override
	public MethodMetadata parseAndValidateMetadata(Class<?> targetType, Method method) {
        // 方法先放入缓存中 表示已经处理
		this.processedMethods.put(Feign.configKey(targetType, method), method);
        
        // 调用父类的parseAndValidateMetadata
		MethodMetadata md = super.parseAndValidateMetadata(targetType, method);

        // 处理类上的RequestMapping注解
        // 因为RequestMapping注解可以加在类上和方法上 两者中注解值有优先级问题
		RequestMapping classAnnotation = findMergedAnnotation(targetType,
				RequestMapping.class);
		if (classAnnotation != null) {
			// 解析header中的produces
            // 此时可能已经从方法的RequestMapping注解获得produces的值
            // 这样处理表示方法上的RequestMapping注解优先于类上的RequestMapping注解
			if (!md.template().headers().containsKey(ACCEPT)) {
				parseProduces(md, method, classAnnotation);
			}

			// 解析header中的consumes 原理同produces
			if (!md.template().headers().containsKey(CONTENT_TYPE)) {
				parseConsumes(md, method, classAnnotation);
			}

			// 解析headers
			parseHeaders(md, method, classAnnotation);
		}
		return md;
	}
    
    /** 处理类上的注解(RequestMapping) */
	@Override
	protected void processAnnotationOnClass(MethodMetadata data, Class<?> clz) {
		if (clz.getInterfaces().length == 0) {
			RequestMapping classAnnotation = findMergedAnnotation(clz,
					RequestMapping.class);
            // 这里只处理类上RequestMapping的path,
            // 其他produces, consumes, headers放在解析方法上的RequestMapping注解之后
			if (classAnnotation != null) {
				// 如果类上的@RequestMapping有value(path) 处理后放入uri中
				if (classAnnotation.value().length > 0) {
					String pathValue = emptyToNull(classAnnotation.value()[0]);
                    // 解析path中的${} 
					pathValue = resolve(pathValue);
                    // 保证uri以/开头
					if (!pathValue.startsWith("/")) {
						pathValue = "/" + pathValue;
					}
                    // 放入uri中
					data.template().uri(pathValue);
				}
			}
		}
	}

	/** 处理方法上的注解(RequestMapping) */
	@Override
	protected void processAnnotationOnMethod(MethodMetadata data,
			Annotation methodAnnotation, Method method) {
        // 如果不是@RequestMapping注解本身 也不带有@RequestMapping注解的话就返回
		if (!RequestMapping.class.isInstance(methodAnnotation) && !methodAnnotation
				.annotationType().isAnnotationPresent(RequestMapping.class)) {
			return;
		}

		RequestMapping methodMapping = findMergedAnnotation(method, RequestMapping.class);
		// 解析HTTP Method
		RequestMethod[] methods = methodMapping.method();
		if (methods.length == 0) {
			methods = new RequestMethod[] { RequestMethod.GET };
		}
		checkOne(method, methods, "method");
		data.template().method(Request.HttpMethod.valueOf(methods[0].name()));

		// 解析path
		checkAtMostOne(method, methodMapping.value(), "value");
		if (methodMapping.value().length > 0) {
			String pathValue = emptyToNull(methodMapping.value()[0]);
			if (pathValue != null) {
				pathValue = resolve(pathValue);
				if (!pathValue.startsWith("/") && !data.template().path().endsWith("/")) {
					pathValue = "/" + pathValue;
				}
				data.template().uri(pathValue, true);
			}
		}

		// 解析header中的produces
		parseProduces(data, method, methodMapping);

		// 解析header中的consumes
		parseConsumes(data, method, methodMapping);

		// 解析headers
		parseHeaders(data, method, methodMapping);

		data.indexToExpander(new LinkedHashMap<Integer, Param.Expander>());
	}

	/** 处理参数上的注解 */
	@Override
	protected boolean processAnnotationsOnParameter(MethodMetadata data,
			Annotation[] annotations, int paramIndex) {
		boolean isHttpAnnotation = false;

		AnnotatedParameterProcessor.AnnotatedParameterContext context = new SimpleAnnotatedParameterContext(
				data, paramIndex);
		Method method = this.processedMethods.get(data.configKey());
		for (Annotation parameterAnnotation : annotations) {
            // 根据参数注解类型获取对应的参数处理器
			AnnotatedParameterProcessor processor = this.annotatedArgumentProcessors
					.get(parameterAnnotation.annotationType());
			if (processor != null) {
				Annotation processParameterAnnotation;
				processParameterAnnotation = synthesizeWithMethodParameterNameAsFallbackValue(
						parameterAnnotation, method, paramIndex);
                // 参数处理器处理【关键代码】
				isHttpAnnotation |= processor.processArgument(context,
						processParameterAnnotation, method);
			}
		}

        // 如果是http注解并且没有对应的expander
        // 什么expander -> 参数转换器
		if (isHttpAnnotation && data.indexToExpander().get(paramIndex) == null) {
			TypeDescriptor typeDescriptor = createTypeDescriptor(method, paramIndex);
			if (this.conversionService.canConvert(typeDescriptor,
					STRING_TYPE_DESCRIPTOR)) {
				Param.Expander expander = this.convertingExpanderFactory
						.getExpander(typeDescriptor);
				if (expander != null) {
					data.indexToExpander().put(paramIndex, expander);
				}
			}
		}
		return isHttpAnnotation;
	}
    // ...
}

AnnotatedParameterProcessor

PathVariableParameterProcessor：@PathVariable 解析路径参数

QueryMapParameterProcessor: @SpringQueryMap 解析请求参数

RequestHeaderParameterProcessor: @RequestHeader 解析请求头

RequestParamParameterProcessor：@RequestParam 解析请求参数

MatrixVariableParameterProcessor: @MatrixVariable 解析矩阵参数

RequestPartParameterProcessor: @RequestPart 解析form表单 File文件

QueryMapParameterProcessor 与 RequestParamParameterProcessor的区别：

前者可以解析自定义实体对象，Map和基本类型，没有特别的限制

后者只能解析Map和基本类型不能解析自定义对象类型

QueryMapParameterProcessor

public class QueryMapParameterProcessor implements AnnotatedParameterProcessor {

	private static final Class<SpringQueryMap> ANNOTATION = SpringQueryMap.class;

	@Override
	public Class<? extends Annotation> getAnnotationType() {
		return ANNOTATION;
	}

	@Override
	public boolean processArgument(AnnotatedParameterContext context,
			Annotation annotation, Method method) {
		int paramIndex = context.getParameterIndex();
		MethodMetadata metadata = context.getMethodMetadata();
        // 对@SpringQueryMap注解所对应的参数的类型没有限制
		if (metadata.queryMapIndex() == null) {
			metadata.queryMapIndex(paramIndex);
			metadata.queryMapEncoded(SpringQueryMap.class.cast(annotation).encoded());
		}
		return true;
	}
}

RequestParamParameterProcessor

public class RequestParamParameterProcessor implements AnnotatedParameterProcessor {

	private static final Class<RequestParam> ANNOTATION = RequestParam.class;

	@Override
	public Class<? extends Annotation> getAnnotationType() {
		return ANNOTATION;
	}

	@Override
	public boolean processArgument(AnnotatedParameterContext context,
			Annotation annotation, Method method) {
		int parameterIndex = context.getParameterIndex();
		Class<?> parameterType = method.getParameterTypes()[parameterIndex];
		MethodMetadata data = context.getMethodMetadata();

        // 参数必须是Map类型 否则不可以成为QueryMap
		if (Map.class.isAssignableFrom(parameterType)) {
			checkState(data.queryMapIndex() == null,
					"Query map can only be present once.");
			data.queryMapIndex(parameterIndex);

			return true;
		}

		RequestParam requestParam = ANNOTATION.cast(annotation);
		String name = requestParam.value();
		checkState(emptyToNull(name) != null,
				"RequestParam.value() was empty on parameter %s", parameterIndex);
		context.setParameterName(name);

		Collection<String> query = context.setTemplateParameter(name,
				data.template().queries().get(name));
		data.template().query(name, query);
		return true;
	}
}

实参类型转换和填充

interface Expander {

    /**
     * Expands the value into a string. Does not accept or return null.
     */
    String expand(Object value);
}

public class SpringMvcContract extends Contract.BaseContract implements ResourceLoaderAware {

    private static final TypeDescriptor STRING_TYPE_DESCRIPTOR = TypeDescriptor
			.valueOf(String.class);
    
	private static class ConvertingExpanderFactory {

		private final ConversionService conversionService;

		ConvertingExpanderFactory(ConversionService conversionService) {
			this.conversionService = conversionService;
		}

		Param.Expander getExpander(TypeDescriptor typeDescriptor) {
			return value -> {
				Object converted = this.conversionService.convert(value, typeDescriptor,
						STRING_TYPE_DESCRIPTOR);
				return (String) converted;
			};
		}

	}
}

Java 中的所有类型
raw type：原始类型，对应 Class 即我们通常说的引用类型，包括普通的类，例如 String.class、List.class 也包括数组(Array.class)、接口(Cloneable.class)、注解(Annotation.class)、枚举(Enum.class)等

primitive types：基本类型，对应 Class 包括 Built-in 内置类型，例如 int.class、char.class、void.class 也包括 Wrappers 内置类型包装类型，例如 Integer.class、Boolean.class、Void.class

parameterized types：参数化类型，对应 ParameterizedType 带有类型参数的类型，即常说的泛型，例如 List、Map、List 实现类 sun.reflect.generics.reflectiveObjects.ParameterizedTypeImpl

type variables：类型变量类型，对应 TypeVariable即参数化类型 ParameterizedType 中的 E、K 等类型变量，表示泛指任何类实现类 sun.reflect.generics.reflectiveObjects.TypeVariableImpl

array types：泛型数组类型，对应 GenericArrayType元素类型是参数化类型或者类型变量的泛型数组类型，例如 T[]实现类 sun.reflect.generics.reflectiveObjects.GenericArrayTypeImpl
Type 接口的另一个子接口 WildcardType 代表通配符表达式类型，或泛型表达式类型，比如?、? super T、? extends T，他并不是 Java 类型中的一种。

private static class BuildTemplateByResolvingArgs implements RequestTemplate.Factory {

    private final QueryMapEncoder queryMapEncoder;

    protected final MethodMetadata metadata;
    private final Map<Integer, Expander> indexToExpander = new LinkedHashMap<Integer, Expander>();

    /** 通过metadata信息和实参创建RequestTemplate */
    @Override
    public RequestTemplate create(Object[] argv) {
        
      // 把metadata中的半成品template拷贝一份  
      RequestTemplate mutable = RequestTemplate.from(metadata.template());
        
      // 处理URI对象
      if (metadata.urlIndex() != null) {
        int urlIndex = metadata.urlIndex();
        checkArgument(argv[urlIndex] != null, "URI parameter %s was null", urlIndex);
        mutable.target(String.valueOf(argv[urlIndex]));
      }
        
      //  
      Map<String, Object> varBuilder = new LinkedHashMap<String, Object>();
      for (Entry<Integer, Collection<String>> entry : metadata.indexToName().entrySet()) {
        int i = entry.getKey();
        Object value = argv[entry.getKey()];
        if (value != null) { // Null values are skipped.
          if (indexToExpander.containsKey(i)) {
            value = expandElements(indexToExpander.get(i), value);
          }
          for (String name : entry.getValue()) {
            varBuilder.put(name, value);
          }
        }
      }

      RequestTemplate template = resolve(argv, mutable, varBuilder);
        
      // 处理queryMap
      if (metadata.queryMapIndex() != null) {
        // add query map parameters after initial resolve so that they take
        // precedence over any predefined values
        Object value = argv[metadata.queryMapIndex()];
        Map<String, Object> queryMap = toQueryMap(value);
        template = addQueryMapQueryParameters(queryMap, template);
      }

      // 处理headerMap
      if (metadata.headerMapIndex() != null) {
        template =
            addHeaderMapHeaders((Map<String, Object>) argv[metadata.headerMapIndex()], template);
      }

      return template;
    }
    

    @SuppressWarnings("unchecked")
    private RequestTemplate addHeaderMapHeaders(Map<String, Object> headerMap,
                                                RequestTemplate mutable) {
      for (Entry<String, Object> currEntry : headerMap.entrySet()) {
        Collection<String> values = new ArrayList<String>();

        Object currValue = currEntry.getValue();
        if (currValue instanceof Iterable<?>) {
          Iterator<?> iter = ((Iterable<?>) currValue).iterator();
          while (iter.hasNext()) {
            Object nextObject = iter.next();
            values.add(nextObject == null ? null : nextObject.toString());
          }
        } else {
          values.add(currValue == null ? null : currValue.toString());
        }

        mutable.header(currEntry.getKey(), values);
      }
      return mutable;
    }

    @SuppressWarnings("unchecked")
    private RequestTemplate addQueryMapQueryParameters(Map<String, Object> queryMap,
                                                       RequestTemplate mutable) {
      for (Entry<String, Object> currEntry : queryMap.entrySet()) {
        Collection<String> values = new ArrayList<String>();

        boolean encoded = metadata.queryMapEncoded();
        Object currValue = currEntry.getValue();
        if (currValue instanceof Iterable<?>) {
          Iterator<?> iter = ((Iterable<?>) currValue).iterator();
          while (iter.hasNext()) {
            Object nextObject = iter.next();
            values.add(nextObject == null ? null
                : encoded ? nextObject.toString()
                    : UriUtils.encode(nextObject.toString()));
          }
        } else {
          values.add(currValue == null ? null
              : encoded ? currValue.toString() : UriUtils.encode(currValue.toString()));
        }

        mutable.query(encoded ? currEntry.getKey() : UriUtils.encode(currEntry.getKey()), values);
      }
      return mutable;
    }

    // ...
}