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?
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.