# 背景服务端的接口一般有固定的返回格式，有数据、返回码和异常时错误信息。结构如下 ```java @Data public class BaseResponse { private String code; private String message; private T data; public boolean isSuccess() { return "SUCCESS".equals(code); } } ``` 正常情况下我们只关注里面的data字段。不做任何处理情况下，需要将`BaseResponse`类型作为Feign Client方法的返回值，然后在调用Feign的业务代码处手动调用`getData()`方法来获取数据。这种重复的代码可以抽出来统一处理（请求数据也类似）。 # 解决方案使用自定义`Decoder`来统一处理，重写`Object decode(Response response, Type type)`方法，其中`Response `就是被调用接口返回的响应，`Type`就是Feign Client方法的返回值，它的实际类型有四种基本情况（其他都是这四种的排列组合），一种是不带泛型的类，一种带固定泛型的类，一种是不固定的T类型的泛型，最后一种是带?的分别如下 ![不带泛型Type.png](https://p1-juejin.byteimg.com/tos-cn-i-k3u1fbpfcp/ea1c233e489c4654af2adf101e9d434e~tplv-k3u1fbpfcp-watermark.image?) ![带泛型Type.png](https://p6-juejin.byteimg.com/tos-cn-i-k3u1fbpfcp/daa63c8c0d63400781b17ef66de1d9bd~tplv-k3u1fbpfcp-watermark.image?) ![泛型是不确定类型.png](https://p1-juejin.byteimg.com/tos-cn-i-k3u1fbpfcp/b5783d3120e942d8a4302f16c7642806~tplv-k3u1fbpfcp-watermark.image?) ![带问号的参数.png](https://p6-juejin.byteimg.com/tos-cn-i-k3u1fbpfcp/7fa03eb4d9df4b098b72ed59e39dc44f~tplv-k3u1fbpfcp-watermark.image?) > 本文只讨论前面两种类型，后面两种类型实际传到`Decode`中是没法知道实际类型的，除非通过某种方法把返回的实际类型传到`Decode`中（比如`ThreadLocal`、方法参数、请求头等等），或者泛型是有上界的，如``，那么可以通过`type`的`getBounds()`方法获取到上界类型，进行序列化。否则无法确定类型进行反序列化。（或者我自己想的一种思路，类似懒加载的方式，不知道能不能实现，就是延迟序列化，等用到的时候确定类型了再序列化）现在就是要将Response中的返回值转换成`BaseResponse`类型，而且是包括`BaseResponse`里面T这个泛型的，如果T中还带了泛型，不论嵌套几层都需要转换好，这样调用地方可以直接使用。我使用的序列化工具是Gson（ObjectMapper也是类似的）。带泛型的转换其实是有现有的方法可以直接转的，但是这里有点难处理的是，将`BaseResponse`类型和参数中的`Type`合并成一个，作为参数传到`Gson`的`fromJson`方法中，查看`Type`类的实现类，发现有一个`ParameterizedType`接口，这个就是描述了对象的参数类型。每个方法说明如下 ```java public interface ParameterizedType extends Type { /** * 返回里面的泛型，比如List, 那么这个方法返回String，如果是Map那么这个方法返回{String, Integer}的数组 * @since 1.5 */ Type[] getActualTypeArguments(); /** * 返回当前这个类的类型，比如List, 那么这个方法返回List，如果是Map那么这个方法返回Map */ Type getRawType(); /** * 如果是内部类的情况，这个方法返回的是最外层的类，也就是封闭类，比如O.I这种类型，返回的是O */ Type getOwnerType(); } ``` 要注意一点，Class对象也是实现了Type接口的。 `ParameterizedType`接口解决了参数合并的问题，自定一个参数类型类，实现这三个方法 ```java import sun.reflect.generics.reflectiveObjects.ParameterizedTypeImpl; import java.lang.reflect.ParameterizedType; import java.lang.reflect.Type; public class MyParameterizedType implements ParameterizedType { private Type type; /** * 将Feign Client方法的返回值注入，只要两种类型，一种是ParameterizedTypeImpl，另一种是具体的Class对象 */ public MyParameterizedType(Type type) { this.type = type; } /** * 属性Type就是BaseResponse的泛型类型，直接返回type就可以 */ @Override public Type[] getActualTypeArguments() { Type[] types = new Type[1]; types[0] = type; return types; } /** * 最外层的类型就是我们要与type合并的BaseResponse类型 */ @Override public Type getRawType() { return BaseResponse.class; } /** * 这个Owner一般没用到，如果type是个内部类静态类情况下，需要返回最外部的类型，这里直接调用Class对象获取封闭类的方法 */ @Override public Type getOwnerType() { if (type instanceof ParameterizedTypeImpl) { ParameterizedTypeImpl typeImpl = (ParameterizedTypeImpl) type; return typeImpl.getRawType().getEnclosingClass(); } if (type instanceof Class) { return ((Class) type).getEnclosingClass(); } return null; } } ``` 这样序列化问题就能解决了，现在只要编写`Decoder`类就可以了。 ```java import com.google.gson.Gson; import feign.FeignException; import feign.Response; import feign.codec.Decoder; import java.io.IOException; import java.lang.reflect.Type; public class MyDecode implements Decoder { private Gson gson = new Gson(); @Override public Object decode(Response response, Type type) throws FeignException, IOException { MyParameterizedType myType = new MyParameterizedType(type); BaseResponse baseResponse = gson.fromJson(response.body().asReader(), myType); if (type instanceof BaseResponse) { return baseResponse; } if (baseResponse.isSuccess()) { return baseResponse.getData(); } throw new RuntimeException("返回异常"); } } ``` 这里加了一个`BaseResponse`判断，如果需要返回整个数据，比如根据`BaseResponse`的返回码做业务逻辑，就可以在Feign Client的方法返回值直接写带泛型的`BaseResponse`类型。也加了一个统一的校验，如果要获取数据，需要返回码是正常才行。 # ObjectMapper泛型嵌套反序列化下面再提供`ObjectMapper`如何处理上面复杂泛型的序列化（也只是前面两种情况泛型中类型确定的情况） ```java public class MyDecode implements Decoder { private ObjectMapper objectMapper = new ObjectMapper(); @Override public Object decode(Response response, Type type) throws FeignException, IOException { TypeFactory typeFactory = objectMapper.getTypeFactory(); //这里留个坑，如果type就是BaseResponse类型，就不需要合并泛型，只要按实际转下即可，读者可以自己实现 BaseResponse baseResponse = objectMapper.readValue(response.body().asInputStream(), typeFactory.constructParametricType(BaseResponse.class, typeFactory.constructType(type))); if (type instanceof BaseResponse) { return baseResponse; } if (baseResponse.isSuccess()) { return baseResponse.getData(); } throw new RuntimeException("返回异常"); } } ``` 重点是通过`TypeFactory`将参数中的`Type`转成`JavaType`（`JavaType`和`ParameterizedType`类似，表示复杂泛型的一种数据结构），再通过`TypeFactory`的`constructParametricType`方法合并`BaseResponse`和`JavaType` # 总结这种写法优点就是一次性反序列化到位，后续使用根据泛型里面的类型直接使用，如果不进行泛型合并，只转成`BaseResponse`类型，如果data的类型是有很多泛型嵌套的，那么可能反序列化类型是有问题的，比如data的类型是List\，那么不指定详细的泛型类型，直接转成`BaseResponse`类型，那么data字段序列化结果会是List，没法直接使用的。关于参数化合并问题，这种思路可以借鉴，运用到其他场景。还有像请求数据统一封装其实也是类似，自定义一个`Encoder`即可，请求就没有参数泛型的问题了。