Tutorial:
Datenbank-Ladeprogramm mit Graphischer Benutzeroberfläche (Java_Intro_02) – Meldungen drucken

Dieses Dokument zeigt, wie ein Drucker ausgewählt wird und auf diesem die Meldungen, die auf die GUI ausgegeben wurden, gedruckt werden.

Dabei werden Befehle verwendet, die bereits in Java 1.1 implementiert sind. Bei diesen ist leicht zu erfassen, wie ein Drucker ausgewählt wird, die zu druckende 'Grafik' für jede Seite erstellt wird und diese Grafik(en) an den Drucker 'gesandt' werden.

Java bietet ab Version 1.4 wesentlich umfangreichere Klassen für das Drucken an. Mit diesen Klassen ist es auch möglich, Dateien mit speziellen Formaten für die Druck – z.B. Portable Document Format (pdf) oder PostScript (ps) – einfach auszudrucken.
Diese neueren Klassen benötigen aber mehr Zeit, um mit ihnen vertraut zu werden – deswegen wurde die einfachste Möglichkeit für die Druck-Aufbereitung für dieses Tutorial verwendet.

Inhaltsverzeichnis:

Vorigerer Schritt: SQL-Kommandos ausführen 

Vorbemerkung und Funktion des Codes 
Vorbedingungen 
Zusätzlicher Code 
* Methode handleEvent(. . .) in der Klasse DB_Load__ActionHandler erweitern 
* Methode processPrint(. . .) in der Klasse DB_Load__ActionHandler codieren 
Gesamter Code beim Ende dieses Schritts 
* Klasse DB_Load 
* Klasse DB_Load__ActionHandler 
* Klasse DB_Load__Thread 
Test 
Weitere Schritte und verwandte Dokumentation 

Nächster Schritt: Packen in JAR-Datei 

Dank für Vorarbeiten

Hilfreich für mich war das Buch von Guido Krüger; das Kapitel mit der Einführung zum Drucken ist zu finden unter
http://www.addisonwesley.de/Service/Krueger/kap15004.htm .

Für mächtigere Befehle empfehle ich als Einstieg die Beschreibung von Torsten Horn unter http://www.torsten-horn.de/techdocs/java-print.htm .

Vorbemerkung und Funktion des Codes

In Java (seit Version 1.4) ist eine reichhaltige Sammlung von Methoden für die Auswahl eines Druckers und das Drucken enthalten.
In diesem Tutorial wird nur eine sehr einfache Möglichkeit des Druckens vorgestellt.

▲ zum Inhaltsverzeichnis

Vorbedingungen

• Schritt 5: SQL-Kommandos ausführen ausgeführt – und dessen Vorbedingungen auch.

▲ zum Inhaltsverzeichnis

Zusätzlicher Code

Der zusätzlich zu implementierende Code besteht aus einer neuen Methode processPrint(. . .) in der Klasse DB_Load__ActionHandler und einem Aufruf dieser Methode in der Methode handleEvent(. . ., die nach dem Anklicken einer Schaltfläche aufgerufen wird.

▲ zum Inhaltsverzeichnis

Methode handleEvent(. . .) in der Klasse DB_Load__ActionHandler erweitern

    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);
      if(cmd.equals("btn_Print")) processPrint(parmCallingFrame);
    }

Das Anklicken der Schaltfläche 'Drucken' bewirkt, daß die Methode processPrint(. . .) aufgerufen wird.

▲ zum Inhaltsverzeichnis

Methode processPrint(. . .) in der Klasse DB_Load__ActionHandler codieren

Zuerst wird der gesamte Code gelistet; die Erklärung der einzelnen Teile des Codes erfolgt nach der Liste.

/*
 * Methode, die einen Drucker auswählen läßt und dann die Meldungen aus der
 * TextArea 'txt_Report' ausdruckt. */
    private static void processPrint(DB_Load parmCallingFrame) {
/* 
 * Auslesen der gesamten Zeichenkette aus dem GUI-Element 'txt_Report'.
 * In dieser Zeichenkette sind auch die Zeilenumbrüche '\n' enthalten. */
      String strTextAreaContent = parmCallingFrame.get_txt_Report().getText();
/* 
 * Variable für die Position eine Zeilenumbruchs '\n'. */
      int intNewLinePosition;
/* 
 * Variable für die 'erste Zeile' innerhalb von 'strTextAreaContent';
 * das ist die Zeichenkette bis zum '\n'. */
      String strLineToBePrinted = parmCallingFrame.get_txt_Report().getText();
/* 
 * Variablen für die Zeilen und Seitenzähler beim Ausdruck. */
      int intLinePrinted = 1;
      int intPagePrinted = 1;
/* 
 * Eröffnen des Print-Jobs;
 * dabei wird der Benutzer aufgefordert, einen Drucker auszuwählen. */
      Frame f = new Frame();
      PrintJob pJob = f.getToolkit().getPrintJob(
          f, "Datenbank-Ladeprogramm - Drucker-Auswahl", null);
      Graphics g = pJob.getGraphics();
/* 
 * Seitenkopf für die erste Seite drucken.
 * Zur Demonstration werden verschiedene Fonts und Farben für den Seitenkkopf
 * und den Inhalt verwendet. */
      g.setColor(Color.black);
      g.setFont(new Font("Arial", Font.PLAIN, 9));
      g.drawString("Seite – " + Integer.toString(intPagePrinted) + " –", 300, 20);
/* 
 * Prüfen ob mindestens eine Zeile innerhalb der TextArea 'txt_Report' exisitert. */
      intNewLinePosition = strTextAreaContent.indexOf("\n");
/* 
 * Schleife, in der Zeile für Zeile aus der Zeichenkette 'strTextAreaContent' extrahiert
 * und gedruckt wird. */
      while (intNewLinePosition >= 0) {
/* 
 * Prüfen ob bereits mehr als 40 Zeilen gedruckt wurden.
 * In diesem Fall wird eine neue Seite begonnen. */
        if (intLinePrinted >= 40) {
/* 
 * Zeilen-Zähler zurücksetzen und Seiten-Zähler um1 erhöhen. */
      intLinePrinted = 1;
      intPagePrinted++;
/* 'Graphic schließen'; damit wird eine Seite gedruckt. */
          g.dispose();
/* Neue 'Graphic' vom Print-Job anfordern; damit wird eine neue Seite begonnen. */
          g = pJob.getGraphics();
/* 
 * Seitenkopf für die neue Seite drucken. */
          g.setColor(Color.black);
          g.setFont(new Font("Arial", Font.PLAIN, 9));
          g.drawString("Seite – " + Integer.toString(intPagePrinted) + " –", 300, 20);
/* Ende der Bearbeitung für eine neue Seite. */
        };
/* 
 * Herauslösen der zu druckenden Zeile und übrige Zeichenkette um diese Zeile verkürzen. */
        strLineToBePrinted = strTextAreaContent.substring(0, intNewLinePosition);
        strTextAreaContent = strTextAreaContent.substring(intNewLinePosition + 1);
/* 
 * Zeile mit Inhalt in einem anderen Font drucken als Seitenkopf.
 * Die vertikale Position der Zeile wird durch den 'intLinePrinted' Zähler bestimmt. */
        g.setColor(Color.black);
        g.setFont(new Font("Courier", Font.PLAIN, 9));
        g.drawString(strLineToBePrinted, 20, 30 + intLinePrinted*12);
/* Zeilen-Zähler erhöhen. */
        intLinePrinted++;
/* 
 * Prüfen ob noch mindestensmindestens eine Zeile innerhalb des Restes
 * der Zeichenkette aus der TextArea 'txt_Report' exisitert. */
        intNewLinePosition = strTextAreaContent.indexOf("\n");
      };
/* 
 * Print-Job beenden; erst danach beginnt der Ausdruck am Drucker. */
      g.dispose();
      pJob.end();
    }

Erklärung der bisher nicht verwendeten Kommandos und Algorithmen.

• /* 
 * Auslesen der gesamten Zeichenkette aus dem GUI-Element 'txt_Report'.
 * In dieser Zeichenkette sind auch die Zeilenumbrüche '\n' enthalten. */
      String strTextAreaContent = parmCallingFrame.get_txt_Report().getText();
/* 
 * Variable für die Position eine Zeilenumbruchs '\n'. */
      int intNewLinePosition;
/* 
 * Variable für die 'erste Zeile' innerhalb von 'strTextAreaContent';
 * das ist die Zeichenkette bis zum '\n'. */
      String strLineToBePrinted = parmCallingFrame.get_txt_Report().getText();

Alle Meldungen wurden für die Verarbeitung in die 'TextArea' txt_Report geschrieben. Von diesem GUI-Element werden die Meldungen jetzt wieder ausgelesen.
  Beim Schreiben wurde jede Meldung durch das Zeilenende '\n' gekennzeichnet; damit können die einzelnen Zeilen mit den Meldungen jetzt wieder getrennt werden.
  Die Zeichenkette einer einzelnen Zeile wird in der Variable strLineToBePrinted aufgehoben.

• /* 
 * Variablen für die Zeilen und Seitenzähler beim Ausdruck. */
      int intLinePrinted = 1;
      int intPagePrinted = 1;
  
  Das in diesem Dokument vorgestellte Drucken (implementiert ab Java Version 1.1) basiert auf dem 'bemalen' einer Fläche – ähnlich wie einfache Grafik-Programme.
  Dadurch gibt es auch keine Methode, um eine Zeichenkette die Text und 'Neue Zeile' Markierungen enthält als Ganzes zu drucken.
  Vielmehr muß jede Zeile über Koordinaten positioniert werden und dann kann der Text 'gemalt' werden.
  Zur Berechnung der vertikalen Koordinaten wird der Zeilenzähler intLinePrinted verwendet.
  
  Der Seitenzähler intPagePrinted wird zum Ausdruck der Seitennummer auf dem Seitenkopf verwendet.

• /* 
 * Eröffnen des Print-Jobs;
 * dabei wird der Benutzer aufgefordert, einen Drucker auszuwählen. */
      Frame f = new Frame();
      PrintJob pJob = f.getToolkit().getPrintJob(
          f, "Datenbank-Ladeprogramm - Drucker-Auswahl", null);
      Graphics g = pJob.getGraphics();

Für das Eröffnen eines Print-Jobs wird ein Objekt vom Type Frame benötigt - fragen Sie bitte nicht nach warum, es ist so implementiert seit Java Version 1.1 .

Aus dem 'Toolkit' des Frame kann ein Print-Job geholt werden:
f.getToolkit().getPrintJob(f, "Datenbank-Ladeprogramm - Drucker-Auswahl", null)
Mit dem Aufruf dieser Methode wird auch das Fenster aufgerufen, mit dem der Benutzer den Drucker auswählen kann und bei Bedarf noch Einstellungen der Seite (z.B. Hoch- oder Querformat) ändern kann.
Als Parameter für die Methode wird wieder das Frame und der Text, der im oberen Balken des Fenster erscheint, mitgegeben.
Im Parameter, der mit dem Wert null gefüllt wird, könnten 'Properties' (Einstellungen) für die Auswahlmöglichkeiten im erscheinenden Fenster übergeben werden. Eine Beschreibung dieser Properties würde bei Weitem die Aufgabe dieses Einführungs-Tutorials überschreiten.
Außerdem wurde ab Java Version 1.4 die Philosophie, wie in Java gedruckt werden kann, fundamental geändert und weit bessere Möglichkeiten für Voreinstellungen geschaffen.
Allerdings sind diese mächtigeren Methoden nicht mehr so leicht zu vermitteln – deswegen wurde für dieses Tutorial die einfachste Möglichkeit des Druckens gewählt.

Der Printhjob enthält dann mit einem Objekt vom Typ Graphics eine 'Fläche', auf der mit einfachen Kommandos gezeichnet oder Text plaziert werden kann.

• /* 
 * Seitenkopf für die erste Seite drucken.
 * Zur Demonstration werden verschiedene Fonts und Farben für den Seitenkkopf
 * und den Inhalt verwendet. */
      g.setColor(Color.black);
      g.setFont(new Font("Arial", Font.PLAIN, 9));
      g.drawString("Seite – " + Integer.toString(intPagePrinted) + " –", 300, 20);

Wie schon erwähnt, kann auf dem Objekt des Typs Graphics jetzt 'gezeichnet werden. Da die Aufgabe nur daraus besteht, einen Text auszugeben, wird nur
* das Wählen der Farbe (g.setColor(Color.black)),
* der Schriftart und -größe (g.setFont(new Font("Arial", Font.PLAIN, 9))) und
* das Platzieren von Text (g.drawString("Seite – " + Integer.toString(intPagePrinted) + " –", 300, 20)) verwendet.
Beim Platzieren von Grafik-Elementen muß die Koordinate (im Beispiel ..., 300, 20)) festgelegt werden.

Für das Ausdrucken von Text muß daher die vertikale Koordinate abhängig von der Zeilennummer berechnet werden:
g.drawString(strLineToBePrinted, 20, 30 + intLinePrinted*12);

• /* 
 * Print-Job beenden; erst danach beginnt der Ausdruck am Drucker. */
      g.dispose();
      pJob.end();

Eine zu druckende Seite wird damit beendet, daß auf das Objekt vom Typ Graphics die Methode dispose() angewandt wird.

Eine neue Seite wird eröffnet, indem ein neues Objekt vom Typ Graphics vom Print-Job angefordert wird: 
g = pJob.getGraphics(); .

Der Ausdruck am Drucker wird begonnen, nachdem der Print-Job beendet wurde:
pJob.end(); .

▲ 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 > Klasse DB_Load.

▲ 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);
      if(cmd.equals("btn_Print")) processPrint(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);
/* 
 * Wenn eine 'Connection zur Datenbank hergestellt werden konnte dann den Thread
 * für das Einlesen der Datei mit den SQL-Kommandos und deren Ausführung starten. */
      if (conToDatabase != null) {
        DB_Load__Thread t = new DB_Load__Thread(parmCallingFrame, conToDatabase);
        t.start();
      }
    }
/*
 * 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;
    }
/*
 * Methode, die einen Drucker auswählen läßt und dann die Meldungen aus der
 * TextArea 'txt_Report' ausdruckt. */
    private static void processPrint(DB_Load parmCallingFrame) {
/* 
 * Auslesen der gesamten Zeichenkette aus dem GUI-Element 'txt_Report'.
 * In dieser Zeichenkette sind auch die Zeilenumbrüche '\n' enthalten. */
      String strTextAreaContent = parmCallingFrame.get_txt_Report().getText();
/* 
 * Variable für die Position eine Zeilenumbruchs '\n'. */
      int intNewLinePosition;
/* 
 * Variable für die 'erste Zeile' innerhalb von 'strTextAreaContent';
 * das ist die Zeichenkette bis zum '\n'. */
      String strLineToBePrinted = parmCallingFrame.get_txt_Report().getText();
/* 
 * Variablen für die Zeilen und Seitenzähler beim Ausdruck. */
      int intLinePrinted = 1;
      int intPagePrinted = 1;
/* 
 * Eröffnen des Print-Jobs;
 * dabei wird der Benutzer aufgefordert, einen Drucker auszuwählen. */
      Frame f = new Frame();
      PrintJob pJob = f.getToolkit().getPrintJob(
          f, "Datenbank-Ladeprogramm - Drucker-Auswahl", null);
      Graphics g = pJob.getGraphics();
/* 
 * Seitenkopf für die erste Seite drucken.
 * Zur Demonstration werden verschiedene Fonts und Farben für den Seitenkkopf
 * und den Inhalt verwendet. */
      g.setColor(Color.black);
      g.setFont(new Font("Arial", Font.PLAIN, 9));
      g.drawString("Seite – " + Integer.toString(intPagePrinted) + " –", 300, 20);
/* 
 * Prüfen ob mindestens eine Zeile innerhalb der TextArea 'txt_Report' exisitert. */
      intNewLinePosition = strTextAreaContent.indexOf("\n");
/* 
 * Schleife, in der Zeile für Zeile aus der Zeichenkette 'strTextAreaContent' extrahiert
 * und gedruckt wird. */
      while (intNewLinePosition >= 0) {
/* 
 * Prüfen ob bereits mehr als 40 Zeilen gedruckt wurden.
 * In diesem Fall wird eine neue Seite begonnen. */
        if (intLinePrinted >= 40) {
/* 
 * Zeilen-Zähler zurücksetzen und Seiten-Zähler um1 erhöhen. */
      intLinePrinted = 1;
      intPagePrinted++;
/* 'Graphic schließen'; damit wird eine Seite gedruckt. */
          g.dispose();
/* Neue 'Graphic' vom Print-Job anfordern; damit wird eine neue Seite begonnen. */
          g = pJob.getGraphics();
/* 
 * Seitenkopf für die neue Seite drucken. */
          g.setColor(Color.black);
          g.setFont(new Font("Arial", Font.PLAIN, 9));
          g.drawString("Seite – " + Integer.toString(intPagePrinted) + " –", 300, 20);
/* Ende der Bearbeitung für eine neue Seite. */
        };
/* 
 * Herauslösen der zu druckenden Zeile und übrige Zeichenkette um diese Zeile verkürzen. */
        strLineToBePrinted = strTextAreaContent.substring(0, intNewLinePosition);
        strTextAreaContent = strTextAreaContent.substring(intNewLinePosition + 1);
/* 
 * Zeile mit Inhalt in einem anderen Font drucken als Seitenkopf.
 * Die vertikale Position der Zeile wird durch den 'intLinePrinted' Zähler bestimmt. */
        g.setColor(Color.black);
        g.setFont(new Font("Courier", Font.PLAIN, 9));
        g.drawString(strLineToBePrinted, 20, 30 + intLinePrinted*12);
/* Zeilen-Zähler erhöhen. */
        intLinePrinted++;
/* 
 * Prüfen ob noch mindestensmindestens eine Zeile innerhalb des Restes
 * der Zeichenkette aus der TextArea 'txt_Report' exisitert. */
        intNewLinePosition = strTextAreaContent.indexOf("\n");
      };
/* 
 * Print-Job beenden; erst danach beginnt der Ausdruck am Drucker. */
      g.dispose();
      pJob.end();
    }
}

▲ zum Inhaltsverzeichnis

Klasse DB_Load__Thread

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) – SQL-Kommandos ausführen > Gesamter Code am Ende diesen Schrittes > Klasse DB_Load__Thread.

▲ zum Inhaltsverzeichnis

Test

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

Eine detaillierte Anleitung mit Abbildungen wie die Datei mit den SQL-Kommandos ausgewählt wird und wie die SQL-Kommandos ausgeführt werden finden Sie unter Datenbank-Ladeprogramm mit Graphischer Benutzeroberfläche (Java_Intro_02) – SQL-Kommandos ausführen > Test.

▲ zum Inhaltsverzeichnis

Weitere Schritte und verwandte Dokumentation

▲ zum Inhaltsverzeichnis