Tutorial:
Datenbank-Ladeprogramm mit Graphischer Benutzeroberfläche (Java_Intro_02) – XML-Struktur lesen

Dieses Dokument zeigt, wie die Parameter für die Verbindung zum Datenbanksystem aus einer Datei mit einer XML-Struktur gelesen werden.
Ziel dieses Schrittes ist, Grundlagenkenntnisse für das Lesen von Daten aus einer XML-Struktur zu vermitteln.

Inhaltsverzeichnis:

Vorigerer Schritt: ActionHandler 

Vorbemerkung und Funktion des Codes 
Vorbedingungen 
Einbindung der externen Bibliothek für die Bearbeitung von XML-Strukturen 
* Herunterladen der Datei 'jdom.jar' aus dem Internet 
* Einbinden der Dateien in den 'Java Build Path' 
Verzeichnis und Datei mit der XML-Struktur erstellen 
Zusätzlicher Code 
* Import der Bibliothek 
* Methode handleEvent(. . .) erweitern und Methode processDBLoad(. . .) eröffnen 
* Methode processGetDBParms(. . .) codieren 
* Methode processConnectToDatabase(. . .) codieren 
Gesamter Code beim Ende dieses Schritts 
* Klasse DB_Load 
* Klasse DB_Load__ActionHandler 
Test 
Mögliche Fehlerursachen 
Weitere Schritte und verwandte Dokumentation 

Nächster Schritt: SQL-Kommandos ausführen 

Vorbemerkung und Funktion des Codes

In diesem Dokument wird der Code so erweitert, daß nach einem Klick auf die Schaltfläche [  Start SQL-Kommandos  ] im ausgewählten Verzeichnis die Datei mit dem Namen 'DB_Parameter.xml' geöffnet wird und daraus die Parameter für die Verbindung zum Datenbanksystem gelesen werden.
Anschließend wird die Verbindung zum Datenbanksystem hergestellt.

In diesem Schritt wird auch erstmals eine Bibliotheks-Datei ('jdom.jar' für das Bearbeiten einer XML-Struktur die ein DOM / 'Document Object Model' darstellt) aus dem Internet heruntergeladen und als 'externes Archiv' in das Project eingebunden.
Als weiteres 'externes Archiv' wird die Datei mit den Klassen, die die Verbindung zum Datenbanksystem herstellen, eingebunden.

▲ zum Inhaltsverzeichnis

Vorbedingungen

• Schritt 3: ActionHandler ausgeführt – und dessen Vorbedingungen auch.

• Eine Datenbank wurde, wie im Dokument MySQL Datenbank für die Verwendung mit Java-Programmen einrichten beschrieben, eingerichtet und die Archiv-Datei mit den Klassen, die die Verbindung zum Datenbanksystem herstellen, wurde aus dem Internet heruntergeladen.
  In den Anleitungen wird angenommen, daß die Datenbank den Namen 'js_tutorial' hat.

▲ zum Inhaltsverzeichnis

Einbindung der externen Bibliothek für die Bearbeitung von XML-Strukturen.

Herunterladen der Datei 'jdom.jar' aus dem Internet

▲ zum Inhaltsverzeichnis

Einbinden der Dateien in den 'Java Build Path'


▲ zum Inhaltsverzeichnis

Verzeichnis und Datei mit der XML-Struktur erstellen.

Das Verzeichnis mit den Dateien kann in jedem beliebigen Verzeichnis erstellt werden.
Um die Zugehörigkeit zu dem Eclipse-Project zu verdeutlichen, wird die Datei direkt im Project erstellt.

Die gerade erstellte Datei wird mit folgender XML-Struktur gefüllt.

<DataBaseParameters>
<DataBaseDriverName>com.mysql.jdbc.Driver</DataBaseDriverName>
<DataBaseName>jdbc:mysql://127.0.0.1:3306/js_tutorial</DataBaseName>
<DataBaseUserID>mysql</DataBaseUserID>
<DataBasePassword>drowssap</DataBasePassword>
</DataBaseParameters>

Die Parameter in diesem Beispiel spezifizieren eine Datenbank mit dem Namen js_tutorial, die auf einem MySQL-Datenbanksystem eingerichtet ist.
Das MySQL-Datenbanksystem läuft auf dem lokalen Computer; das ist jener Computer auf dem auch dieses Tutorial ausgeführt wird.

▲ zum Inhaltsverzeichnis

Zusätzlicher Code

Der zusätzliche Code wird ausschließlich in der Klasse DB_Load__ActionHandler hinzugefügt.

Er besteht aus einer neuen Methode (processDBLoad(. . .)) und dem Import der gerade in den 'Build Path' aufgenommenen Bibliothek.

Import der Bibliothek

import java.awt.*;
import java.awt.event.*;
import java.io.*;
import java.sql.*;
import org.jdom.*;
import org.jdom.input.*;

Diese Bibliothek java.io enthält Klassen für das Öffnen und Bearbeiten von Dateien.

Diese Bibliothek java.sql enthält Klassen für den Zugriff auf SQL-Datenbanken.

Diese Bibliothek org.jdom enthält Klassen für das Lesen und Bearbeiten einer XML-Struktur die dem Document-Object-Model (DOM) entspricht.

▲ zum Inhaltsverzeichnis

Methode handleEvent(. . .) erweitern und Methode processDBLoad(. . .) codieren

    public static void handleEvent(DB_Load parmCallingFrame, ActionEvent parmActionEvent) {
/* Zuerst wird die 'Identifikation' des GUI-Element aus dem ActionEvent extrahiert. */
      String cmd = parmActionEvent.getActionCommand().trim();
/* Je nach Auslöser des Events wird die entsprechende Methode aufgerufen. */
      if(cmd.equals("btn_Select")) processSelectFile(parmCallingFrame);
      if(cmd.equals("btn_Start")) processDBLoad(parmCallingFrame);
    }

Der 'Action-Command' der Schaltfläche bestimmt, welche Methode aufgerufen wird.

/*
 * Methode die ausgeführt wird wenn die SQL-Kommandos aus der zuvor ausgewählten Datei
 * ausgeführt werden sollen. */
    private static void processDBLoad(DB_Load parmCallingFrame) {
/* 
 * Damit diese Methode nicht überladen wird, werden eigene Methoden
 * für das Ermitteln der Paramater für die Verbindung zur Datenbank,
 * für das Aufbauen der Verbindung zur Datenbank und
 * für das Ausführen der SQL-Kommandos
 * aufgerufen. */
/* 
 * Die Übergabe der Parameter für die Verbindung zur Datenbank erfolgt durch
 * ein String-Array. */
      String[] array_DB_Parms;
/* 
 * Aufrufen der Methode, in der die Parameter für die Verbindung zur Datenbank ermittelt werden. */
      array_DB_Parms = processGetDBParms(parmCallingFrame);
/* 
 * Prüfen, ob alle DB-Parameter ermittelt werden konnten;
 * bei fehlenden Werten wird ein Array ohne Elemente zurückgeliefert.
 * In diesem Fall wird die Methode beendet; es erfolgt keine weitere Verarbeitung. */
      if (array_DB_Parms.length <= 0) return;
/* 
 * Die Verbindung (connection) zum Datenbanksystem wird in einer eigenen Methode eröffnet.
 * Die folgende Variable wird zum Prüfen, ob der Aufbau der Verbindung erfolgreich war, und
 * zur Weitergabe an die Methode, in der die SQL-Kommandos ausgeführt werden, verwendet. */
      Connection conToDatabase = null;
/* 
 * Aufrufen der Methode, in der die Parameter für die Verbindung zur Datenbank ermittelt werden. */
      conToDatabase = processConnectToDatabase(parmCallingFrame, array_DB_Parms);
    }

Damit die Methode übersichtlich bleibt, werden in Ihr weitere Methoden aufgerufen.
Die Methode enthält die Werte, die von einer zur anderen Methode übergeben werden.

▲ zum Inhaltsverzeichnis

Methode processGetDBParms(. . .) codieren

Die Liste des Code in diesem Teil des Dokuments enthält nur Teile, die bisher noch nicht beschrieben wurden.
Code, der in den vorausgesetzten Tutorial schon mehrmals verwendet und beschrieben wurde, wird hier nicht mehr dokumentiert.

Für eine komplette Liste des Codes sehen Sie bitte unter Klasse DB_Load_ActionHandler nach.

/*
 * Methode die aus der Datei mit der XML-Struktur die Parameter für die Verbindung
 * zur Datenbank ausliest.
 * Die Parameter werden im String-Array an die aufrufende Methode zurückgerufen */
    private static String[] processGetDBParms(DB_Load parmCallingFrame) {

Dieser Methode liefert einen Wert zurück.
Das unterscheidet sie von den bisher in den Einführungs-Tutorials vorgestellten Methoden.
Dieser Wert ist nicht ein einfacher Typ sondern eine Array aus Strings. Damit können mehrere Werte vom Type 'String' an die aufrufende Methode zurückgeliefert werden.

/* 
 * Die Übergabe der Parameter für die Verbindung zur Datenbank erfolgt durch
 * ein String-Array. */
      String[] array_DB_Parms = new String[4];

Zu Beginn der Methode wird das Array mit den vier 'String'-Werten definiert.
In diesen 'String's werden die Werte für
 * die Java-Klasse mit dem passenden Treiber für das Datenbanksystem;
 * den Namen der Datenbank mit dem für Java erforderlichen Werten;.
 * die Benutzer-Identifikation für die Datenbank;
 * das eventuell festgelegte Passwort.

/* 
 * Extrahieren des Verzeichnis-Namens aus dem im Text-Feld enthaltenen
 * String mit Verzeichnis und Datei-Namen für die Datei mit den SQL-Kommandos. */
      String strDirectoryName = parmCallingFrame.get_txt_InputFile().getText();
/* 
 * Trennen von Verzeichnis und Datei durch den System-spezifischen 'file-separator'. */
      String strDirectorySeparator = System.getProperty("file.separator");
/* 
 * Postion des letzten 'file-separator' in der Zeichenkette ermitteln. */
      int intLastDirectorySeparator = strDirectoryName.lastIndexOf(strDirectorySeparator);
/* 
 * Wenn kein 'file-separator' vorhanden ist dann kann die Zeichenkette nicht
 * 'sinnvoll' sein: In diesem Fall Fehlermeldung im Report-Bereich der GUI ausgeben. */
      if (intLastDirectorySeparator <= 0) {
        parmCallingFrame.get_txt_Report().append(
            "Ungültiger Verzeichnis-/Datei-Name: " + strDirectoryName + "\n");
/* Zum Zeichen eines Fehlers ein leeres Array zurückliefern. */
        return new String[0];
      }
/* 
 * Extrahieren des Teiles mit dem Verzeichnis. */
      strDirectoryName = strDirectoryName.substring(0, intLastDirectorySeparator + 1);

Mit dem vorgestellten Code wird aus der Zeichenkette, die das Verzeichnis und den Datei-Namen der Datei mit den SQL-Kommandos enthält, jener Teil 'herausgeschnitten', der das Verzeichnis enthält.
Dieses Verzeichnis mit der Datei wurde mit dem im vorigen Schritt vorgestellten Code vom Benutzer ausgewählt.

/* 
 * 'Bauen' der Zeichenkette mit Verzeichnis- und Datei-Name für die Datei
 * mit der XML-Struktur, die die Parameter enthält. */
      strDirectoryName += "DB_Connection.xml";

Als letzter Teil wird der fixe Dateinamen für die Datei mit der XML-Struktur für die Parameter 'angehängt'.
Der Name der Variable, strDirectoryName, ist jetzt etwas irreführend weil auch wieder der Name einer Datei enthalten ist.

/* 
 * 'Bauen' der Zeichenkette mit Verzeichnis- und Datei-Name für die Datei
 * mit der XML-Struktur, die die Parameter enthält. */
      strDirectoryName += "DB_Connection.xml";

Als letzter Teil wird der fixe Dateinamen für die Datei mit der XML-Struktur für die Parameter 'angehängt'.
Der Name der Variable, strDirectoryName, ist jetzt etwas irreführend weil auch wieder der Name einer Datei enthalten ist.

/* 
 * Öffnen der Datei mit der XML-Struktur.
 * Die Klassen und Methoden sind im package org.jdom.input enthalten. */
      try {
/* Die Klasse SAXBuilder ermöglicht ein einfaches Bearbeiten einer Datei
 * mit einer XML-Struktur, die dem Document-Object_Model (DOM) entspricht. */ 
        SAXBuilder parser = new SAXBuilder();
/* Das 'document' enthält dann die gesamte XML-Struktur aus der Datei. */ 
        Document document = parser.build(strDirectoryName);
/* Das Einstiegselement der XML-Struktur wird 'ergriffen'. */ 
        Element XML_RootElement = document.getRootElement();
      }
      catch(JDOMException e) {
/* 
 * Fehler: Datei enthält keine XML-Struktur entsprechend dem DOM.
 * Meldung im Report-Bereich der GUI ausgeben. */
        parmCallingFrame.get_txt_Report().append(
            "'Not well formed exception' beim Öffnen der Datei: " +
            strDirectoryName + "\n");
/* Zum Zeichen eines Fehlers ein leeres Array zurückliefern. */
        return new String[0];
      }
      catch(Exception e) {
/* 
 * Anderer Fehler beim Versuch, die Datei mit der XML-Struktur zu öffnen.
 * Meldung im Report-Bereich der GUI ausgeben. */
        parmCallingFrame.get_txt_Report().append(
            "Anderer Fehler (als XML-Problem) beim Öffnen der Datei: " +
            strDirectoryName + "\n");
/* Zum Zeichen eines Fehlers ein leeres Array zurückliefern. */
        return new String[0];
      }

Der vorgestellte Code benutzt spezialisierte Klassen aus der importierten Bibliothek 'jdom.jar' um eine Datei mit einer XML-Struktur zu öffnen, sofort zu prüfen ob die XML-Struktur auch dem Document-Object-Model (DOM) entspricht und das Wurzel-Element der XML-Struktur in einer spezialisierten Datenstruktur vom Typ Element für weitere Bearbeitungen zur Verfügung zu stellen.

Eine detaillierte Erläuterung der Funktionalitäten zur Bearbeitung von XML-Strukturen würde das Ziel dieses Tutorials sprengen.
Bei Interesse empfehle ich, weitere Informationen in den zahlreichen Internet-Beiträgen anderer Autoren nachzulesen.

/* 
 * Die verwendete XML-Struktur ist sehr einfach weil alle XML-Elemente mit den Parametern
 * direkt 'unter' dem 'root'-Element angeordnet sind. */
/* 
 * Methoden des packagage 'org.jdom.*' extrahieren die Werte der einzelnen XML-Einträge
 * wenn der Name des XML-Eintrags angegeben wird. */
/* 
 * Zur Vereinfachung wird nur eine Variable für alle XML-Einträge verwendet. */
      Element elementSingleParm;
/* 
 * Extrahieren des Namens der Datei mit der Klasse, die die Verbindung zum Datenbanksystem
 * herstellt. */
      elementSingleParm = XML_RootElement.getChild("DataBaseDriverName");
      if (elementSingleParm == null) {
/* XML-Eintrag mit Namen 'DataBaseDriverName' nicht gefunden.
 * Fehler im Report-Bereich der GUI ausgeben und zum Zeichen eines Fehlers
 * ein leeres String-Array an die aufrufende Methode zurückliefern. */
        parmCallingFrame.get_txt_Report().append(
            "XML-Eintrag 'DataBaseDriverName' nicht vorhanden.\n");
        return new String[0];
      }
/* 
 * Wert des XML-Eintrages in den vorgesehenen String des String-Arrays übernehmen. */
      array_DB_Parms[0] = elementSingleParm.getTextTrim();
/* Zur Kontrolle des Programm-Fortschrittes den Wert im Report-Bereich der GUI anzeigen. */
        parmCallingFrame.get_txt_Report().append(
            "DataBaseDriverName: " + array_DB_Parms[0] + "\n");

Für die Ermittlung der Werte eines 'Elementes' aus der XML-Struktur werden ebenfalls spezialisierte Klassen aus der importierten Bibliothek 'jdom.jar' verwendet.

Im obigen Auszug aus dem Code wird nur das Auslesen eines Parameters aus der XML-Struktur beschrieben – die Ermittlung der drei anderen Parameter erfolgt auf vergleichbare Weise.

Die XML-Struktur besteht aus einer hierachischen Anordnung von Daten-Strukturen des Typs Element.
Nach dem Einlesen der Datei mit der XML-Struktur kann das 'root'-Element eingelesen werden und von diesem die 'darunter' angeordneten 'Elemente' ermittelt werden.
Für das 'Anfassen' eines untergeordneten Elementes gibt es verschiedene Möglichkeiten; in diesem Beispiel wird jene vorgestellt, die das Element über den Element-Namen ermittelt:
elementSingleParm = XML_RootElement.getChild("DataBaseDriverName");

Nach dem Ermitteln über den Namen muß geprüft werden, ob auch wirklich ein gesuchtes Element vorhanden ist:
if (elementSingleParm == null) {

Ist das gesuchte Element vorhanden, kann der Wert ausgelesen werden:
array_DB_Parms[0] = elementSingleParm.getTextTrim();

Auf eine Prüfung, ob das Element 'leer' ist (z.B. <DataBaseDriverName></DataBaseDriverName>) wird in diesem Einführungsbeispiel verzichtet.

▲ zum Inhaltsverzeichnis

Methode processConnectToDatabase(. . .) codieren

In dieser Methode wird die Verbindung zur Datenbank hergestellt und diese Verbindung ('connection') an die aufrufende Methode zurückgeliefert.
Die Wirkung der einzelnen Teile des Codes ist in den Kommentaren ausführlich beschrieben.

/*
 * Methode, die die Verbindung (connection) zur Datenbank herstellt.
 * Die 'connection' wird von der Methode zurückgeliefert. */
    private static Connection processConnectToDatabase(
                                  DB_Load parmCallingFrame, String[] parmArray_DB_Parms) {
/*
 * Variable, die von der Methode zurückgeliefert wird. */
      Connection conToDatabase = null;
/* */
      try {
/*
 * Klasse für die Verbindung zum Datenbanksystem 'konstruieren'.
 * Diese Klasse wird vom Hersteller des Datenbanksystems mitgeliefert und kann
 * deswegen nicht statisch im Code definiert werden.
 * Für dieses Beispiel wurde der Name der Klasse über die Parameter in der XML-Struktur
 * eingelesen.
 * Die Bibliotheks-Datei (*.jar) muß beim Start des Programms in der Liste der *.jar-Datein
 * enthalten sein.
 * Das Konstruieren der Klasse erfolgt mit der Java-Klasse 'Class'. */
        Class.forName(parmArray_DB_Parms[0]);
/*
 * Als Konvention (für Java festgelegt) heißt die 'konstruierte' Klasse für die Verbindung
 * zum Datenbanksystem 'DriverManager'.
 * Das erfolgreiche 'Konstruieren' wird auf der GUI gemeldet. */
        parmCallingFrame.get_txt_Report().append(
            "'DriverManager' konstruiert für: " + parmArray_DB_Parms[0] + "\n");
/*
 * Der 'DriverManager' enhält eine Methode mit der die Verbindung zu einer Datenbank
 * des Datenbanksystems erstellt werden kann.
 * Dazu muß der Name der Datenbank, ein berechtigter Benutzer und dessen Passwort
 * an die Methode als Parameter übergeben werden. */
        conToDatabase = DriverManager.getConnection(
            parmArray_DB_Parms[1], parmArray_DB_Parms[2], parmArray_DB_Parms[3]);
/*
 * Das erfolgreiche Verbinden zu Datenbank wird auf der GUI gemeldet. */
        parmCallingFrame.get_txt_Report().append(
            "Verbindung erfolgreich zur Datenbank: " + parmArray_DB_Parms[1] + "\n");
/*
 * Zur Vereinfachung der Verarbeitung 'darf' das Datenbanksystem entscheiden wann
 * ein 'Commit' ausgeführt wird.
 * Diese Einstellung wird für das Tutorial gewählt um eventuelle Fehler durch ein
 * vergessenes 'Commit' zu vermeiden.
 * Für reale Entwicklungen soll diese Einstellung nicht verwendet werden
 * weil im 'Echtbetrieb' ein 'Commit' oder 'Rollback' so gesetzt werden muß,
 * daß die Integrität der Daten gewahrt bleibt - auch wenn ein Fehler auftritt. */
        conToDatabase.setAutoCommit(true);
      }
      catch (Exception Exc) {
/*
 * Verbinden zur Datenbank war nicht erfolgreich;
 * Fehler auf der GUI melden und den zurückgelieferten Wert auf 'null' setzen
 * als Zeichen, daß das Programm abgebrochen werden muß. */
        parmCallingFrame.get_txt_Report().append(
            "Fehler beim Verbinden zur Datenbank: " + Exc.toString() + "\n");
        conToDatabase = null;
      }
/*
 * Erstellte Verbindung zur Datenbank an die aufrufende Methode zurückliefern. */
      return conToDatabase;
    }

▲ zum Inhaltsverzeichnis

Gesamter Code am Ende dieses Schrittes

Klasse DB_Load

Der Code dieser Klasse wurde in diesem Schritt nicht verändert.
Für eine Liste des gesamten Codes folgen Sie bitte dem Link zu Tutorial: Datenbank-Ladeprogramm mit Graphischer Benutzeroberfläche (Java_Intro_02) - ActionHandler > Gesamter Code am Ende diesen Schrittes.

▲ zum Inhaltsverzeichnis

Klasse DB_Load__ActionHandler

package js_intro02.client;
 
import java.awt.*;
import java.awt.event.*;
import java.io.*;
import java.sql.*;
import org.jdom.*;
import org.jdom.input.*;
/**
 *
 * @author kurt@javascout.biz
 * @date 2008-02-07
 *
 * @description
 *  Klasse mit statischen Methoden die ausgeführt werden wenn ein 'event'
 *  (z.B. der Klick einer Maustaste) aufgetreten ist.
 *  Detail-Dokumentation finden Sie bei den einzelnen Methoden.
 *
 * @change-log
 * when         who               why
 * --------------------------------------------------------
 *
 */
public class DB_Load__ActionHandler {
/*
 * Methode die ermittelt, bei welchem GUI-Element ein 'ActionEvent' ausgelöst wurde
 * und die entsprechende Methode aufruft. */
    public static void handleEvent(DB_Load parmCallingFrame, ActionEvent parmActionEvent) {
/* Zuerst wird die 'Identifikation' des GUI-Element aus dem ActionEvent extrahiert. */
      String cmd = parmActionEvent.getActionCommand().trim();
/* Je nach Auslöser des Events wird die entsprechende Methode aufgerufen. */
      if(cmd.equals("btn_Select")) processSelectFile(parmCallingFrame);
      if(cmd.equals("btn_Start")) processDBLoad(parmCallingFrame);
    }
/*
 * Methode die ausgeführt wird wenn die Datei mit den SQL-Kommandos ausgewählt werden soll. */
    public static void processSelectFile(DB_Load parmCallingFrame) {
/* 
 * Fenster für den 'File-dialog' aufrufen;
 * in diesem kann der Benutzer eine Datei auswählen. */
      FileDialog fd = new FileDialog(parmCallingFrame,
                                     "Bitte wählen Sie die Datei mit den SQL-Kommandos",
                                     FileDialog.LOAD);
/* 
 * Anfangswerte für Verzeichnis und Dateiname setzen und Fenster sichtbar machen. */
      fd.setFile("");
      fd.setDirectory("");
      fd.setVisible(true);
/* 
 * Name für gewähltes Verzeichnis und Datei aus dem 'File-dialog' holen
 * und einen String bilden. */
      String strDirectoryAndFileName = fd.getDirectory() + fd.getFile();
/* 
 * Verzeichnis und Datei-Name im entsprechenden Feld anzeigen. */
      parmCallingFrame.get_txt_InputFile().setText(strDirectoryAndFileName);
    }
/*
 * Methode die ausgeführt wird wenn die SQL-Kommandos aus der zuvor ausgewählten Datei
 * ausgeführt werden sollen. */
    private static void processDBLoad(DB_Load parmCallingFrame) {
/* 
 * Damit diese Methode nicht überladen wird, werden eigene Methoden
 * für das Ermitteln der Paramater für die Verbindung zur Datenbank,
 * für das Aufbauen der Verbindung zur Datenbank und
 * für das Ausführen der SQL-Kommandos
 * aufgerufen. */
/* 
 * Die Übergabe der Parameter für die Verbindung zur Datenbank erfolgt durch
 * ein String-Array. */
      String[] array_DB_Parms;
/* 
 * Aufrufen der Methode, in der die Parameter für die Verbindung zur Datenbank ermittelt werden. */
      array_DB_Parms = processGetDBParms(parmCallingFrame);
/* 
 * Prüfen, ob alle DB-Parameter ermittelt werden konnten;
 * bei fehlenden Werten wird ein Array ohne Elemente zurückgeliefert.
 * In diesem Fall wird die Methode beendet; es erfolgt keine weitere Verarbeitung. */
      if (array_DB_Parms.length <= 0) return;
/* 
 * Die Verbindung (connection) zum Datenbanksystem wird in einer eigenen Methode eröffnet.
 * Die folgende Variable wird zum Prüfen, ob der Aufbau der Verbindung erfolgreich war, und
 * zur Weitergabe an die Methode, in der die SQL-Kommandos ausgeführt werden, verwendet. */
      Connection conToDatabase = null;
/* 
 * Aufrufen der Methode, in der die Parameter für die Verbindung zur Datenbank ermittelt werden. */
      conToDatabase = processConnectToDatabase(parmCallingFrame, array_DB_Parms);
    }
/*
 * Methode die aus der Datei mit der XML-Struktur die Parameter für die Verbindung
 * zur Datenbank ausliest.
 * Die Parameter werden im String-Array an die aufrufende Methode zurückgerufen */
    private static String[] processGetDBParms(DB_Load parmCallingFrame) {
/* 
 * Die Übergabe der Parameter für die Verbindung zur Datenbank erfolgt durch
 * ein String-Array. */
      String[] array_DB_Parms = new String[4];
/* 
 * Extrahieren des Verzeichnis-Namens aus dem im Text-Feld enthaltenen
 * String mit Verzeichnis und Datei-Namen für die Datei mit den SQL-Kommandos. */
      String strDirectoryName = parmCallingFrame.get_txt_InputFile().getText();
/* 
 * Trennen von Verzeichnis und Datei durch den System-spezifischen 'file-separator'. */
      String strDirectorySeparator = System.getProperty("file.separator");
/* 
 * Postion des letzten 'file-separator' in der Zeichenkette ermitteln. */
      int intLastDirectorySeparator = strDirectoryName.lastIndexOf(strDirectorySeparator);
/* 
 * Wenn kein 'file-separator' vorhanden ist dann kann die Zeichenkette nicht
 * 'sinnvoll' sein: In diesem Fall Fehlermeldung im Report-Bereich der GUI ausgeben. */
      if (intLastDirectorySeparator <= 0) {
        parmCallingFrame.get_txt_Report().append(
            "Ungültiger Verzeichnis-/Datei-Name: " + strDirectoryName + "\n");
/* Zum Zeichen eines Fehlers ein leeres Array zurückliefern. */
        return new String[0];
      }
/* 
 * Extrahieren des Teiles mit dem Verzeichnis. */
      strDirectoryName = strDirectoryName.substring(0, intLastDirectorySeparator + 1);
/* 
 * 'Bauen' der Zeichenkette mit Verzeichnis- und Datei-Name für die Datei
 * mit der XML-Struktur, die die Parameter enthält. */
      strDirectoryName += "DB_Connection.xml";
/* 
 * Kompletten String zur Kontrolle im Report-Bereich der GUI ausgeben. */
      parmCallingFrame.get_txt_Report().append(
            "Datei mit den Datenbank-Parametern: " + strDirectoryName + "\n");
/* 
 * XML-Element, daß den 'Einstieg' in die hierarchische XML-Struktur ermöglicht. */
      Element XML_RootElement;
/* 
 * Öffnen der Datei mit der XML-Struktur.
 * Die Klassen und Methoden sind im package org.jdom.input enthalten. */
      try {
/* Damit das Öffnen auch mit Windows-Betriebssystemen funktioniert,
 * muß an den SAXBuilder eine 'file' übergeben werden. */ 
        File f = new File(strDirectoryName);
/* Die Klasse SAXBuilder ermöglicht ein einfaches Bearbeiten einer Datei
 * mit einer XML-Struktur, die dem Document-Object_Model (DOM) entspricht. */ 
        SAXBuilder parser = new SAXBuilder();
/* Das 'document' enthält dann die gesamte XML-Struktur aus der Datei. */ 
        Document document = parser.build(f);
/* Das Einstiegselement der XML-Struktur wird 'ergriffen'. */ 
        XML_RootElement = document.getRootElement();
      }
      catch(JDOMException e) {
/* 
 * Fehler: Datei enthält keine XML-Struktur entsprechend dem DOM.
 * Meldung im Report-Bereich der GUI ausgeben. */
        parmCallingFrame.get_txt_Report().append(
            "'Not well formed exception' beim Öffnen der Datei: " +
            strDirectoryName + "\n");
/* Zum Zeichen eines Fehlers ein leeres Array zurückliefern. */
        return new String[0];
      }
      catch(Exception e) {
/* 
 * Anderer Fehler beim Versuch, die Datei mit der XML-Struktur zu öffnen.
 * Meldung im Report-Bereich der GUI ausgeben. */
        parmCallingFrame.get_txt_Report().append(
            "Anderer Fehler (als XML-Problem) beim Öffnen der Datei: " +
            strDirectoryName + "\n");
/* Zum Zeichen eines Fehlers ein leeres Array zurückliefern. */
        return new String[0];
      }
/* 
 * Die verwendete XML-Struktur ist sehr einfach weil alle XML-Elemente mit den Parametern
 * direkt 'unter' dem 'root'-Element angeordnet sind. */
/* 
 * Methoden des packagage 'org.jdom.*' extrahieren die Werte der einzelnen XML-Einträge
 * wenn der Name des XML-Eintrags angegeben wird. */
/* 
 * Zur Vereinfachung wird nur eine Variable für alle XML-Einträge verwendet. */
      Element elementSingleParm;
/* 
 * Extrahieren des Namens der Datei mit der Klasse, die die Verbindung zum Datenbanksystem
 * herstellt. */
      elementSingleParm = XML_RootElement.getChild("DataBaseDriverName");
      if (elementSingleParm == null) {
/* XML-Eintrag mit Namen 'DataBaseDriverName' nicht gefunden.
 * Fehler im Report-Bereich der GUI ausgeben und zum Zeichen eines Fehlers
 * ein leeres String-Array an die aufrufende Methode zurückliefern. */
        parmCallingFrame.get_txt_Report().append(
            "XML-Eintrag 'DataBaseDriverName' nicht vorhanden.\n");
        return new String[0];
      }
/* 
 * Wert des XML-Eintrages in den vorgesehenen String des String-Arrays übernehmen. */
      array_DB_Parms[0] = elementSingleParm.getTextTrim();;
/* Zur Kontrolle des Programm-Fortschrittes den Wert im Report-Bereich der GUI anzeigen. */
        parmCallingFrame.get_txt_Report().append(
            "DataBaseDriverName: " + array_DB_Parms[0] + "\n");
/* 
 * Extrahieren des Namens der Datenbank inklusive der spezifizierenden Zeichen. */
      elementSingleParm = XML_RootElement.getChild("DataBaseName");
      if (elementSingleParm == null) {
/* XML-Eintrag mit Namen 'DataBaseName' nicht gefunden.
 * Fehler im Report-Bereich der GUI ausgeben und zum Zeichen eines Fehlers
 * ein leeres String-Array an die aufrufende Methode zurückliefern. */
        parmCallingFrame.get_txt_Report().append(
            "XML-Eintrag 'DataBaseName' nicht vorhanden.\n");
        return new String[0];
      }
/* 
 * Wert des XML-Eintrages in den vorgesehenen String des String-Arrays übernehmen. */
      array_DB_Parms[1] = elementSingleParm.getTextTrim();;
/* Zur Kontrolle des Programm-Fortschrittes den Wert im Report-Bereich der GUI anzeigen. */
        parmCallingFrame.get_txt_Report().append(
            "DataBaseName: " + array_DB_Parms[1] + "\n");
/* 
 * Extrahieren des Benutzer-Namens für den Datenbank-Zugriff. */
      elementSingleParm = XML_RootElement.getChild("DataBaseUserID");
      if (elementSingleParm == null) {
/* XML-Eintrag mit Namen 'DataBaseUserID' nicht gefunden.
 * Fehler im Report-Bereich der GUI ausgeben und zum Zeichen eines Fehlers
 * ein leeres String-Array an die aufrufende Methode zurückliefern. */
        parmCallingFrame.get_txt_Report().append(
            "XML-Eintrag 'DataBaseUserID' nicht vorhanden.\n");
        return new String[0];
      }
/* 
 * Wert des XML-Eintrages in den vorgesehenen String des String-Arrays übernehmen. */
      array_DB_Parms[2] = elementSingleParm.getTextTrim();;
/* Zur Kontrolle des Programm-Fortschrittes den Wert im Report-Bereich der GUI anzeigen. */
        parmCallingFrame.get_txt_Report().append(
            "DataBaseUserID: " + array_DB_Parms[2] + "\n");
/* 
 * Extrahieren des Passworts für den Datenbank-Zugriff. */
      elementSingleParm = XML_RootElement.getChild("DataBasePassword");
      if (elementSingleParm == null) {
/* XML-Eintrag mit Namen 'Password' nicht gefunden.
 * Fehler im Report-Bereich der GUI ausgeben und zum Zeichen eines Fehlers
 * ein leeres String-Array an die aufrufende Methode zurückliefern. */
        parmCallingFrame.get_txt_Report().append(
            "XML-Eintrag 'DataBasePassword' nicht vorhanden.\n");
        return new String[0];
      }
/* 
 * Wert des XML-Eintrages in den vorgesehenen String des String-Arrays übernehmen. */
      array_DB_Parms[3] = elementSingleParm.getTextTrim();;
/* Zur Kontrolle des Programm-Fortschrittes den Wert im Report-Bereich der GUI anzeigen. */
        parmCallingFrame.get_txt_Report().append(
            "DataBasePassword: " + array_DB_Parms[3] + "\n");
/* 
 * Zurückliefern des String-Arrays mit den Parametern. */
      return array_DB_Parms;
    }
/*
 * Methode, die die Verbindung (connection) zur Datenbank herstellt.
 * Die 'connection' wird von der Methode zurückgeliefert. */
    private static Connection processConnectToDatabase(
                                  DB_Load parmCallingFrame, String[] parmArray_DB_Parms) {
/*
 * Variable, die von der Methode zurückgeliefert wird. */
      Connection conToDatabase = null;
/* */
      try {
/*
 * Klasse für die Verbindung zum Datenbanksystem 'konstruieren'.
 * Diese Klasse wird vom Hersteller des Datenbanksystems mitgeliefert und kann
 * deswegen nicht statisch im Code definiert werden.
 * Für dieses Beispiel wurde der Name der Klasse über die Parameter in der XML-Struktur
 * eingelesen.
 * Die Bibliotheks-Datei (*.jar) muß beim Start des Programms in der Liste der *.jar-Datein
 * enthalten sein.
 * Das Konstruieren der Klasse erfolgt mit der Java-Klasse 'Class'. */
        Class.forName(parmArray_DB_Parms[0]);
/*
 * Als Konvention (für Java festgelegt) heißt die 'konstruierte' Klasse für die Verbindung
 * zum Datenbanksystem 'DriverManager'.
 * Das erfolgreiche 'Konstruieren' wird auf der GUI gemeldet. */
        parmCallingFrame.get_txt_Report().append(
            "'DriverManager' konstruiert für: " + parmArray_DB_Parms[0] + "\n");
/*
 * Der 'DriverManager' enhält eine Methode mit der die Verbindung zu einer Datenbank
 * des Datenbanksystems erstellt werden kann.
 * Dazu muß der Name der Datenbank, ein berechtigter Benutzer und dessen Passwort
 * an die Methode als Parameter übergeben werden. */
        conToDatabase = DriverManager.getConnection(
            parmArray_DB_Parms[1], parmArray_DB_Parms[2], parmArray_DB_Parms[3]);
/*
 * Das erfolgreiche Verbinden zu Datenbank wird auf der GUI gemeldet. */
        parmCallingFrame.get_txt_Report().append(
            "Verbindung erfolgreich zur Datenbank: " + parmArray_DB_Parms[1] + "\n");
/*
 * Zur Vereinfachung der Verarbeitung 'darf' das Datenbanksystem entscheiden wann
 * ein 'Commit' ausgeführt wird.
 * Diese Einstellung wird für das Tutorial gewählt um eventuelle Fehler durch ein
 * vergessenes 'Commit' zu vermeiden.
 * Für reale Entwicklungen soll diese Einstellung nicht verwendet werden
 * weil im 'Echtbetrieb' ein 'Commit' oder 'Rollback' so gesetzt werden muß,
 * daß die Integrität der Daten gewahrt bleibt - auch wenn ein Fehler auftritt. */
        conToDatabase.setAutoCommit(true);
      }
      catch (Exception Exc) {
/*
 * Verbinden zur Datenbank war nicht erfolgreich;
 * Fehler auf der GUI melden und den zurückgelieferten Wert auf 'null' setzen
 * als Zeichen, daß das Programm abgebrochen werden muß. */
        parmCallingFrame.get_txt_Report().append(
            "Fehler beim Verbinden zur Datenbank: " + Exc.toString() + "\n");
        conToDatabase = null;
      }
/*
 * Erstellte Verbindung zur Datenbank an die aufrufende Methode zurückliefern. */
      return conToDatabase;
    }
}

▲ zum Inhaltsverzeichnis

Test

Der Code für das Programm kann jetzt durch Auswahl von Run>Run ausgeführt werden.

▲ zum Inhaltsverzeichnis

Mögliche Fehlerursachen

In diesem Schritt sind erstmals Werte erforderlich, die nicht beim Programmieren sofort einer Syntax-Prüfung unterzogen werden können.
Im Zuge von Trainings haben sich folgende Fehler als häufig erwiesen;

• Tippfehler bei den Parametern
  Wenn Sie die Datei mit der XML-Struktur (siehe Verzeichnis und Datei mit der XML-Struktur erstellen) selbst getippt haben, prüfen Sie, ob die Namen der XML-Elemente und deren Werte genau so in Groß- und Kleinbuchstaben geschrieben sind wie erforderlich.
  Ein Wert com.mysql.jdbc.driver ist unterschiedlich zu com.mysql.jdbc.Driver.

• Datenbanksystem ist nicht gestartet oder die Werte für den Datenbanknamen, den User-ID oder das Password stimmen nicht überein
  Auch diese Werte sind 'sensibel' auf Groß und Kleinschreibung.
  Weiters ist auch möglich, daß Sicherheitseinrichtungen den Zugriff verhindern.
  Prüfen Sie - wie in MySQL Datenbank für die Verwendung mit Java-Programmen einrichten > Prüfen auf korrekte Installation der Datenbank beschrieben - ob Sie von dem Computer, auf dem Sie das Beispiel testen, auf die Datenbank zugreifen können.
  Verwenden sie dabei die TCP/IP-Adresse, den Datenbank-Namen, den User-ID und das Password genau so, wie die Werte in der Datei mit den Parametern stehen.

▲ zum Inhaltsverzeichnis

Weitere Schritte und verwandte Dokumentation

▲ zum Inhaltsverzeichnis