Scala 提升案例对象的json序列化

我想为JSON序列化定义一个类，如下所示：

case class Foo(id: String, variety: Variety)

sealed trait Variety
case object Bar extends Variety { override def toString = "1" }
case object Baz extends Variety { override def toString = "2" }

它应该像这样序列化和反序列化：

write[Foo](Foo("foo1", Bar))
"""{"id":"foo1", "variety":"1"}"""

read[Foo]("""{"id":"foo2", "variety":"2"}""")
Foo("foo2", Baz)

但是它序列化到

{id:“foo2”，“variety:{}}

，并且无法反序列化。可以使用这样的case对象吗？我使用的是lift-json_2.10 2.6-M2

---

使用lift json处理枚举有更好的方法吗？

我使用以下类为case对象创建自定义序列化程序，而不是case对象，而是将

Variation

设置为case类和

Bar

/

Baz

s

。 如果您关心json的格式，只需选择fieldKey和identifierOverride就可以了

object SpecialObjectSerializers {
  val FieldKeyDefault = "scalaObject"

  class SingleObjectSerializer[T <: AnyRef](obj: T, FieldKey : String = FieldKeyDefault,
                                             identifierOverride : Option[JValue] = None) extends Serializer[T] {
    val Identifier = identifierOverride.getOrElse(JString(obj.getClass.getName))
    override def serialize(implicit format: Formats): PartialFunction[Any, JValue] = {
      case `obj` =>
        JObject(List(JField(FieldKey, Identifier)))
    }
    override def deserialize(implicit format: Formats): PartialFunction[(TypeInfo, JValue), T] = {
      case (_, JObject(List(JField(FieldKey, Identifier)))) => obj
    }
  }

  class RichSerializer[T](serializer: Serializer[T]) {
    def +(that: Serializer[T]) = {
      new Serializer[T] {
        override def deserialize(implicit format: Formats) = serializer.deserialize.orElse(that.deserialize)
        override def serialize(implicit format: Formats) = serializer.serialize.orElse(that.serialize)
      }
    }
  }

  implicit def toRichSerializer[T](serializer: Serializer[T]) = new RichSerializer(serializer)

  def caseObjectsSerializer[T <: AnyRef](objs: T*): Serializer[T] = {
    val serializers: Seq[Serializer[T]] = objs.map(new SingleObjectSerializer(_))
    serializers.reduceLeft[Serializer[T]] {
      case (s1, s2) => s1 + s2
    }
  }
}

对象特殊对象序列化程序{
val FieldKeyDefault=“scalaObject”
类SingleObjectSerializer[T
JObject（列表（JField（FieldKey，标识符）））
}
重写def反序列化（隐式格式：格式）：PartialFunction[（TypeInfo，JValue），T]={
case（u，JObject（List（JField（FieldKey，Identifier）））=>obj
}
}
类RichSerializer[T]（序列化程序：序列化程序[T]）{
def+（即：序列化程序[T]）={
新序列化程序[T]{
重写def反序列化（隐式格式：Formats）=serializer.deserialize.orElse（that.deserialize）
重写def serialize（隐式格式：Formats）=serializer.serialize.orElse（that.serialize）
}
}
}
隐式def toRichSerializer[T]（序列化程序：序列化程序[T]）=新的RichSerializer（序列化程序）
def壳体对象蒸发器[T s1+s2
}
}
}