首页 > 文章 > 软件教程

Moshi 处理 Null 值并使用默认值的开脑洞解决方案

时间：2026-08-20 23:17:34 187浏览收藏

先看问题

对于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: MutableSetout Annotation>,
        moshi: Moshi
    ): JsonAdapter? {
        if (annotations.isNotEmpty()) return null

        // 基础数据类型忽略，moshi自己处理，就是直接是 基础数据类型的json：例如“1”，“true”
        if (type === String::class.ja va) return null

        if (type === Boolean::class.ja vaPrimitiveType) return null
        if (type === Byte::class.ja vaPrimitiveType) return null
        if (type === Char::class.ja vaPrimitiveType) return null
        if (type === Double::class.ja vaPrimitiveType) return null
        if (type === Float::class.ja vaPrimitiveType) return null
        if (type === Int::class.ja vaPrimitiveType) return null
        if (type === Long::class.ja vaPrimitiveType) return null
        if (type === Short::class.ja vaPrimitiveType) return null

        if (type === Boolean::class.ja va) return null
        if (type === Byte::class.ja va) return null
        if (type === Char::class.ja va) return null
        if (type === Double::class.ja va) return null
        if (type === Float::class.ja va) return null
        if (type === Int::class.ja va) return null
        if (type === Long::class.ja va) return null
        if (type === Short::class.ja va) return null

        val delegate = moshi.nextAdapter(this, type, annotations)

        // 对象类型的走我们自己的，例如打括号包起来的："{}"
        return SkipNullsAdapter(delegate)
    }
}

SkipNullsAdapter 也没啥说的

private class SkipNullsAdapter(
    private val delegate: JsonAdapter
) : JsonAdapter() {

    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  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: ListInt>? = null, // 如果想保持为null，就加上 ? 问号

    val str: String = "abc", // 不想要 null，就不要加问号

    val i: Int = 1,
)

输出

Test(list=null, str=abc, i=5)

解释下（AI生成的，我改了改。但是我觉得解释的足够清楚了）

工作原理

这个类最核心的魔法发生在 selectName() 方法中：

1. 它首先调用被包装的 JsonReader 的 selectName() 方法来查找下一个字段。
1. 如果找到了一个匹配的字段 (index >= 0)，它会立刻用 peek() 方法查看该字段的值。
1. 如果值是 Token.NULL:
- a. 它会立即调用 skipValue() 来消耗掉这个 null 值。
- b. 然后它设置内部的 ignoreSkipName 和 ignoreSkipValue 标志位为 true。
- c. 最后，它向调用者（KSP Adapter）谎称没有找到这个字段，返回 -1。
1. KSP生成的Adapter收到-1后，会认为这是一个未知字段，并进入其 case -1 分支，该分支会尝试调用 skipName() 和 skipValue()，并使用属性的默认值。
1. 我们重写的 skipName() 和 skipValue() 方法会检查对应的 ignore... 标志位。如果为true，它们会消耗掉这个标志位并直接返回，从而“屏蔽”了KSP Adapter多余的跳过操作，避免了在错误的流位置上操作而导致的异常。

结果

通过上述流程，值为null的字段被巧妙地从解析流中移除。这使得Moshi的后续处理逻辑会认为该字段在JSON中“缺失”。

Kotlin 的 data class 中对应的非空属性必须要提供默认值（例如 val name: String = ""），Moshi会使用这个默认值。如果没有默认值会导致异常。

状态管理

ignoreSkipName 和 ignoreSkipValue 是处理这种“欺骗”行为所必需的状态，它们确保了在 selectName 手动跳过一个键值对后，能够正确地拦截并忽略掉Adapter后续的、多余的 skip 调用。
在 endObject() 方法中，这些状态被强制重置。这是一个防御性措施，确保在一个对象解析作用域结束时，所有临时状态都被清理干净，防止状态泄露并污染到外层对象的解析。