convalidare json in scala con lift-json

StackOverflow https://stackoverflow.com/questions/9474417

  •  13-11-2019
  •  | 
  •  

Domanda

Vorrei verificare che json contenga un elenco di chiavi/valori prima di tentare di eseguire il marshalling in una classe case utilizzando lift-json.I dati potrebbero essere nidificati.

Per esempio:

{ 
 "name": "stack",
 "desc": "desc",
 "age": 29,
 "address": {
  "street": "123 elm", 
  "postal_code": 22222,
  "city": "slc",
 }
}

In quali modi posso verificare che questo JSON contenga valori per "nome", "età" e "indirizzo\via"?Supponiamo che tutti gli altri campi siano facoltativi.

Scusate se mi manca qualcosa di ovvio, ma sospetto che qualcosa del genere sia stato risolto prima.

A proposito, qualcuno ha provato Orderly? https://github.com/nparry/orderly4jvm

È stato utile?

Soluzione

Per come la vedo io hai alcune opzioni:

  1. Potresti utilizzare "API parser pull di basso livello" di lift-json (cerca quella frase su questa pagina) per afferrare ciascuno dei campi che ti interessano.Se non hai ottenuto tutti i campi desiderati nel momento in cui incontri il token Fine, lanci un'eccezione.Se disponi del campo obbligatorio, crea il tuo oggetto.

    Pro:Questo analizza il JSON solo una volta.È il modo più performante di utilizzare lift-json.

    Contro:Hai creato un software fragile e arrotolato a mano.

  2. Potresti usare JsonAST di lift-json, che è il normale risultato della chiamata its parse metodo (cercare "Parsing JSON" su questa pagina), quindi le sue espressioni simili a XPath (cerca "XPath + HOFs" su questa pagina) per determinare se i campi obbligatori sono presenti.Se lo sono, crea il tuo oggetto passando i campi appropriati al costruttore.

    Pro:Meno mano lanciata del n. 1.Analizza i dati solo una volta.

    Contro:Questo non è così veloce come il punto 2.

  3. Utilizzare i metodi da #1 o #2 per determinare se i campi obbligatori sono presenti.Se lo sono, usa la deserializzazione di lift-json (cerca l'intestazione "Serializzazione" su questa pagina) per creare e opporsi.

    Pro: Mi sto davvero sforzando qui... Se ti aspettassi che gran parte dei dati fossero errati, saresti in grado di determinarlo prima di avviare il processo un po' più pesante di deserializzazione lift-json

    Contro:Hai analizzato i dati due volte nel caso in cui i dati siano validi.

  4. Basta usare la deserializzazione di lift-json (cercare l'intestazione "Serializzazione" su questa pagina).Fa più o meno ciò che è descritto al punto 2, tranne che utilizza la riflessione per capire quali campi sono obbligatori.

    Pro:Questa è la soluzione più sostenibile

    Contro:È più lento del numero 1 e del numero 2.

La mia raccomandazione:A meno che tu non abbia assolutamente bisogno delle migliori prestazioni possibili, usa il punto 4.Se hai davvero bisogno di velocità, usa il numero 1.Un altro vantaggio derivante dall'utilizzo di una soluzione di stile #1 o #2 è che consentono di eseguire una strana coercizione sui dati, ad esempio mappare due nomi di campo alternativi in ​​JSON su un singolo campo nell'oggetto scala.

Altri suggerimenti

Questo ha funzionato per me:JSON a XML in Scala e trattare l'opzione ()

Ecco una mia semplice domanda da una mia precedente domanda. Non è una corrispondenza perfetta per le tue esigenze, ma può darti alcune idee:

import util.parsing.json.JSON._

object JsonSoap {
  def main(args: Array[String]) {
    val x = parseFull("""{"name":"Joe","surname":"SOAP"}""")

    val y = x collect {
      case m: Map[_, _] => m collect {
        case (key: String, value: String) => key -> value
      }
    }

    val z = for (m <- y; name <- m.get("name"); surname <- m.get("surname"))
    yield {
      <soap:Envelope xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:xsd="http://www.w3.org/2001/XMLSchema" xmlns:soap="http://schemas.xmlsoap.org/soap/envelope/">
        <soap:Body>
          <Person>
            <Name>{name}</Name>
            <Surname>{surname}</Surname>
          </Person>
        </soap:Body>
      </soap:Envelope>
    }

    println(z)
  }
}

Hai dato un'occhiata a questi:

Analizza JSON in Scala utilizzando Standard Scala

Analizzare json e iterare attraverso l'oggetto

Semplice da json a XML

Fondamentalmente stai convalidando lo schema, quindi crea un descrittore che corrisponda al tuo oggetto e cammina l'oggetto usando la convalida di Jsonast che ogni livello ha gli elementi giusti. Il modo in cui strutturi il tuo validatore dipende da te, ma mi spedirei i tipi in modo da poter camminare sia l'AST che il validatore insieme.

Ho sviluppato questo parser/validatore JSONhttps://github.com/higherstate/jameson

Il nostro team ha iniziato a guardare l'ordinato. Per gli oggetti JSON che stiamo usando, ordinati può descriverli sufficientemente. Penso che li useremo.

La libreria ordinata che hai menzionato: https://github.com/nparry/orderly4jvmSembra essere molto buono. Fornisce messaggi di errore decenti quando la convalida non riesce.

Abbiamo esaminato l'uso dello schema JSON, in particolare la Biblioteca Java JSON-Schema-Validatore:https://github.com/fge/json-schema-validator

I messaggi di errore non erano così descrittivi.

Autorizzato sotto: CC-BY-SA insieme a attribuzione
Non affiliato a StackOverflow
scroll top