这个问题的解决方案是在几个月前找到的。所以我想尽快发布这个问题的答案。问题在于，由于代码中的错误，类被序列化为标准Kryo FieldSerializer，这是不向前兼容的。我们必须执行以下操作来反序列化旧类并将其转换为新的序列化类。
情况是：

case class ClassA(field1 : Long, field2 : String)

是这样连载的：

object ClassASerializer extends Serializer[ClassA] with Serializable{
  override def write(kryo: Kryo, output: Output, t: ClassA) = {
      output.writeLong    { t.field1 }
      output.writeString  { t.field2 }
 }
  override def read(kryo: Kryo, input: Input, aClass: Class[ClassA]) = 
       classA( 
           field1 = input.readLong(),
           field2 = input.readLong()
       )

并且循环了一个Seq，其中包含要用序列化程序序列化的类，以便为所有类注册所有序列化程序。

protected def registry: Seq[aClass: Class[A], serializer: Serializer[A]] = ...
    final def register(kryo: Kryo) = {
         registry.foreach { registrable => kryo.register(registrable.aClass, registrable.serializer) }
    }

需要通过添加一个新字段来修改这个类，该字段是另一个case类的示例。
为了执行这样的更改，我们必须使用与Kryo库“可选”有关的注解，

...
import com.esotericsoftware.kryo.serializers.FieldSerializer.Optional
import scala.annotation.meta.field
...

case class ClassA(field1 : Long, field2 : String,  @(Optional @field)("field3") field3 : ClassB)

序列化器被修改，例如当阅读旧的序列化类时，它可以用默认值示例化field3，并且当写入时，写入这样的默认值：

object ClassASerializer extends Serializer[ClassA] with Serializable{
  override def write(kryo: Kryo, output: Output, t: ClassA) = {
      output.writeLong    { t.field1 }
      output.writeString  { t.field2 }
      kryo.writeObject(output, Option { t.field3 } getOrElse ClassB.default, ClassBSerializer)

 }
  override def read(kryo: Kryo, input: Input, aClass: Class[ClassA]) = 
       ClassA( 
           field1 = input.readLong(),
           field2 = input.readLong(),
           field3 = ClassB.default
       )

kryo序列化器注册也被修改为注册可选字段：

protected def registry: Seq[aClass: Class[A], serializer: Serializer[A]] = ...
    def optionals = Seq("field3")

    final def register(kryo: Kryo) = {
        optionals.foreach { optional =>
        kryo.getContext.asInstanceOf[ObjectMap[Any, Any]].put(optional, true) }
        registry.foreach { registrable => kryo.register(registrable.aClass, registrable.serializer) }
    }

因此，我们可以编写新版本的序列化类。之后，我们必须删除可选的注解，修改序列化器以便从新序列化类中读取真实的字段，并删除可选的序列化器注册并将其添加到注册表Seq。
同时，我们纠正了代码中通过FieldSerializer强制序列化的错误，但这不在问题的范围内。

我假设您遇到所有这些麻烦是因为现有数据是用FieldSerializer序列化的，这会阻止您在保持向后兼容性的同时添加新字段。
如果是这样的话，那么我发现一件事很有用
1.将所有当前数据从使用FieldSerializer序列化的数据迁移到使用VersionFieldSerializer序列化的数据，使用如下方法：在这里，您需要使用两个序列化器注册子序列化器。

import com.esotericsoftware.kryo.Kryo;
import com.esotericsoftware.kryo.io.Input;
import com.esotericsoftware.kryo.serializers.FieldSerializer;
import com.esotericsoftware.kryo.serializers.VersionFieldSerializer;

public class FieldToVersionFieldMigrationSerializer<T> extends VersionFieldSerializer<T> {

  private final FieldSerializer<T> fieldSerializer;

  public FieldToVersionFieldMigrationSerializer(Kryo kryo, Class<T> type, FieldSerializer<T> fieldSerializer) {
    super(kryo, type);
    this.fieldSerializer = fieldSerializer;
  }

  @Override
  public T read(Kryo kryo, Input input, Class<T> type) {
    try {
      return super.read(kryo, input, type);
    } catch (Exception e) {
      return fieldSerializer.read(kryo, input, type);
    }
  }
}

1.迁移所有数据以支持VersionFieldSerializer后，可以引入新字段，并使用@Since对其进行注解以支持向后兼容性
此外，如果您已经解决了这个问题，请让我们知道您是如何做到的。