秒懂Retrofit2之GsonConverter

Dear 丶 2022-05-17 00:11 240阅读 0赞

> 版权申明】非商业目的可自由转载  
> 博文地址：[https://blog.csdn.net/ShuSheng0007/article/details/81387328][https_blog.csdn.net_ShuSheng0007_article_details_81387328]  
> 出自：shusheng007

系列文章  
[最简单易懂的Retrofit2源码详解][Retrofit2]  
[用Retrofit+RxJava2封装优雅的网络请求框架][Retrofit_RxJava2]  
[秒懂Retrofit2之Converter][Retrofit2_Converter]

### 文章目录 ###

*  概述
 *  Converter的作用
 *  GsonConverterFactory源码解析
 *   *  GsonConverterFactory
     *  GsonRequestBodyConverter
     *  GsonResponseBodyConverter
 *  总结

# 概述 #

前两天分析了Retrofit的源码，个人认为其精髓就在于**CallAdapter** 与**Converter**的设计上，本文我们就先研究下`Converter`的知识，下一篇再研究`CallAdapter`。强烈建议先阅读 [秒懂Retrofit2之Converter][Retrofit2_Converter]

# Converter的作用 #

假设我们不为`Retrofit`设置任何`Converter`，那么`Retrofit`能正常工作吗？有什么限制？先看下面代码：

*code1*

@POST
        @Multipart
        Call<ResponseBody>method1(@Part("p") RequestBody rBody);
    
        @POST
        Call<Void>method2(@Body RequestBody rBody);

*code2*

@POST
        @Multipart
        Call<String>method1(@Part("p") Map<String,String> rBody);
    
        @POST
        Call<List<User>>method2(@Body User rBody);

*code1* 是没有添加自定义`converter`时可以做的，而*code2*是添加了`GsonConverter`后可以做的。可以发现仅仅使用默认的`converter`的话会在使用上存在巨大限制。

*  对于方法的请求参数来说
    
    使用`@Part`,`@PartMap`,`@Body`标记的参数类型就只能是`RequestBody`
 *  对于方法的返回结果来说

方法放回结果的泛型参数只支持`ResponseBody`与`Void`

那样对我们的使用来说就麻烦了许多，需要不断的将数据在我们自己的类型与`ResponseBody`之间互相转换。而`GsonConverterFactory`就是为了将这个数据类型转换的工作自动化而生的。

# GsonConverterFactory源码解析 #

得益于`Gson`的强大，使的 `GsonConverterFactory`非常简单，源码也仅仅只有3个类。  
![这里写图片描述][70]

## GsonConverterFactory ##

我就是通过这个工厂来调用**请求转换器**`requestBodyConverter`与**结果转换器**`responseBodyConverter`的

public final class GsonConverterFactory extends Converter.Factory {
    
      //最常使用的静态工厂方法，使用默认的Gson实例	
      public static GsonConverterFactory create() {
        return create(new Gson());
      }
    
      //使用这个工厂方法可以从外部传入Gson对象，我们可以对这个Gson对象做很多配置
      public static GsonConverterFactory create(Gson gson) {
        ...
        return new GsonConverterFactory(gson);
      }
    
      private final Gson gson;
      private GsonConverterFactory(Gson gson) {
        this.gson = gson;
      }
    
      @Override
      public Converter<ResponseBody, ?> responseBodyConverter(Type type, Annotation[] annotations,
          Retrofit retrofit) {
        TypeAdapter<?> adapter = gson.getAdapter(TypeToken.get(type));
        return new GsonResponseBodyConverter<>(gson, adapter);
      }
    
      @Override
      public Converter<?, RequestBody> requestBodyConverter(Type type,
          Annotation[] parameterAnnotations, Annotation[] methodAnnotations, Retrofit retrofit) {
        TypeAdapter<?> adapter = gson.getAdapter(TypeToken.get(type));
        return new GsonRequestBodyConverter<>(gson, adapter);
      }
    }

源码简洁的令人发指，首先由两个静态工厂方法可以获得对象实例，其中一个可以出入一个Gson对象，这就产生了很多想象空间。因为我们可以在外部配置这个`Gson`对象的各种属性，关于如何配置，希望你调研一下，肯定又会惊叹于`Gson`设计的精妙。剩下两个函数我都不好意思讲了，不然会有侮辱读者智商的嫌疑。

## GsonRequestBodyConverter ##

请求转化器

final class GsonRequestBodyConverter<T> implements Converter<T, RequestBody> {
      private static final MediaType MEDIA_TYPE = MediaType.get("application/json; charset=UTF-8");
      private static final Charset UTF_8 = Charset.forName("UTF-8");
    
      private final Gson gson;
      private final TypeAdapter<T> adapter;
    
      GsonRequestBodyConverter(Gson gson, TypeAdapter<T> adapter) {
        this.gson = gson;
        this.adapter = adapter;
      }
    
      @Override public RequestBody convert(T value) throws IOException {
        Buffer buffer = new Buffer();
        Writer writer = new OutputStreamWriter(buffer.outputStream(), UTF_8);
        JsonWriter jsonWriter = gson.newJsonWriter(writer);
        adapter.write(jsonWriter, value);
        jsonWriter.close();
        return RequestBody.create(MEDIA_TYPE, buffer.readByteString());
      }
    }

结构很清晰，就是将一个**T**类型的数据**value**，例如为`User`，通过`convert()`转化为`RequestBody`类型的数据。如果你觉得看不懂，肯定不是看不懂逻辑而是看不懂转换的代码，别装了，承认看不懂不难！那就去研究`Gson`吧，少年！

## GsonResponseBodyConverter ##

结果转换器

final class GsonResponseBodyConverter<T> implements Converter<ResponseBody, T> {
      private final Gson gson;
      private final TypeAdapter<T> adapter;
    
      GsonResponseBodyConverter(Gson gson, TypeAdapter<T> adapter) {
        this.gson = gson;
        this.adapter = adapter;
      }
    
      @Override public T convert(ResponseBody value) throws IOException {
        JsonReader jsonReader = gson.newJsonReader(value.charStream());
        try {
          T result = adapter.read(jsonReader);
          if (jsonReader.peek() != JsonToken.END_DOCUMENT) {
            throw new JsonIOException("JSON document was not fully consumed.");
          }
          return result;
        } finally {
          value.close();
        }
      }
    }

结构仍然很清晰，就是通过`convert()`将`RequestBody`类型的**value**数据转换为我们期望的**T**类型的数据，例如**T**为`User`。如果你又觉得看不懂，肯定不是看不懂逻辑而是看不懂转换的代码，别装了，承认看不懂不难！那就去研究`Gson`吧，少女！

# 总结 #

目前除了`GsonConverter`以外，源码中还包含了很多其他的的转换器，例如`jackson`、`guave`、`java8`、`simplexml`等等，当遇到相应的场景时可以使用，如果现存的`Converter`不能满足我们的需求，我们就需要自己开发一个转换器了。

[https_blog.csdn.net_ShuSheng0007_article_details_81387328]: https://blog.csdn.net/ShuSheng0007/article/details/81387328
[Retrofit2]: https://blog.csdn.net/shusheng0007/article/details/81335264
[Retrofit_RxJava2]: https://blog.csdn.net/shusheng0007/article/details/80460982
[Retrofit2_Converter]: https://blog.csdn.net/ShuSheng0007/article/details/89675797
[70]: /images/20220517/38a33513481e45eeb46c511b48ee9c4c.png