Spring boot中，feign远程调用api,用@SpringQueryMap接收GET请求参数，自定义QueryMapEncoder处理特殊类型的参数转换

feign远程调用时，get请求时，如果有特殊的字段类型，用@SpringQueryMap接收参数时，会出现异常，需要自定义QueryMapEncoder

本文例举OffsetDateTime字段类型处理：

1.OffsetDateTimeQueryMapEncoder文件：

import feign.Param;

import feign.QueryMapEncoder;

import feign.codec.EncodeException;

import org.apache.commons.lang3.ObjectUtils;



import java.lang.reflect.Field;

import java.time.OffsetDateTime;

import java.time.format.DateTimeFormatter;

import java.util.*;

import java.util.concurrent.ConcurrentHashMap;

import java.util.stream.Collectors;



public class OffsetDateTimeQueryMapEncoder implements QueryMapEncoder {

private final Map<Class<?>, ObjectParamMetadata> classToMetadata = new ConcurrentHashMap<>();



@Override

public Map<String, Object> encode(Object object) throws EncodeException {

ObjectParamMetadata metadata = classToMetadata.computeIfAbsent(object.getClass(),

ObjectParamMetadata::parseObjectType);



return metadata.objectFields.stream()

.map(field -> this.FieldValuePair(object, field))

.filter(fieldObjectPair -> fieldObjectPair.right.isPresent())

.collect(Collectors.toMap(this::fieldName, this::fieldObject));



}



private String fieldName(Pair<Field, Optional<Object>> pair) {

Param alias = pair.left.getAnnotation(Param.class);

return alias != null ? alias.value() : pair.left.getName();

}



// 可扩展为策略模式，支持更多的格式转换

private Object fieldObject(Pair<Field, Optional<Object>> pair) {

Object fieldObject = pair.right.get();

if (ObjectUtils.isNotEmpty(fieldObject) && fieldObject instanceof OffsetDateTime) {

fieldObject = DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss xxx").format((OffsetDateTime) fieldObject);

}

return fieldObject;

}



private Pair<Field, Optional<Object>> FieldValuePair(Object object, Field field) {

try {

return Pair.pair(field, Optional.ofNullable(field.get(object)));

} catch (IllegalAccessException e) {

throw new EncodeException("Failure encoding object into query map", e);

}

}



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> allFields = new ArrayList<Field>();



for (Class<?> currentClass = type; currentClass != null; currentClass = currentClass.getSuperclass()) {

Collections.addAll(allFields, currentClass.getDeclaredFields());

}



return new ObjectParamMetadata(allFields.stream()

.filter(field -> !field.isSynthetic())

.peek(field -> field.setAccessible(true))

.collect(Collectors.toList()));

}

}



private static class Pair<T, U> {

private Pair(T left, U right) {

this.right = right;

this.left = left;

}



public final T left;

public final U right;



public static <T, U> Pair<T, U> pair(T left, U right) {

return new Pair<>(left, right);

}



}

}

2.在FeignConfig中，配置自定义的OffsetDateTimeQueryMapEncoder：

@Configuration

public class FeignConfig {


@Bean

public QueryMapEncoder queryMapEncoder() {

return new OffsetDateTimeQueryMapEncoder();

}



}

3.在远程需要使用feign的api接口，引用configuration：

@FeignClient(contextId = "xxxx",name = "xxxx",configuration = FeignConfig.class)

配置完成后，使用OffesetDateTime作为参数，get传参就不会报错。