MySQL JSON-Datei auf Datenbank anwenden

[mierl]

Hallo,
ich arbeite zum ersten mal mit Datenbanken und habe mir hierfür dies tutorial angesehen: https://netbeans.org/kb/docs/java/hibernate-java-se.html
Nun arbeitet man dort mit einer Beispiel Datenbank namens sakila.
Ich möchte aber mit einer eigenen Datenbank arbeiten, die eine JSON-Datei ist. Nur weiß ich jetzt nicht wie ich das bewerkstellige, da es im tutorial nicht erläutert wird wie die herangehensweise mit anderen Datenbanken aussieht.
ich hoffe jemand kann mir helfen

 

[Tobse]

Eine JSON-Datei ist keine Datenbank.

Du kannst Daten von/nach JSON serialisieren, aber das wars dann auch schon. Ich kann mir aber durchaus vorstellen, dass es JDBC-Treiber gibt, welche letztendlich in eine JSON-Datei schreiben. Du wärst aber mit SQLite besser beholfen.

 

[mierl]

Ich habe jetzt nachgelesen, dass man eine JSON Datei zum Beispiel mithilfe JSON.simple deserialisieren kann. Wie kann ich nun diese Daten auf meine Datenbank laden?

 

[Thallius]

Ich glaube Du wirfst da einiges durcheinander.... Welche Datenbank denn, welche Daten?

 

[mierl]

Es tut mir leid wenn ich was verwechsele und man mich nicht sofort versteht, ich lerne java noch und hatte mit Datenbanken zuvor noch nichts am hut.
Ich möchte wissen wie ich die Daten aus der JSON-Datei in eine Datenbank bekomme.

 

[Thallius]

Ich fragte bereits "Welche Datenbank", "Welche Daten"?

 

[mierl]

ich möchte eine datenbank einrichten und diese mit daten aus einer JSON-Datei befüllen.

 

[Tobse]

ich möchte eine datenbank einrichten und diese mit daten aus einer JSON-Datei befüllen.

Okey, das ist kein Problem. Das ist aber was anderes wie eine "JSON-Datenbank".

Hier erstmal Lesestoff:

Datenbanken im allgemeinen: http://www.datenbanken-verstehen.de/datenbanken/datenbank-grundlagen/datenbank/
Relationale Datenbanken: http://www.datenbanken-verstehen.de...datenbankmodell/relationales-datenbankmodell/
Graph-Datenbanken (für eine 1:1 übernahme aus JSON gut geeignet): https://de.wikipedia.org/wiki/Graphdatenbank

Jetzt zu deinem Anliegen:

Ja, du kannst JSON mit Java auslesen. Da gibt es unzählige Libraries für; wähle, welche dir am besten gefällt. Eine offizielle Auflistung gibt es auf http://json.org

Wenn du die JSON-Daten dann vorliegen hast, kannst du entweder:

1. die Daten in Beans/Entities schieben und dann mit O/RM Frameworks wie Hibernate in die Datenbank schreiben
2. per SQL / Cypher Query direkt in die DB schreiben

[EDIT]
Noch mehr Lesestoff für die Anbindung an die DB (sofern das in dem Arktiel auf der NetBeans-Seite nicht schon erklärt wurde):
https://docs.oracle.com/javase/tutorial/jdbc/basics/

SQL Tutorial beim W3C: http://www.w3schools.com/sql/
Einführung in die Query-Language für Graph-Datenbanken, da ist aber die Syntax von DB zu DB teils sehr unterschiedlich: http://neo4j.com/developer/cypher-query-language/
[/EDIT]

 

[mierl]

vielen dank für deine umfrangreiche antwort! ich werde mich jetzt erstmal mit dem stoff auseindandersetzen

 

[mierl]

also ich habe jetzt eine Entitätsklasse mit Getter und Settern, wie schaut jetzt die schnittstelle zur JSON-Datei aus? im Netbeans-tutorial seh ich die schnittstelle zur sakila datenbank auch nicht

 

[Tobse]

Du erstellst dir eine Klasse, die aus deinem JSON Entities ausliest (Beispiel mit json-simple)

public class JSONEntityReader implements Itarator<MyEntity> {
    public JSONEntityReader(JSONObject jsonRoot) {
        // ...
    }

    public boolean hasNext() {
        // ...
    }

    public MyEntity next() {
        MyEntity o = new MyEntity();
        o.setFoo(jsonObject.getString("foo"));
        // ...
        return o;
    }
}

Und den benutzt du dann, um die Entities in die Datenbank zu schreiben. Mit Hibernate sollte das dann kein Problem mehr sein, ohne könnte das so aussehen:

public class EntityPersister {
    public void persist(Iterator<MyEntity> it, Connection conn) throws IOException {
        PerparedStatement stmt = conn.prepare("INSERT INTO ...");
        // ...
        stmt.bindParam(1, it.getFoo());
        //...
        stmt.execute();
    }
}

// ...
JSONObject jsonData = (JSONObject) JSONValue.parse(...);
new EntityPersister().persist(new JSONEntityReader(jsonData));

 

[mierl]

ok ich glaube ich habs noch nicht ganz verstanden,
ich habe also meine Klasse Person mit den Attributen String vorname und String nachname und dazu die getter und setter.

public class Person {
   
    private String firstName;
    private String lastName;
   
    public Person(String firstName, String lastName){
       
        this.firstName = firstName;
        this.lastName = lastName;
    }

    public String getFirstName() {
        return firstName;
    }

    public void setFirstName(String firstName) {
        this.firstName = firstName;
    }

    public String getLastName() {
        return lastName;
    }

    public void setLastName(String lastName) {
        this.lastName = lastName;
    }
   
}

nun schreibe ich die Klasse die aus der JSON Datei die Entities herausliest

import java.util.Iterator;
import org.json.simple.JSONArray;
import org.json.simple.JSONObject;

public class JSONEntityReader implements Iterator <Person> {
       
    private int index;
   
    public JSONEntityReaderA(JSONObject jsonObject){
        int index = 0;       
    }
   
    @Override
    public boolean hasNext() {
        return index < länger der JSON-Datei;
    }
   
    public Author next() {
        Author o = new Author();
        o.setFoo(jsonObject.getString("foo"));
        // ...
        return o;
    }
}

ich habe nun recherchiert wie ich aus meine JSON-Datei die Vor- und Nachnamen auslesen kann:

        JSONArray person = (JSONArray) jsonObject.get("person");
        Iterator i1 = authors.iterator();
        while (i1.hasNext()) {
            JSONObject slide = (JSONObject) i1.next();
            String fName = (String) slide.get("first_name");
        }

        Iterator i2 = authors.iterator();
        while (i2.hasNext()) {
            JSONObject slide = (JSONObject) i2.next();
            String lName = (String) slide.get("last_name");
        }

Meine frage ist nun wo ich den Code für das auslesen einfüge?

 

[Tobse]

Wie ich sehe hast du schon einen Iterator für die Personen in der JSON-Datei (i1 und i2). Die kannst du doch bequem mit deinem Iterator EntityReader verknüpfen:

public EntityReader(JSONObject json) {
    this.authors = ((JSONArray) json.get("person")).iterator();
}

public boolean hasNext() { return this.authors.hasNext() }
public Author next() {
    if (this.hasNext()) {
        Author a = new Author();
        JSONObject authorNode = (JSONObject) authors.next();
        a.setFirstName((String) authorNode.get("first_name"));
        a.setLastName((String) authorNode.get("last_name"));
        return a;
    } else {
        return null;
    }
}

 

[mierl]

ach ich habe mich da nur verschrieben eigentlich sollte das heißen:

JSONArray authors = (JSONArray) jsonObject.get("authors");
        Iterator i1 = authors.iterator();
        while (i1.hasNext()) {
            JSONObject slide = (JSONObject) i1.next();
            String fName = (String) slide.get("first_name");
        }

        Iterator i2 = authors.iterator();
        while (i2.hasNext()) {
            JSONObject slide = (JSONObject) i2.next();
            String lName = (String) slide.get("last_name");
        }

wo füge ich das ein? in die Personenklasse oder in den reader?

 

[Tobse]

So in der form macht das doch keinen Sinn - du erstellst zwei iteratoren um über die selben Objekte zu iterieren. Das eine mal liest du den Vornamen, das andere mal den Nachnamen. Schau dir meinen Code nochmal an und versuch drauf zu kommen, was ich gemeint habe

 

[mierl]

ich verstehe nicht wie du auf authors in deinem quellcode kommst? auf welches authors nimmst du bezug?

 

[Tobse]

Du schreibst ja in deinem Code dashier:

JSONArray person = (JSONArray) jsonObject.get("person");
Iterator i1 = authors.iterator();

Ich schließe daraus, dass dein JSON so aussieht:

{
    "person": [
        {
            "first_name": "Vorname",
            "last_name": "Nachname"
        },
        {
            "first_name": "Vorname",
            "last_name": "Nachname"
        }
    ]
}

Wenn du jetzt deinem EntityReader das "person"-Array oder das Top-Level Objekt übergibt, kannst du im Konstruktor des Readers ja direkt den Iterator für das Array bekommen:

class EntityReader implements Iterator<Person> {
    private Iterator<JSONValue> authors;
    public EntityReader(JSONObject personObj) {
        authors = ((JSONArray) personObj.get("person")).iterator();
    }
}

Und mithilfe des authors Iterators kannst du dann den EntityReader implementieren.

 

[mierl]

ok ich merk schon ich muss mir noch eine menge an wissen aneignen,
ich schau es mir morgen nochmal genauer an.
vielen dank für deine hilfe und einen schönen restabend wünsche ich dir