先看问题
对于Json中的Null值，常规处理的方式给对象加一个?号。
{
"str": null,
"i":"5"
}
data class Test(
val str: String? = "abc", // 必须加问号，否则会崩溃
val i: Int = 1,
)
这样就会有个问题，str会被赋值为null。
但是我们期望null值的时候，使用abc这个默认值，做不到。除非后台不返回这个str这个字段，就会使用默认值。
激烈讨论过程
对于null这个问题的理解，在Moshi Github上有着非常激烈的讨论。
总结下来就是：官方认为，后台返回 null，是业务的一种形式，代表这个业务不存在。我们应该在团队合作中，约定一个规范的Json格式行为，而不是无脑区兜底null值。
官方最终的解释：
It has one answer in Moshi and this is Moshi's opinion :).
答案只有一个，那就是 Moshi 的看法:)。
好好好，Moshi团队你有你的看法。但是……但是，理想是很美好，我也想规范，但是现实不允许，先不说后台大哥好不好说话，就说历史API接口，没人敢动、也没人想动。
解决方案
在Github的讨论中，不乏各种各样的解决方案，比如JakeWharton大神给出的自定义注解解决方案
这用起来很难，我不可能每个字段都去加吧。。。。。
在最后的回复，我看到了一个大开脑洞的方案，太巧妙了。
自定义JsonReader，当读取到 null 的字段，直接忽略掉，欺骗上面的人，说这个字段不存在，上面的人就会用默认数值构造函数。太鸡贼了。无需用什么自定义注解，无痛切入现在的项目。
首先自定义 DefaultIfNullFactory
用于向moshi注册解析器，常规步骤，不多解析。
class DefaultIfNullFactory : JsonAdapter.Factory {
override fun create(
type: Type,
annotations: MutableSet<out Annotation>,
moshi: Moshi
): JsonAdapter<*>? {
if (annotations.isNotEmpty()) return null
// 基础数据类型忽略，moshi自己处理，就是直接是 基础数据类型的json：例如“1”，“true”
if (type === String::class.java) return null
if (type === Boolean::class.javaPrimitiveType) return null
if (type === Byte::class.javaPrimitiveType) return null
if (type === Char::class.javaPrimitiveType) return null
if (type === Double::class.javaPrimitiveType) return null
if (type === Float::class.javaPrimitiveType) return null
if (type === Int::class.javaPrimitiveType) return null
if (type === Long::class.javaPrimitiveType) return null
if (type === Short::class.javaPrimitiveType) return null
if (type === Boolean::class.java) return null
if (type === Byte::class.java) return null
if (type === Char::class.java) return null
if (type === Double::class.java) return null
if (type === Float::class.java) return null
if (type === Int::class.java) return null
if (type === Long::class.java) return null
if (type === Short::class.java) return null
val delegate = moshi.nextAdapter<Any>(this, type, annotations)
// 对象类型的走我们自己的，例如打括号包起来的："{}"
return SkipNullsAdapter(delegate)
}
}
SkipNullsAdapter 也没啥说的
private class SkipNullsAdapter(
private val delegate: JsonAdapter<Any>
) : JsonAdapter<Any>() {
override fun fromJson(reader: JsonReader): Any? {
// 如果是对象结构，才包装 reader 跳过 null
return if (reader.peek() == JsonReader.Token.BEGIN_OBJECT) {
// 使用自己的 reader
delegate.fromJson(JsonReaderSkipNullValuesWrapper(reader))
} else {
delegate.fromJson(reader)
}
}
override fun toJson(writer: JsonWriter, value: Any?) {
delegate.toJson(writer, value)
}
}
欺骗的艺术来了
自己新建一个这个com.squareup.moshi包名（路径名）下，因为JsonReader 不允许外部继承。我们需要假装自己是它包里的类。
然后自定义一个JsonReaderSkipNullValuesWrapper。
class JsonReaderSkipNullValuesWrapper(
private val wrapped: JsonReader
) : JsonReader() {
private var ignoreSkipName = false
private var ignoreSkipValue = false
override fun close() {
wrapped.close()
}
override fun beginArray() {
wrapped.beginArray()
}
override fun endArray() {
wrapped.endArray()
}
override fun beginObject() {
wrapped.beginObject()
}
override fun endObject() {
wrapped.endObject()
ignoreSkipName = false
ignoreSkipValue = false
}
override fun hasNext(): Boolean {
return wrapped.hasNext()
}
override fun peek(): Token {
return wrapped.peek()
}
override fun nextName(): String {
return wrapped.nextName()
}
override fun selectName(options: Options): Int {
val index = wrapped.selectName(options)
// 这里进行欺骗，返回-1表示没有这个字段
return if (index >= 0 && wrapped.peek() == Token.NULL) {
wrapped.skipValue()
ignoreSkipName = true
ignoreSkipValue = true
-1
} else {
index
}
}
override fun skipName() {
if (ignoreSkipName) {
ignoreSkipName = false
return
}
wrapped.skipName()
}
override fun nextString(): String {
return wrapped.nextString()
}
override fun selectString(options: Options): Int {
return wrapped.selectString(options)
}
override fun nextBoolean(): Boolean {
return wrapped.nextBoolean()
}
override fun <T : Any?> nextNull(): T? {
return wrapped.nextNull()
}
override fun nextDouble(): Double {
return wrapped.nextDouble()
}
override fun nextLong(): Long {
return wrapped.nextLong()
}
override fun nextInt(): Int {
return wrapped.nextInt()
}
override fun nextSource(): BufferedSource {
return wrapped.nextSource()
}
override fun skipValue() {
if (ignoreSkipValue) {
ignoreSkipValue = false
return
}
wrapped.skipValue()
}
override fun peekJson(): JsonReader {
return wrapped.peekJson()
}
override fun promoteNameToValue() {
wrapped.promoteNameToValue()
}
}
使用
val moshi = Moshi.Builder()
.add(DefaultIfNullFactory()) // 注册进来
.build()
结果验证
Json
{
"list": null,
"str": null,
"i":"5"
}
data class
data class Test(
val list: List<Int>? = null, // 如果想保持为null，就加上 ? 问号
val str: String = "abc", // 不想要 null，就不要加问号
val i: Int = 1,
)
输出
Test(list=null, str=abc, i=5)
解释下（AI生成的，我改了改。但是我觉得解释的足够清楚了）
工作原理
这个类最核心的魔法发生在 selectName() 方法中：
-
- 它首先调用被包装的
JsonReader的selectName()方法来查找下一个字段。
- 它首先调用被包装的
-
- 如果找到了一个匹配的字段 (
index >= 0)，它会立刻用peek()方法查看该字段的值。
- 如果找到了一个匹配的字段 (
-
- 如果值是
Token.NULL:
- a. 它会立即调用
skipValue()来消耗掉这个null值。 - b. 然后它设置内部的
ignoreSkipName和ignoreSkipValue标志位为true。 - c. 最后，它向调用者（KSP Adapter）谎称没有找到这个字段，返回
-1。
- 如果值是
-
- KSP生成的Adapter收到
-1后，会认为这是一个未知字段，并进入其case -1分支，该分支会尝试调用skipName()和skipValue()，并使用属性的默认值。
- KSP生成的Adapter收到
-
- 我们重写的
skipName()和skipValue()方法会检查对应的ignore...标志位。如果为true，它们会消耗掉这个标志位并直接返回，从而“屏蔽”了KSP Adapter多余的跳过操作，避免了在错误的流位置上操作而导致的异常。
- 我们重写的
结果
通过上述流程，值为null的字段被巧妙地从解析流中移除。这使得Moshi的后续处理逻辑会认为该字段在JSON中“缺失”。
Kotlin 的 data class 中对应的非空属性 必须 要提供默认值（例如 val name: String = ""），Moshi会使用这个默认值。如果没有默认值会导致异常。
状态管理
ignoreSkipName和ignoreSkipValue是处理这种“欺骗”行为所必需的状态，它们确保了在selectName手动跳过一个键值对后，能够正确地拦截并忽略掉Adapter后续的、多余的skip调用。- 在
endObject()方法中，这些状态被强制重置。这是一个防御性措施，确保在一个对象解析作用域结束时，所有临时状态都被清理干净，防止状态泄露并污染到外层对象的解析。
Bingo
巧妙的思路
