Skip to content

Technik Blog

Programmieren | Arduino | ESP32 | MicroPython | Python | Raspberry Pi | Raspberry Pi Pico

Menu
  • Smarthome
  • Gartenautomation
  • Arduino
  • ESP32 & Co.
  • Raspberry Pi & Pico
  • Solo Mining
  • Deutsch
  • English
Menu

Apache Groovy #13 – JSON Daten verarbeiten

Posted on 26. Oktober 202229. April 2023 by Stefan Draeger

In diesem Beitrag zeige ich dir, wie du JSON Daten in Apache Groovy verarbeiten und erstellen kannst.

  • Was sind JSON Daten und wie sind diese aufgebaut?
  • Eine kleine JSON-Datei
  • Parsen der JSON-Daten in Apache Groovy mit JsonSlurper
  • Listen im JSON verarbeiten
    • Ein komplexes JSON Parsen
  • Daten in ein JSON speichern
    • Benutzerdefinierte Ausgabe von JSON Daten
  • Quellenangabe

Was sind JSON Daten und wie sind diese aufgebaut?

Das JSON Format ist ein sehr strukturiertes Datenformat, in welchem du deine Daten textbasiert mit einem Schlüssel / Wertepaar ablegen kannst. Dabei kannst du Datenformate wie Text, Zahl und Listen verwenden.

Auf Wikipedia.org findest du einen sehr guten Artikel zum JSON Format sowie die Entstehungsgeschichte. Da all dieses für diesen Beitrag zu weit gehen würde, verlinke ich dir diesen gerne.

Seite „JavaScript Object Notation“. In: Wikipedia – Die freie Enzyklopädie. Bearbeitungsstand: 18. Oktober 2022, 14:18 UTC. URL: https://de.wikipedia.org/w/index.php?title=JavaScript_Object_Notation&oldid=227144590 (Abgerufen: 23. Oktober 2022, 15:32 UTC)

Eine kleine JSON-Datei

Erstellen wir zunächst eine kleine JSON-Datei, um diese später zu parsen.

{
  "Vorname": "Stefan",
  "Nachname": "Draeger",
  "Alter": 42
}

Im Internet gibt es diverse Tools zum Prüfen von JSON-Dateien, diese sollten wir vorab nutzen, um eventuelle Fehler in unserem Aufbau zu finden. Ich kann dir hier das Tool https://jsonformatter.org/json-parser empfehlen, welches wirklich recht einfach zu benutzen ist.

Parsen der JSON-Daten in Apache Groovy mit JsonSlurper

Die oben gezeigten Daten sind recht übersichtlich und wir können diese in einer Variablen ablegen.

Mit dem Objekt „JsonSlurper“ können wir sehr einfach ein JSON-Objekt in eine Map parsen und somit an die Daten über den Schlüssel (engl. Key) gelangen.

import groovy.json.JsonSlurper 

String jsonData = '{ "Vorname": "Stefan", "Nachname": "Draeger", "Alter": 42}'
println("JSON Daten: "+jsonData)
println("")

JsonSlurper jsonSlurper = new JsonSlurper()
Map data = jsonSlurper.parseText(jsonData)

data.each { schluessel, wert ->
    println("Schlüssel [$schluessel] = Wert [$wert]")
}

println("")

Ausgabe in der GroovyConsole:

JSON Daten: { "Vorname": "Stefan", "Nachname": "Draeger", "Alter": 42}

Schlüssel [Alter] = Wert [42]
Schlüssel [Nachname] = Wert [Draeger]
Schlüssel [Vorname] = Wert [Stefan]

https://groovy-lang.org/processing-json.html

Listen im JSON verarbeiten

Eine Liste in JSON wird mit einer öffnenden eckigen Klammer „[“ begonnen und endet mit der schließenden eckigen Klammer „]“.

Wir können nun recht einfach eine Liste mit Zahlen oder Text in einem Schlüssel / Wertepaar im JSON Format speichern.

{
 "Zahlen": [1,2,3,4,5],
 "Zeichen": ["ABC","DEF", "GHI", "JKL"]
}

Im Nachfolgenden zeige ich dir ein kleines Programm zum Parsen und ausgeben der beiden Listen aus dem JSON.

import groovy.json.JsonSlurper 

String jsonData = '''
{
 "Zahlen": [1,2,3,4,5],
 "Zeichen": ["ABC","DEF", "GHI", "JKL"]
}
'''
println("JSON Daten: "+jsonData)
println("")

JsonSlurper jsonSlurper = new JsonSlurper()
Map data = jsonSlurper.parseText(jsonData)

data.each { schluessel, wert ->
   println("Schlüssel [$schluessel] = Wert [$wert]")
   wert.each {println(it)}
}

println("")

Ausgabe in der GroovyConsole:

JSON Daten: 
{
 "Zahlen": [1,2,3,4,5],
 "Zeichen": ["ABC","DEF", "GHI", "JKL"]
}


Schlüssel [Zahlen] = Wert [[1, 2, 3, 4, 5]]
1
2
3
4
5
Schlüssel [Zeichen] = Wert [[ABC, DEF, GHI, JKL]]
ABC
DEF
GHI
JKL

Ein komplexes JSON Parsen

Wir können ebenfalls innerhalb von Listen auch ein komplexes Objekt speichern. Im nachfolgenden Beispiel möchte ich eine kleine Liste von Personen auslesen und in einem entsprechenden Objekt speichern.

{
  "Personen": {
    "Person": [
      {
        "Vorname": "Stefan",
        "Nachname": "Draeger",
        "Alter": 42
      },
      {
        "Vorname": "Max",
        "Nachname": "Mustermann",
        "Alter": 24
      },
      {
        "Vorname": "Melanie",
        "Nachname": "Musterfrau",
        "Alter": 36
      }
    ]
  }
}

Erzeugen wir zunächst die Klasse Person mit den Feldern

  • Vorname > String,
  • Nachname > String,
  • Alter > Integer
import groovy.transform.ToString

@ToString
class Person {

    String vorname;
    String nachname;
    Integer alter;

}

Hier jetzt das komplette Programm zum Auslesen aller Personen Objekte aus der JSON-Datei.

import groovy.transform.ToString
import groovy.json.JsonSlurper 

@ToString
class Person {

    String vorname;
    String nachname;
    Integer alter;

}

List<Person> personen = new ArrayList<>()

String jsonData = '''
{
  "Personen": {
    "Person": [
      {
        "Vorname": "Stefan",
        "Nachname": "Draeger",
        "Alter": 42
      },
      {
        "Vorname": "Max",
        "Nachname": "Mustermann",
        "Alter": 24
      },
      {
        "Vorname": "Melanie",
        "Nachname": "Musterfrau",
        "Alter": 36
      }
    ]
  }
}
'''


JsonSlurper jsonSlurper = new JsonSlurper()
Map data = jsonSlurper.parseText(jsonData)

data.each { schluessel, wert ->
   println("Schlüssel [$schluessel] = Wert [$wert]")
   assert wert instanceof Map
   wert.each {s,w ->
       w.each {
          personen.add(new Person(vorname: it["Vorname"], nachname: it["Nachname"], alter: it["Alter"])) 
       }      
   }
}

println("gespeicherte Personen: "+personen)

Ausgabe in der GroovyConsole:

Schlüssel [Personen] = Wert [[Person:[[Alter:42, Nachname:Draeger, Vorname:Stefan], [Alter:24, Nachname:Mustermann, Vorname:Max], [Alter:36, Nachname:Musterfrau, Vorname:Melanie]]]]
gespeicherte Personen: [Person(Stefan, Draeger, 42), Person(Max, Mustermann, 24), Person(Melanie, Musterfrau, 36)]

Daten in ein JSON speichern

Bisher habe ich dir lediglich gezeigt, wie du Daten aus einem JSON lesen und verarbeiten kannst, jetzt möchte ich dir gerne zeigen, wie du Daten in eine JSON-Datei speicherst.

Nutzen wir zunächst die zuvor gezeigte Klasse Person um eine Person mit den Daten Vorname, Nachname & Alter zu erzeugen.

Mit der Klasse JsonOutput und der Funktion toJson können wir nun recht einfach dieses Objekt in ein JSON String speichern.

Die Funktion toJson gibt es in diversen Implementationen, in meinem Fall verwende ich Implementation mit einem Parameter vom Typ java.lang.Object.

import groovy.json.JsonOutput

class Person{
  String vorname
  String nachname
  Integer alter
}

Person p1 = new Person(vorname:"Stefan", nachname:"Draeger", alter:42)

String jsonData = JsonOutput.toJson(p1)

println(jsonData)

Ausgabe in der GroovyConsole:

{"vorname":"Stefan","nachname":"Draeger","alter":42}

Benutzerdefinierte Ausgabe von JSON Daten

Mit der Klasse JsonOutput können wir ganze Objekte als JSON speichern, dabei werden alle Daten in das spätere JSON Objekt gespeichert, dieses führt dazu das die Ausgabe sehr groß wird und ggf. unnötige Daten enthält.

Hier können wir den JsonGenerator verwenden, dieser bietet die Möglichkeiten bestimmte Felder oder sogar Daten auszuschließen.

In meinem Fall musste ich die bereits installierte Groovy Version auf die neue Version 4.0.6 aktualisieren, um den JsonGenerator verwenden zu können.

Im nachfolgenden Beispiel habe ich das Feld „vorname“ von dem Export mit der Funktion „excludeFieldsByName“ ausgeschlossen.

import groovy.json.*

class Person{
  String vorname
  String nachname
  Integer alter
}

Person person = new Person(vorname:"Stefan", nachname:"Draeger", alter:42)

def generator = new JsonGenerator.Options()
                   .excludeFieldsByName('vorname')
                   .build()

println(generator.toJson(person))

Ausgabe in der GroovyConsole:

{"nachname":"Draeger","alter":42}

In der Ausgabe kannst du erkennen, dass das Feld „vorname“ im Erzeugen JSON wie erwartet fehlt.

Quellenangabe

Für diesen Beitrag habe ich die englische Dokumentation von https://groovy-lang.org/processing-json.html verwendet. Auf der genannten Seite findest weitergehende Informationen, wie du JSON Daten in Apache Groovy verarbeiten kannst.

Schreibe einen Kommentar Antworten abbrechen

Deine E-Mail-Adresse wird nicht veröffentlicht. Erforderliche Felder sind mit * markiert

Fragen oder Feedback?

Du hast eine Idee, brauchst Hilfe oder möchtest Feedback loswerden?
Support-Ticket erstellen

Newsletter abonnieren

Bleib auf dem Laufenden: Erhalte regelmäßig Updates zu neuen Projekten, Tutorials und Tipps rund um Arduino, ESP32 und mehr – direkt in dein Postfach.

Jetzt Newsletter abonnieren

Unterstütze meinen Blog

Wenn dir meine Inhalte gefallen, freue ich mich über deine Unterstützung auf Tipeee.
So hilfst du mit, den Blog am Leben zu halten und neue Beiträge zu ermöglichen.

draeger-it.blog auf Tipeee unterstützen

Vielen Dank für deinen Support!
– Stefan Draeger

Kategorien

Tools

  • Unix-Zeitstempel-Rechner
  • ASCII Tabelle
  • Spannung, Strom, Widerstand und Leistung berechnen
  • Widerstandsrechner
  • 8×8 LED Matrix Tool
  • 8×16 LED Matrix Modul von Keyestudio
  • 16×16 LED Matrix – Generator

Links

Blogverzeichnis Bloggerei.de TopBlogs.de das Original - Blogverzeichnis | Blog Top Liste Blogverzeichnis trusted-blogs.com

Stefan Draeger
Königsberger Str. 13
38364 Schöningen
Tel.: 01778501273
E-Mail: info@draeger-it.blog

Folge mir auf

link zu Fabook
link zu LinkedIn
link zu YouTube
link zu TikTok
link zu Pinterest
link zu Instagram
  • Impressum
  • Datenschutzerklärung
  • Disclaimer
  • Cookie-Richtlinie (EU)
©2025 Technik Blog | Built using WordPress and Responsive Blogily theme by Superb
Cookie-Zustimmung verwalten
Wir verwenden Technologien wie Cookies, um Geräteinformationen zu speichern und/oder darauf zuzugreifen. Wir tun dies, um das Surferlebnis zu verbessern und um personalisierte Werbung anzuzeigen. Wenn Sie diesen Technologien zustimmen, können wir Daten wie das Surfverhalten oder eindeutige IDs auf dieser Website verarbeiten. Wenn Sie Ihre Zustimmung nicht erteilen oder zurückziehen, können bestimmte Funktionen beeinträchtigt werden.
Funktional Immer aktiv
Die technische Speicherung oder der Zugang ist unbedingt erforderlich für den rechtmäßigen Zweck, die Nutzung eines bestimmten Dienstes zu ermöglichen, der vom Teilnehmer oder Nutzer ausdrücklich gewünscht wird, oder für den alleinigen Zweck, die Übertragung einer Nachricht über ein elektronisches Kommunikationsnetz durchzuführen.
Vorlieben
Die technische Speicherung oder der Zugriff ist für den rechtmäßigen Zweck der Speicherung von Präferenzen erforderlich, die nicht vom Abonnenten oder Benutzer angefordert wurden.
Statistiken
Die technische Speicherung oder der Zugriff, der ausschließlich zu statistischen Zwecken erfolgt. Die technische Speicherung oder der Zugriff, der ausschließlich zu anonymen statistischen Zwecken verwendet wird. Ohne eine Vorladung, die freiwillige Zustimmung deines Internetdienstanbieters oder zusätzliche Aufzeichnungen von Dritten können die zu diesem Zweck gespeicherten oder abgerufenen Informationen allein in der Regel nicht dazu verwendet werden, dich zu identifizieren.
Marketing
Die technische Speicherung oder der Zugriff ist erforderlich, um Nutzerprofile zu erstellen, um Werbung zu versenden oder um den Nutzer auf einer Website oder über mehrere Websites hinweg zu ähnlichen Marketingzwecken zu verfolgen.
Optionen verwalten Dienste verwalten Verwalten von {vendor_count}-Lieferanten Lese mehr über diese Zwecke
Einstellungen anzeigen
{title} {title} {title}