Альтернатива синтаксическому анализу json с параметром [либо [A, B]] в scala - PullRequest
Новая
       44

Альтернатива синтаксическому анализу json с параметром [либо [A, B]] в scala

2 голосов
/ 18 февраля 2020

Например, здесь payload является необязательным и имеет 3 варианта:

Как я могу проанализировать json с типами, подобными опции [либо [A, B, C]], но использовать абстрактный тип данных, использующий вещи запечатанный тип черты или сумма?

Ниже приведен минимальный пример с некоторой котельной пластиной:

https://scalafiddle.io/sf/K6RUWqk/1


// Start writing your ScalaFiddle code here
val json =
  """[
       {
         "id": 1,
         "payload" : "data"
       },
       {
         "id": 2.1,
         "payload" : {
           "field1" : "field1",
           "field2" : 5,
           "field3" : true
         }
       },
      {
         "id": 2.2,
         "payload" : {
           "field1" : "field1",
         }
       },
       {
         "id": 3,
          payload" : 4
       },
       {
         "id":4,
          "
       }
     ]"""

final case class Data(field1: String, field2: Option[Int])
type Payload = Either[String, Data]
final case class Record(id: Int, payload: Option[Payload])

import io.circe.Decoder
import io.circe.generic.semiauto.deriveDecoder

implicit final val dataDecoder: Decoder[Data] = deriveDecoder
implicit final val payloadDecoder: Decoder[Payload] = Decoder[String] either Decoder[Data]
implicit final val recordDecoder: Decoder[Record] = deriveDecoder

val result = io.circe.parser.decode[List[Record]](json)
println(result)

1 Ответ

3 голосов
/ 18 февраля 2020

Ваш код почти в порядке, у вас просто проблемы с синтаксисом в json, и Record.id должно быть Double вместо Int - потому что это поле присутствует в вашем json ("id": 2.1 ). Пожалуйста, найдите исправленную версию ниже: 

val json =
      s"""[
       {
         "id": 1,
         "payload" : "data"
       },
       {
         "id": 2.1,
         "payload" : {
           "field1" : "field1",
           "field2" : 5,
           "field3" : true
         }
       },
       {
         "id": 2.2,
         "payload" : {
           "field1" : "field1"
         }
       },    





       {
         "id": 3,
         "payload" : 4
       },





       {
         "id": 4
       }
     ]"""

    type Payload = Either[String, Data]
    final case class Data(field1: String, field2: Option[Int])
    final case class Record(id: Double, payload: Option[Payload]) // id is a Double in your json in some cases

    import io.circe.Decoder
    import io.circe.generic.semiauto.deriveDecoder

    implicit val dataDecoder: Decoder[Data] = deriveDecoder
    implicit val payloadDecoder: Decoder[Payload] = Decoder[String] either Decoder[Data]
    implicit val recordDecoder: Decoder[Record] = deriveDecoder

    val result = io.circe.parser.decode[List[Record]](json)
    println(result)

Который произвел в моем случае: 

Right(List(Record(1.0,Some(Left(data))), Record(2.1,Some(Right(Data(field1,Some(5))))), Record(2.2,Some(Right(Data(field1,None)))), Record(3.0,Some(Left(4))), Record(4.0,None)))

ОБНОВЛЕНИЕ:

Более общий подход будет использовать так называемый Sum Types или простыми словами - общий sealed trait с несколькими различными реализациями. Пожалуйста, смотрите более подробную информацию на следующей странице Circe do c: https://circe.github.io/circe/codecs/adt.html

В вашем случае это может быть достигнуто примерно так: 

import cats.syntax.functor._
  import io.circe.Decoder
  import io.circe.generic.semiauto.deriveDecoder

  sealed trait Payload

  object Payload {
    implicit val decoder: Decoder[Payload] = {
      List[Decoder[Payload]](
        Decoder[StringPayload].widen,
        Decoder[IntPayload].widen,
        Decoder[ObjectPayload].widen
      ).reduce(_ or _)
    }
  }

  case class StringPayload(value: String) extends Payload

  object StringPayload {
    implicit val decoder: Decoder[StringPayload] = Decoder[String].map(StringPayload.apply)
  }

  case class IntPayload(value: Int) extends Payload

  object IntPayload {
    implicit val decoder: Decoder[IntPayload] = Decoder[Int].map(IntPayload.apply)
  }

  case class ObjectPayload(field1: String, field2: Option[Int]) extends Payload

  object ObjectPayload {
    implicit val decoder: Decoder[ObjectPayload] = deriveDecoder
  }

  final case class Record(id: Double, payload: Option[Payload])

  object Record {
    implicit val decoder: Decoder[Record] = deriveDecoder
  }

  def main(args: Array[String]): Unit = {
    val json =
      s"""[
       {
         "id": 1,
         "payload" : "data"
       },
       {
         "id": 2.1,
         "payload" : {
           "field1" : "field1",
           "field2" : 5,
           "field3" : true
         }
       },
       {
         "id": 2.2,
         "payload" : {
           "field1" : "field1"
         }
       },
       {
         "id": 3,
         "payload" : "4"
       },
       {
         "id": 4
       }
     ]"""

    val result = io.circe.parser.decode[List[Record]](json)
    println(result)
  }

, который В моем случае выдается следующий вывод: 

Right(List(Record(1.0,Some(StringPayload(data))), Record(2.1,Some(ObjectPayload(field1,Some(5)))), Record(2.2,Some(ObjectPayload(field1,None))), Record(3.0,Some(StringPayload(4))), Record(4.0,None)))

Надеюсь, это поможет!

...