Muster-Code für ein DBA (DataBase-Access Objekt)

Dieses Dokument enthält Code-Muster für eine einfache DBA- (DataBase-Access-) Klasse und Erweiterungen, die entsprechend den jeweiligen Anforderungen zusätzlich implementiert werden können.

Inhaltsverzeichnis:

Vorbedingung 
Einfacher Muster-Code für ein DBA 
Anleitung zur Adaptierung 
* Änderung des Namens des Java-Packages 
* Adaptieren des Kommentars 
* Änderung des Namens der Klasse 
* Änderung des Namens für die DB-Tabelle und und der Attribute der DB-Tabelle 
* Adaptieren der Teil-SQL-Kommandos 
* Definitionen der Variablen dieser Klasse 
* Werte aus dem Result-Set in die Variablen übertragen 
* Werte aus den Variablen in das Prepared Statement übertragen 
* Adaptieren der Platzhalter in der Methode insert(...) 
* Adaptieren der Position des Schlüsselwertes in der Methode update(...) 
* Adaptieren der Methode selectByUserKnownKey(...) 
* Adaptieren der Methoden selectNext(...) und selectPrevious(...) 

Weitere Schritte und verwandte Dokumentation 

Vorbedingung:

• Tutorial für die Programmierung eines Heavyweight-Clients (Fat-Client) durchgearbeitet.

• Datenmodell fertig ausgearbeitet.

▲ zum Inhaltsverzeichnis

Einfacher Muster-Code für ein DBA

Welche Platzhalter durch Bezeichnungen des eigentlichen Projektes zu ersetzen sind finden Sie im Abschnitt
Anleitung zur Adaptierung.

package application_package.dba;
/*
 * Package für die Verbindung zur Datenbank. */
import java.sql.*;
/*
 * Package mit der Basisklasse für ein DataBase-Access Objekt. */
import js_base.dba.JSBS_DBA;
/* Package mit dem Minimalen Set an Parametern. Diese enthalten das Arbeitsdatum.
 * Das Arbeitsdatum wird für verschiedene Abfragen gebraucht. */
import js_base.structures.JSBS_MinimalParameters;
/**
 * 
 * @author name[at]company
 * @date 20xx-xx-xx
 *
 * @description
 *  DataBase-Access Object (DBA)
 *  Namen für DB-Tabelle und Attributs-Namen finden Sie gleich
 *  unterhalb der Klassen-Definition.
 *  
 *  Anwender-bekannter-Schlüssel: VariableName, VariableName
 * 
 * @change-log
 * when          who                       why
 * -----------------------------------------------------------------
 * 
 */
public class application_dbtable_DBA extends JSBS_DBA {
/*
 * KONSTANTE Werte für Namen der DB-Tabelle und die Attribute der DB-Tabelle.
 * ---------------------
 * Die Aufgabe der einzelnen Attribute ist unter VARIABLEN beschrieben. */
/*
 * Name der DB-Tabelle. */
    public final static String CONST_TABLE_NAME = "DBTable";
/* Attribut für ...... */
    public final static String CONST_AttributeName = "AttributeName";
/*
 * KONSTANTE Werte die als Teile von SQL-Kommandos verwendet werden.
 * --------------------- */
/*
 * Zeichenkette mit allen Attributen die in SELECT- und INSERT-Kommandos vorkommen.
 * Der Teil CONST_COMMON_ATTRIBUTES_LIST ist in der Basisklasse JSBS_DBA definiert. */
    final static String CONST_ALL_ATTRIBUTES_LIST =
        CONST_COMMON_ATTRIBUTES_LIST + ", " +
        CONST_AttributeName + ", " +
        CONST_AttributeName + ", " +
        CONST_AttributeName;
/*
 * Zeichenkette mit allen Attributen die in UPDATE-Kommandos vorkommen.
 * Der Teil CONST_COMMON_ATTRIBUTES_LIST_FOR_UPDATE ist in der Basisklasse JSBS_DBA definiert. */
    final static String CONST_ALL_ATTRIBUTES_LIST_FOR_UPDATE =
        "update " + CONST_TABLE_NAME + " set " +
        CONST_COMMON_ATTRIBUTES_LIST_FOR_UPDATE +
        CONST_AttributeName + " =?, " +
        CONST_AttributeName + " =?, " +
        CONST_AttributeName + " =? " +
        " where ";
/*
 * Zeichenkette mit allen Attributen und dem Namen der DB-Tabelle für ein SELECT-Kommando. */
    final static String CONST_SELECT_ALL_ATTRIBUTES =
        "select " + CONST_ALL_ATTRIBUTES_LIST +
        " from " + CONST_TABLE_NAME;
/*
 * VARIABLE dieser Klasse.
 * Diese Variablen reflektieren die Attribute der DB-Tabelle.
 * --------------------- */
/* 
 * Beschreibung der Variable ... . */
    public String VariableName;
/*
 * Beschreibung der Variable ... . */
    public int VariableName;
/*
 * Beschreibung einer Variable die als BLOB (Binary Large OBject) gespeichert wird ... . */
    public byte[] VariableName_for_BLOB;
/*
 * METHODEN */
/* ---------------------
 * METHODE zum Übertragen der Werte aus dem 'SQLResultSet' in die Variablen dieser Klasse.
 * Das 'SQLResultSet' ist eine Klasse im packaga 'java.sql' das nach einem SELECT
 * die Werte der selektierten Datensätze enthält. */
    public void getValuesFromSQLResultSet(ResultSet parmSQLResultSet)
        throws SQLException {
/*
 * Aufruf der Methode der Superklasse um die 'Common Attributes' zu Übertragen. */
        try {
             getSQLResultSetForCommonAttributes(parmSQLResultSet);
        }
        catch (SQLException SQLExc) {
/* Wenn ein Fehler aufgetreten ist diesen an die aufrufende Methode zurückliefern. */
             throw SQLExc;
        }
/* Spezifische Werte für diese DBA-Klasse übertragen. */
        try {
             this.VariableName = parmSQLResultSet.getBigDecimal(CONST_AttributeName);
             this.VariableName_for_BLOB = parmSQLResultSet.getBytes(CONST_AttributeName);
             this.VariableName = parmSQLResultSet.getClob(CONST_AttributeName);
             this.VariableName = parmSQLResultSet.getDate(CONST_AttributeName);
             this.VariableName = parmSQLResultSet.getDouble(CONST_AttributeName);
             this.VariableName = parmSQLResultSet.getFloat(CONST_AttributeName);
             this.VariableName = parmSQLResultSet.getInt(CONST_AttributeName);
             this.VariableName = parmSQLResultSet.getLong(CONST_AttributeName);
             this.VariableName = parmSQLResultSet.getShort(CONST_AttributeName);
             this.VariableName = parmSQLResultSet.getString(CONST_AttributeName);
             this.VariableName = parmSQLResultSet.getTimestamp(CONST_AttributeName);
        }
/* Wenn ein Fehler aufgetreten ist diesen an die aufrufende Methode zurückliefern. */
        catch (SQLException SQLExc) {throw SQLExc;}
    }
/* ---------------------
 * METHODE zum Übertragen der Werte aus den Variablen dieser Klasse in das 'PreparedStatement'.
 * Das 'PreparedStatement' ist eine Klasse im packaga 'java.sql' für ein UPDATE oder INSERT
 * das SQL-Kommando mit den neuen Werten, die auf die DB-Tabelle geschrieben werden sollen,
 * enthält. */
    public void setValuesToSQLStatement(PreparedStatement parmSQLStatement)
        throws SQLException {
/*
 * Aufruf der Methode der Superklasse um die 'Common Attributes' zu Übertragen. */
        try {
            setSQLStatementWithCommonAttributes(parmSQLStatement);
        }
        catch (SQLException SQLExc) {
/* Wenn ein Fehler aufgetreten ist diesen an die aufrufende Methode zurückliefern. */
            throw SQLExc;
        }
/* Spezifische Werte für diese DBA-Klasse übertragen. */
        try {
            parmSQLStatement.setBigDecimal(10, this.VariableName);
            parmSQLStatement.setBytes(11, this.VariableName_for_BLOB);
            parmSQLStatement.setClob(12, this.VariableName);
            parmSQLStatement.setDate(13, this.VariableName);
            parmSQLStatement.setDouble(14, this.VariableName);
            parmSQLStatement.setFloat(15, this.VariableName);
            parmSQLStatement.setInt(16, this.VariableName);
            parmSQLStatement.setLong(17, this.VariableName);
            parmSQLStatement.setShort(18, this.VariableName);
            parmSQLStatement.setString(19, this.VariableName);
            parmSQLStatement.setTimestamp(20, this.VariableName);
        }
/* Wenn ein Fehler aufgetreten ist diesen an die aufrufende Methode zurückliefern. */
        catch (SQLException SQLExc) {throw SQLExc;}
    }
/* ---------------------
 * METHODE zum Einfügen eines neuen Datensatzes in die DB-Tabelle.
 * Voraussetzung ist, dass zuvor geprüft wurde, dass der Wert von DataSetID
 * (ein Common Attribute) noch nicht auf der DB-Tabelle existiert.
 * 'Connection' ist eine Klasse aus dem package 'java.sql' und enthält die
 * Verbindung zum Datenbanksystem. */
    public void insert(Connection parmDBCon) {
/* Aufbauen des SQL-Kommandos in einer eigenen Zeichenkette (String).
 * Gegenüber einem direkten Schreiben des SQL-Kommandos als Parameter
 * beim 'Construct' des 'SQLStatement' hilft der eigene String beim Debuggen. */
      final String locstrSQLCommand = "insert into " + CONST_TABLE_NAME + " (" +
                                      CONST_ALL_ATTRIBUTES_LIST +
                                      ") VALUES (" +
/* 9 'Platzhalter' für die 'Common Attributes'. */
                                      "?, ?, ?, ?, ?, ?, ?, ?, ?, " +
/* X 'Platzhalter' für die spezifischen Variablen dieser DBA-Klassen. */
                                      "?, ?, ?)";
/* 'PreparedStatement' ist eine Klasse aus dem 'java.sql'-package die das
 * SQL-Kommando an das Datenbanksystem überträgt. */
      PreparedStatement SQLStatement;
/* Es folgt die Ausführung des SQL-Kommandos; die dafür zuständigen Klassen
 * und Methoden arbeiten mit 'try/catch' zur Fehlerbehandlung. */
      try {
/* Gerade vorher definiertes 'PreparedStatement' konstruieren
 * und dabei als Parameter das SQL-Kommando übergeben. */
        SQLStatement = parmDBCon.prepareStatement(locstrSQLCommand);
/* Methode zum Übertragen der Werte aus den Variablen dieser Klasse
 * in das SQL-Kommando aufrufen. */
        setValuesToSQLStatement(SQLStatement);
/* SQL-Kommando an die Datenbank 'absenden'. */
        SQLStatement.executeUpdate();
/* SQL-Kommando wurde fehlerfrei ausgeführt; die Fehlerfreiheit wird durch eine
 * 'leere' Zeichenkette in der Variablen 'ErrorMsg' (definiert in der geerbten Basisklasse)
 * an die aufrufende Methode zurückgemeldet. */
        ErrorMsg = "";
      }
      catch (SQLException SQLExc) {
/* Wenn ein Fehler aufgetreten ist dann den Fehler-Text extrahieren und an die
 * aufrufende Methode zurückliefern. */
        ErrorMsg = SQLExc.getMessage();
      }
    }
/* ---------------------
 * METHODE zum Ändern eines bestehenden Datensatzes in der DB-Tabelle.
 * Das ist eine 'Wrapper-Methode' für einen einfacheren Aufruf der Methode wenn
 * der Primärschlüssel (DataSetID) nicht verändert werden muss.
 * 'Connection' ist eine Klasse aus dem package 'java.sql' und enthält die
 * Verbindung zum Datenbanksystem. */
    public void update(Connection parmDBCon) {
/* Eigentliche Methode aufrufen und als Wert für den Primärschlüssel den Wert '0'
 * übergeben. */
      update(parmDBCon, 0);
    }
/* 
 * METHODE zum Ändern eines bestehenden Datensatzes in der DB-Tabelle.
 * Dabei wird auch der Primärschlüssel (DataSetID) geändert.
 * Das kann nötig sein wenn in der Version 'MobileClient' auf dem
 * 'asynchronen' Gerät und auf dem Server zufällig ein gleicher Wert für den
 * DataSetID generiert wurde. Dann muss auf der Datenbank des mobilen
 * Client mit dieser Methode der DataSetID (Primärschlüssel) geändert werden.
 * Ist der Wert im Parameter 'parmDataSetIDToSelect' 0 dann wird der Wert von
 * DataSetID nicht geändert.
 * 'Connection' ist eine Klasse aus dem package 'java.sql' und enthält die
 * Verbindung zum Datenbanksystem. */
    public void update(Connection parmDBCon, double parmDataSetIDToSelect) {
/* Definieren der Variablen mit dem DataSetID der später für die Selektion
 * beim Datanbank-Zugriff verwendet wird. */
      double dblDataSetIDToSelect;
/* Wenn als Parameter der Wert '0' übergeben wurde dann wird für die Selektion
 * von der Datenbank der Wert aus diesem Objekt verwendet. */
      if (parmDataSetIDToSelect == 0) dblDataSetIDToSelect = this.DataSetID;
/* Wenn als Parameter ein Wert übergeben wurde dann wird dieser für die Selektion
 * von der Datenbank verwendet. */
      else dblDataSetIDToSelect = parmDataSetIDToSelect;
/* 
 * Aufbauen des SQL-Kommandos in einer eigenen Zeichenkette (String).
 * Gegenüber einem direkten Schreiben des SQL-Kommandos als Parameter
 * beim 'Construct' des 'SQLStatement' hilft der eigene String beim Debuggen. */
      final String locstrSQLCommand = CONST_ALL_ATTRIBUTES_LIST_FOR_UPDATE +
/* CONST_DataSetID ist der Primärschlüssel und in der geerbten Basisklasse
 * als 'Common Attribute' definiert. */
                                      CONST_DataSetID + " =?";
/* 'PreparedStatement' ist eine Klasse aus dem 'java.sql'-package die das
 * SQL-Kommando an das Datenbanksystem überträgt. */
      PreparedStatement SQLStatement;
/* Es folgt die Ausführung des SQL-Kommandos; die dafür zuständigen Klassen
 * und Methoden arbeiten mit 'try/catch' zur Fehlerbehandlung. */
      try {
/* Gerade vorher definiertes 'PreparedStatement' konstruieren
 * und dabei als Parameter das SQL-Kommando übergeben. */
        SQLStatement = parmDBCon.prepareStatement(locstrSQLCommand);
/* Methode zum Übertragen der Werte aus den Variablen dieser Klasse
 * in das SQL-Kommando aufrufen. */
        setValuesToSQLStatement(SQLStatement);
/* Wert für den Primärschlüssel (in der Basisklasse definiert) in die Zeichenkette
 * mit dem SQL-Kommando einfügen.
 * Der Wert für die Position ('indicator') ist um 1 höher als die Anzahl der Attribute
 * dieses DBA.
 * BITTE BEACHTEN: aus der Basisklasse werden bereits 9 Attribute geerbt ! */
        SQLStatement.setDouble(indicator, dblDataSetIDToSelect);
/* SQL-Kommando an die Datenbank 'absenden'. */
        SQLStatement.executeUpdate();
/* SQL-Kommando wurde fehlerfrei ausgeführt; die Fehlerfreiheit wird durch eine
 * 'leere' Zeichenkette in der Variablen 'ErrorMsg' (definiert in der geerbten Basisklasse)
 * an die aufrufende Methode zurückgemeldet. */
        ErrorMsg = "";
      }
      catch (SQLException SQLExc) {
/* Wenn ein Fehler aufgetreten ist dann den Fehler-Text extrahieren und an die
 * aufrufende Methode zurückliefern. */
        ErrorMsg = SQLExc.getMessage();
      }
    }
/* ---------------------
 * METHODE zum Lesen eines Datensatzes wenn der Primärschlüssel bekannt ist.
 * Mit dem Primärschlüssel kann maximal 1 Datensatz gefunden werden.
 * Über den zurückgegeben 'boolean' Wert wird der aufrufenden Methode signalisiert,
 * ob ein Datensatz gefunden wurde.
 * 'Connection' ist eine Klasse aus dem package 'java.sql' und enthält die
 * Verbindung zum Datenbanksystem. */
    public boolean selectByDataSetID(Connection parmDBCon, double parmDataSetID) {
/* Aufbauen des SQL-Kommandos in einer eigenen Zeichenkette (String).
 * Gegenüber einem direkten Schreiben des SQL-Kommandos als Parameter
 * beim 'Construct' des 'SQLStatement' hilft der eigene String beim Debuggen. */
      final String locstrSQLCommand = CONST_SELECT_ALL_ATTRIBUTES +
/* CONST_DataSetID ist der Primärschlüssel und wurde als Parameter übergeben. */
                                      " where " + CONST_DataSetID + " =?";
/* 'PreparedStatement' ist eine Klasse aus dem 'java.sql'-package die das
 * SQL-Kommando an das Datenbanksystem überträgt. */
      PreparedStatement SQLStatement;
/* Es folgt die Ausführung des SQL-Kommandos; die dafür zuständigen Klassen
 * und Methoden arbeiten mit 'try/catch' zur Fehlerbehandlung. */
      try {
/* Gerade vorher definiertes 'PreparedStatement' konstruieren
 * und dabei als Parameter das SQL-Kommando übergeben. */
        SQLStatement = parmDBCon.prepareStatement(locstrSQLCommand);
/* Wert für den Primärschlüssel (aus den Parametern) in die Zeichenkette
 * mit dem SQL-Kommando einfügen. */
        SQLStatement.setDouble(1, parmDataSetID);
/* SQL-Kommando an die Datenbank 'absenden'; die Werte des gefundenen Datensatzes
 * sind dann im Objekt der Klasse 'ResultSet'. */
        ResultSet SQLResultSet = SQLStatement.executeQuery();
/* 
 * Prüfen ob ein Datensatz gefunden wurde. */
        if (!SQLResultSet.next()) {
/* Kein Datensatz mit dem gesuchten Primärschlüsssel gefunden;
 * das mit dem 'boolschen Wert' an die aufrufende Methode signalisieren. */
          ErrorMsg = "";
          return false;
        }
/* Datensatz mit dem gesuchten Primärschlüsssel gefunden;
 * Methode zum Übertragen der Werte aufrufen. */
        getValuesFromSQLResultSet(SQLResultSet);
/* SQL-Kommando wurde fehlerfrei ausgeführt; die Fehlerfreiheit wird durch eine
 * 'leere' Zeichenkette in der Variablen 'ErrorMsg' (definiert in der geerbten Basisklasse)
 * an die aufrufende Methode zurückgemeldet. */
        ErrorMsg = "";
        return true;
      }
      catch (SQLException SQLExc) {
/* Wenn ein Fehler aufgetreten ist dann den Fehler-Text extrahieren und an die
 * aufrufende Methode zurückliefern. */
        ErrorMsg = SQLExc.getMessage();
/* Zusätzlich muß in dieser Methode auch ein Wert zurückgeliefert werden. */
        return false;
      }
    }
/* ---------------------
 * METHODE zum Lesen eines Datensatzes mit den 'ObjectID' der ein Business Object
 * intern eindeutig identifiziert.
 * Mit diesem Wert und dem Arbeitsdatum (im Parameter JSBS_MinimalParameters enthalten)
 * kann maximal 1 Datensatz gefunden werden.
 * Über den zurückgegeben 'boolean' Wert wird der aufrufenden Methode signalisiert,
 * ob ein Datensatz gefunden wurde.
 * 'Connection' ist eine Klasse aus dem package 'java.sql' und enthält die
 * Verbindung zum Datenbanksystem. */
    public boolean selectByObjectID(Connection parmDBCon, JSBS_MinimalParameters parmMinParm,
                                        double parmObjectID) {
/* Aufbauen des SQL-Kommandos in einer eigenen Zeichenkette (String).
 * Gegenüber einem direkten Schreiben des SQL-Kommandos als Parameter
 * beim 'Construct' des 'SQLStatement' hilft der eigene String beim Debuggen. */
      final String locstrSQLCommand = CONST_SELECT_ALL_ATTRIBUTES +
/* Selectionskriterien in die Zeichenkette einfügen. */
                                      " where " + CONST_ValidFrom + " <=?" +
                                      " and " + CONST_ValidTill + " >=?" +
                                      " and " + CONST_ObjectID + " =?" +
/* Sortierkriterium, damit jener Datensatz, dessen Gültigkeitsgrenzen am nächsten zum aktuellen
 * Datum liegen, ausgewählt wird. */
                                      " order by " + CONST_ValidFrom + " desc, " +
                                      CONST_ValidTill + " asc";
/* Das im Parameter 'JSBS_MinimalParameters' enthaltene Arbeitsdatum muß in das
 * Datumsformat der 'java.sql' Klassen konvertiert werden. */
      Date locdteWorkDate = new Date(parmMinParm.calWorkDate.getTime().getTime());
/* 'PreparedStatement' ist eine Klasse aus dem 'java.sql'-package die das
 * SQL-Kommando an das Datenbanksystem überträgt. */
      PreparedStatement SQLStatement;
/* Es folgt die Ausführung des SQL-Kommandos; die dafür zuständigen Klassen
 * und Methoden arbeiten mit 'try/catch' zur Fehlerbehandlung. */
      try {
/* Gerade vorher definiertes 'PreparedStatement' konstruieren
 * und dabei als Parameter das SQL-Kommando übergeben. */
        SQLStatement = parmDBCon.prepareStatement(locstrSQLCommand);
/* Wert für die Selektion in die Zeichenkette mit dem SQL-Kommando einfügen. */
        SQLStatement.setDate(1, locdteWorkDate);
        SQLStatement.setDate(2, locdteWorkDate);
        SQLStatement.setDouble(3, parmObjectID);
/* SQL-Kommando an die Datenbank 'absenden'; die Werte des gefundenen Datensatzes
 * sind dann im Objekt der Klasse 'ResultSet'. */
        ResultSet SQLResultSet = SQLStatement.executeQuery();
/* 
 * Prüfen ob ein Datensatz gefunden wurde. */
        if (!SQLResultSet.next()) {
/* Kein Datensatz mit dem gesuchten ObjectID gefunden;
 * das mit dem 'boolschen Wert' an die aufrufende Methode signalisieren. */
          ErrorMsg = "";
          return false;
        }
/* Datensatz mit dem gesuchten ObjectID gefunden;
 * Methode zum Übertragen der Werte aufrufen. */
        getValuesFromSQLResultSet(SQLResultSet);
/* Prüfen ob der gefundene Datensatz mit dem größten 'ValidFrom'-Datum nicht vielleicht
 * erst in der Zukunft beginnt. */
        if (this.ValidFrom.getTime() > locdteWorkDate.getTime()) {
/* Datensatz ist erst in der Zukunft gültig; an die aufrufende Methode signalisieren,
 * dass kein Datensatz gefunden wurde. */
          ErrorMsg = "";
          return false;
        }
/* SQL-Kommando wurde fehlerfrei ausgeführt; die Fehlerfreiheit wird durch eine
 * 'leere' Zeichenkette in der Variablen 'ErrorMsg' (definiert in der geerbten Basisklasse)
 * an die aufrufende Methode zurückgemeldet. */
        ErrorMsg = "";
        return true;
      }
      catch (SQLException SQLExc) {
/* Wenn ein Fehler aufgetreten ist dann den Fehler-Text extrahieren und an die
 * aufrufende Methode zurückliefern. */
        ErrorMsg = SQLExc.getMessage();
/* Zusätzlich muß in dieser Methode auch ein Wert zurückgeliefert werden. */
        return false;
      }
    }
/* ---------------------
 * METHODE zum Lesen eines Datensatzes mit den Werten, die ein Business Object
 * für einen Anwender eindeutig identifizieren.
 * Mit diesen Werten und dem Arbeitsdatum (im Parameter JSBS_MinimalParameters enthalten)
 * kann maximal 1 Datensatz gefunden werden.
 * Über den zurückgegeben 'boolean' Wert wird der aufrufenden Methode signalisiert,
 * ob ein Datensatz gefunden wurde.
 * 'Connection' ist eine Klasse aus dem package 'java.sql' und enthält die
 * Verbindung zum Datenbanksystem. */
    public boolean selectByUserKnownKey(Connection parmDBCon, JSBS_MinimalParameters parmMinParm,
                                        String parmSelectVariableName1, String parmSelectVariableName2) {
/* Aufbauen des SQL-Kommandos in einer eigenen Zeichenkette (String).
 * Gegenüber einem direkten Schreiben des SQL-Kommandos als Parameter
 * beim 'Construct' des 'SQLStatement' hilft der eigene String beim Debuggen. */
      final String locstrSQLCommand = CONST_SELECT_ALL_ATTRIBUTES +
/* Selectionskriterien in die Zeichenkette einfügen. */
                                      " where " + CONST_ClientID + " =?" +
                                      " and " + CONST_ValidFrom + " <=?" +
                                      " and " + CONST_ValidTill + " >=?" +
                                      " and " + CONST_AttributeName1 + " =?" +
                                      " and " + CONST_AttributeName2 + " =?" +
/* Sortierkriterium, damit jener Datensatz, dessen Gültigkeitsgrenzen am nächsten zum aktuellen
 * Datum liegen, ausgewählt wird. */
                                      " order by " + CONST_ValidFrom + " desc, " +
                                      CONST_ValidTill + " asc";
/* Das im Parameter 'JSBS_MinimalParameters' enthaltene Arbeitsdatum muß in das
 * Datumsformat der 'java.sql' Klassen konvertiert werden. */
      Date locdteWorkDate = new Date(parmMinParm.calWorkDate.getTime().getTime());
/* 'PreparedStatement' ist eine Klasse aus dem 'java.sql'-package die das
 * SQL-Kommando an das Datenbanksystem überträgt. */
      PreparedStatement SQLStatement;
/* Es folgt die Ausführung des SQL-Kommandos; die dafür zuständigen Klassen
 * und Methoden arbeiten mit 'try/catch' zur Fehlerbehandlung. */
      try {
/* Gerade vorher definiertes 'PreparedStatement' konstruieren
 * und dabei als Parameter das SQL-Kommando übergeben. */
        SQLStatement = parmDBCon.prepareStatement(locstrSQLCommand);
/* Wert für die Selektion in die Zeichenkette mit dem SQL-Kommando einfügen. */
        SQLStatement.setInt(1, parmMinParm.intClientID);
        SQLStatement.setDate(2, locdteWorkDate);
        SQLStatement.setDate(3, locdteWorkDate);
        SQLStatement.setString(4, parmSelectVariableName1);
        SQLStatement.setString(5, parmSelectVariableName2);
/* SQL-Kommando an die Datenbank 'absenden'; die Werte des gefundenen Datensatzes
 * sind dann im Objekt der Klasse 'ResultSet'. */
        ResultSet SQLResultSet = SQLStatement.executeQuery();
/* 
 * Prüfen ob ein Datensatz gefunden wurde. */
        if (!SQLResultSet.next()) {
/* Kein Datensatz mit dem gesuchten Anwender-bekannten Schlüssel gefunden;
 * das mit dem 'boolschen Wert' an die aufrufende Methode signalisieren. */
          ErrorMsg = "";
          return false;
        }
/* Datensatz mit dem gesuchten Anwender-bekannten Schlüssel gefunden;
 * Methode zum Übertragen der Werte aufrufen. */
        getValuesFromSQLResultSet(SQLResultSet);
/* Prüfen ob der gefundene Datensatz mit dem größten 'ValidFrom'-Datum nicht vielleicht
 * erst in der Zukunft beginnt. */
        if (this.ValidFrom.getTime() > locdteWorkDate.getTime()) {
/* Datensatz ist erst in der Zukunft gültig; an die aufrufende Methode signalisieren,
 * dass kein Datensatz gefunden wurde. */
          ErrorMsg = "";
          return false;
        }
/* SQL-Kommando wurde fehlerfrei ausgeführt; die Fehlerfreiheit wird durch eine
 * 'leere' Zeichenkette in der Variablen 'ErrorMsg' (definiert in der geerbten Basisklasse)
 * an die aufrufende Methode zurückgemeldet. */
        ErrorMsg = "";
        return true;
      }
      catch (SQLException SQLExc) {
/* Wenn ein Fehler aufgetreten ist dann den Fehler-Text extrahieren und an die
 * aufrufende Methode zurückliefern. */
        ErrorMsg = SQLExc.getMessage();
/* Zusätzlich muß in dieser Methode auch ein Wert zurückgeliefert werden. */
        return false;
      }
    }
/* ---------------------
 * METHODE zum Lesen eines Datensatzes dessen Werte für den Anwender-bekannten-Schlüssel
 * in der Sortier-Reihenfolge nach den Werten, die als Parameter übergeben werden, auftreten.
 * Mit diesen Werten und dem Arbeitsdatum (im Parameter JSBS_MinimalParameters enthalten)
 * kann maximal 1 Datensatz gefunden werden.
 * Über den zurückgegeben 'boolean' Wert wird der aufrufenden Methode signalisiert,
 * ob ein Datensatz gefunden wurde.
 * 'Connection' ist eine Klasse aus dem package 'java.sql' und enthält die
 * Verbindung zum Datenbanksystem. */
    public boolean selectNext(Connection parmDBCon, JSBS_MinimalParameters parmMinParm,
                                        String parmSelectVariableName1, String parmSelectVariableName2,
                                        String parmSelectVariableName3) {
/* Aufbauen des SQL-Kommandos in einer eigenen Zeichenkette (String).
 * Gegenüber einem direkten Schreiben des SQL-Kommandos als Parameter
 * beim 'Construct' des 'SQLStatement' hilft der eigene String beim Debuggen. */
      final String locstrSQLCommand = CONST_SELECT_ALL_ATTRIBUTES +
/* Selectionskriterien in die Zeichenkette einfügen. */
                                      " where " + CONST_ClientID + " =?" +
                                      " and " + CONST_ValidFrom + " <=?" + " and " + CONST_ValidTill + " >=?" +
/* Selectionskriterien für 3 Variablen; bei mehr oder weniger Variablen ist das Statement anzupassen. */
                                      " and ((" + CONST_AttributeName1 + " =?" + " and " +
                                                  CONST_AttributeName2 + " =?" + " and " +
                                                  CONST_AttributeName3 + " >?" +
                                       ") or (" + CONST_AttributeName1 + " =?" + " and " +
                                                  CONST_AttributeName2 + " >?" +
                                       ") or " + CONST_AttributeName1 + " >?" +
                                           ") " +
/* Sortierkriterium, damit jener Datensatz, dessen Gültigkeitsgrenzen am nächsten zum aktuellen
 * Datum liegen, ausgewählt wird. */
                                      " order by " + 
/* Sortierkriterium für 3 Variablen; bei mehr oder weniger Variablen ist das Statement anzupassen. */
                                                     CONST_AttributeName1 + " asc, " +
                                                     CONST_AttributeName2 + " asc, " +
                                                     CONST_AttributeName3 + " asc, " +
                                                     CONST_ValidFrom + " desc, " + CONST_ValidTill + " asc " +
/* Nur den ersten Datensatz der sortierten Liste zurückliefern. */
                                                     " limit 1 ";
/* Das im Parameter 'JSBS_MinimalParameters' enthaltene Arbeitsdatum muß in das
 * Datumsformat der 'java.sql' Klassen konvertiert werden. */
      Date locdteWorkDate = new Date(parmMinParm.calWorkDate.getTime().getTime());
/* 'PreparedStatement' ist eine Klasse aus dem 'java.sql'-package die das
 * SQL-Kommando an das Datenbanksystem überträgt. */
      PreparedStatement SQLStatement;
/* Es folgt die Ausführung des SQL-Kommandos; die dafür zuständigen Klassen
 * und Methoden arbeiten mit 'try/catch' zur Fehlerbehandlung. */
      try {
/* Gerade vorher definiertes 'PreparedStatement' konstruieren
 * und dabei als Parameter das SQL-Kommando übergeben. */
        SQLStatement = parmDBCon.prepareStatement(locstrSQLCommand);
/* Wert für die Selektion in die Zeichenkette mit dem SQL-Kommando einfügen. */
        SQLStatement.setInt(1, parmMinParm.intClientID);
        SQLStatement.setDate(2, locdteWorkDate);
        SQLStatement.setDate(3, locdteWorkDate);
        SQLStatement.setString(4, parmSelectVariableName1);
        SQLStatement.setString(5, parmSelectVariableName2);
        SQLStatement.setString(6, parmSelectVariableName3);
        SQLStatement.setString(7, parmSelectVariableName1);
        SQLStatement.setString(8, parmSelectVariableName2);
        SQLStatement.setString(9, parmSelectVariableName1);
/* SQL-Kommando an die Datenbank 'absenden'; die Werte des gefundenen Datensatzes
 * sind dann im Objekt der Klasse 'ResultSet'. */
        ResultSet SQLResultSet = SQLStatement.executeQuery();
/* 
 * Prüfen ob ein Datensatz gefunden wurde. */
        if (!SQLResultSet.next()) {
/* Kein Datensatz mit dem gesuchten Anwender-bekannten Schlüssel gefunden;
 * das mit dem 'boolschen Wert' an die aufrufende Methode signalisieren. */
          ErrorMsg = "";
          return false;
        }
/* Datensatz mit dem gesuchten Anwender-bekannten Schlüssel gefunden;
 * Methode zum Übertragen der Werte aufrufen. */
        getValuesFromSQLResultSet(SQLResultSet);
/* Prüfen ob der gefundene Datensatz mit dem größten 'ValidFrom'-Datum nicht vielleicht
 * erst in der Zukunft beginnt. */
        if (this.ValidFrom.getTime() > locdteWorkDate.getTime()) {
/* Datensatz ist erst in der Zukunft gültig; an die aufrufende Methode signalisieren,
 * dass kein Datensatz gefunden wurde. */
          ErrorMsg = "";
          return false;
        }
/* SQL-Kommando wurde fehlerfrei ausgeführt; die Fehlerfreiheit wird durch eine
 * 'leere' Zeichenkette in der Variablen 'ErrorMsg' (definiert in der geerbten Basisklasse)
 * an die aufrufende Methode zurückgemeldet. */
        ErrorMsg = "";
        return true;
      }
      catch (SQLException SQLExc) {
/* Wenn ein Fehler aufgetreten ist dann den Fehler-Text extrahieren und an die
 * aufrufende Methode zurückliefern. */
        ErrorMsg = SQLExc.getMessage();
/* Zusätzlich muß in dieser Methode auch ein Wert zurückgeliefert werden. */
        return false;
      }
    }
/* ---------------------
 * METHODE zum Lesen eines Datensatzes dessen Werte für den Anwender-bekannten-Schlüssel
 * in der Sortier-Reihenfolge vor den Werten, die als Parameter übergeben werden, auftreten.
 * Mit diesen Werten und dem Arbeitsdatum (im Parameter JSBS_MinimalParameters enthalten)
 * kann maximal 1 Datensatz gefunden werden.
 * Über den zurückgegeben 'boolean' Wert wird der aufrufenden Methode signalisiert,
 * ob ein Datensatz gefunden wurde.
 * 'Connection' ist eine Klasse aus dem package 'java.sql' und enthält die
 * Verbindung zum Datenbanksystem. */
    public boolean selectPrevious(Connection parmDBCon, JSBS_MinimalParameters parmMinParm,
                                        String parmSelectVariableName1, String parmSelectVariableName2,
                                        String parmSelectVariableName3) {
/* Aufbauen des SQL-Kommandos in einer eigenen Zeichenkette (String).
 * Gegenüber einem direkten Schreiben des SQL-Kommandos als Parameter
 * beim 'Construct' des 'SQLStatement' hilft der eigene String beim Debuggen. */
      final String locstrSQLCommand = CONST_SELECT_ALL_ATTRIBUTES +
/* Selectionskriterien in die Zeichenkette einfügen. */
                                      " where " + CONST_ClientID + " =?" +
                                      " and " + CONST_ValidFrom + " <=?" + " and " + CONST_ValidTill + " >=?" +
/* Selectionskriterien für 3 Variablen; bei mehr oder weniger Variablen ist das Statement anzupassen. */
                                      " and ((" + CONST_AttributeName1 + " =?" + " and " +
                                                  CONST_AttributeName2 + " =?" + " and " +
                                                  CONST_AttributeName3 + " <?" +
                                       ") or (" + CONST_AttributeName1 + " =?" + " and " +
                                                  CONST_AttributeName2 + " <?" +
                                       ") or " + CONST_AttributeName1 + " <?" +
                                           ") " +
/* Sortierkriterium, damit jener Datensatz, dessen Gültigkeitsgrenzen am nächsten zum aktuellen
 * Datum liegen, ausgewählt wird. */
                                      " order by " + 
/* Sortierkriterium für 3 Variablen; bei mehr oder weniger Variablen ist das Statement anzupassen. */
                                                     CONST_AttributeName1 + " desc, " +
                                                     CONST_AttributeName2 + " desc, " +
                                                     CONST_AttributeName3 + " desc, " +
                                                     CONST_ValidFrom + " desc, " + CONST_ValidTill + " asc " +
/* Nur den ersten Datensatz der sortierten Liste zurückliefern. */
                                                     " limit 1 ";
/* Das im Parameter 'JSBS_MinimalParameters' enthaltene Arbeitsdatum muß in das
 * Datumsformat der 'java.sql' Klassen konvertiert werden. */
      Date locdteWorkDate = new Date(parmMinParm.calWorkDate.getTime().getTime());
/* 'PreparedStatement' ist eine Klasse aus dem 'java.sql'-package die das
 * SQL-Kommando an das Datenbanksystem überträgt. */
      PreparedStatement SQLStatement;
/* Es folgt die Ausführung des SQL-Kommandos; die dafür zuständigen Klassen
 * und Methoden arbeiten mit 'try/catch' zur Fehlerbehandlung. */
      try {
/* Gerade vorher definiertes 'PreparedStatement' konstruieren
 * und dabei als Parameter das SQL-Kommando übergeben. */
        SQLStatement = parmDBCon.prepareStatement(locstrSQLCommand);
/* Wert für die Selektion in die Zeichenkette mit dem SQL-Kommando einfügen. */
        SQLStatement.setInt(1, parmMinParm.intClientID);
        SQLStatement.setDate(2, locdteWorkDate);
        SQLStatement.setDate(3, locdteWorkDate);
        SQLStatement.setString(4, parmSelectVariableName1);
        SQLStatement.setString(5, parmSelectVariableName2);
        SQLStatement.setString(6, parmSelectVariableName3);
        SQLStatement.setString(7, parmSelectVariableName1);
        SQLStatement.setString(8, parmSelectVariableName2);
        SQLStatement.setString(9, parmSelectVariableName1);
/* SQL-Kommando an die Datenbank 'absenden'; die Werte des gefundenen Datensatzes
 * sind dann im Objekt der Klasse 'ResultSet'. */
        ResultSet SQLResultSet = SQLStatement.executeQuery();
/* 
 * Prüfen ob ein Datensatz gefunden wurde. */
        if (!SQLResultSet.next()) {
/* Kein Datensatz mit dem gesuchten Anwender-bekannten Schlüssel gefunden;
 * das mit dem 'boolschen Wert' an die aufrufende Methode signalisieren. */
          ErrorMsg = "";
          return false;
        }
/* Datensatz mit dem gesuchten Anwender-bekannten Schlüssel gefunden;
 * Methode zum Übertragen der Werte aufrufen. */
        getValuesFromSQLResultSet(SQLResultSet);
/* Prüfen ob der gefundene Datensatz mit dem größten 'ValidFrom'-Datum nicht vielleicht
 * erst in der Zukunft beginnt. */
        if (this.ValidFrom.getTime() > locdteWorkDate.getTime()) {
/* Datensatz ist erst in der Zukunft gültig; an die aufrufende Methode signalisieren,
 * dass kein Datensatz gefunden wurde. */
          ErrorMsg = "";
          return false;
        }
/* SQL-Kommando wurde fehlerfrei ausgeführt; die Fehlerfreiheit wird durch eine
 * 'leere' Zeichenkette in der Variablen 'ErrorMsg' (definiert in der geerbten Basisklasse)
 * an die aufrufende Methode zurückgemeldet. */
        ErrorMsg = "";
        return true;
      }
      catch (SQLException SQLExc) {
/* Wenn ein Fehler aufgetreten ist dann den Fehler-Text extrahieren und an die
 * aufrufende Methode zurückliefern. */
        ErrorMsg = SQLExc.getMessage();
/* Zusätzlich muß in dieser Methode auch ein Wert zurückgeliefert werden. */
        return false;
      }
    }
}

▲ zum Inhaltsverzeichnis

Anleitung zur Adaptierung

Am leichtesten funktioniert die Anpassung des Muster-Codes an die eigenen Erfordernisse durch Kopieren des Muster-Codes und Verwendung von Edit > Find/Replace... .

Für 'Platzhalter', die nur einmalig im Muster-Code vorkommen ist die 'Find'-Funktion ist hilfreich zum Finden der beschriebenen 'Platzhalter'.

▲ zum Inhaltsverzeichnis

Änderung des Namens des Java-Packages

package application_package.dba;
/*

Dieser Name kommt nur einmal in der ersten Zeile vor.
Ein zeitsparendes Vorgehen ist, beim Kopieren des Muster-Codes diese Zeile nicht zu überschreiben und dann die Zeile des Muster-Codes mit dem Platzhalter für den Namen des Java-Packages zu löschen.

▲ zum Inhaltsverzeichnis

Adaptieren des Kommentars

'Kein Kommentar ist besser als ein falscher'.

Aus diesem Grund ist im Muster-Code auch keine Hintergrund-Information über Entwurfs-Entscheidungen für die DB-Tabelle vorhanden.
Meiner Erfahrung nach ist hilfreich, im Kommentar zu sehen, welche Variable jenen Schlüssel bilden, mit denen der Anwender ein Business Object eindeutig identifizieren kann.

▲ zum Inhaltsverzeichnis

Änderung des Namens der Klasse

 */
public class application_dbtable_DBA extends JSBS_DBA {
/*

Dieser Name muss mit dem Namen der Klasse übereinstimmen, der beim Eröffnen der Klasse gewählt wurde.
Dieser Name kommt nur einmal vor.

▲ zum Inhaltsverzeichnis

Änderung der Namen für die DB-Tabelle und der Attribute der DB-Tabelle

/*
 * Name der DB-Tabelle. */
    public final static String CONST_TABLE_NAME = "DBTable";
/* Attribut für ...... */
    public final static String CONST_AttributeName = "AttributeName";
/*

Der Name der DB-Tabelle ist nur an dieser Stelle des Codes zu Ändern.

Die Namen der Attribute der DB-Tabelle sind als Werte von 'String's mit passenden Namen definiert.
Das bietet den Vorteil, dass beim Formulieren von SQL-Kommandos die Wahrscheinlichkeit geringer ist, durch einen Tippfehler ein ungültiges SQL-Kommando zu formulieren – das erst dann bemerkt wird wenn das Kommando im laufenden Programm ausgeführt wird.

Im Muster-Code ist nur die Definition für ein Attribut der DB-Tabelle enthalten; für Ihre Implementierung sind sicherlich mehrere Attribute erforderlich.

▲ zum Inhaltsverzeichnis

Adaptieren der Teil-SQL-Kommandos

/*
 * KONSTANTE Werte die als Teile von SQL-Kommandos verendet werden.
 * --------------------- */
/*
 * Zeichenkette mit allen Attributen die in SELECT- und INSERT-Kommandos vorkommen.
 * Der Teil CONST_COMMON_ATTRIBUTES_LIST ist in der Basisklasse JSBS_DBA definiert. */
    final static String CONST_ALL_ATTRIBUTES_LIST =
        CONST_COMMON_ATTRIBUTES_LIST + ", " +
        CONST_AttributeName + ", " +
        CONST_AttributeName + ", " +
        CONST_AttributeName;
/*
 * Zeichenkette mit allen Attributen die in UPDATE-Kommandos vorkommen.
 * Der Teil CONST_COMMON_ATTRIBUTES_LIST_FOR_UPDATE ist in der Basisklasse JSBS_DBA definiert. */
    final static String CONST_ALL_ATTRIBUTES_LIST_FOR_UPDATE =
        "update " + CONST_TABLE_NAME + " set " +
        CONST_COMMON_ATTRIBUTES_LIST_FOR_UPDATE +
        CONST_AttributeName + " =?, " +
        CONST_AttributeName + " =?, " +
        CONST_AttributeName + " =? " +
        " where ";
/*