1

我正在尝试构建一个类，其中某些值是可观察的但也是可序列化的。

这显然有效并且序列化有效，但是必须为每个字段添加一个 setter 并且必须change(...)在每个 setter 内手动调用，这是非常繁重的样板：

interface Observable {

    fun change(message: String) {
        println("changing $message")
    }
}

@Serializable
class BlahVO : Observable {

    var value2: String = ""
        set(value) {
            field = value
            change("value2")
        }

    fun toJson(): String {
        return Json.encodeToString(serializer(), this)
    }
}

println(BlahVO().apply { value2 = "test2" }) 正确输出

changing value2
{"value2":"test2"}

我试过介绍代表：

interface Observable {

    fun change(message: String) {
        println("changing $message")
    }

    
    @Suppress("ClassName")
    class default<T>(defaultValue: T) {

        private var value: T = defaultValue

        operator fun getValue(observable: Observable, property: KProperty<*>): T {
            return value
        }

        operator fun setValue(observable: Observable, property: KProperty<*>, value: T) {
            this.value = value
            observable.change(property.name)
        }

    }

}

@Serializable
class BlahVO : Observable {

    var value1: String by Observable.default("value1")

    fun toJson(): String {
        return Json.encodeToString(serializer(), this)
    }
}

println(BlahVO().apply { value1 = "test1" })正确触发更改检测，但不会序列化：

changing value1
{}

如果我从 Observable 转到 ReadWriteProperty，

interface Observable {

    fun change(message: String) {
        println("changing $message")
    }

    fun <T> look(defaultValue: T): ReadWriteProperty<Observable, T> {
        return OP(defaultValue, this)
    }

    class OP<T>(defaultValue: T, val observable: Observable) : ObservableProperty<T>(defaultValue) {
        override fun setValue(thisRef: Any?, property: KProperty<*>, value: T) {
            super.setValue(thisRef, property, value)
            observable.change("blah!")
        }
    }
}

@Serializable
class BlahVO : Observable {

    var value3: String by this.look("value3")

    fun toJson(): String {
        return Json.encodeToString(serializer(), this)
    }
}

结果是一样的：

changing blah!
{}

对于 Delegates.vetoable 也是如此

var value4: String by Delegates.vetoable("value4", {
        property: KProperty<*>, oldstring: String, newString: String ->
    this.change(property.name)
    true
})

输出：

changing value4
{}

代表似乎不适用于 Kotlin 序列化

还有哪些其他选项可以在不破坏其序列化的情况下观察属性的变化，这些选项也可以在其他平台（KotlinJS、KotlinJVM、Android...）上运行？

4

1 回答 1

2

目前不支持 Kotlin Delegates 的序列化和反序列化kotlinx.serialization。
GitHub 上有一个关于此功能的未解决问题 #1578 。

根据问题，您可以创建一个中间数据传输对象，该对象被序列化而不是原始对象。您也可以编写一个自定义序列化程序来支持 Kotlin Delegates 的序列化，这似乎是更多样板，然后编写自定义 getter 和 setter，如问题中所建议的那样。

数据传输对象

通过将原始对象映射到没有委托的简单数据传输对象，您可以利用默认的序列化机制。这还具有很好的副作用，可以从框架特定的注释中清除数据模型类，例如@Serializable.

class DataModel {
    var observedProperty: String by Delegates.observable("initial") { property, before, after ->
        println("""Hey, I changed "${property.name}" from "$before" to "$after"!""")
    }

    fun toJson(): String {
        return Json.encodeToString(serializer(), this.toDto())
    }
}

fun DataModel.toDto() = DataTransferObject(observedProperty)

@Serializable
class DataTransferObject(val observedProperty: String)

fun main() {
    val data = DataModel()
    println(data.toJson())
    data.observedProperty = "changed"
    println(data.toJson())
}

这会产生以下结果：

{"observedProperty":"initial"}
Hey, I changed "observedProperty" from "initial" to "changed"!
{"observedProperty":"changed"}

自定义数据类型

如果更改数据类型是一种选择，您可以编写一个透明地（反）序列化的包装类。以下内容可能会起作用。

@Serializable
class ClassWithMonitoredString(val monitoredProperty: MonitoredString) {
    fun toJson(): String {
        return Json.encodeToString(serializer(), this)
    }
}

fun main() {
    val monitoredString = obs("obsDefault") { before, after ->
        println("""I changed from "$before" to "$after"!""")
    }
    
    val data = ClassWithMonitoredString(monitoredString)
    println(data.toJson())
    data.monitoredProperty.value = "obsChanged"
    println(data.toJson())
}

这会产生以下结果：

{"monitoredProperty":"obsDefault"}
I changed from "obsDefault" to "obsChanged"!
{"monitoredProperty":"obsChanged"}

但是，您会丢失有关更改了哪个属性的信息，因为您无法轻松访问字段名称。此外，如上所述，您还必须更改数据结构，这可能是不可取的，甚至是不可能的。此外，目前这仅适用于字符串，尽管可能会使它更通用。此外，这需要大量的样板文件开始。但是，在调用站点上，您只需将实际值包装在对obs. 我使用以下样板来让它工作。

typealias OnChange = (before: String, after: String) -> Unit

@Serializable(with = MonitoredStringSerializer::class)
class MonitoredString(initialValue: String, var onChange: OnChange?) {
    var value: String = initialValue
        set(value) {
            onChange?.invoke(field, value)

            field = value
        }

}

fun obs(value: String, onChange: OnChange? = null) = MonitoredString(value, onChange)

object MonitoredStringSerializer : KSerializer<MonitoredString> {
    override val descriptor: SerialDescriptor = PrimitiveSerialDescriptor("MonitoredString", PrimitiveKind.STRING)

    override fun serialize(encoder: Encoder, value: MonitoredString) {
        encoder.encodeString(value.value)
    }

    override fun deserialize(decoder: Decoder): MonitoredString {
        return MonitoredString(decoder.decodeString(), null)
    }
}
于 2021-11-24T18:19:41.550 回答