关于Android数据解析的容错，你做过这些么？

Android开发者解析服务端返回的数据时候，一般会使用Gson/FastJson/moshi等数据解析框架。例如笔者项目中用的就是Gson，但是大多数使用者包括我之前都只是停留在使用的阶段。

Gson的toJson() 和 fromJson() 这两个方法是Gson的最基本的使用方式，当被问及Gson如何对Json数据容错，如何灵活序列化和反序列化的时候，就有点懵。

Json数据容错，最简单的方式是让前后端数据保持一致，就根本不存在容错的问题，但是现实场景并不如我们预期那么好。

举几个例子：User类中的姓名，有的接口返回 name ，有的接口返回 username ，如何容错呢？ age 字段返回的是 “18” 这样的字符串，而java对象将其解析成 Int 类型的时候，Gson 有一定的类型容错性，能够解析成功，但是如果 age 字段的返回值变成了 “” 、null呢？如何让其不抛出异常，并且设置默认值为 0?

接下来就详细看看，Gson是如何对数据做容错解析。

常规的使用，除了 toJson() 将 java 对象序列化成 Json 数据，或者 fromJson() 将 Json 数据反序列化成 java 对象，唯一需要注意的就是泛型擦除（下一篇讲），针对泛型的解析，无非就是参数的差异。

Gson 的注解：

@SerializedName 和 @Expose

@SerializedName可以用来配置 Json 字段的名字，最常见的场景就是不同语言的命名方式不统一，有的使用下划线，有的使用驼峰命名。如 user_name 、userName、或者不规范的 username。那如果多个接口返回的数据结构一致，只有 fieldName 不一致，这样就可以通过 @SerializedName 来做容错。

在 @SerializedName 中，还有一个 alternate 字段，用来对同一个字段配置多个解析名称。

class User{
	@SerializedName(value = "user_name", alternate = arrayOf("name","username"))
	var userName :String? = null
	@SerializedName("user_age")
	var age = 0
}

再来看 @Expose ，它是用于指定一个字段是否参与序列化和反序列化, 但是一旦使用@Expose，那么常规的 new Gson() 是不能生效的，需要使用　GsonBuilder 配合　.excludeFeildWithoutExposeAnnotation 方法使用，它有两个配置项：serialize 和 deserialize ,用于指定序列化和反序列化是否包含此字段，默认值都是　true

class User{
    @SerializedName(value = "user_name",alternate = arrayOf("name","username"))
    @Expose
    var userName :String? = null
    @Expose
    var gender = 0
    var age = 0
    @Expose(serialize = true,deserialize = false)
    var genderDesc = ""
}

fun User.gsonTest(){
    // 序列化
    val user = User()
    user.userName = "xyd"
    user.age = 18
    user.gender = 1
    user.genderDesc = "男"

    val gson = GsonBuilder()
            .excludeFieldsWithoutExposeAnnotation()
            .create()

    val jsonStr = gson.toJson(user)
    Log.d("xyd","json:$jsonStr")
    // json:{"gender":1,"genderDesc":"男","user_name":"xyd"}

    val newUser = gson.fromJson(jsonStr,User::class.java)
    Log.d("xyd","genderDesc:${newUser.genderDesc}")
    // genderDesc:
}

可以看到，genderDesc 只参与了序列化，而未参与反序列化。

注意：　一旦使用了 @Expose 后，所有的字段都必须要显式的标记，否则不参与序列化和反序列化。

Gson 中的许多问题可以通过这两个重要的注解解决，但是更灵活的处理方式就需要进阶了。

GsonBuilder　进阶

前面了解到，想要构造一个 Gson 对象，有两种方式：new Gson() 或利用　GsonBuilder 构造。

例如，默认情况下， Gson 是不会解析 null 字段的，而我们通过　serializeNulls() 方法，来让 Gson 序列化 null 字段。

val user = User()
user.age = 18
user.gender = 1

// 序列化
val jsonStr = GsonBuilder().create().toJson(user)
Log.d("xyd","json:$jsonStr")
// json:{"age":18,"gender":1}

// 反序列化
val jsonStr1 = GsonBuilder().serializeNulls().create().toJson(user)
Log.d("xyd","json1:$jsonStr1")
// json1:{"age":18,"gender":1,"userName":null}

GsonBuild 提供了更多的操作：

.serializeNulls() 序列化 null 字段
.setDateFormat() 设置日期格式，如　setDateFormate("yyyy-MM-dd")
.disableInnerClassSerialization: 禁止序列化内部类
.generateNonExcutableJson()：生成不可直接解析的 JSON，会多 )]}' 这 4 个字符。
.disableHtmlEscaping()：禁止转移 HTML 标签
.setPrettyPrinting()：格式化输出

无论是注解还是 GsonBuilder 中提供的一些方法，都是 Gson 针对一些特殊场景为我们提供的便捷 API，更复杂的就不能解决了。

TypeAdapter

如果前面介绍的规则都满足不了业务，Gson 还有更进一步的处理方式，那就是使用 TypeAdapter。这个 TypeAdapter 实际是 Object 类型，也就是一个泛指。

使用 TypeAdapter 就需要用到 GsonBuilder 中的　registerTypeAdapter() 方法。

public GsonBuilder registerTypeAdapter(Type type, Object typeAdapter) {
    $Gson$Preconditions.checkArgument(typeAdapter instanceof JsonSerializer<?>
        || typeAdapter instanceof JsonDeserializer<?>
        || typeAdapter instanceof InstanceCreator<?>
        || typeAdapter instanceof TypeAdapter<?>);
    if (typeAdapter instanceof InstanceCreator<?>) {
      instanceCreators.put(type, (InstanceCreator) typeAdapter);
    }
    if (typeAdapter instanceof JsonSerializer<?> || typeAdapter instanceof JsonDeserializer<?>) {
      TypeToken<?> typeToken = TypeToken.get(type);
      factories.add(TreeTypeAdapter.newFactoryWithMatchRawType(typeToken, typeAdapter));
    }
    if (typeAdapter instanceof TypeAdapter<?>) {
      factories.add(TypeAdapters.newFactory(TypeToken.get(type), (TypeAdapter)typeAdapter));
    }
    return this;
  }

可以看到注册方法，需要指定一个数据类型，且除了支持 TypeAdapter ，还支持 JsonSerializer JsonDeserializer。他们的区别是什么？

TypeAdapter(抽象类)、JsonSerializer(接口)、JsonDeserializer(接口)。

TypeAdapter　中包含两个主要的方法　write() 和 read() 方法，分别用于接管序列化和反序列化。

JsonSerializer　只用来接管序列化。

JsonDeserializer　只用来接管反序列化。

举个使用实例：

val user = User()
user.age = 18
user.gender = 1
// 反序列化
val jsonStr = """ {"name":"xyd","age":18,"gender":""} """
val newUser = GsonBuilder().create.fromJson(jsonStr, User:class.java)
Log.e("xyd", "gender")

上面的例子中，gender 应该是一个 Int 值，而 Json 字符串中是 "" , 这样的代码跑起来就会直接报错。怎么处理呢？我们通过实现 JsonDeserializer 接口，来接管反序列化的操作。

class IntegerDefaultAdapter : JsonDeserializer<Int>{
	override fun deserialize(json : JsonElement?, typeOfT : Type?, context : JsonDeserializationContext?){
		try{
			return json!!.getAsInt()
		}catch(e : NumberFormatException){
			return 0
		}
	}
}

这样当转换 Int 出现异常时，返回默认值 0。然后使用 registerTypeAdapter() 方法加入其中。

val newUser = GsonBuilder()
        .registerTypeAdapter(Int::class.java, IntegerDefault0Adapter())
        .create().fromJson(jsonStr,User::class.java)
Log.i("xyd","gender : ${newUser.gender}")
// gender : 0

TypeAdapter 的使用，到这里就介绍完了。