如何使用 play-json 忽略空对象？

Question

我是 Scala 和函数式编程的新手，所以这个问题可能有一个非常简单的答案。但是，我无法弄清楚，所以这里是：

我有一个案例类层次结构，它表示编译器中的抽象语法树。在某些时候，我有一个List[Statement] 形式的语句列表。这将使用 Json 对象数组进行序列化，其中每个对象代表一个语句。但是，有些语句是多余的，所以我不想序列化它们。例如，返回 void。以下代码有望澄清这一点：

sealed trait Statement

sealed trait Expression

case object Empty extends Expression

case class Return(e: Expression) extends Statement

我想要的是根本不序列化 Return(Empty)。现在我得到类似的东西：

"Return": {}

我怎样才能简单地忽略 Return(Empty) ？ 使其更通用。我不想像{} 这样的json 中有空对象。我如何确保他们不会进入我的 json？

这是我迄今为止尝试过的（但没有奏效）：

implicit val statementListWrites = StatementListWrites

object StatementListWrites extends Writes[List[Statement]] {
  override def writes(stms: List[Statement]) =
    JsArray(stms.filter(stm => {
      stm match {
        case Return(Empty) => false
        case _ => true
      }
    }).map(s => Json.toJson(s)))
}

也许上述技术有效，但由于某种原因，据我所知，它甚至没有被称为开始。

Answer 1

在这种情况下你应该小心，因为你有密封的特质，所以你应该有条不紊地工作。

让我们将问题分解为更小的问题，假设您只想将对象写入 json。那么我们就可以解决删除空对象的问题了。

我添加了更多类来阐明这个想法：

sealed trait Expression
case object Empty extends Expression
case class NonEmptyExpression(x: Int) extends Expression

sealed trait Statement
case class Return(e: Expression) extends Statement
case class NoReturn(x: Int) extends Statement

第一步（为表达式提供编写器）：

为此，您必须为Empty 和NonEmptyExpression 创建作家，所以我们可以这样做：

val emptyExpressionWrites = new Writes[Empty.type] {
  override def writes(e: Empty.type) = Json.obj()
}

val nonEmptyExpressionWrites = Json.writes[NonEmptyExpression]

implicit val expressionWrites = new Writes[Expression] {
  override def writes(exp: Expression) = {
    exp match {
      case Empty => emptyExpressionWrites.writes(Empty)
      case nonEmptyExpression: NonEmptyExpression => nonEmptyExpressionWrites.writes(nonEmptyExpression)
    }
  }
}

第二步（为语句提供作者）：

您必须为Return 和NoReturn 提供作家。请注意，play 能够知道如何为Return 创建作家，并且它有Expression，因为我将expressionWriter 定义为implicit。所以它现在知道如何序列化Expression。

val returnWrites = Json.writes[Return]
val noReturnWrites = Json.writes[NoReturn]

val statementWrites = new Writes[Statement] {
  override def writes(s: Statement) = {
    s match {
      case r: Return => returnWrites.writes(r)
      case nr: NoReturn => noReturnWrites.writes(nr)
    }
  }
}

让我们测试一下，确保它正常工作：

val statementWithNonEmpty = Return(NonEmptyExpression(100))
println(s"statementWithNonEmpty Json: ${statementWrites.writes(statementWithNonEmpty).toString()}")

val statementWithEmpty = Return(Empty)
println(s"statementWithEmpty Json: ${statementWrites.writes(statementWithEmpty).toString()}")

输出是：

statementWithNonEmpty Json: {"e":{"x":100}}

statementWithEmpty Json: {"e":{}}

最后一步（创建没有 Empty 的 List writer）：

val listStatementWrites = new Writes[Seq[Statement]] {
  override def writes(o: Seq[Statement]) = {
    val listWithoutEmpty = o.filter {
      case Return(Empty) => false
      case _ => true
    }

    JsArray(listWithoutEmpty.map(statementWrites.writes))
  }
}

让我们试试吧：

val listOfStatements = List(Return(NonEmptyExpression(100)), Return(Empty), Return(NonEmptyExpression(200)))
println(s"listOfStatements: ${listStatementWrites.writes(listOfStatements).toString()}")

输出是：

listOfStatements: [{"e":{"x":100}},{"e":{"x":200}}]