前言

在与后端对接过程中，常常会出现因为后端不规范，导致某些String字段有时传null，有时传""。但我们在对接时并不知道哪些可能为空，他到底会传啥，总不能将Bean类中的所有字段都标为?，不合适，但是不标为？的话，GsonConverterFactory会将其转为"null"字符串，导致页面的一些控件显示为null很不合适，所以需要我们统一对String字段却传来的null值进行处理转为""空字符串。

同理，对于是List集合的字段，后端有时不传[]，而是传个null，我们也需要对这种情况进行统一处理，将其转为[]

这里我们使用TypeAdapter对其进行处理，我们先了解一下TypeAdapter这个类

1. 内容解析

1.1 TypeAdapter

1.1.1 解释

该类中有两个方法write()和read()

write()

public abstract void write(JsonWriter out, T value) throws IOException;

  /**
   * Writes one JSON value (an array, object, string, number, boolean or null)
   * for {@code value}.
   *
   * @param value the Java object to write. May be null.
   */

为value写入一个JSON数据

read()

public abstract T read(JsonReader in) throws IOException;

/**
   * Reads one JSON value (an array, object, string, number, boolean or null)
   * and converts it to a Java object. Returns the converted object.
   *
   * @return the converted Java object. May be null.
   */

读取一个JSON数据并将其转换为Object对象

1.1.2 示例

看上面的解释可能不好理解，不如我们试试官方给的示例

class PointTypeAdapter : TypeAdapter<Point>() {
    override fun write(out: JsonWriter, value: Point) {
        if (value == null) {
            out.nullValue()
            return
        }
        var xy = "${value.x},${value.y}"
        out.value(xy)
    }   
    override fun read(reader: JsonReader): Point? {
        if (reader.peek() == JsonToken.NULL) {
            reader.nextNull()
            return null
        }
        var xy = reader.nextString()
        var parts = xy.split(",")
        var x = Integer.parseInt(parts[0])
        var y = Integer.parseInt(parts[1])
        return Point(x, y)
    }
}

1.2 TypeAdapterFactory

创建完TypeAdapter，那该如何使用呢，我们怎么控制什么时候使用该PointTypeAdapter解析，什么时候不用它呢？这里用到了TypeAdapterFactory

class MyTypeAdapterFactory : TypeAdapterFactory {

    override fun <T : Any?> create(gson: Gson?, type: TypeToken<T>): TypeAdapter<T>? {
        val rawType = type.rawType     
        if (rawType== Point::class.java){
            return PointTypeAdapter() as TypeAdapter<T>
        }
        return null
    }
}

通过getRawType()获取此类型的原始类型，当类型为Point类型时，返回PointTypeAdapter()，代表使用它来进行解析，如果不是返回null，则是默认的解析方式。

注意：

其实我们不需要TypeAdapterFactory也可以使用TypeAdapter，如下所示，针对基本类型使用registerTypeAdapter()方法，而针对其他类型，要使用registerTypeHierarchyAdapter()方法，当然也可以这两个连用

val gson = GsonBuilder()
.registerTypeAdapter(String::class.java,StringTypeAdapter())
.registerTypeHierarchyAdapter(Point::class.java,PointTypeAdapter())
.create()

1.3 Gson对象创建

既然要解析数据，我们就要创建Gson()对象，平时我们是通过val gson = Gson()直接创建，要使用TypeAdapterFactory，我们通过以下方式创建

val typeAdapterGson =GsonBuilder().registerTypeAdapterFactory(MyTypeAdapterFactory()).create()

1.4 测试使用

通过以下例子，感受下

data class Graph(var origin:String,var points:List<Point>)

//解析该Json字符串：{"origin":"0.0","points":["1,2"]}
//通过PointTypeAdapter处理的
val gson = GsonBuilder().registerTypeAdapterFactory(MyTypeAdapterFactory()).create()
val graphAdapter = gson.getAdapter(Graph::class.java)

//普通的处理方式
val gson1 = Gson()
val graphAdapter1 = gson1.getAdapter(Graph::class.java)


val json = "{\"origin\":\"0.0\",\"points\":[\"1,2\"]}"
//PointTypeAdapter处理
val graph = graphAdapter.fromJson(json)
Log.i(TAG, "graph: $graph")
try {
    //未经PointTypeAdapter处理正常解析的
    val graph1 = graphAdapter1.fromJson(json)
    Log.i(TAG, "graph1: $graph1")
} catch (e: Exception) {
    Log.i(TAG, "解析生成graph1失败：${e.message}")
}

打印的结果如下：

graph: Graph(origin=0.0, points=[Point(1, 2)])

解析生成graph1失败：java.lang.IllegalStateException: Expected BEGIN_OBJECT but was STRING at line 1 column 28 path $.points[0]

可以看到，将String转为Object对象时，使用到了PointTypeAdapter的read()方法

对于{"origin":"0.0","points":["1,2"]}这样的数据，如果我们不做任何处理，直接转Graph，是会转化失败的，因为"points":["1,2"]并不能转为List<Point>，但经过PointTypeAdapter的read()方法处理后，"points":["1,2"]这样的数据我们可以转化为List<Point>

val point = Point(1, 2)
val graph2 = Graph("0.0", listOf(point))
val json1 = graphAdapter.toJson(graph2)
Log.i(TAG, "PointTypeAdapter处理生成的: $json1")
val json2 = graphAdapter1.toJson(graph2)
Log.i(TAG, "未经PointTypeAdapter处理生成的: $json2")

打印的结果如下：

PointTypeAdapter处理生成的: {"origin":"0.0","points":["1,2"]}
未经PointTypeAdapter处理生成的: {"origin":"0.0","points":[{"x":1,"y":2}]}

可以看到，将Object转为JSON数据时，用到了PointTypeAdapter的write()方法

1.5 小结

所以使用TypeAdapter

将String转为Object时会用到read()方法
将Object转为String时会用到write()方法

所以，我们想统一对字符串传来的null值进行处理，相当于在String转为Object时，只需要我们创建TypeAdapter，并在read()方法里进行处理即可。

2. null转为""具体实现

2.1 创建TypeAdapter

class StringAdapter : TypeAdapter<String>() {
    //此方法是将Object转为Json数据
    override fun write(out: JsonWriter, value: String?) {
        if(value==null){
            out.nullValue()
            return
        }
        out.value(value)
    }

    //读取时，会将null转为""
    override fun read(jsonReader: JsonReader): String {
        //peek()返回下一个令牌的类型，但并不使用它
        if (jsonReader.peek() == JsonToken.NULL) {
            //使用流中的下一个令牌
            //nextNull()如果下一个字段不是null或者流关闭，就会报错
            jsonReader.nextNull()
            return ""
        }
        return jsonReader.nextString()
    }
}

将数据解析为Object对象时，我们会用到read()方法，当jsonReader.peek() == JsonToken.NULL下一个令牌是NULL时，即后端给我们的String字段传的是null时，我们返回""空字符串，否则就正常返回。因为我们的TypeAdapter是针对String字段，所以我们使用它jsonReader.nextString()正常返回即可。

注意： 因为是流处理，我们虽然返回了""，但是我们需要处理掉流中的null令牌,调用jsonReader.nextNull()方法，否则会报错Expected a name but was NULL at line 3 column 20 path $.testParam

如果我们没有处理该null令牌，导致下次解析不是NULL类型值时，但使用的是null,导致解析错误。

2.2 创建TypeAdapterFactory

class MyTypeAdapterFactory : TypeAdapterFactory {

    override fun <T : Any?> create(gson: Gson?, type: TypeToken<T>): TypeAdapter<T>? {
        val rawType = type.rawType           
        
        if (rawType == String::class.java) {
            return StringAdapter() as TypeAdapter<T>
        }
        return null
    }
}

2.3 创建Gson对象

val gson = GsonBuilder().registerTypeAdapterFactory(MyTypeAdapterFactory()).create()

2.4 将GsonConverterFactory的create()方法内添加该Gson对象

val retrofit =   Retrofit.Builder().addConverterFactory(GsonConverterFactory.create(gson))
                .baseUrl("http://192.168.14.57:4523/mock/1059885/")
                .build()

2.5 测试使用

2.5.1 网络请求

使用Apifox来创建网络接口，后续再单独写一篇介绍如何使用该软件，是真的好用

2.5.1.1 创建接口

//获取String字段为null的数据
@GET("nullString")
fun getNullStringData(): Call<TestBean>

该接口返回的数据如下

{
    "code": 200,
    "testParam": null
}

2.5.1.2 未使用TypeAdapter进行解析

val normalRetrofit =
Retrofit.Builder().addConverterFactory(GsonConverterFactory.create())
.baseUrl("http://192.168.14.57:4523/mock/1059885/")
.build()

val normalApiService = normalRetrofit.create(ApiService::class.java)

normalApiService.getNullStringData().enqueue(object : Callback<TestBean> {
    override fun onResponse(call: Call<TestBean>, response: Response<TestBean>) {       
        response.body()?.let {          
            tvMsg.text = "code:${it.code}\n testParam:${it.testParam}"
            Log.i(TAG, "onResponse: $it")
        }
    }

    override fun onFailure(call: Call<TestBean>, t: Throwable) {
        Log.i(TAG, "onFailure: ${t.message}")
        tvMsg.text = "请求失败：${t.message}"
    }
})

打印出来的数据如下

TestBean(testParam=null, code=200)

2.5.1.3 使用了TypeAdapter处理的解析

val typeAdapterRetrofit =    
 Retrofit.Builder().addConverterFactory(GsonConverterFactory.create(typeAdapterGson))
.baseUrl("http://192.168.14.57:4523/mock/1059885/")
.build()

val typeAdapterApiService = typeAdapterRetrofit.create(ApiService::class.java)

typeAdapterApiService.getNullStringData().enqueue(object : Callback<TestBean> {
    override fun onResponse(call: Call<TestBean>, response: Response<TestBean>) {
        response.body()?.let {          
            tvMsg.text = "code:${it.code}\n testParam:${it.testParam}"
            Log.i(TAG, "onResponse: $it")
        }
    }

    override fun onFailure(call: Call<TestBean>, t: Throwable) {
        Log.i(TAG, "onFailure: ${t.message}")
        tvMsg.text = "请求失败：${t.message}"
    }
})

打印出来的数据如下

TestBean(testParam=, code=200)

2.5.1.4 小结

可以看到，使用了StringTypeAdapter，在面对字段类型为String，但传来的值为null的情况时，会将其转为""

2.5.2 本地测试

如果你不想创建接口，也可以来通过解析{"code":200,"testParam":null}本地验证下

val str = "{\n" +
"  \"code\": 200,\n" +
"  \"testParam\": null\n" +
"}"
val testBean1 = normalGson.fromJson<TestBean>(str, TestBean::class.java)
val testBean2 = typeAdapterGson.fromJson<TestBean>(str, TestBean::class.java)
//看会将null转为什么
Log.i(TAG, "onCreate: str1:$testBean1")
Log.i(TAG, "onCreate: str2:$testBean2")

打印出来的数据如下

str1:TestBean(testParam=null, code=200)
str2:TestBean(testParam=, code=200)

可以看的，使用TypeAdapter的Gson对象，会将类型为String但值为null的数据直接转为""

3 null转为[]具体实现

3.1 创建TypeAdapter

class CollectionTypeAdapter<T, E>(
    //为什么Java可以直接写typeToken: TypeToken<T>，kotlin不行？
    private val elementTypeAdapter: TypeAdapter<T>, private val typeToken: TypeToken<E>
) : TypeAdapter<Collection<T>>() {

    override fun write(out: JsonWriter, value: Collection<T>?) {
        if (value == null) {
            out.nullValue()
            return
        }
        out.beginArray()
        for (element in value) {
            elementTypeAdapter.write(out, element)
        }
        out.endArray()
    }

    override fun read(jsonReader: JsonReader): Collection<T> {
        val constructorConstructor = ConstructorConstructor(HashMap())
        val constructor = constructorConstructor.get(typeToken)
                as ObjectConstructor<out Collection<T>>

        if (jsonReader.peek() == JsonToken.NULL) {
            jsonReader.nextNull()
//return emptyList()
//这样写会报错：field language has type java.util.ArrayList, got kotlin.collections.EmptyList，当ListBean为ArrayList而不是List时会报错
//return mutableListOf()
            return constructor.construct()
        }
        val collection: MutableCollection<T> = constructor.construct() as MutableCollection<T>

        jsonReader.beginArray()
        while (jsonReader.hasNext()) {
            val instance: T = elementTypeAdapter.read(jsonReader)
            collection.add(instance)
        }
        jsonReader.endArray()
        return collection
    }
}

与2.1创建的TypeAdapter相比，最大的不同有如下几点

read()和write()方法对数据处理，需要使用jsonReader.beginArray()开始，jsonReader.endArray()结束
构造方法里需要传一个类型为TypeAdapter的elementTypeAdapter对象，供read()和write()方法读取和写入使用

write()

因为我们集合内的数据可能为各种类型，所以我们不能再像2.1中那样使用out.value(value)，该方法只能传入String类型，而TypeAdapter的write()方法解释如下，可以写入各种类型，所以我们使用传来的elementTypeAdapter对象的这个方法来写入集合内的各个元素。

Writes one JSON value (an array, object, string, number, boolean or null)for {@code value}.

read()

当集合字段返回null时，我们需要返回空集合，这里我们先通过ConstructorConstructor的get()方法创建TypeToken类型的ObjectConstructor对象，然后使用ObjectConstructor的construct()方法来创建Collection集合，而不是return emptyList()，若字段是ArrayList类型而不是List时，使用return emptyList()就会报错

field com.myfittinglife.typeadapterdemo.entities.ListBean.language has type java.util.ArrayList, got kotlin.collections.EmptyList

读取时，我们也是使用传来的elementTypeAdapter对象的read()方法来读取该集合内的各个元素数据。

3.2 创建TypeAdapterFactory

class MyTypeAdapterFactory : TypeAdapterFactory {

    override fun < T> create(gson: Gson, typeToken: TypeToken<T>): TypeAdapter<T>? {
        val rawType = typeToken.rawType
        if (rawType == String::class.java) {
            return StringTypeAdapter() as TypeAdapter<T>
        }
        if (rawType == Point::class.java) {
            return PointTypeAdapter() as TypeAdapter<T>
        }
        //测试Collection.class.isAssignableFrom(rawType)
        //不用rawType==Collection::class.java，因为集合可能为ArrayList、List、或者其它继承自List的类型，写==就定死了，这个isAssignableFrom()
        //方法表示该对象表示的类或接口与指定参数表示的类或接口相同，或其超类或超接口相同，则返回true
        if (Collection::class.java.isAssignableFrom(rawType)) {
            //获取底层实例
            val type: Type = typeToken.type
            //获取此集合内的元素类型
            val elementType: Type = `$Gson$Types`.getCollectionElementType(type, rawType)
            //生成该元素类型的TypeAdapter
            val elementTypeAdapter = gson.getAdapter(TypeToken.get(elementType))

            //----
            return CollectionTypeAdapter(elementTypeAdapter, typeToken)  as TypeAdapter<T>
        }
        return null
    }
}

这里判断是集合类型，没有像上面用到rawType==Collection::class.java来判断，而是通过isAssignableFrom()方法，因为集合可能为ArrayList、List、或者其它继承自List的类型，写==就定死了，这个isAssignableFrom()方法表示该对象表示的类或接口与指定参数表示的类或接口相同，或其超类或超接口相同，则返回true，所以用这个来判断是否是集合类型比较好。
3.1小结TypeAdapter的构造方法内需要我们传入一个集合内元素的TypeAdapter，这里通过如下方式获取

//获取底层实例
val type: Type = typeToken.type
//获取此集合内的元素类型
val elementType: Type = `$Gson$Types`.getCollectionElementType(type, rawType)
//生成该元素类型的TypeAdapter
val elementTypeAdapter = gson.getAdapter(TypeToken.get(elementType))
return CollectionTypeAdapter(elementTypeAdapter, typeToken)  as TypeAdapter<T>

3.3 测试使用

其它步骤和2.3和2.4相同，这里我们直接测试使用

data class ListBean(val name: String, val language: List<String>)
或
data class ListBean(val name: String, val language: ArrayList<String>)
或
data class ListBean(val name: String, val language: Set<String>)
等...

字符串转Object

这里我们解析字符串{"language":null,"name":"李华"}，字段language集合为null

val str = "{\"language\":null,\"name\":\"李华\"}"
val myGson = GsonBuilder().registerTypeAdapterFactory(MyTypeAdapterFactory()).create()
val typeAdapterBean = myGson.fromJson<ListBean>(str, ListBean::class.java)
Log.i(TAG, "typeAdapterBean: $typeAdapterBean")

打印的结果如下

ListBean(name=李华, language=[])

可以看到，我们解析时将null直接转为了[]

Object转字符串

val listBean = ListBean("张帅", listOf())
//或val listBean = ListBean("张帅", setOf())
val str = myGson.toJson(listBean)
Log.i(TAG, "str:$str")

打印的结果如下

str:{"language":[],"name":"张帅"}

3.4 疑问

其实在TypeAdapter的构造方法内还是有点疑惑，为什么这里不能直接使用泛型T呢？如果直接写泛型T，

在TypeAdapterFactory内创建TypeAdapter时，就会报错

 override fun < T> create(gson: Gson, typeToken: TypeToken<T>): TypeAdapter<T>? {
     .....
     return CollectionTypeAdapter(elementTypeAdapter, typeToken)  as TypeAdapter<T>
 }

错误提示

Type mismatch.
Required: T Found: Any!
Type mismatch.
Required: CapturedType(out (kotlin.Any..kotlin.Any?)) Found: T

这里的参数typeToken本身和返回的TypeAdapter不是一样的是泛型T吗？为什么编辑器会显示编译错误？还请知道的大神指教下，不胜感激。

4 总结

想要统一处理字段为String但值为null的数据，可以使用TypeAdapter对其进行统一处理
若想处理集合为空不传[]，但传的是null的情况，也可以用这种方法
对多种类型处理的多个TypeAdapter，只需在TypeAdapterFactory对不同类型使用不同TypeAdapter即可

举一反三，如果出现String字段传来Int的错误、List内的元素可能传各种类型、还有.....(怒气暴增)不说了，哪有这种不规范的接口，我去打后端去了！！！

以上就是全部内容，如果本文对你有帮助，请别忘记点赞start，如果有不恰当的地方也请提出来，下篇文章见。

Github

参考文章

⭐使用gson将null String对象转换成空白字符串

⭐Kotlin Json库问题总结（Gson以及Moshi的坑）

TypeAdapter处理Gson解析，null值替换为““,null值替换为[]

前言

1. 内容解析

1.1 TypeAdapter

1.1.1 解释

1.1.2 示例

1.2 TypeAdapterFactory

1.3 Gson对象创建

1.4 测试使用

1.5 小结

2. null转为""具体实现

2.1 创建TypeAdapter

2.2 创建TypeAdapterFactory

2.3 创建Gson对象

2.4 将GsonConverterFactory的create()方法内添加该Gson对象

2.5 测试使用

2.5.1 网络请求

2.5.1.1 创建接口

2.5.1.2 未使用TypeAdapter进行解析

2.5.1.3 使用了TypeAdapter处理的解析

2.5.1.4 小结

2.5.2 本地测试

3 null转为[]具体实现

3.1 创建TypeAdapter

3.2 创建TypeAdapterFactory

3.3 测试使用

3.4 疑问

4 总结

参考文章