Feign原理解析（三）参数的处理
参数的处理
之前的章节提到过接口方法的解析，现在再看一下这个方法：
public Map<String, MethodHandler> apply(Target key) {
List<MethodMetadata> metadata = contract.parseAndValidatateMetadata(key.type());
Map<String, MethodHandler> result = new LinkedHashMap<String, MethodHandler>();
for (MethodMetadata md : metadata) {
BuildTemplateByResolvingArgs buildTemplate;
if (!md.formParams().isEmpty() && md.template().bodyTemplate() == null) {
buildTemplate = new BuildFormEncodedTemplateFromArgs(md, encoder, queryMapEncoder);
} else if (md.bodyIndex() != null) {
buildTemplate = new BuildEncodedTemplateFromArgs(md, encoder, queryMapEncoder);
} else {
buildTemplate = new BuildTemplateByResolvingArgs(md, queryMapEncoder);
}
result.put(md.configKey(),
factory.create(key, md, buildTemplate, options, decoder, errorDecoder));
}
return result;
}
经过Contract类的parseAndValidatateMetadata(Class targetType)方法解析过接口中的方法之后，会得出方法元数据MethodMetadata的集合，然后需要遍历这个集合，根据不同的条件创建RequestTemplate请求模板构建类BuildTemplateByResolvingArgs的实例，这里有三种：
- 1.表单处理实例：BuildFormEncodedTemplateFromArgs
- 2.包含请求体body处理实例：BuildEncodedTemplateFromArgs
- 3.除上述两种之外的：BuildTemplateByResolvingArgs
RequestTemplate.Factory
interface Factory {
/**
* create a request template using args passed to a method invocation.
*/
RequestTemplate create(Object[] argv);
}
这个接口只有一个方法，就是创建RequestTemplate 请求模板
BuildTemplateByResolvingArgs关键方法解析
重写RequestTemplate.Factory的RequestTemplate create(Object[] argv)
@Override
public RequestTemplate create(Object[] argv) {
RequestTemplate mutable = new RequestTemplate(metadata.template());
if (metadata.urlIndex() != null) {
int urlIndex = metadata.urlIndex();
checkArgument(argv[urlIndex] != null, "URI parameter %s was null", urlIndex);
mutable.insert(0, 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);
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);
}
if (metadata.headerMapIndex() != null) {
template = addHeaderMapHeaders((Map<String, Object>) argv[metadata.headerMapIndex()], template);
}
return template;
}
分析如下：
- 1.复制元数据MethodMetadata的RequestTemplate
- 2.处理URI类型参数
- 3.获取@Param参数
- 4.替换模板，处理参数
- 5.处理@QueryMap参数
- 6.处理@HeaderMap参数
将@QueryMap注解声明的对象转化为Map：toQueryMap (Object value)
private Map<String, Object> toQueryMap (Object value) {
if (value instanceof Map) {
return (Map<String, Object>)value;
}
try {
return queryMapEncoder.encode(value);
} catch (EncodeException e) {
throw new IllegalStateException(e);
}
}
如果被@QueryMap注解声明的对象是Map类型则直接返回，否则将被QueryMapEncoder对象编码成Map对象，Feign默认的QueryMapEncoder如下：
class Default implements QueryMapEncoder {
private final Map<Class<?>, ObjectParamMetadata> classToMetadata =
new HashMap<Class<?>, ObjectParamMetadata>();
@Override
public Map<String, Object> encode (Object object) throws EncodeException {
try {
ObjectParamMetadata metadata = getMetadata(object.getClass());
Map<String, Object> fieldNameToValue = new HashMap<String, Object>();
for (Field field : metadata.objectFields) {
Object value = field.get(object);
if (value != null && value != object) {
fieldNameToValue.put(field.getName(), value);
}
}
return fieldNameToValue;
} catch (IllegalAccessException e) {
throw new EncodeException("Failure encoding object into query map", e);
}
}
private ObjectParamMetadata getMetadata(Class<?> objectType) {
ObjectParamMetadata metadata = classToMetadata.get(objectType);
if (metadata == null) {
metadata = ObjectParamMetadata.parseObjectType(objectType);
classToMetadata.put(objectType, metadata);
}
return metadata;
}
private static class ObjectParamMetadata {
private final List<Field> objectFields;
private ObjectParamMetadata (List<Field> objectFields) {
this.objectFields = Collections.unmodifiableList(objectFields);
}
private static ObjectParamMetadata parseObjectType(Class<?> type) {
List<Field> fields = new ArrayList<Field>();
for (Field field : type.getDeclaredFields()) {
if (!field.isAccessible()) {
field.setAccessible(true);
}
fields.add(field);
}
return new ObjectParamMetadata(fields);
}
}
}
这个类主要就是利用反射解析class中的field，并做了一个小小的缓存，之后再填充参数到Map中
将解析@QueryMap获取的Map放入queries中：addQueryMapQueryParameters
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() : RequestTemplate.urlEncode(nextObject.toString()));
}
} else {
values.add(currValue == null ? null : encoded ? currValue.toString() : RequestTemplate.urlEncode(currValue.toString()));
}
mutable.query(true, encoded ? currEntry.getKey() : RequestTemplate.urlEncode(currEntry.getKey()), values);
}
return mutable;
}
遍历Map，根据@QueryMap的encoded参数来判断是否需要对value进行url encode，然后再通过RequestTemplate 的query方法将key-value放入queries中
将值转换为字符串：expandElements
private Object expandElements(Expander expander, Object value) {
if (value instanceof Iterable) {
return expandIterable(expander, (Iterable) value);
}
return expander.expand(value);
}
private List<String> expandIterable(Expander expander, Iterable value) {
List<String> values = new ArrayList<String>();
for (Object element : value) {
if (element!=null) {
values.add(expander.expand(element));
}
}
return values;
}
如果value属于Iterable类型（例如List），则调用expandIterable方法展开L并转换为String列表，转换的过程就是调用Expander 的expand方法转换为字符串，默认的是ToStringExpander，也就是调用value的toString方法直接转换
将@HeaderMap注解声明的Map放入headers中：addQueryMapQueryParameters
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;
}
这个处理过程跟@QueryMap差不多，就不赘述了，有一点需要注意的
- @QueryMap是从Feign 9.7版本才开始支持pojo的，9.7版本以前是跟@HeaderMap一样只能声明Map类型的参数
参数处理：resolve(Object[] argv, RequestTemplate mutable,Map variables)
protected RequestTemplate resolve(Object[] argv, RequestTemplate mutable,
Map<String, Object> variables) {
// Resolving which variable names are already encoded using their indices
Map<String, Boolean> variableToEncoded = new LinkedHashMap<String, Boolean>();
for (Entry<Integer, Boolean> entry : metadata.indexToEncoded().entrySet()) {
Collection<String> names = metadata.indexToName().get(entry.getKey());
for (String name : names) {
variableToEncoded.put(name, entry.getValue());
}
}
return mutable.resolve(variables, variableToEncoded);
}
BuildTemplateByResolvingArgs的resolve方法只是简单的将需要encode的参数加入variableToEncoded集合，然后交由RequestTemplate进行处理
form表单参数解析：BuildFormEncodedTemplateFromArgs
private static class BuildFormEncodedTemplateFromArgs extends BuildTemplateByResolvingArgs {
private final Encoder encoder;
private BuildFormEncodedTemplateFromArgs(MethodMetadata metadata, Encoder encoder, QueryMapEncoder queryMapEncoder) {
super(metadata, queryMapEncoder);
this.encoder = encoder;
}
@Override
protected RequestTemplate resolve(Object[] argv, RequestTemplate mutable,
Map<String, Object> variables) {
Map<String, Object> formVariables = new LinkedHashMap<String, Object>();
for (Entry<String, Object> entry : variables.entrySet()) {
if (metadata.formParams().contains(entry.getKey())) {
formVariables.put(entry.getKey(), entry.getValue());
}
}
try {
encoder.encode(formVariables, Encoder.MAP_STRING_WILDCARD, mutable);
} catch (EncodeException e) {
throw e;
} catch (RuntimeException e) {
throw new EncodeException(e.getMessage(), e);
}
return super.resolve(argv, mutable, variables);
}
}
这个类是继承自BuildTemplateByResolvingArgs，重写了父类的resolve方法，在@Param声明的参数列表中找出属于form的数据，然后再encode放入RequestTemplate的body当中，然后再调用父类的resolve方法处理其他参数
默认的Encoder：Default
class Default implements Encoder {
@Override
public void encode(Object object, Type bodyType, RequestTemplate template) {
if (bodyType == String.class) {
template.body(object.toString());
} else if (bodyType == byte[].class) {
template.body((byte[]) object, null);
} else if (object != null) {
throw new EncodeException(
format("%s is not a type supported by this encoder.", object.getClass()));
}
}
}
这里需要注意一下，Feign默认的Encoder只处理String 和 byte[] 类型的如果是其他类型并且参数不为null时将抛出EncodeException异常，当然，Feign也集成了一些第三方的Json处理包，比如Jackson和Gson等都可以处理这类数据
请求体body处理：BuildEncodedTemplateFromArgs
private static class BuildEncodedTemplateFromArgs extends BuildTemplateByResolvingArgs {
private final Encoder encoder;
private BuildEncodedTemplateFromArgs(MethodMetadata metadata, Encoder encoder, QueryMapEncoder queryMapEncoder) {
super(metadata, queryMapEncoder);
this.encoder = encoder;
}
@Override
protected RequestTemplate resolve(Object[] argv, RequestTemplate mutable,
Map<String, Object> variables) {
Object body = argv[metadata.bodyIndex()];
checkArgument(body != null, "Body parameter %s was null", metadata.bodyIndex());
try {
encoder.encode(body, metadata.bodyType(), mutable);
} catch (EncodeException e) {
throw e;
} catch (RuntimeException e) {
throw new EncodeException(e.getMessage(), e);
}
return super.resolve(argv, mutable, variables);
}
}
这个类是继承自BuildTemplateByResolvingArgs，重写了父类的resolve方法，在参数列表中找出属于body的数据（之前提到过，没有被@Param、@QueryMap、@HeaderMap注解声明过，并且不是URI类型的参数的就属于body类型参数，而且body类型参数不能与form类型参数共存并且只能有一个body类型参数，否则会报错），然后再encode放入RequestTemplate的body当中，然后再调用父类的resolve方法处理其他参数