如何在Scala中以字符串形式读取嵌套json对象的一部分

user 发表于 Dev

用户

我想将json对象读入scala类，该类将json对象的一部分保留为字符串，而不尝试解析它。

这是json的样子：

[
  {
    "contractType": "NullContract",
    "contractDefinition": {
      "column": "age",
      "conditions": [
        {
          "conditionType": "equalsCondition",
          "conditionDefinition": {
            "column": "species",
            "value": "person"
          }
        }
      ]
    }
  }
]

我正在使用杰克逊图书馆。这是我的映射器：

val mapper = new ObjectMapper()
    .registerModule(DefaultScalaModule)
    .configure(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES, false)
    .setSerializationInclusion(Include.NON_ABSENT)

这是我的课：

case class ContractJson(contractType: String, contractDefinition: String)

，这就是我希望得到的对象看起来的样子。

这是解析它的代码：

val contractJson: Array[ContractJson] = mapper.readValue(contractsJsonString, classOf[Array[ContractJson]])

我收到的错误消息：Can not deserialize instance of java.lang.String out of START_OBJECT token开始解析时contractDefinition

安德烈（Andriy Plokhotnyuk）

如果允许使用其他库，并且contractDefinition字段类型不限于此，请String尝试jsoniter-scala的将原始JSON值提取到字节数组的功能。

您将需要添加依赖项：

libraryDependencies ++= Seq(
  "com.github.plokhotnyuk.jsoniter-scala" %% "jsoniter-scala-core"   % "1.1.0" % Compile,
  "com.github.plokhotnyuk.jsoniter-scala" %% "jsoniter-scala-macros" % "1.1.0" % Provided // required only in compile-time
)

然后使用编解码器定义类型并解析输入：

import java.nio.charset.StandardCharsets.UTF_8

import com.github.plokhotnyuk.jsoniter_scala.macros._
import com.github.plokhotnyuk.jsoniter_scala.core._

import scala.util.hashing.MurmurHash3

object RawVal {
  def apply(s: String) = new RawVal(s.getBytes)

  implicit val codec: JsonValueCodec[RawVal] = new JsonValueCodec[RawVal] {
    override def decodeValue(in: JsonReader, default: RawVal): RawVal = new RawVal(in.readRawValAsBytes())

    override def encodeValue(x: RawVal, out: JsonWriter): Unit = out.writeRawVal(x.bs)

    override val nullValue: RawVal = new RawVal(new Array[Byte](0))
  }
}

case class RawVal private(bs: Array[Byte]) {
  def this(s: String) = this(s.getBytes(UTF_8))

  override lazy val hashCode: Int = MurmurHash3.arrayHash(bs)

  override def equals(obj: Any): Boolean = obj match {
    case that: RawVal => java.util.Arrays.equals(bs, that.bs)
    case _ => false
  }

  override def toString: String = new String(bs, UTF_8)
}

case class ContractJson(contractType: String, contractDefinition: RawVal)

implicit val codec: JsonValueCodec[List[ContractJson]] = JsonCodecMaker.make(CodecMakerConfig)

val jsonBytes =
  """[
    |  {
    |    "contractType": "NullContract",
    |    "contractDefinition": {
    |      "column": "age",
    |      "conditions": [
    |        {
    |          "conditionType": "equalsCondition",
    |          "conditionDefinition": {
    |            "column": "species",
    |            "value": "person"
    |          }
    |        }
    |      ]
    |    }
    |  }
    |]
    |""".stripMargin.getBytes("UTF-8")

val contractJsons = readFromArray(jsonBytes)

println(contractJsons)

打印结果将是：

List(ContractJson(NullContract, {
  "column": "age",
  "conditions": [
    {
      "conditionType": "equalsCondition",
      "conditionDefinition": {
        "column": "species",
        "value": "person"
      }
    }
  ]
}))

本文收集自互联网，转载请注明来源。

如有侵权，请联系 [email protected] 删除。