Posted: Januar 18th, 2014 | Filed under: Java, Programmieren, Software, Tutorials | Tags: Config, datei, File, INI-Alternative, JSON, Konfigurationsdatei, Property | 1 Comment »
In meiner langjährigen Programmiererfahrung hatte ich schon öfters die Ehre mit sogenannten .ini- bzw. Property-Dateien zu arbeiten. Ich muss sagen, wirklich zufrieden war ich damit nie. Oft gab es Probleme mit der Identifikation von boolean Werten. Auch das behandeln von Listen in der jeweiligen Property-Datei war stets ein Sonderfall und handelte mir manchmal Schwierigkeiten ein. Ich glaube nicht mal das meine Abneigung an den prinzipiellen Aufbau und Grundgedanken einer .ini-Dateie gerichtet ist, vielmehr stören mich die mangelhaften Implementierungen der jeweiligen Programmiersprachen.
In folgendem Artikel möchte ich euch meine Implementierung einer Konfigurationsdatei auf Basis von JSON vorstellen. Diese verwendet die Bibliothek GSON und wird für folgende Implementierung benötigt. Wie ihr die Bibliothek in euer Projekt einbinden könnt erfahrt ihr hier nachlasen.
Die Klasse Config.java verwendet den Singleton-Mechanismus. Vorteil: Ihr müsst die Konfigurationsdatei nur einmal laden und erhält im Anschluss darauf Zugriff auf die jeweiligen Attribute innerhalb jeder anderen Klasse in eurer Applikation.
Config.java
package de.roth.json.config;
import java.io.BufferedReader;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileWriter;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.ArrayList;
import com.google.gson.Gson;
import com.google.gson.GsonBuilder;
public class Config {
// Hier schreibst du deine Attribute hin
public String TITLE;
public int WIDTH;
public int HEIGHT;
public double RATIO;
public ArrayList<String> NAMES;
public Config() {
// Hier die Standardwerte der Attribute, falls diese
// nicht in der Konfigurationsdatei vorhanden sind.
this.WIDTH = 800;
this.HEIGHT = 600;
this.RATIO = 0.6;
this.NAMES = new ArrayList<String>();
this.NAMES.add("Peter");
this.NAMES.add("Paul");
}
// DON'T TOUCH THE FOLLOWING CODE
private static Config instance;
public static Config getInstance() {
if (instance == null) {
instance = fromDefaults();
}
return instance;
}
public static void load(File file) {
instance = fromFile(file);
// no config file found
if (instance == null) {
instance = fromDefaults();
}
}
public static void load(String file) {
load(new File(file));
}
private static Config fromDefaults() {
Config config = new Config();
return config;
}
public void toFile(String file) {
toFile(new File(file));
}
public void toFile(File file) {
Gson gson = new GsonBuilder().setPrettyPrinting().create();
String jsonConfig = gson.toJson(this);
FileWriter writer;
try {
writer = new FileWriter(file);
writer.write(jsonConfig);
writer.flush();
writer.close();
} catch (IOException e) {
e.printStackTrace();
}
}
private static Config fromFile(File configFile) {
try {
Gson gson = new GsonBuilder().setPrettyPrinting().create();
BufferedReader reader = new BufferedReader(new InputStreamReader(
new FileInputStream(configFile)));
return gson.fromJson(reader, Config.class);
} catch (FileNotFoundException e) {
return null;
}
}
@Override
public String toString() {
Gson gson = new GsonBuilder().setPrettyPrinting().create();
return gson.toJson(this);
}
} |
Die Verwendung dieser Klasse ist sehr einfach. Schaut selbst:
Test.java
package de.roth.json.config;
public class Test {
public static void main(String[] args) {
// Konfigurationsdatei laden, falls vorhanden.
// Ansonsten werden die Werte im Konstruktor verwendet
Config.load("config.json");
// Zugriff auf Attribut
Config.getInstance().TITLE = "Neuer Titel";
Config.getInstance().RATIO = 0.4;
for (String s : Config.getInstance().NAMES) {
System.out.println(s);
}
// Speichern der Konfigurationsdatei
Config.getInstance().toFile("config.json");
}
} |
Da in unserem Beispiel noch keine Konfigurationsdatei vorhanden war ergibt sich nach dem ändern und sichern der Konfiguration folgende JSON-Datei.
{
"TITLE": "Neuer Titel",
"WIDTH": 800,
"HEIGHT": 600,
"RATIO": 0.4,
"NAMES": [
"Peter",
"Paul"
]
} |
Mit Hilfe dieser Implementierung und GSON ist es natürlich auch möglich vollständige Objekte als Konfigurationsattribut abzulegen. GSON löst automatisch jedes Objekt in primitive Datenstrukturen auf und speichert es im Anschluss darauf als JSON-Objekt in der Konfigurationsdatei ab.
GitHub
Den Quellcode zu dem Projekt könnt ihr euch auch auf GitHub ansehen:
https://github.com/frankred/json-config-file
Download
Das ganze Beispiel könnt ihr euch zusätzlich hier als vollständiges Eclipse-Projekt herunterladen.
Posted: Dezember 4th, 2013 | Filed under: Java, Programmieren | Tags: Java, JAVA JSON lesen, JAVA read JSON, JSON, JSON decode | 9 Comments »
Da sich JSON aus meiner Sicht immer mehr gegenüber dem Klassiker XML durchsetzt und ich mittlerweile auch die Verwendung einer JSON-Datei gegenüber einer gängigen “Property-Datei” (*.ini) bevorzuge, hier ein kleines Tutorial mit Hilfe ihr von Googles JSON-Bibliothek gson Json-Dateien einlesen bzw. erzeugen könnt.
GSON Bibliothek herunterladen und einbinden
Zu allererst müsst ihr die Java-Bibliothek gson herunterladen: https://code.google.com/p/google-gson/downloads/list und entpacken. Für die Verwendung benötigt ihr lediglich die Datei gson-X.X.X.jar.
Falls ihr eclipse als IDE eurer Wahl verwendet, könnt ihr hier nachlesen wie ihr diese genau einbindet (unter dem Abschnitt “Bibliothek ins Projekt importieren”).
JSON-Datei lesen
Als Beispiel verwende ich folgende, relativ simple JSON-Datei, welche dennoch alle wichtigen Strukturen wie Array oder Objekt beinhaltet.
personen.json
{
"personen" : [
{
"name" : "Frank",
"alter" : 27,
"hobbys" : [
{
"name" : "Karlsruher SC"
},
{
"name" : "Computer spielen"
}
]
},
{
"name" : "Peter",
"alter" : 21,
"hobbys" : [
{
"name" : "Tennis"
},
{
"name" : "Boxen"
}
]
}
]
}
Prinzipiell kann man JSON-Dateien mit Hilfe zwei verschiedener Vorgehensweise auslesen. Entweder direkt über ein vorhandenes Java-Objekt, oder allgemein über das sogenannte JsonObject. In diesem Beispiel verwende ich den Weg über das JsonObject.
GsonExample.java
import java.io.BufferedReader;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.InputStreamReader;
import com.google.gson.Gson;
import com.google.gson.JsonArray;
import com.google.gson.JsonObject;
public class GsonExample {
public static void main(String[] args) {
Gson gson = new Gson();
try {
// Datei "personen.json" über einen Stream einlesen
FileInputStream input = new FileInputStream("personen.json");
BufferedReader reader = new BufferedReader(new InputStreamReader(input));
// Datei als JSON-Objekt einlesen
JsonObject json = gson.fromJson(reader, JsonObject.class);
// Attribut "personen" als Array lesen
JsonArray personen = json.getAsJsonArray("personen");
for(int i = 0; i < personen.size(); i++){
JsonObject person = personen.get(i).getAsJsonObject();
// Attribute ausgeben z.B.: name, alter und hobbies
System.out.println(person.get("name").getAsString());
System.out.println(person.get("alter").getAsInt());
// Attribut "hobbys" als Array lesen
JsonArray hobbys = person.get("hobbys").getAsJsonArray();
for(int k = 0; k < hobbys.size(); k++){
JsonObject hobby = hobbys.get(k).getAsJsonObject();
// Name des Hobbys ausgeben
System.out.println(hobby.get("name").getAsString());
}
System.out.println("------");
}
} catch (FileNotFoundException e) {
e.printStackTrace();
}
}
} |
Konsolenausgabe
Frank
27
Karlsruher SC
Computer spielen
——
Peter
21
Tennis
Boxen
——
Ich hoffe ich konnte dem ein oder anderen damit helfen. Wie ihr ein vorhandenes Java-Objekt inklusive der vollständigen Daten-Struktur in eine JSON-Datei umwandelt und wieder einliest zeige ich euch das nächste mal.
Ein Karlsruher Bloggt!
In meiner langjährigen Programmiererfahrung hatte ich schon öfters die Ehre mit sogenannten .ini- bzw. Property-Dateien zu arbeiten. Ich muss sagen, wirklich zufrieden war ich damit nie. Oft gab es Probleme mit der Identifikation von boolean Werten. Auch das behandeln von Listen in der jeweiligen Property-Datei war stets ein Sonderfall und handelte mir manchmal Schwierigkeiten ein. Ich glaube nicht mal das meine Abneigung an den prinzipiellen Aufbau und Grundgedanken einer .ini-Dateie gerichtet ist, vielmehr stören mich die mangelhaften Implementierungen der jeweiligen Programmiersprachen.
