~Java4Beginners~
~Java4Beginners~

H2DatabaseEngine

Die H2 Database Engine, kurz H2, ist ein in der Programmiersprache Java geschriebenes relationales Datenbankmanagementsystem.

Der Vorteil liegt darin, dass Sie als lokale Datenbank relativ schnell und effizient einsetzbar ist. Auch ein Serverbetrieb ist mit H2 möglich.

Einbinden von H2

Um H2 in ein Java-Projekt einzubinden, ist es ausreichend, die im bin-Ordner vorhandene JAR-Datei unserer Bibiliothek hinzuzufügen.

notwendige Imports

Um mit einer H2-Datenbank arbeiten zu können, benötigen wir eine Reihe von imports.

import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.sql.Statement;
Import Benötigt für
java.sql.Connection Stellt die Verbindung zu unserer Datenbank her
java.sql.DriverManager Der DriverManager dient als Sammelbecken für alle Datenbanktreiber.
java.sql.ResultSet ResultSet wird bei Datenbankabfragen benötigt. Das Ergebnis der Abfrage wird in ein ResultSet eingelesen.
java.sql.SQLException Benötigt für das Exception-Handling beim Auftreten von SQL-Fehlern
java.sql.Statement Benötigt für Abfragen und Datenbankmanipulationen
Nachdem wir nun die benötigten Imports haben, beschäftigen wir uns mit der Arbeit mit einer H2 Datenbank.

Grundsätzlich haben wir 3 Arbeitsschritte durchzuführen.
  1. Datenbankverbindung öffnen
  2. Anweisungen ausführen
  3. Datenbankverbindung schließen

Datenbankverbindung herstellen

Der Vorteil von H2 ist es, dass wir nicht erst eine Datenbank anlegen müssen. Ausserdem benötigen wir relativ wenig Angaben, da wir mit H2 lokal arbeiten (für Netzwerke gibt es bessere Datenbankmanagementsysteme). Von daher benötigen wir für die Datenbank schon mal keinen Usernamen und Userpassword.

Da wir allerdings die Datenbankverbindung und die dazugehörigen Abfragen auslagern, benötigen wir den Standardkonstruktor, um ein Objekt unserer Klasse zu erstellen, um auf die private-Methoden der Datenbankklasse zugreifen zu können.

Für das Öffnen der Datenbankverbindung verwenden wir eine eigene Methode.

public class rezeptinator_database 
{
  private rezeptinator_errorlog err = new rezeptinator_errorlog();
  private Connection connection;
  private Statement statement;
  private ResultSet resultSet;   
  // Standardkonsturktor zur Objekterstellung
  rezeptinator_database(){}  
  /**
   * Datenbankverbindung öffnen
   * @author Markus Badzura
   * @since 1.0.008
   */
  private void openDatabase()
  {
    try
    {
      Class.forName("org.h2.Driver");
      connection = DriverManager.getConnection("jdbc:h2:./db/"
              + "rezeptinator", "", "");
    }
    catch(SQLException | ClassNotFoundException e)
    {
      err.schreibe(e.toString(), "databse");
    }
  }
}
Mit der Anweisung Class.forName("org.h2.Driver"); binden wir den H2-Datenbankdriver ein. Alternativ hätten wir das auch mit der Import-Anweisung import org.h2.Driver; erreicht, aber an dieser Stelle soll auch mal eine Alternative zum import angezeigt werden.

Interessenter werden die Connection-Informationen.
Information Bedeutung
jdbc:h2: Java Database Connectivity:h2 bedeutet, dass dies die Schnittstelle von Java zu der H2-Datenbank ist.
./db/rezeptinator ./steht für die relative Pfadangabe, db/ für einen Ordner, rezeptinator für den Datenbanknamen. Zu beachten ist hierbei, dass der Datenbankname keine weiteren Endungen erhält. Wenn der Ordner oder die Datenbank nicht existiert, werden Sie angelegt.
"";"" Username und Password. Da wir local arbeiten, können diese Parameter leer bleiben.

DML oder DDL-Anweisungen

Wenn wir eine Datenbank erstellen lassen, müssen wir diese auch mit Leben befüllen. Um zu überprüfen, ob meine Datenbank den gleichen Stand wie meine Anwendung hat, verwende ich eine Tabelle version, welche bei Nichtvorhandensein erstellt wird. Dadurch weiß ich als Entwickler, dass das Programm erstmalig verwendet wird. Wenn die Tabelle vorhanden ist, kann ich die Versionsnummer auslesen und mti der Anwendungsversionsnummer vergleichen. Sollte die Datenbank älter sein, als die Anwendung, können notwendige SQL-Anweisungen durchgeführt werden, um die Funktionalität zu gewährleisten.
Erstellen wir nun die Methode, welche überprüft ob die Tabelle vorhanden ist oder nicht und die notwendigen, weiteren Schritte dann vollzieht.

Die Abfolge ist hierbei immer die gleiche.
  1. Statement aus der aktuellen Verbindung erstellen.
  2. SQL-Anweisung erstellen als String
  3. Methode executeQuery(String query) ausführen bei Abfragen, executeUpdate(query) ausführen bei CREATE-Anweisungen
Wenn wir eine Abfrage erstellen und ein Ergebnis erhalten, wird dieses in einem ResultSet gespeichert. Dieses ResulSet lesen wir Datensatzweise aus.
Wir haben die Möglichkeit die Ergebnisse als Spaltenzahlangabe auszulesen. Da dies allerdings eine Großzahl von Fehlermöglichkeiten eröffnet, sollten Sie sich angewöhnen, grundsätzlich immer den Spaltennamen anzugeben.

ResultSet.getString("Spaltenname");

  /**
   * Wenn Tabelle version nicht existiert, dann anlegen. 
   * Überprüfen, ob ein Eintrag in der Tabelle existiert. Wenn ja,
   * dann den Wert auslesen, wenn nein, dann die Version 1.0 eintragen.
   * @author Markus Badzura
   * @since 1.0.008
   */
  private void checkVersion()
  {
    int anzahl = 0;
    try
    {
      statement = connection.createStatement();
      String query = "CREATE TABLE IF NOT EXISTS version ("
              + "version CHAR(9))";
      statement.executeUpdate(query);
      resultSet = statement.executeQuery("SELECT COUNT(*) AS anzahl "
              + "FROM version");
      while(resultSet.next())
      {
        anzahl = resultSet.getInt("anzahl");
      }
      if (anzahl == 1)
      {
        resultSet = statement.executeQuery("SELECT * FROM version");
        while(resultSet.next())
        {
          version = resultSet.getString("version");
        }
      }
      else
      {
        query = "INSERT INTO version (version) VALUES ('1.0')";
        statement.executeQuery(query);
        version = "1.0";
      }
      System.out.println(anzahl);
      System.out.println(version);
    }
    catch(SQLException e)
    {
      err.schreibe(e.toString(), "checkVersion");
    }
  }

Verbindung schließen

Um die Datenbankverbindung zu beenden, schließen wir die Connection.

  /**
   * Datenbankverbindung schließen
   * @author Markus Badzura
   * @since 1.0.008
   */
  private void closeDatabase()
  {
    try
      {
          connection.close();
      }
      catch(SQLException e)
      {
        err.schreibe(e.toString(),"closeDatabase");         
      }    
  }

Beispiel Aufruf der Versionprüfung

Die bisher erstellten Methoden sind alle private. Um nun die Datenbank zu öffnen, die Versionsnummer zu ermitteln, und die Datenbankverbindung zu beenden, erstellen wir eine public Methode.

  /**
   * Ermitteln der in der Datenbank hinterlegen Versionsnummer
   * @author Markus Badzura
   * @since 1.0.008
   */
  public void determineVersion()
  {
    openDatabase();
    checkVersion();
    closeDatabase();
  }
Da diese Methode public ist, können wir Sie aus einer anderen Klasse heraus über ein Objekt ausführen.

private rezeptinator_database database = new rezeptinator_database();
database.determineVersion();
nach oben Java4Beginners -- Seitenversion 1.0 -- Stand: 2017-06-21