Kotlin + Arrow + Gson = None？

Question

我在 Kotlin 中有一个简单的图书和借阅者图书馆模型，如果一本书有借阅者，它就会被签出。我使用箭头选项对借款人的 absence/presence 进行编码：

data class Borrower(val name: Name, val maxBooks: MaxBooks)
data class Book(val title: String, val author: String, val borrower: Option<Borrower> = None)

我在 Gson 中遇到问题 serializing/deserializing 这些对象 to/from JSON - 特别是 Option<Borrower> 到 JSON [=15= 的表示] 在一本书中：

[
  {
    "title": "Book100",
    "author": "Author100",
    "borrower": {
      "name": "Borrower100",
      "maxBooks": 100
    }
  },
  {
    "title": "Book200",
    "author": "Author200",
    "borrower": null
  }
]

我的反序列化代码：

fun jsonStringToBooks(jsonString: String): List<Book> {
    val gson = Gson()
    return try {
        gson.fromJson(jsonString, object : TypeToken<List<Book>>() {}.type)
    } catch (e: Exception) {
        emptyList()
    }
}

我得到一个空列表。几乎相同的 jsonStringToBorrowers 工作正常。

有人能给我指出正确的方向吗？

使用 kotlinx.serialization 或 Klaxon 等不同的 JSON 库是否更好？他们是如何做到 null <-> None 的？

谢谢！

Answer 1

由于您在返回空列表之前没有记录异常这一事实有点隐藏了这个问题。如果你记录了那个异常你会得到这个：

java.lang.RuntimeException: Failed to invoke private arrow.core.Option() with no args

这意味着 Gson 不知道如何创建 Option class 因为它没有 public 空构造函数。事实上，Option 是一个密封的 class (hence abstract)，有 2 个具体的 children classes：Some 和 None。为了获得 Option 的实例，您应该使用其中一种工厂方法，例如 Option.just(xxx) 或 Option.empty() 等。

现在，为了修复您的代码，您需要告诉 Gson 如何反序列化 Option class。为此，您需要向 gson object.

注册一个类型适配器

可能的实现如下：

class OptionTypeAdapter<E>(private val adapter: TypeAdapter<E>) : TypeAdapter<Option<E>>() {

    @Throws(IOException::class)
    override fun write(out: JsonWriter, value: Option<E>) {
        when (value) {
            is Some -> adapter.write(out, value.t)
            is None -> out.nullValue()
        }
    }

    @Throws(IOException::class)
    override fun read(input: JsonReader): Option<E> {
        val peek = input.peek()
        return if (peek != JsonToken.NULL) {
            Option.just(adapter.read(input))
        } else {
            input.nextNull()
            Option.empty()
        }
    }

    companion object {

        fun getFactory() = object : TypeAdapterFactory {
            override fun <T> create(gson: Gson, type: TypeToken<T>): TypeAdapter<T>? {
                val rawType = type.rawType as Class<*>
                if (rawType != Option::class.java) {
                    return null
                }
                val parameterizedType = type.type as ParameterizedType
                val actualType = parameterizedType.actualTypeArguments[0]
                val adapter = gson.getAdapter(TypeToken.get(actualType))
                return OptionTypeAdapter(adapter) as TypeAdapter<T>
            }
        }
    }

}

您可以通过以下方式使用它：

fun main(args: Array<String>) {
    val gson = GsonBuilder()
        .registerTypeAdapterFactory(OptionTypeAdapter.getFactory())
        .create()
    val result: List<Book> = try {
        gson.fromJson(json, TypeToken.getParameterized(List::class.java, Book::class.java).type)
    } catch (e: Exception) {
        e.printStackTrace()
        emptyList()
    }

    println(result)
}

该代码输出：

[Book(title=Book100, author=Author100, borrower=Some(Borrower(name=Borrower100, maxBooks=100))), Book(title=Book200, author=Author200, borrower=None)]

Kotlin + Arrow + Gson = None？

Kotlin + Arrow + Gson = None?

gson

kotlin

arrow-kt