Analysieren Sie JSON-Strings in Scala

1. Verwenden Sie Option, um JSON-Strings in Scala zu parsen
2. Verwenden Sie APIs zum Parsen von JSON-Strings in Scala
3. Abschluss

In diesem Artikel erfahren Sie, wie Sie JSON-Strings in der Programmiersprache Scala parsen.

JSON ist ein gängiges Format für den Austausch von und zu einem Webserver. Das Ziel hier ist also, dass wir einen gegebenen JSON-String mit einem Array von Objekten in Scala-Objekte deserialisieren wollen, damit wir ihn in unserer Anwendung verwenden können.

Wir können JSON mit den einfachen Scala-Methoden und -Funktionen parsen oder verschiedene APIs und Bibliotheken verwenden, um JSON-Dateien wie die Lift-JSON-Bibliothek und Circe zu parsen.

Verwenden Sie Option, um JSON-Strings in Scala zu parsen

Wir können Option zusammen mit Pattern Match in Scala verwenden, um einen JSON-String zu parsen. Nehmen wir an, wir haben die folgende JSON-Zeichenfolge:

{
        "languages": [{
            "name": "English",
            "is_active": true,
            "completeness": 4.5
        }, {
            "name": "Japanese",
            "is_active": true,
            "completeness": 1.4
        }]
}

Wir können den folgenden Code verwenden, um ihn Scala-Objekten zuzuordnen:

class parse[T]
{
    def unapply(X:Option[Any]):Option[T] = if(X.isEmpty) {
        None
    } else {
        Some(X.get.asInstanceOf[T])
    }
}

object A extends parse[Map[String,Any]]
object B extends parse[List[Any]]
object C extends parse[String]
object D extends parse[Double]
object E extends parse[Boolean]

for{
    A(mp) <- List(JSON.parseFull(str))
    B(languages) = mp.get("languages")
    language<-languages
    A(temp) = Some(language)
    C(store_name) = temp.get("name")
    E(check_active) = temp.get("is_active")
    D(completeness_level) = temp.get("completeness")
}
yield{
    (store_name,check_active,completeness_level)
}

Verwenden Sie APIs zum Parsen von JSON-Strings in Scala

Wir können eine bekannte Lift-JSON-Bibliothek verwenden, um die JSON-Zeichenfolge zu analysieren. Diese Bibliothek enthält viele Methoden, die verwendet werden könnten, um die JSON-Zeichenfolge in Scala-Objekte zu deserialisieren.

Beispielcode:

import net.liftweb.json.DefaultFormats
import net.liftweb.json._

case class Employee(
    Name: String,
    id: Int,
    username: String,
    password: String,
    DepartmentsWorking: List[String]
)

object ParseJsonArray extends App {
    implicit val formats = DefaultFormats

    val str ="""
    {
      "employees": [
    { "Account": {
      "Name": "YMail",
      "id": 3,
      "username": "srj",
      "password": "123456srj",
      "DepartmentsWorking": ["sales", "IT", "HR"]
    }},
    ]}
    """

    val json = parse(str)
    val contents = (json \\ "Account").children
    for (temp <- contents) {
        val m = temp.extract[Employee]
        println(s"Employee: ${m.Name}, ${m.id}")
        println(" Departments working: " + m.DepartmentsWorking.mkString(","))
    }
}

Im obigen Code haben wir eine Case-Klasse Employee erstellt, um die JSON-Daten abzugleichen.

Der Vorteil der Verwendung von APIs besteht darin, dass sie uns dabei helfen, prägnanteren Code zu schreiben und viele Funktionen bereitzustellen, die primitive Scala-Methoden möglicherweise nicht bieten.

Abschluss

In diesem Artikel haben wir zwei Methoden gesehen, eine, bei der wir einfache alte Scala-Methoden verwendet haben, und eine andere, bei der wir eine andere Methode verwendet haben, bei der wir eine bekannte API zum Analysieren der JSON-Zeichenfolge verwendet haben. Und wir haben verstanden, dass APIs beim Parsen aufgrund der Einfachheit des Schreibens und seiner Funktionalitäten immer bevorzugt werden.