序列化探索之二 - Kotlin
文章不长，但代码演示居多，可选择性阅读
Kotlin以扩展包的形式提供了序列化能力，使得能够以“Kotlin方式”进行序列化。Kotlin设计目标，是提供一个序列化抽象，具体格式实现可用Json、CBOR、Protobuf、Properties、Yaml等进行替换。但就目前的进度，仅提供了对Json的稳定支持。其它格式都处于试验阶段。
因此，我们看Kotlin的序列化，主要看的就是数据对象与Json之间的序列化和反序列化。
能力展示
场景假设：需要序列化一个数据类，包含五个字段
- resourceId：资源ID
- resourceType：资源类型
- updatedTime：更新时间
- usn：更新序列号
- data：资源数据
为方便演示，这些字段的类型和组织结构依据场景的不同而不同，下面演示针对这个数据类的对象的序列化。
基础能力
开局一段基础代码，下面的使用方式应该是我们能够使用得最多的场景和方式。
@Serializable
class ResourceBasic<T> {
@SerialName("id")
var resourceId: String? = null
@SerialName("type")
var resourceType: String? = null
var updatedTime: Long? = null
var usn: Long? = null
var data: T? = null
override fun toString(): String {
return "ResourceBasic(resourceId=$resourceId, resourceType=$resourceType, updatedTime=$updatedTime, usn=$usn, data=$data)"
}
}
fun main() {
val resource = ResourceBasic<JsonElement>().apply {
this.resourceId = UUID.randomUUID().toString()
this.resourceType = "record"
this.updatedTime = LocalDateTime.now().toInstant(ZoneOffset.UTC).toEpochMilli()
this.usn = null
this.data = buildJsonObject {
put("images", buildJsonArray { add("https://www.ppp.com/cdwrgwarhg.png") })
}
}
val jsonFormat = Json {
prettyPrint = true
encodeDefaults = true
}
// 序列化
val jsonString = jsonFormat.encodeToString(resource)
println(jsonString)
// 反序列化
val decodedResource = jsonFormat.decodeFromString<ResourceBasic<JsonElement>>(jsonString)
println(decodedResource)
}
输出
{
"id": "74020041-79c4-456c-bd42-c372a4049d61",
"type": "record",
"updatedTime": 1633780307486,
"usn": null,
"data": {
"images": [
"https://www.ppp.com/cdwrgwarhg.png"
]
}
}
ResourceBasic(resourceId=74020041-79c4-456c-bd42-c372a4049d61, resourceType=record, updatedTime=1633780307486, usn=null, data={"images":["https://www.ppp.com/cdwrgwarhg.png"]})
上面展示了Kotlin序列化的最基础能力
- 被序列化的类上必须添加@Serializable注解
- 被序列化的类可以带泛型
- 可以通过@SerialName注解修改序列化的键名
- 序列化时调用Json.encodeToString即可
- 反序列化时调用Json.decodeFromString即可
更多参考官方手册
自定义序列化逻辑
上例中更新时间为Long，但实际代码编写中使用LocalDateTime更为方便，此时我们需要为LocalDateTime写一个自定义序列化器。
@Serializable
class ResourceInCustomSerializer {
var resourceId: String? = null
var resourceType: String? = null
@Serializable(with = LocalDateTimeAsLongSerializer::class)
var updatedTime: LocalDateTime? = null
var usn: Long? = null
var data: JsonElement? = null
override fun toString(): String {
return "ResourceBasic(resourceId=$resourceId, resourceType=$resourceType, updatedTime=$updatedTime, usn=$usn, data=$data)"
}
}
object LocalDateTimeAsLongSerializer : KSerializer<LocalDateTime> {
override val descriptor: SerialDescriptor = buildClassSerialDescriptor("java.util.LocalDateTime")
override fun serialize(encoder: Encoder, value: LocalDateTime) {
encoder.encodeLong(value.toInstant(ZoneOffset.UTC).toEpochMilli())
}
override fun deserialize(decoder: Decoder): LocalDateTime {
return LocalDateTime.ofInstant(Instant.ofEpochMilli(decoder.decodeLong()), ZoneOffset.UTC)
}
}
fun main() {
val resource = ResourceInCustomSerializer().apply {
this.resourceId = UUID.randomUUID().toString()
this.resourceType = "record"
this.updatedTime = LocalDateTime.now()
this.usn = null
this.data = buildJsonObject {
put("images", buildJsonArray { add("https://www.ppp.com/cdwrgwarhg.png") })
}
}
val jsonFormat = Json {
prettyPrint = true
encodeDefaults = true
}
// 序列化
val jsonString = jsonFormat.encodeToString(resource)
println(jsonString)
// 反序列化
val decodedResource = jsonFormat.decodeFromString<ResourceInCustomSerializer>(jsonString)
println(decodedResource)
}
要点
- 自定义LocalDateTimeAsLongSerializer，实现KSerializer接口，重写一个属性，两个方法
- descriptor：类型描述
- serialize：序列化逻辑
- deserialize：反序列化逻辑
- @Serializable(with = LocalDateTimeAsLongSerializer::class)标注在目标属性上
上下文
上面的例子再变一下，updateTime有时可能想要转换为Long，有时却想要转换为ISO8601格式的字符串。即，要求根据不同上下文的变化选择不同的序列化器。
@Serializable
class ResourceInCustomSerializer {
var resourceId: String? = null
var resourceType: String? = null
@Contextual
var updatedTime: LocalDateTime? = null
var usn: Long? = null
var data: JsonElement? = null
override fun toString(): String {
return "ResourceBasic(resourceId=$resourceId, resourceType=$resourceType, updatedTime=$updatedTime, usn=$usn, data=$data)"
}
}
object LocalDateTimeAsLongSerializer : KSerializer<LocalDateTime> {
override val descriptor: SerialDescriptor = buildClassSerialDescriptor("java.util.LocalDateTime")
override fun serialize(encoder: Encoder, value: LocalDateTime) {
encoder.encodeLong(value.toInstant(ZoneOffset.UTC).toEpochMilli())
}
override fun deserialize(decoder: Decoder): LocalDateTime {
return LocalDateTime.ofInstant(Instant.ofEpochMilli(decoder.decodeLong()), ZoneOffset.UTC)
}
}
object LocalDateTimeAsStringSerializer : KSerializer<LocalDateTime> {
override val descriptor: SerialDescriptor = buildClassSerialDescriptor("java.util.LocalDateTime")
override fun serialize(encoder: Encoder, value: LocalDateTime) {
encoder.encodeString(value.toString())
}
override fun deserialize(decoder: Decoder): LocalDateTime {
return LocalDateTime.parse(decoder.decodeString())
}
}
fun main() {
val resource = ResourceInCustomSerializer().apply {
this.resourceId = UUID.randomUUID().toString()
this.resourceType = "record"
this.updatedTime = LocalDateTime.now()
this.usn = null
this.data = buildJsonObject {
put("images", buildJsonArray { add("https://www.ppp.com/cdwrgwarhg.png") })
}
}
var jsonFormat = Json {
prettyPrint = true
encodeDefaults = true
serializersModule = serializersModuleOf(LocalDateTime::class, LocalDateTimeAsLongSerializer)
}
// LocalDateTime转换为Long的序列化和反序列化
var jsonString = jsonFormat.encodeToString(resource)
println(jsonString)
var decodedResource = jsonFormat.decodeFromString<ResourceInCustomSerializer>(jsonString)
println(decodedResource)
jsonFormat = Json {
prettyPrint = true
encodeDefaults = true
serializersModule = serializersModuleOf(LocalDateTime::class, LocalDateTimeAsStringSerializer)
}
// LocalDateTime转换为String的序列化和反序列化
jsonString = jsonFormat.encodeToString(resource)
println(jsonString)
decodedResource = jsonFormat.decodeFromString<ResourceInCustomSerializer>(jsonString)
println(decodedResource)
}
要点
- 目标字段使用@Contextual注解，表明该字段的序列化器到上下文中去找
- 定义多个针对LocalDateTime的序列化器
- 在Json实例中，指定当前所用序列化模块，为LocalDateTime注册对应的序列化器，上面，我们用了两个Json实例，分别对应不同的上下文，注册不同的序列化器，对同一个对象的序列化结果有了不同的行为
序列化的多态
如果我们的Resource有两个版本，它们拥有共同的三个属性：resourceId、resourceType、data，其中一个版本拥有updatedTime，另一个版本拥有usn，于是有了类型的层次结构。现在假设我有一个列表，该列表同时有两个版本的数据，为了在反序列化时能够恢复出具体元素的类型，在序列化时就需要将元素的类型信息也进行序列化，这就是序列化的多态。如果你觉得对这个概念模式，谷歌一下“jackson @class”，一定是似曾相识。
@Serializable
abstract class ResourceBase {
var resourceId: String? = null
var resourceType: String? = null
var data: String? = null
}
@Serializable
class ResourceWithUsn : ResourceBase() {
var usn: Long? = null
}
@Serializable
class ResourceWithUpdatedTime : ResourceBase() {
var updatedTime: Long? = null
}
fun main() {
val resources = listOf(
ResourceWithUsn().apply {
this.resourceId = "1"
this.resourceType = "record"
this.data = "这是数据"
this.usn = 123
},
ResourceWithUpdatedTime().apply {
this.resourceId = "2"
this.resourceType = "tag"
this.data = "这是标签"
this.updatedTime = Instant.now().toEpochMilli()
}
)
val jsonFormat = Json {
prettyPrint = true
classDiscriminator = "@class"
serializersModule = SerializersModule {
polymorphic(ResourceBase::class) {
subclass(ResourceWithUpdatedTime::class)
subclass(ResourceWithUsn::class)
}
}
}
val jsonString = jsonFormat.encodeToString(resources)
println(jsonString)
}
序列化结果
[
{
"@class": "com.gitee.floyd.serialization.kotlin.ResourceWithUsn",
"resourceId": "1",
"resourceType": "record",
"data": "这是数据",
"usn": 123
},
{
"@class": "com.gitee.floyd.serialization.kotlin.ResourceWithUpdatedTime",
"resourceId": "2",
"resourceType": "tag",
"data": "这是标签",
"updatedTime": 1633753842785
}
]
要点
- 父类和子类都要标注@Serializable
- Json实例中，注册多态声明，这里，我们声明ResourceBase的子类包含ResourceWithUpdatedTime、ResourceWithUsn
- 可以通过classDiscriminator自定义类型标记的key，这里写成@class，是为了让读者回想起jackson
Kotlin实际的多态稍有不同，由于Kotlin序列化的大部分工作都是在编译期完成的，因此将一个待序列化的对象声明为其父类型，也能够触发多态。还有接口、密封类在多态中也有不同的特性，具体参见官方手册
Java会有多态问题吗？
不会，Java序列化结果是二进制流，其中已经包含类型信息，不存在反序列化时候不知道具体类型的情况。也就是说，序列化的多态问题，只是对语言无关的序列化格式如Json有意义。
Json能力
之前在使用Vertx时，深感其提供的Json库好用至极；Jackson也提供了Tree Mode，让用户能够在不创建类对象的情况下灵活构建Json对象；kotlin也提供了类似的能力——JsonElement，不过它没那么强大：能够凭空构建一个JsonElement，能够遍历其中的数据，却不能修改其中的数据。
当然，Json能力并非本文的重点，我们的重点在于探究Kotlin序列化的使用方式和原理，因此有关Json能力，参考官方手册。
原理解析
Kotlin序列化几乎所有逻辑都在编译期生成。因此，配置Kotlin序列化时，需要同时引入序列化插件和序列化包
plugins {
kotlin("plugin.serialization") version "1.5.31"
}
dependencies {
implementation("org.jetbrains.kotlinx:kotlinx-serialization-json:1.3.0")
}
从@Serializable讲起
为目标类添加@serializable注解，编译器会自动生成序列化逻辑，以一个最简单的类进行展示
@Serializable
class SimpleData {
val id: Long? = null
}
其字节码反编译结果整理之后如下（去除了多余的噪声）
public final class SimpleData {
private final Long id;
public static final SimpleData.Companion Companion = ... ...
public final Long getId() {
return this.id;
}
... ...
@JvmStatic
public static final void write$Self(SimpleData self, CompositeEncoder output, SerialDescriptor serialDesc) {
if (Intrinsics.areEqual(self.id, (Object)null) ^ true || output.shouldEncodeElementDefault(serialDesc, 0)) {
output.encodeNullableSerializableElement(serialDesc, 0, (KSerializer)LongSerializer.INSTANCE, self.id);
}
}
public static final class Companion {
... ...
public final KSerializer serializer() {
return (KSerializer)SimpleData.$serializer.INSTANCE;
}
}
public static final class $serializer implements GeneratedSerializer {
public static final SimpleData.$serializer INSTANCE;
private static final SerialDescriptor $$serialDesc;
private $serializer() {
}
static {
SimpleData.$serializer var0 = new SimpleData.$serializer();
INSTANCE = var0;
PluginGeneratedSerialDescriptor var1 = new PluginGeneratedSerialDescriptor("com.gitee.floyd.serialization.kotlin.SimpleData", (GeneratedSerializer)INSTANCE, 1);
var1.addElement("id", true);
$$serialDesc = var1;
}
@NotNull
public KSerializer[] typeParametersSerializers() {
return DefaultImpls.typeParametersSerializers(this);
}
@NotNull
public SerialDescriptor getDescriptor() {
return $$serialDesc;
}
public void serialize(Encoder encoder, SimpleData value) {
SerialDescriptor var3 = $$serialDesc;
Encoder encoder = encoder.beginStructure(var3);
SimpleData.write$Self(value, encoder, var3);
encoder.endStructure(var3);
}
public void serialize(Encoder var1, Object var2) {
this.serialize(var1, (SimpleData)var2);
}
public SimpleData deserialize(Decoder decoder) {
SerialDescriptor var2 = $$serialDesc;
int var4 = 0;
Long var5 = null;
Decoder decoder = decoder.beginStructure(var2);
if (decoder.decodeSequentially()) {
var5 = (Long)decoder.decodeNullableSerializableElement(var2, 0, (KSerializer)LongSerializer.INSTANCE, var5);
var4 = Integer.MAX_VALUE;
} else {
while(true) {
int var3 = decoder.decodeElementIndex(var2);
switch(var3) {
case 0:
var5 = (Long)decoder.decodeNullableSerializableElement(var2, 0, (KSerializer)LongSerializer.INSTANCE, var5);
var4 |= 1;
break;
default:
throw (Throwable)(new UnknownFieldException(var3));
}
}
}
decoder.endStructure(var2);
return new SimpleData(var4, var5, (SerializationConstructorMarker)null);
}
public Object deserialize(Decoder var1) {
return this.deserialize(var1);
}
}
}
解读一下生成的这个类
- 编译器生成了伴生类Companion，同时附带serializer()方法，返回一个KSerializer对象
- 类本身新增静态方法
write$Self(SimpleData self, CompositeEncoder output, SerialDescriptor serialDesc)，在生成的序列化器中有被调用 - 看生成的序列化器内部——getDescriptor方法，返回一个SerialDescriptor对象
- 看生成的序列化器内部——serialize方法
- 传入Encoder对象、数据类对象
- 调用Encoder的方法，将数据类型写入
- 看生成的序列化器内部——deserialize方法
- 传入Decoder
- 从decoder中解析出字段，构建新的SimpleData对象并传入
- 看生成的序列化器，跟上面我们自己写的序列化器，像不像，其实它们就是一样的。
要点
-
添加了@Serializable的类，会自动生成属于自己类的序列化器
-
实际上随着Kotlin序列化库的引入，你会发现，所有Kotlin原生类型也都被添加了一个扩展方法，serializer()
点进去看看他们的逻辑，依然是内置实现了KSerializer
public fun String.Companion.serializer(): KSerializer<String> = StringSerializer internal object StringSerializer : KSerializer<String> { override val descriptor: SerialDescriptor = PrimitiveSerialDescriptor("kotlin.String", PrimitiveKind.STRING) override fun serialize(encoder: Encoder, value: String): Unit = encoder.encodeString(value) override fun deserialize(decoder: Decoder): String = decoder.decodeString() } -
我们会发现几个关键定义：KSerializer、SerialDescriptor、Encoder、Decoder、SerialKind，搞清楚它们之间的联系，就基本清楚了Kotlin的序列化原理。
Kotlin序列化的设计思路
+---------+ Serialization +------------+ Encoding +---------------+
| Objects | --------------> | Primitives | ---------> | Output format |
+---------+ +------------+ +---------------+
这张图取自官方手册，对于理解至关重要。Kotlin将序列化分为两个阶段
- 阶段一（序列化）：将目标对象序列化成基础类型，如Long、Char、String等，这一步是通用的，与最终序列化格式无关。这一步对应KSerializer
- 阶段二（编码）：基础类型编码为最终格式，如Json、Protobuf。这一步对应Encoder、Decoder
核心类解析
现在我们可以来看那几个关键定义
-
KSerializer
它定义了Encoder和目标对象value的关系，即控制了编码器编码和解码目标对象的逻辑。编码时，需要用到类描述信息SerialDescriptor
public interface KSerializer<T> : SerializationStrategy<T>, DeserializationStrategy<T> { override val descriptor: SerialDescriptor } public interface SerializationStrategy<in T> { public val descriptor: SerialDescriptor public fun serialize(encoder: Encoder, value: T) } public interface DeserializationStrategy<T> { public val descriptor: SerialDescriptor public fun deserialize(decoder: Decoder): T } -
SerialDescriptor
从名称就可得知，它定义了目标类型的描述信息，它的常规实现是SerialDescriptorImpl
- serialName：序列化名称，一般是类名
- kind：目标类型，下文会讲
- elements：当为类类型时，会包含多个属性，它们是以元素集合的形式提供的，具体可以看SerialDescriptorImpl实现
public interface SerialDescriptor { public val serialName: String public val kind: SerialKind public val isNullable: Boolean get() = false public val isInline: Boolean get() = false public val elementsCount: Int public val annotations: List<Annotation> get() = emptyList() public fun getElementName(index: Int): String public fun getElementIndex(name: String): Int public fun getElementAnnotations(index: Int): List<Annotation> public fun isElementOptional(index: Int): Boolean } -
Encoder/Decoder
上面说了，Encoder负责从原始类型向最终类型的转换，从接口定义就能看出
- serializersModule：这是一个专门为上下文和多态准备的类，下面会讲到
- encodeXXX：写入各种类型的数据，其中枚举和内联类一般会特殊处理
- beginStructure：当要编码的是一个复杂对象时，就需要用到CompositeEncoder，具体参见其源码，不过原理和Encoder差不多，套娃而已
- 最后两个方法只是快捷方法，用户自定义序列化器的情况：其实也只是套娃而已。
public interface Encoder { public val serializersModule: SerializersModule public fun encodeNotNullMark() {} public fun encodeNull() public fun encodeBoolean(value: Boolean) ... ... //所有原始类型的编码方法 public fun encodeString(value: String) public fun encodeEnum(enumDescriptor: SerialDescriptor, index: Int) public fun encodeInline(inlineDescriptor: SerialDescriptor): Encoder public fun beginStructure(descriptor: SerialDescriptor): CompositeEncoder public fun <T : Any?> encodeSerializableValue(serializer: SerializationStrategy<T>, value: T) { serializer.serialize(this, value) } public fun <T : Any> encodeNullableSerializableValue(serializer: SerializationStrategy<T>, value: T?) { val isNullabilitySupported = serializer.descriptor.isNullable if (isNullabilitySupported) { return encodeSerializableValue(serializer as SerializationStrategy<T?>, value) } if (value == null) { encodeNull() } else { encodeNotNullMark() encodeSerializableValue(serializer, value) } } } -
SerialKind
枚举了所有类型，其中CONTEXTUAL（上下文）和PolymorphicKind（多态）下文有详细讲解
public sealed class SerialKind { public object ENUM : SerialKind() public object CONTEXTUAL : SerialKind() } public sealed class PrimitiveKind : SerialKind() { public object BOOLEAN : PrimitiveKind() public object BYTE : PrimitiveKind() public object CHAR : PrimitiveKind() public object SHORT : PrimitiveKind() public object INT : PrimitiveKind() public object LONG : PrimitiveKind() public object FLOAT : PrimitiveKind() public object DOUBLE : PrimitiveKind() public object STRING : PrimitiveKind() } public sealed class StructureKind : SerialKind() { public object CLASS : StructureKind() public object LIST : StructureKind() public object MAP : StructureKind() public object OBJECT : StructureKind() } public sealed class PolymorphicKind : SerialKind() { public object SEALED : PolymorphicKind() public object OPEN : PolymorphicKind() }
看看Json序列化的实现
先引入一个定义：SerialFormat，它是专门定义用来作为序列化入口的接口，我们的实现类都使用它，包括Json类（这里的serializersModule暂且忽略）
public interface SerialFormat {
public val serializersModule: SerializersModule
}
最常用的它的子类：StringFormat，定义了针对字符串的操作方式，及其快捷方式
public interface StringFormat : SerialFormat {
public fun <T> encodeToString(serializer: SerializationStrategy<T>, value: T): String
public fun <T> decodeFromString(deserializer: DeserializationStrategy<T>, string: String): T
}
public inline fun <reified T> StringFormat.encodeToString(value: T): String =
encodeToString(serializersModule.serializer(), value)
public inline fun <reified T> StringFormat.decodeFromString(string: String): T =
decodeFromString(serializersModule.serializer(), string)
最常用的序列化方法是StringFormat.encodeToString(value: T)，实际调用Json.encodeToString，它的逻辑：创建StreamingJsonEncoder（Encoder的实现类），将数据写入JsonStringBuilder，完成后转换为字符串进行返回。进入StreamingJsonEncoder查看，可以看到它定义了Composer类，控制Json格式的组合
public final override fun <T> encodeToString(serializer: SerializationStrategy<T>, value: T): String {
val result = JsonStringBuilder()
try {
val encoder = StreamingJsonEncoder(
result, this,
WriteMode.OBJ,
arrayOfNulls(WriteMode.values().size)
)
encoder.encodeSerializableValue(serializer, value)
return result.toString()
} finally {
result.release()
}
}
如果我们去AbstractJsonLexer.kt下面看，还可以看到预定义的各种Json元字符。
实现上下文和多态
前文我们能够看到，在使用上下文和多态功能时，会创建SerializersModule，事实上，SerializersModule就是专门为上下文和多态设计的，因此首先要拆解SerializersModule，可以看到，它只包含了两类方法，上下文和多态，其中上下文返回的是KSerializer，多态在序列化和反序列化各自定义了一个方法。
public sealed class SerializersModule {
public fun <T : Any> getContextual(kclass: KClass<T>): KSerializer<T>? =
getContextual(kclass, emptyList())
public abstract fun <T : Any> getContextual(
kClass: KClass<T>,
typeArgumentsSerializers: List<KSerializer<*>> = emptyList()
): KSerializer<T>?
public abstract fun <T : Any> getPolymorphic(baseClass: KClass<in T>, value: T): SerializationStrategy<T>?
public abstract fun <T : Any> getPolymorphic(baseClass: KClass<in T>, serializedClassName: String?): DeserializationStrategy<out T>?
}
其唯一的实现类SerialModuleImpl如下，它维护了四个map
- class2ContextualFactory：存储类型和上下文Provider的映射，上下文Provider根据类型参数得到最终的序列化器
- polyBase2Serializers：存储了基类和具体值的真实类型的序列化器的映射关系，用于多态序列化
- polyBase2NamedSerializers：存储了基类和序列化后的类名的反序列化器的映射关系，用于多态反序列化
- polyBase2DefaultProvider：存储了针对基类的默认反序列化器
internal class SerialModuleImpl(
private val class2ContextualFactory: Map<KClass<*>, ContextualProvider>,
@JvmField val polyBase2Serializers: Map<KClass<*>, Map<KClass<*>, KSerializer<*>>>,
private val polyBase2NamedSerializers: Map<KClass<*>, Map<String, KSerializer<*>>>,
private val polyBase2DefaultProvider: Map<KClass<*>, PolymorphicProvider<*>>
) : SerializersModule() {
override fun <T : Any> getPolymorphic(baseClass: KClass<in T>, value: T): SerializationStrategy<T>? {
if (!value.isInstanceOf(baseClass)) return null
return polyBase2Serializers[baseClass]?.get(value::class) as? SerializationStrategy<T>
}
override fun <T : Any> getPolymorphic(baseClass: KClass<in T>, serializedClassName: String?): DeserializationStrategy<out T>? {
// Registered
val registered = polyBase2NamedSerializers[baseClass]?.get(serializedClassName) as? KSerializer<out T>
if (registered != null) return registered
// Default
return (polyBase2DefaultProvider[baseClass] as? PolymorphicProvider<T>)?.invoke(serializedClassName)
}
override fun <T : Any> getContextual(kClass: KClass<T>, typeArgumentsSerializers: List<KSerializer<*>>): KSerializer<T>? {
return (class2ContextualFactory[kClass]?.invoke(typeArgumentsSerializers)) as? KSerializer<T>?
}
}
现在我们可以按照步骤来看上下文和多态的实现方方法了
-
注册类和对应的序列化器，实际上就是创建SerialModuleImpl对象，并赋值给SerialFormat的serializersModule属性。
实际写入的是SerialModuleImpl.class2ContextualFactory属性
Json { serializersModule = serializersModuleOf(LocalDateTime::class, LocalDateTimeAsLongSerializer) } -
调用StringFormat.encodeToString()，它调用serializersModule.serializer()方法获取对应的序列化器
public inline fun <reified T> StringFormat.encodeToString(value: T): String = encodeToString(serializersModule.serializer(), value) public inline fun <reified T> SerializersModule.serializer(): KSerializer<T> { return serializer(typeOf<T>()).cast() }重点就在
serializer(typeOf了，根据类型确定序列化器（走反射），源码过长过碎，这里就不展示了，只说大致逻辑()) - 如果类型是枚举，则创建枚举序列化器
- 如果是接口，则创建PolymorphicSerializer，即多态序列化器，
- 如果伴生对象中存在序列化器，则直接使用（@Serializable自动生成的那个）
- 如果有Polymorphic注解，或者Serializable直接中明确指明使用PolymorphicSerializer，则返回多态序列化器
- 否则，调用SerialModuleImpl.getContextual()方法，根据类获取之前注册到上下文中的序列化器。
可以看到，在不同的情况下，会返回不同的序列化器，所谓上下文和多态，都是通过序列化器实现的。这里要多提的一点是，多态一定是通过PolymorphicSerializer实现的，因为它需要添加一个type字段。
总结
可以看到，上下文和多态，实际上都只是根据类型确定序列化器和反序列化器的过程，而这些序列化器默认来自SerializersModule。
当然，我们最终也可以显式地指定序列化器，跳过这个决定的过程，毕竟，StringFormat的方法都可以接收序列化器。
开发属于自己的序列化格式
这里做一个小演示，如果我想要实现自己的序列化格式，只需要三步
- 实现Encoder
- 实现SerialFormat
- 使用
// 实现Encoder
class FloydEncoder(
private val sb: StringBuilder,
override val serializersModule: SerializersModule
) : AbstractEncoder() {
override fun encodeValue(value: Any) {
sb.append("$value}")
}
override fun encodeElement(descriptor: SerialDescriptor, index: Int): Boolean {
sb.append("{${descriptor.getElementName(index)}=")
return true
}
}
// 实现SerialFormat
object Floyd : StringFormat {
override val serializersModule: SerializersModule = EmptySerializersModule
override fun <T> decodeFromString(deserializer: DeserializationStrategy<T>, string: String): T {
TODO("Not yet implemented")
}
override fun <T> encodeToString(serializer: SerializationStrategy<T>, value: T): String {
val sb = StringBuilder()
FloydEncoder(sb, serializersModule).encodeNullableSerializableValue(serializer, value).toString()
return sb.toString()
}
}
// 使用
@Serializable
data class Resource(
val id: String,
val desc: String
)
fun main() {
val resource = Resource("1", "用于测试自定义Encoder的资源")
val encodeString = Floyd.encodeToString(resource)
println(encodeString)
}
输出
{id=1}{desc=用于测试自定义Encoder的资源}
哪些文档能看
这里只讲了主要部分，具体细节还有更多，目前网络上系统介绍Kotlin序列化的文章不多，还是以官方文档为主
- 首推官方文档
- 然后Kotlin 序列化Api doc
- 然后是源码
不过看源码有一个很重的感受：Kotlin库总是将抽象本身定义得比较抽象，然后大量使用扩展方法来为这些抽象增加能力，这会导致代码片段比较碎。如果用IDEA查看源码，会出现库的索引页全是类型，极不方便查找，但事实上可能只有少数几个kt源文件，所以需要探寻更加时刻Kotlin库的源码查看方式。
总结
优点
- Kotlin原生，使用起来相对优雅
- 其抽象逻辑具有很强的扩展性，要基于此实现自己的序列化格式也比较容易
- 序列化逻辑编译期生成，可能会比较快，这点尚未验证
缺点
- 太新，不够成熟，尽管Json版本已经稳定了，但其中很多API还是被标注为“实验性”的。如果线上要使用，我可能还是会选择Jackson吧。
- 不能很好滴和第三方库如Spring等很好地融合。
此外，本文所有代码，都能在这里找到。