Tutorial:
JavaScout ProjectAssist, Task-Frame Grundlagen (Java_Fatclient_01) –
Server-Side BO (Business-Object) Klasse für 'ProjectLanguage'

In diesem Dokument wird die Klasse mit den Methoden für die Verarbeitung eines Business-Object (BO) auf der Server-Seite einer Geschäftsanwendung implementiert.
Diese Klasse wird allgemein als BOS (Business-Object-Server) bezeichnet und sie steuert über den Aufruf von DBA-Objekten die Datenbank-Zugriffe für ein BO.

Einen Überblick über die verschiedenen Klassen zur Verwaltung von persistenten Daten finden Sie im Dokument Business-Object – Überblick über die Funktion zum Abfragen und Speichern von Daten.
Eine detailliertere Beschreibung der Aufgabe einer Server-Side BO Klasse finden Sie im Dokument Business-Object – Server-Side Class (Klasse für die Programme auf dem Server).

Inhaltsverzeichnis:

Voriger Schritt: General BO (Business Object) Klasse für 'ProjectLanguage' 

Vorbemerkung 
Vorbedingungen 
BOS-Klasse eröffnen 
Code für die BOS-Klasse 
* Von Basisklasse erben 
* Importieren der Bibliotheken 
* Variablen der Klasse 
* Constructor-Methoden 
* Elementare Methoden für die Verwaltung der Verbindung zur Datenbank 
* Interne Methoden für das Speichern von Daten 
* Methode store(...) 
* Methoden select... 
Gesamter Code am Ende des Schrittes 
Klasse JS_ProjAssist_ProjectLanguage_BOS 
Weitere Schritte und verwandte Dokumentation 

Nächster Schritt: Client-Side BO (Business-Object) Klasse für 'ProjectLanguage' 

Vorbemerkung

Zur Vereinfachung des Codes werden nur jene Constructor-Methoden implementiert, die für dieses Tutorial notwendig sind.
Andere Constructor-Methoden, die im Dokument Business-Object – Server-Side Class (Klasse für die Programme auf dem Server) beschrieben sind (z.B. Übernahme einer geöffneten DB-Connection und Übernahme der Werte aus einem BO) werden in diesem Beispiel nicht implementiert.

Der Code für die vorgestellte Klasse erscheint vielleicht etwas über-ambitioniert für die einfache Anforderung.
Für die 'Massenproduktion' von BOS-Objekten wurde aber ein Muster-Code entwickelt, aus dem durch Ersetzen von 'Platzhaltern' einfach und vor allem schnell bedarfsgerechte BOS-Klassen implementiert werden können.
Der Muster-Code und die Anleitungen zur Adaption sind im Dokument Muster-Code für ein BOS (Server-Side Klasse eines Business-Object) beschrieben.
Der in diesem Tutorial vorgestellte Code folgt der Struktur des Muster-Codes – dadurch wird das Verstehen und Adaptieren leichter.

Wenn Sie die folgende Erklärung nicht verstehen ist das auch kein Hindernis für das Durcharbeiten des Tutorials.

Der Code der Klasse ist deswegen so umfangreich, weil mehrere Arten von 'Constructors' und verschiedenen Methoden für das Verwalten der Verbindung zur Datenbank benötigt werden. Dieser gleichbleibende Code kann nicht von einer Basisklasse geerbt werden weil Java keine Mehrfachvererbung erlaubt und aus Qualitäts- und Aufwands-Überlegungen die Generelle Klasse des BO geerbt wird.

▲ zum Inhaltsverzeichnis

Vorbedingungen:

• Voriger Schritt General BO (Business Object) Klasse für 'ProjectLanguage' dieses Tutorials abgeschlossen.

• Überblicks-Kenntnisse über die theoretschen Grundlagen aus den Dokumenten Business-Object – Überblick über die Funktion zum Abfragen und Speichern von Daten, Business-Object – Realisierung mit Java-Klassen und Business-Object – Server-Side Class (Klasse für die Programme auf dem Server).

▲ zum Inhaltsverzeichnis

BOS-Klasse eröffnen

Diese Klasse wird in einem eigenen Java-Package erstellt. Das Java-Package wird bei der Erstellung der Klasse definiert.

Das Erstellen einer neuen Klasse wurde bereits mehrmals im Detail und mit Abbildungen beschrieben.
Aus diesem Grund wird er Vorgang nur mehr in Stichworten beschrieben.
Wenn sie unsicher sind, nehmen Sie bitte die ausführliche Anleitung unter JavaScout ProjectAssist, Task-Frame Grundlagen (Java_Fatclient_01) – DataBase-Access (DBA) Klasse für DB-Tabelle 'ProjLang' > DBA-Klasse eröffnen als Richtlinie.

• Um eine neue Java-Klasse zu eröffnen wird mit der rechten Maustaste das Project (Java_Fatclient_01) angeklickt und aus dem Kontext-Menu >New>Class ausgewählt.

• Im darauf hin erscheinenden Fenster (New Java Class) wird

• Das 'Package' (js_projassist.bos) festgelegt.

• Der Name der Klasse (JS_ProjAssist_ProjectLanguage_BOS) festgelegt.
  ProjectLanguage ist die Bezeichnung des BO (Business-Object).

• Folgende Auswahl-Möglichkeiten werden de-markiert:
  [  ] public static void main(String[] args)
  [  ] Constructors from superclass
  [  ] Inherited abstract methods

• Die anderen bereits vorgegebenen Werte werden nicht verändert.

• Durch Anklicken der Schaltfläche [ Finish ] wird die Datei für den Quell-Code der Klasse angelegt.

▲ zum Inhaltsverzeichnis

Code für die BOS-Klasse

Der Code für die BOS-Klasse folgt dem Schema wie es unter Business-Object – Server-Side Class (Klasse für die Programme auf dem Server) vorgestellt wurde.

Der gesamte Code ist unter Klasse JS_ProjAssist_ProjectLanguage_BOS gelistet und mit Kommentaren versehen.
Aus diesem Grund wird anschließend der Code nicht mehr im Gesamten wiederholt sondern nur mehr Erläuterungen gegeben.

▲ zum Inhaltsverzeichnis

Von Basisklasse erben

package js_projassist.bos;
. . . . . . . .
. . . . . . . .
/*
 * Geerbte Generelle Klasse des BO. */
import js_projassist.bo.JS_ProjAssist_ProjectLanguage_BO;
. . . . . . . .
. . . . . . . .
/* */
public class JS_ProjAssist_ProjectLanguage_BOS extends JS_ProjAssist_ProjectLanguage_BO {
/*

Die Variablen des Business-Objects und Methoden zum Kopieren und Vergleichen der Werte der Variablen, sind in der Generellen Klasse des BO 'ProjectLanguage' definiert.
Mit den obigen Anweisungen wird die Bibliothek, in der diese Klasse enthalten ist, importiert und von dieser Klasse 'geerbt'.

▲ zum Inhaltsverzeichnis

Importieren der Bibliotheken

package js_projassist.bos;
/*
 * Package für die Verbindung zur Datenbank. */
import java.sql.*;
/* Java-interne Klasse für ein Datum; benötigt für Umwandlung des Datums
 * in die Klasse aus der Bibliothek 'java.sql'. */
import java.util.Date;
/*
 * Basis-Klasse mit unterstützenden Methoden für die Verarbeitung von BO. */
import js_base.bo.JSBS_BO_Services;
/* Basis-Klasse für die Verwaltung der geöffneten Verbindungen zur Datenbank. */
import js_base.connections.JSBS_DB_ConnectionManager;
/* Basis-Klasse mit dem Minimalen Set an Parametern. Diese enthalten das Arbeitsdatum.
 * Das Arbeitsdatum wird für verschiedene Abfragen gebraucht. */
import js_base.structures.JSBS_MinimalParameters;
/*
 * Geerbte Generelle Klasse des BO. */
import js_projassist.bo.JS_ProjAssist_ProjectLanguage_BO;
/* DBA-Klasse für den Zugriff auf die DB-Tabelle. */
import js_projassist.dba.JS_ProjAssist_ProjLang_DBA;
/* */
public class JS_ProjAssist_ProjectLanguage_BOS extends JS_ProjAssist_ProjectLanguage_BO {
/*

Neben der schon beschriebenen Bibliothek mit der Basisklasse werden folgende weitere Bibliotheken benötigt:

• import java.sql.*;
ist die mit Java ausgelieferte Bibliothek mit den Klassen, die die Verbindung zu einem relationalen Datenbank-System herstellen.

Für die Verbindung zu einem konkret ausgewählten Datenbanksystem eines bestimmten Herstellers ist zusätzlich die von diesem Hersteller bereitgestellte Bibliothek notwendig.
Die Klassen und Methoden in dieser Hersteller-spezifischen Bibliothek wird von den Methoden in den Klassen der Bibliothek java.sql aufgerufen.
Die Hersteller-spezifische Bibliothek wurde im Schritt Einrichten von Project und Integrieren von Java-Bibliotheken > Einbindung der Libraries (Programm-Bibliotheken) in den Java Build Path eingebunden und im Schritt Weitere XML-Dateien einlesen > ConnectionManager für die Verwaltung der Verbindungen zur Datenbank konstruieren (in der Basisklasse JSBS_DB_ConnectionManager) konstruiert.

• import java.util.Date;
ist die Klasse mit dem innerhalb von Java verwendeten einfachen Datums-Format.
Diese Klasse ist nur notwendig um das Datum (im neueren Format GregorianCalendar) aus der Struktur der JSBS_MinimalParameters in das für Datenbank-Zugriffe notwendige Datum der Klasse java.sql.Date umwandeln zu können.

• import js_base.bo.JSBS_BO_Services;
JSBS_BO_Services ist die Klasse mit unterstützenden Methoden für die Verarbeitung von BO.
In dieses Klasse werden Methoden für die Umwandlung des Datums in verschiedene (Datums-)Klassen und Methoden für die Berechnung des Gültigkeits-Zeitraums des BO verwendet.

• import js_base.connections.JSBS_DB_ConnectionManager;
JSBS_DB_ConnectionManager ist die Klasse für die Verbindung (Connection) zum Datenbank-System.
In der Klasse werden nicht nur Verbindungen eröffnet sondern auch von BOS nicht mehr benötigte Verbindungen in einer Liste verwaltet.
Damit kann bei einer neuerlichen Anforderung für ein Connection durch ein anderes BOS eine bereits geöffnete Connection zur Verfügung gestellt werden.
Durch dieses Verfahren wird die Zeit für das neuerliche Eröffnen einer Connection gespart und die Geschwindigkeit des Zugriffs auf die Datenbank wesentlich verbessert.

• import js_base.structures.JSBS_MinimalParameters;
enthält die Struktur mit den minimal notwendigen Parametern, die allgemeine Informationen (z.B. Name des Benutzers, gewähltes Arbeitsdatum) zwischen der Client-Applikation und den Klassen die auf der Server-Seite laufen, übertragen.
Einer dieser Parameter ist das aktuelle Arbeitsdatum und dieses ist notwendig, um die zu diesem Zeitpunkt gültigen Werte eines 'Objektes' selektieren zu können.
Eine genauere Information über die Aufzeichnung von historischen Daten und die Bedeutung des Datums finden Sie unter DBA (DataBase-Access) Klasse > Attribute zur Führung der Historie von Änderungen.

• import js_projassist.dba.JS_ProjAssist_ProjLang_DBA;
ist die Klasse für das zugeordnete DataBase-Access (DBA) Object. Über das DBA wird der Zugriff auf eine Tabelle der Datenbank gesteuert.
Die Entwicklung des zugehörenden DBA wurde im Schritt Tutorial: JavaScout ProjectAssist, Task-Frame Grundlagen (Java_Fatclient_01) – DataBase-Access (DBA) Klasse für DB-Tabelle 'ProjLang' beschrieben.

▲ zum Inhaltsverzeichnis

Variablen der Klasse

Neben den Geschäfts-spezifischen Variablen, die mit der Generellen Klasse für das BO geerbt wurden (siehe Tutorial: JavaScout ProjectAssist, Task-Frame Grundlagen (Java_Fatclient_01) – General BO (Business-Object) Klasse für 'ProjectLanguage' > Variablen der Klasse) werden Variablen definiert, die vorwiegend für die Verwaltung der Verbindung zum Datenbank-System verwendet werden.

Bitte lesen Sie die Kommentare im Code für eine genauere Erklärung des Zwecks der jeweiligen Variable.

▲ zum Inhaltsverzeichnis

Constructor-Methoden

Die Constructor-Methoden werden in verschiedenen Variationen für die übernommenen Parameter implementiert.
Über die Art der Parameter wird gesteuert,
* ob gleich Werte für die Variablen des BO übernommen werden und
* ob die Connection zur Datenbank innerhalb des BOS eröffnet (und wieder geschlossen) wird oder
* ob eine geöffnete Connection als Parameter übergeben wird – und nicht innerhalb des BOS wieder geschlossen werden darf.

Bitte lesen Sie die Kommentare im Code für eine genauere Erklärung des Zwecks der jeweiligen Methode.

▲ zum Inhaltsverzeichnis

Elementare Methoden für die Verwaltung der Verbindung zur Datenbank

Die Methoden constructionWithConnectionManager(...) und constructionWithDBConnection(...) übertragen die Werte aus den Parametern, die an die jeweilige Constructor-Methode übergeben wurden, in Variable der Klasse und setzen die entsprechenden Flags (Merker vom Java-Typ boolean) innerhalb der Klasse.

Die Methoden getDatabaseConnection(...), commitAndCloseDBConnection(...) und rollbackAndCloseDBConnection(...) verwalten das Öffnen und Schließen der Verbindung zur Datenbank (Connection) und setzen dabei die entsprechenden Flags (Merker vom Java-Typ boolean) innerhalb der Klasse.

Bitte lesen Sie die Kommentare im Code für eine genauere Erklärung des Zwecks der jeweiligen Methode.

▲ zum Inhaltsverzeichnis

Interne Methoden für das Speichern von Daten

Die Methode überträgt die Werte aus den Geschäfts-spezifischen Variablen des BO auf das zugehörige DBA-Objekt.

Die Methoden internalInsert(...) und internalUpdate(...) rufen die entsprechenden Methoden im zugehörigen DBA-Objekt auf und diese führen die entsprechenden SQL-Kommandos ('insert' bzw. 'update') aus.
In diesem Methoden ist auch die Logik enthalten, die die Gültigkeit der jeweiligen Werte eines BO festlegt.
Falls Sie bisher die Erläuterungen über die 'historische Führung von Werten' innerhalb eines BO nicht beachtet haben und jetzt Ihr Interesse geweckt wurde:
Die Erklärung finden Sie unter DBA (DataBase-Access) Klasse > Attribute zur Führung der Historie von Änderungen.

Bitte lesen Sie die Kommentare im Code für eine genauere Erklärung des Zwecks der jeweiligen Methode.

▲ zum Inhaltsverzeichnis

Methode store(...)

Die Methode enthält den aufwändigsten Code der gesamten Klasse – vermutlich des gesamten Tutorials.

Der umfangreiche Code ist dadurch bedingt, daß in dieser Methode unterschieden wird, ob erstmals ein Business-Object (BO) angelegt wird oder für ein bestehendes BO eine Änderung ausgeführt wird.
Die Codierung dieser Entscheidung und der resultierenden Verarbeitung in dieser Klasse 'entlastet' den Code innerhalb des Task-Frames in der die Methode aufgerufen wird.
Im Task-Frame ist keine Entscheidung notwendig ob ein 'insert' oder 'update' notwendig ist - es braucht dann nur diese Methode aufgerufen werden.

Vor der Entscheidung und Ausführung der passenden Methoden des zugehörigen DBA-Objektes ist Code implementiert, der prüft, ob bereits eine Connection zur Datenbank existiert oder ob die Connection erst zu Eröffnen ist.
Wenn die Connection in der Methode eröffnet wurde dann wird sie am Ende der Verarbeitung auch wieder 'geschlossen'.

Bitte lesen Sie die Kommentare im Code für eine genauere Erklärung des Zwecks der jeweiligen Verarbeitungs-Zweige dieser Methode.

▲ zum Inhaltsverzeichnis

Methoden select...

Diese Methoden rufen - nach dem Prüfen und eventuellen Eröffnen der Connection zur Datenbank – die jeweilige Methode des zugehörigen DBA-Objektes auf und übernehmen anschließend die Werte aus den Variablen des DBA-Objektes in die Variablen dieser BO-Klasse.

Bitte lesen Sie die Kommentare im Code für eine genauere Erklärung des Zwecks der jeweiligen Methode.

▲ zum Inhaltsverzeichnis

Gesamter Code am Ende des Schrittes

Klasse JS_ProjAssist_ProjectLanguage_BOS

package js_projassist.bos;
/*
 * Package für die Verbindung zur Datenbank. */
import java.sql.*;
/* Java-interne Klasse für ein Datum; benötigt für Umwandlung des Datums
 * in die Klasse aus der Bibliothek 'java.sql'. */
import java.util.Date;
/*
 * Basis-Klasse mit unterstützenden Methoden für die Verarbeitung von BO. */
import js_base.bo.JSBS_BO_Services;
/* Basis-Klasse für die Verwaltung der geöffneten Verbindungen zur Datenbank. */
import js_base.connections.JSBS_DB_ConnectionManager;
/* Basis-Klasse mit dem Minimalen Set an Parametern. Diese enthalten das Arbeitsdatum.
 * Das Arbeitsdatum wird für verschiedene Abfragen gebraucht. */
import js_base.structures.JSBS_MinimalParameters;
/*
 * Geerbte Generelle Klasse des BO. */
import js_projassist.bo.JS_ProjAssist_ProjectLanguage_BO;
/* DBA-Klasse für den Zugriff auf die DB-Tabelle. */
import js_projassist.dba.JS_ProjAssist_ProjLang_DBA;
/* */
public class JS_ProjAssist_ProjectLanguage_BOS extends JS_ProjAssist_ProjectLanguage_BO {
/*
 * VARIABLE dieser Klasse.
 * --------------------- */
/* Minimales Set von Parametern (Benutzer-Name, Arbeitsdatum,
 * Identifikation des Arbeitsplatzes); dieses Set wird vom Client-Side-BO übergeben . */
    private JSBS_MinimalParameters structJSBS_MinimalParameters = null;
/*
 * Die folgenden Variablen dienen für die Verwaltung der Verbindung zur Datenbank.
 * --------------------- */
/* 
 * Flag, ob die DB-Connection (Verbindung zur Datenbank) bereits hergestellt wurde.
 * Das kann entweder durch Übergabe als Parameter beim 'Constructor' oder durch eine Methode
 * innerhalb dieser Klasse geschehen sein. */
    private boolean bol_structDBConEstablished = false;
/* 
 * Referenzen zum Connection-Manager oder zur DB-Connection die außerhalb dieses Objektes
 * definiert sind.
 * Einer der beiden Werte wird als Parameter in einem passenden 'Constructor' übergeben. */
    private JSBS_DB_ConnectionManager structJSBS_DB_ConnectionManager = null;
    private Connection structDBCon = null;
/* 
 * Nummer der eventuell intern eröffneten 'Connection' zur Datenbank. */
    private int intDBConReference = 0;
/*
 * ---------------------
 * Die folgende Variable ist das DBA-Objekt für den Zugriff auf die DB-Tabelle.
 * Dieses DBA-Objekt wird mehrfach gebraucht und deswegen global in der Klasse definiert. */
    private JS_ProjAssist_ProjLang_DBA
      structJS_ProjAssist_ProjLang_DBA = new JS_ProjAssist_ProjLang_DBA();
/* --------------------
 * CONSTRUCTOR-METHODEN */
/* --------------------
 * In diesen 'Constructors' werden Parameter beim Erstellen eines Objektes dieser Klasse
 * übergeben.
 * In diesem einfachen Beispiel werden die Verbindungen zur Datenbank innerhalb dieser
 * Klasse verwaltet; deswegen werden nur Constructors implementiert, die den
 * 'JSBS_DB_ConnectionManager' als Parameter übernehmen. */
/* --------------------- */
/*
 * Constructor-Methode mit Minimal-Parametern und DB-Connection-Manager als Parameter. */
    public JS_ProjAssist_ProjectLanguage_BOS(
                JSBS_MinimalParameters parmMinParm,
                Connection parmDBCon) {
/*
 * Aufruf der Unterstützungs-Methode zur Übernahme der Parameter-Werte. */
      constructionWithDBConnection(parmMinParm, parmDBCon);
    }
/*
 * Constructor-Methode mit Minimal-Parametern und geöffneter DB-Connection als Parameter. */
    public JS_ProjAssist_ProjectLanguage_BOS(
                JSBS_MinimalParameters parmMinParm,
                JSBS_DB_ConnectionManager parmJSBS_DB_ConnectionManager) {
/*
 * Aufruf der Unterstützungs-Methode zur Übernahme der Parameter-Werte. */
      constructionWithConnectionManager(parmMinParm, parmJSBS_DB_ConnectionManager);
    }
/*
 * Constructor-Methode mit Minimal-Parametern, DB-Connection-Manager und
 * einem BO der gleichen Klasse (aus dem die Werte übernommen werden) als Parameter. */
    public JS_ProjAssist_ProjectLanguage_BOS(
                JSBS_MinimalParameters parmMinParm,
                JSBS_DB_ConnectionManager parmJSBS_DB_ConnectionManager,
                JS_ProjAssist_ProjectLanguage_BO parmJS_ProjAssist_ProjectLanguage_BO) {
/*
 * Aufruf der Unterstützungs-Methode zur Übernahme der Parameter-Werte. */
      constructionWithConnectionManager(parmMinParm, parmJSBS_DB_ConnectionManager);
/*
 * Aufruf der Unterstützungs-Methode zur Übernahme der Werte aus einem als Parameter
 * übergebenem BO. Diese Methode ist in der geerbten generellen Klasse implementiert. */
      copyFromJS_ProjAssist_ProjectLanguage_BO(parmJS_ProjAssist_ProjectLanguage_BO);
    }
/* ---------------------
 * METHODEN zur UNTERSTÜTZUNG der Übernahme der Parameter der CONSTRUCTOR-Methoden.
 * In diesen Methoden werden die Parameter, die in unterschiedlichen Constructor-Methoden
 * übernommen wurden auf die Variablen dieses Objekts übertragen.
 * --------------------- */
/* 
 * METHODE zum Übernehmen eines DB-Connection-Managers. */
    private void constructionWithConnectionManager(
                JSBS_MinimalParameters parmMinParm,
                JSBS_DB_ConnectionManager parmJSBS_DB_ConnectionManager) {
/*
 * Kopieren der Werte aus dem Minimalen Set der Parameter in die Variable dieses Objekts. */
      structJSBS_MinimalParameters = new JSBS_MinimalParameters(parmMinParm);
/*
 * Übertragen der Referenz auf den DB-Connection-Manager in die Variable dieses Objekts. */
      structJSBS_DB_ConnectionManager = parmJSBS_DB_ConnectionManager;
/*
 * Setzen des Flags (Merker) daß eine Verbindung zur Datenbank (DB-Connection) noch nicht
 * eröffnet ist. Das Eröffnen der Verbindung muß dann in der jeweiligen Methode mit dem
 * Zugriff auf die Datenbank erfolgen. */
      bol_structDBConEstablished = false;
    }
/* 
 * METHODE zum Übernehmen einer bereits geöffneten DB-Connection (Verbindung zur Datenbank). */
    private void constructionWithDBConnection(
                JSBS_MinimalParameters parmMinParm,
                Connection parmDBConnection) {
/*
 * Kopieren der Werte aus dem Minimalen Set der Parameter in die Variable dieses Objekts. */
      structJSBS_MinimalParameters = new JSBS_MinimalParameters(parmMinParm);
/*
 * Übertragen der Referenz auf die DB-Connection (Verbindung zur Datenbank)
 * in die entsprechende Variable dieses Objekts. */
      structDBCon = parmDBConnection;
/*
 * Setzen des Flags (Merker) daß eine Verbindung zur Datenbank (DB-Connection) beim
 * 'construct' des Objektes als Parameter übergeben wurde. */
      bol_structDBConEstablished = true;
    }
/* ---------------------
 * ELEMENTARE METHODEN zur Eröffnung der Verbindung zur Datenbank,
 * gesteuerte 'commit' und 'rollback' und 'insert' und 'update' der
 * haupt-zugeordneten DB-Tabelle.
 * --------------------- */
/* 
 * METHODE zum Eröffnen einer Verbindung zur Datenbank (DB-Connection).
 * Über den übergebenen Parameter (parmReadOnly) wird gesteuert ob die DB-Connection
 * im 'autocommit'-Modus geöffnet werden soll.
 * Wenn nur von der Datenbank gelesen werden soll ist die Übergabe von 'true' als
 * Parameter-Wert sinnvoll weil dann mit 'autocommit' geöffnet wird und damit ein
 * schnellerer Zugriff (bessere Performanz) erreicht wird.
 *
 * Rückgabe-Wert
 * signaliesiert ob die Verbindung zur Datenbank (DB-Connection) erfolgreich eröffnet wurde. */
    private boolean getDatabaseConnection(boolean parmReadOnly) {
/*
 * Anfordern einer DB-Verbindung vom DB-Connection-Manager.
 * Die Referenz-Nummer wird in der globalen Variable dieser Klasse gespeichert. */
      intDBConReference =
          structJSBS_DB_ConnectionManager.reserveConnection(this, parmReadOnly);
/*
 * Prüfen ob eine Verbindung zur Datenbank hergestellt werden konnte.
 * Eine Referenz-Nummer gleich oder größer '0' bedeutet eine ordnungsgemäße Verbindung zur DB. */
      if (intDBConReference < 0) {
/* Verbindung zur Datenbank konnte nicht hergestellt werden.
 * Status-Code (auf Fehler) setzen und Fehlermeldung übernehmen. */
        StatusCode = CONST_DB_SYSTEM_ERROR;
        StatusMsg = structJSBS_DB_ConnectionManager.StatusMsg;
/*
 * Fehler an aufrufende Methode signalisieren. */
        return false;
      }
/*
 * Anfordern einer DB-Verbindung war fehlerfrei;
 * Referenz auf die DB-Verbindun in die Variable der Klasse übernehmen und
 * erfolgreiche Anforderung an aufrufende Methode signalisieren. */
      structDBCon =
          structJSBS_DB_ConnectionManager.getReservedConnection(this, intDBConReference);
      bol_structDBConEstablished = true;
      return true;
    }
/* 
 * METHODE zum Prüfen, ob eine Verbindung zur Datenbank (DB-Connection) 'geschlossen' werden muß.
 * In diesem Fall Prüfen ob ein 'commit' ausgeführt werden muß und danach wird die
 * DB-Connection an den Connection-Manager 'zurückgegeben'.
 * Diese Methode wird am Ende von Methoden für geschäftsbezogene Verarbeitung aufgerufen und
 * enthält Code, der in allen Methoden für geschäftsbezogene Verarbeitung ausgeführt werden muß.
 * Als Parameter werden 'Flags' übergeben ob die DB-Connection in der aufrufenden Methode
 * hergestellt wurde und ob die DB-Connection im 'autocommit'-Modus geöffnet wurde. */
    private void commitAndCloseDBConnection(boolean parmDBConOpenedInCallingMethod,
                                            boolean parmReadOnly) {
/* 
 * Wenn die DB-Connection nicht in der aufrufenden Methode geöffnet wurde dann
 * wird diese Methode sofort abgebrochen. */
      if (! parmDBConOpenedInCallingMethod) return;
/* 
 * 'commit' wird nur ausgeführt, wenn die DB-Connection nicht im 'autocommit'-Modus offen ist. */
      if (! parmReadOnly) {
/* 'commit' über die try/catch-Logik ausführen damit ein eventueller Fehler beim 'commit'
 * abgefangen werden kann. */
        try {structDBCon.commit();}
        catch (SQLException SQLExc) {
/* Fehler beim Ausführen des 'commit'; Fehler an die aufrufende Methode zurückliefern. */
          StatusCode = CONST_DB_SYSTEM_ERROR;
          StatusMsg = SQLExc.getMessage();
/* Um auf der sicheren Seite zu sein wird gleich noch ein 'rollback' ausgeführt. */
          rollbackAndCloseDBConnection(parmDBConOpenedInCallingMethod, parmReadOnly);
        }
      }
/* 
 * DB-Connection an den Connection-Manager 'zurückgeben' – der Connection-Manager verwaltet die
 * offene DB-Connection und vewendet sie wieder bei der nächsten Anforderung. */
      structJSBS_DB_ConnectionManager.returnReservedConnection(this, intDBConReference);
      bol_structDBConEstablished = false;
    }
/* 
 * METHODE zum Prüfen, ob auf eine Verbindung zur Datenbank (DB-Connection) ein
 * 'rollback' ausgeführt und die DB-Connection dann 'geschlossen' werden muß.
 * In diesem Fall wird die DB-Connection an den Connection-Manager 'zurückgegeben'.
 * Diese Methode wird am Ende von Methoden für geschäftsbezogene Verarbeitung aufgerufen
 * wenn die notwendigen Operationen auf die Datenbank nicht komplett ausgeführt werden können.
 * Diese Methode enthält Code, der in allen Methoden für geschäftsbezogene Verarbeitung
 * ausgeführt werden muß.
 * Als Parameter werden 'Flags' übergeben ob die DB-Connection in der aufrufenden Methode
 * hergestellt wurde und ob die DB-Connection im 'autocommit'-Modus geöffnet wurde. */
    private void rollbackAndCloseDBConnection(boolean parmDBConOpenedInCallingMethod,
                                              boolean parmReadOnly) {
/* 
 * Wenn die DB-Connection nicht in der aufrufenden Methode geöffnet wurde dann
 * wird diese Methode sofort abgebrochen. */
      if (! parmDBConOpenedInCallingMethod) return;
/* 
 * 'rollback' wird nur ausgeführt, wenn die DB-Connection nicht im 'autocommit'-Modus offen ist. */
      if (! parmReadOnly) {
/* 'rollback' über die try/catch-Logik ausführen damit ein eventueller Fehler
 * abgefangen werden kann. */
        try {structDBCon.rollback();}
        catch (SQLException SQLExc) {
/* Fehler beim Ausführen des 'rollback'; Fehler an die aufrufende Methode zurückliefern. */
          StatusCode = CONST_DB_SYSTEM_ERROR;
          StatusMsg = SQLExc.getMessage();
        }
      }
/* 
 * DB-Connection an den Connection-Manager 'zurückgeben' – der Connection-Manager verwaltet die
 * offene DB-Connection und vewendet sie wieder bei der nächsten Anforderung. */
      structJSBS_DB_ConnectionManager.returnReservedConnection(this, intDBConReference);
      bol_structDBConEstablished = false;
    }
/* 
 * METHODE zum Übertragen der Attribute auf das haupt-zugeordnete DBA-Objekt. */
    private void setDBAAttributes(JS_ProjAssist_ProjLang_DBA parmJS_ProjAssist_ProjLang_DBA) {
/* 
 * Aufruf der Methode der geerbten Klasse (Superklasse) um die 'Common Attributes'
 * zu kopieren. */
      super.setCommonDBAAttributes(parmJS_ProjAssist_ProjLang_DBA);
/* 
 * Übertragen der geschäfts-spezifischen Werte dieses BO. */
      parmJS_ProjAssist_ProjLang_DBA.ProjectCode = this.ProjectCode;
      parmJS_ProjAssist_ProjLang_DBA.LanguageCode = this.LanguageCode;
      parmJS_ProjAssist_ProjLang_DBA.TargetDirectory = this.TargetDirectory;
    }
/* 
 * METHODE zum Einfügen eines Datensatzes in die DB-Tabelle.
 * Diese Methode beschränkt sich auf das Versorgen der 'Common Attributes'
 * mit Werten.
 * Geschäfts-relevante Attribute sind bereits in der aufrufenden Methode ('store')
 * mit den Werten versorgt worden.
 * Über den Parameter wird der Methode mitgeteilt, daß der Datensatz, der in die
 * DB-Tabelle eingefügt werden soll, der erste eines 'Objektes' ist (Parameter 'true').
 * Ein 'Objekt' wird durch einen eindeutigen Anwender-Schlüssel identifiziert.
 * Ein 'Objekt' kann in zeitlicher Abfolge aus mehreren Datensätzen bestehen.
 * Ein neuer Datensatz für ein bestehendes 'Objekt' erfolgt dann, wenn sich
 * der Wert von mindestens einem geschäftsrelevanten Attribut geändert hat.
 * Das 'insert' bei Änderung eines 'Objektes' wird durch den Parameter 'false'
 * mitgeteilt. */
    private void internalInsert(boolean parmFirstInsert) {
/* 
 * Gültigkeit des Datensatzes festlegen.
 * Dabei wird als Beginn der Gültigkeit das (möglicherweise vom Anwender) gewählte
 * und im minimalen Set der Parameter übertragene Datum verwendet. */
      ValidFrom = JSBS_BO_Services.getNewValidFrom(structJSBS_MinimalParameters);
      ValidTill = JSBS_BO_Services.getGoodTillCancelled_SQLDate();
/* 
 * Anwender dessen Eingabe das Einfügen des Datensatzes ausgelöst hat im zuständigen
 * Attribut speichern und Systemzeit (des Computers) übernehmen. */
      ChangedBy = structJSBS_MinimalParameters.strUserName;
      ChangedAt = new Timestamp(new Date().getTime());
/* 
 * Holen eines Surrogates (künstlicher Schlüssel) über die entsprechende Methode
 * und Prüfen, ob das Surrogat bereits als Wert für einen 'DataSetID' verwendet wurde.
 * Dabei werden maximal 9 Versuche durchgeführt einen 'ungebrauchten' Wert zu finden. */
      int intTrialCounter = 9;
      do {
/* Methode, die eine weit gestreute Zufallszahl liefert, aufrufen. */
        DataSetID = JSBS_BO_Services.generateSurrogate();
/* Datenbankzugriff zum Prüfen ob dieses Surrogate bereits als Schlüssel benutzt wird. */
        boolean locbolDataSetExists =
            structJS_ProjAssist_ProjLang_DBA.selectByDataSetID(structDBCon, this.DataSetID);
/* Prüfen ob der seltene Fall eingetreten ist, daß das Surrogat bereits verwendet wird. */
        if (locbolDataSetExists) {
/* Reduzieren des Zählers der noch durchzuführenden Versuche und
 * wieder am Anfang der Schleife beginnen. */
          intTrialCounter--;
          continue;
        }
        else {
/* Vor dem weiterarbeiten prüfen ob nicht ein Fehler beim DB-Zugriff aufgetreten ist.
 * Ein Fehler wird durch eine nicht leere Error-Message signalisiert. */
          if (structJS_ProjAssist_ProjLang_DBA.ErrorMsg.length() > 0) {
/* DBA-Objekt meldet einen Fehler.
 * Status-Code setzen und Fehler-Meldung aus dem DBA-Objekt übernehmen. */
            StatusCode = CONST_DB_SYSTEM_ERROR;
            StatusMsg = structJS_ProjAssist_ProjLang_DBA.ErrorMsg;
/* Verarbeitung abbrechen. */
            return;
          }
/* DBA-Objekt mit generiertem Surrogat existiert noch nicht. Verarbeitung fortsetzen. */
          if (parmFirstInsert) {
/* Erstes Data-Set eines neuen Daten-Objekts wird eingefügt.
 * Entsprechende Common Attributes versorgen. */
            ObjectID = DataSetID;
            CreatedAt = ChangedAt;
            CreatedBy = ChangedBy;
          }
/* Übertragen der Werte der Variablen dieses BO auf die Variablen des DBA-Objektes. */
          setDBAAttributes(structJS_ProjAssist_ProjLang_DBA);
/* Aufrufen der Methode die das SQL-INSERT in die DB-Tabelle ausführt. */
          structJS_ProjAssist_ProjLang_DBA.insert(structDBCon);
/* 
 * Prüfen ob bei der DB-Operation ein Fehler aufgetreten ist. */
          if (structJS_ProjAssist_ProjLang_DBA.ErrorMsg.length() > 0) {
/* DBA-Objekt meldet einen Fehler.
 * Status-Code setzen und Fehler-Meldung aus dem DBA-Objekt übernehmen. */
            StatusCode = CONST_DB_SYSTEM_ERROR;
            StatusMsg = structJS_ProjAssist_ProjLang_DBA.ErrorMsg;
          }
/* INSERT abgeschlossen; Methode beenden. */
          return;
        }
      } while (intTrialCounter > 0);
/* 
 * Alle 9 generierten Surrogats-Werte sind bereits als Schlüssel verwendet.
 * Das weist auf eine volle DB-Tabelle hin – das in die Fehlermeldung schreiben. */
      StatusCode = CONST_DB_UNKNOWN_ERROR;
      StatusMsg = "No surrogate found after 9 trials; database-table seems to be full.";
    }
/* 
 * METHODE zum Update eines bestehenden Datensatzes.
 * Die Verarbeitung ist sehr einfach weil die Geschäftslogik in der nach
 * 'außen' sichtbaren Methode ('store') vorhanden ist. */
    private void internalUpdate() {
/* 
 * Übertragen der Werte der Variablen dieses BO auf die Variablen des DBA-Objektes. */
      setDBAAttributes(structJS_ProjAssist_ProjLang_DBA);
/* Aufrufen der Methode die das SQL-UPDATE in der DB-Tabelle ausführt. */
      structJS_ProjAssist_ProjLang_DBA.update(structDBCon);
/* 
 * Prüfen ob bei der DB-Operation ein Fehler aufgetreten ist. */
      if (structJS_ProjAssist_ProjLang_DBA.ErrorMsg.length() > 0) {
/* DBA-Objekt meldet einen Fehler.
 * Status-Code setzen und Fehler-Meldung aus dem DBA-Objekt übernehmen. */
        StatusCode = CONST_DB_SYSTEM_ERROR;
        StatusMsg = structJS_ProjAssist_ProjLang_DBA.ErrorMsg;
      }
/* UPDATE abgeschlossen; Methode beendet. */
    }
/* ---------------------
 * METHODEN FÜR GESCHÄFTSBEZOGENE VERARBEITUNG.
 * Diese Methoden werden in der Client-Side-Klasse für das Business Object (BO)
 * aufgerufen wenn Daten gespeichert werden müssen.
 * 
 * Die Methode 'store' unterscheidet ob ein Geschäftsobjekt (BO / Business-Object)
 * erstmalig gespeichert werden muß oder die Daten eines bestehenden BO geändert wurden.
 * 
 * Die Methoden 'select....' führen eine Abfrage durch.
 * In dieser Klasse sind aber nur 'select...'-Methoden implementiert, die per Definition
 * maximal einen Datensatz auswählen.
 * Methoden die mehr als einen Datensatz finden könnten, sind in der Klasse
 * JS_ProjAssist_ProjectLanguage_BOS_Set implementiert.
 * --------------------- */
/* 
 * METHODE zum Speichern der Werte in den Variablen dieses BO.
 * Oder technisch: Die Daten werden persistent gemacht.
 *
 * Die Methode unterscheidet, ob ein neues BO eingefügt werden soll oder ob
 * geschäfts-relevante Werte eines bestehenden BO verändert wurden.
 *
 * Ein BO ist durch eine eindeutige Anwender-Identifikation definiert.
 * Sehen Sie bitte bei der Methode 'selectByUserKnownKey(.....)' nach, welche
 * Variable die Anwender-Identifikation bilden.
 *
 * Ein neues BO wird dann eingefügt, wenn das 'Common Attribute' ObjectID den
 * Wert 0 enthält. */
    public void store() {
/* Lokales Flag setzen, daß das 'commit' durch den implementierten Code gesteuert wird. */
      boolean bol_autocommit = false;
/* Variable für den Status auf OK (fehlerfrei) setzen. */
      this.StatusCode = CONST_OK;
      this.StatusMsg = "";
/* 
 * Der folgende Code prüft, ob beim construct dieses Objektes bereits eine geöffnete
 * Verbindung zur Datenbank als Parameter übergeben wurde oder nicht und führt
 * entsprechende Verarbeitungen aus. */
/* Lokales Flag zum Merken ob die Verbindung zur Datenbank in dieser Methode eröffnet wird. */
      boolean bol_structDBConOpenedInThisMethod = false;
/* Prüfen ob die Verbindung zur Datenbank noch nicht eröffnet ist.
 * Sie könnte als Parameter einer Constructor-Methode übergeben worden sein. */
      if (! bol_structDBConEstablished) {
/* Methode, die die Verbindung zur Datenbank herstellt, aufrufen. */
        bol_structDBConOpenedInThisMethod = getDatabaseConnection(bol_autocommit);
      }
/*
 * Prüfen ob eine Verbindung zur Datenbank hergestellt werden konnte.
 * Eine Referenz-Nummer gleich oder größer '0' bedeutet eine ordnungsgemäße Verbindung zur DB. */
      if (intDBConReference < 0) {
/* Verbindung zur Datenbank konnte nicht hergestellt werden.
 * Status-Code (auf Fehler) setzen und Fehlermeldung übernehmen. */
        StatusCode = CONST_DB_SYSTEM_ERROR;
        StatusMsg = structJSBS_DB_ConnectionManager.StatusMsg;
/*
 * Weitere Verarbeitung abbrechen;
 * Aufrufende Methode bekommt Fehler über StatusCode signalisiert. */
        return;
      }
/*
 * Entscheiden ob das BO neu erstellt wurde (ObjectID gleich 0) oder
 * eine Änderung eines Wertes einer Geschäfts-relevanten-Variable erfolgt ist. */
      if (ObjectID == 0) {
/*
 * Speichern eines neuen Business-Object angefordert.
 * Prüfen, daß noch kein BO mit dem gleichen Anwender-bekannten Schlüssel existiert. */
        boolean locbolDataSetExists =
          structJS_ProjAssist_ProjLang_DBA.selectByUserKnownKey(
              structDBCon, structJSBS_MinimalParameters,
             this.ProjectCode, this.LanguageCode);
        if (locbolDataSetExists) {
/* BO mit dem gleichen Anwender-bekannten Schlüssel existiert bereits auf der DB-Tabelle.
 * Fehler an aufrufende Methode signalisieren, Rollback einleiten und Methode beenden. */
          StatusCode = CONST_DUPLICATE_KEY;
          StatusMsg = "";
          rollbackAndCloseDBConnection(bol_structDBConOpenedInThisMethod,
                                       bol_autocommit);
          return;
        }
        else {
/* Kein entsprechender Datensatz gefunden; könnte aber auch ein Fehler beim DB-Zugriff sein. */
          if (structJS_ProjAssist_ProjLang_DBA.ErrorMsg.length() > 0) {
/* DBA-Objekt meldet einen Fehler.
 * Status-Code setzen und Fehler-Meldung aus dem DBA-Objekt übernehmen. */
            StatusCode = CONST_DB_SYSTEM_ERROR;
            StatusMsg = structJS_ProjAssist_ProjLang_DBA.ErrorMsg;
/* Rollback einleiten und Methode beenden. */
            rollbackAndCloseDBConnection(bol_structDBConOpenedInThisMethod,
                                       bol_autocommit);
            return;
          }
        }
/* 
 * Wenn die Verarbeitung bis hierher gelaufen ist, existiert kein BO mit dem
 * gleichen Anwender-bekannten Schlüssel und die DB-Abfrage danach war fehlerfrei.
 * 
 * Neuen Datensatz für dieses BO in die DB-Tabelle einfügen.
 * Der Prameter signalisiert, daß es sich um den ersten Datensatz für ein neues BO handelt. */
        internalInsert(true);
/* Prüfen ob bei der aufgerufenen Methode ein Fehler aufgetreten ist. */
        if (StatusCode != CONST_OK) {
/* Rollback einleiten und Methode beenden. */
          rollbackAndCloseDBConnection(bol_structDBConOpenedInThisMethod,
                                       bol_autocommit);
          return;
        }
      }
      else {
/*
 * Änderung eines Wertes einer Geschäfts-relevanten-Variable erfolgt.
 * Die Gültigkeit des aktuell gültigen Datensatzes wird auf den Tag vor
 * dem Arbeitsdatum (ein Parameter aus dem minimalen Set der Parameter) gesetzt.
 * Das ist das Zeichen, daß der Datensatz nicht länger gültig ist.
 * Dann wird ein neuer Datensatz mit dem gleichen ObjectID eingefügt,
 * dessen Gültigkeitsbeginn ('ValidFrom') das aktuelle Arbeitsdatum ist. */
/*
 * Zuerst wird der aktuell gültige Datensatz gelesen um zu prüfen, ob ein anderer
 * Anwender eine Änderung vorgenommen hat.
 * Die Änderung könnte in der Zeit passiert sein, als der jetzt zu ändernde Datensatz
 * gelesen wurde (um die Daten anzuzeigen) und jetzt, wo die geänderten Daten
 * gespeichert werden sollen.
 * 
 * Zum Lesen des Vergleichs-BOS wird ein neues BOS 'konstruiert' und dabei die bestehende
 * DB-Connection als Parameter übergeben. */
        JS_ProjAssist_ProjectLanguage_BOS existingJS_ProjAssist_ProjectLanguage_BOS =
          new JS_ProjAssist_ProjectLanguage_BOS(structJSBS_MinimalParameters, structDBCon);
/*
 * Datensatz mit dem DatasetID lesen; das bringt den Datensatz der vor einiger Zeit
 * gelesen wurde. */
        existingJS_ProjAssist_ProjectLanguage_BOS.selectByDataSetID(this.DataSetID);
/* Mit der aufgerufenen Methode muß ein Datensatz gefunden werden.
 * Wenn das nicht der Fall ist, dann eine Fehlerbehandlung durchführen. */
        if (existingJS_ProjAssist_ProjectLanguage_BOS.StatusCode != CONST_OK) {
/* Datensatz nicht gefunden oder ein Fehler beim DB-Zugriff ist aufgetreten.
 * Status-Code in dieses Objekt übernehmen und Fehlermeldung anpassen. */
          this.StatusCode = existingJS_ProjAssist_ProjectLanguage_BOS.StatusCode;
          this.StatusMsg = "Unexpected Error during re-read:" +
                              existingJS_ProjAssist_ProjectLanguage_BOS.StatusMsg;
/* Rollback ist nicht notwendig - aber in der aufgerufenen Methode wird
 * wenn notwendig die DB-Connection geschlossen.
 * Anschließend Methode beenden. */
          rollbackAndCloseDBConnection(bol_structDBConOpenedInThisMethod,
                                       bol_autocommit);
          return;
        }
/* Datensatz gefunden; so sollte es sein. */
/* Zuerst prüfen ob die Gültigkeit des Datensatzes in der Zwischenzeit beendet wurde.
 * Das weist auf eine Veränderung des BO hin. */
        if (this.differentValidTill(
                existingJS_ProjAssist_ProjectLanguage_BOS.ValidTill)){
/* Anderer Benutzer hat das BO inzwischen verändert. */
          this.StatusCode = CONST_CHANGED_INBETWEEN;
          this.StatusMsg = "";
/* Rollback ist nicht notwendig - aber in der aufgerufenen Methode wird
 * wenn notwendig die DB-Connection geschlossen.
 * Anschließend Methode beenden. */
          rollbackAndCloseDBConnection(bol_structDBConOpenedInThisMethod,
                                       bol_autocommit);
          return;
        }
/* Noch prüfen ob überhaupt ein Wert einer geschäfts-relevanten Variable verändert wurde.
 * Wenn keine Veränderung erfolgt ist wird auch kein neuer Datensatz eingefügt. */
        if (! this.isDifferent(existingJS_ProjAssist_ProjectLanguage_BOS)){
/* Keine Änderung eines Wertes einer geschäftsrelevanten Variable. */
          this.StatusCode = CONST_NOTHING_TO_UPDATE;
          this.StatusMsg = "";
/* Rollback ist nicht notwendig - aber in der aufgerufenen Methode wird
 * wenn notwendig die DB-Connection geschlossen.
 * Anschließend Methode beenden. */
          rollbackAndCloseDBConnection(bol_structDBConOpenedInThisMethod,
                                       bol_autocommit);
          return;
        }
/*
 * Gültigkeit des bestehenden Datensatzes als 'beendet' markieren.
 * Das wird durch ein Datum vor dem aktuellen Arbeitsdatum indiziert. */
        existingJS_ProjAssist_ProjectLanguage_BOS.ValidTill =
          JSBS_BO_Services.getNewValidTill(structJSBS_MinimalParameters);
/* Änderung des bestehenden Datensatzes auf der DB-Tabelle durchführen. */
        existingJS_ProjAssist_ProjectLanguage_BOS.internalUpdate();
/* Prüfen ob das Update fehlerfrei durchgeführt wurde.
 * Wenn das nicht der Fall ist, dann eine Fehlerbehandlung durchführen. */
        if (existingJS_ProjAssist_ProjectLanguage_BOS.StatusCode != CONST_OK) {
/* Datensatz nicht gefunden oder ein Fehler beim DB-Zugriff ist aufgetreten.
 * Status-Code in dieses Objekt übernehmen und Fehlermeldung anpassen. */
          this.StatusCode = existingJS_ProjAssist_ProjectLanguage_BOS.StatusCode;
          this.StatusMsg = "Unexpected Error during update of existing record: " +
                              existingJS_ProjAssist_ProjectLanguage_BOS.StatusMsg;
/* Rollback ausführen und wenn notwendig die DB-Connection schließen.
 * Anschließend Methode beenden. */
          rollbackAndCloseDBConnection(bol_structDBConOpenedInThisMethod,
                                       bol_autocommit);
          return;
        }
/*
 * Als letzte Datenbank-Operation einen neuen Datensatz mit den aktuellen Werten
 * in die DB-Tabelle einfügen.
 * Der Parameter ('false') teilt der aufgerufenen Methode mit, daß der
 * Datensatz eine Änderung eines bestehenden BO ist. */
        internalInsert(false);
/* Prüfen ob das Insert fehlerfrei durchgeführt wurde.
 * Wenn das nicht der Fall ist, dann eine Fehlerbehandlung durchführen. */
        if (this.StatusCode != CONST_OK) {
/* Rollback ausführen und wenn notwendig die DB-Connection schließen.
 * Anschließend Methode beenden. */
          rollbackAndCloseDBConnection(bol_structDBConOpenedInThisMethod,
                                       bol_autocommit);
          return;
        }
/* Alle DB-Operationen fehlerfrei; 'commit' ausführen. */
        commitAndCloseDBConnection(bol_structDBConOpenedInThisMethod,
                                   bol_autocommit);
      }
    }
/* 
 * METHODE zum Selektieren eines Datensatzes mit dem Primär-Schlüssel der DB-Tabelle.
 * Es kann nur ein Datensatz gefunden werden – dieser ist Teil eines Business-Objektes (BO). */
    public void selectByDataSetID(double parmDataSetID) {
/* Lokales Flag setzen, daß in dieser Methode keine Änderungen auf der DB-Tabelle erfolgen.
 * Damit erfolgt auch kein 'commit' durch den implementierten Code.
 * Zur Verbesserung der Performanz des DB-Systems wird damit 'autocommit' erlaubt. */
      boolean bol_autocommit = true;
/* Variable für den Status auf OK (fehlerfrei) setzen. */
      this.StatusCode = CONST_OK;
      this.StatusMsg = "";
/* 
 * Der folgende Code prüft, ob beim construct dieses Objektes bereits eine geöffnete
 * Verbindung zur Datenbank als Parameter übergeben wurde oder nicht und führt
 * entsprechende Verarbeitungen aus. */
/* Lokales Flag zum Merken ob die Verbindung zur Datenbank in dieser Methode eröffnet wird. */
      boolean bol_structDBConOpenedInThisMethod = false;
/* Prüfen ob die Verbindung zur Datenbank noch nicht eröffnet ist.
 * Sie könnte als Parameter einer Constructor-Methode übergeben worden sein. */
      if (! bol_structDBConEstablished) {
/* Methode, die die Verbindung zur Datenbank herstellt, aufrufen. */
        bol_structDBConOpenedInThisMethod = getDatabaseConnection(bol_autocommit);
      }
/*
 * Prüfen ob eine Verbindung zur Datenbank hergestellt werden konnte.
 * Eine Referenz-Nummer gleich oder größer '0' bedeutet eine ordnungsgemäße Verbindung zur DB. */
      if (intDBConReference < 0) {
/* Verbindung zur Datenbank konnte nicht hergestellt werden.
 * Status-Code (auf Fehler) setzen und Fehlermeldung übernehmen. */
        StatusCode = CONST_DB_SYSTEM_ERROR;
        StatusMsg = structJSBS_DB_ConnectionManager.StatusMsg;
/*
 * Weitere Verarbeitung abbrechen;
 * Aufrufende Methode bekommt Fehler über StatusCode signalisiert. */
        return;
      }
/*
 * Datenbank-Zugriff über das DBA-Objekt ausführen. */
      if (structJS_ProjAssist_ProjLang_DBA.selectByDataSetID(structDBCon, parmDataSetID)) {
/* Datensatz existiert und wurde fehlerfrei gelesen.
 * Attributs-Werte auf die Varaiblen dieses BO übertragen. */
        getDBAAttributes(structJS_ProjAssist_ProjLang_DBA);
/* Commit ist nicht notwendig - aber in der aufgerufenen Methode wird
 * wenn notwendig die DB-Connection geschlossen.
 * Anschließend Methode beenden. */
        commitAndCloseDBConnection(bol_structDBConOpenedInThisMethod,
                                   bol_autocommit);
        return;
      }
      else {
/* Kein entsprechender Datensatz gefunden; könnte aber auch ein Fehler beim DB-Zugriff sein. */
        if (structJS_ProjAssist_ProjLang_DBA.ErrorMsg.length() < 0) {
/* DBA-Objekt meldet keinen Fehler; d.h. ein passender Datensatz wurde nicht gefunden.
 * Status-Code setzen und Fehler-Meldung leer lassen. */
          StatusCode = CONST_NOT_FOUND;
          StatusMsg = "";
/* Rollback ist nicht notwendig - aber in der aufgerufenen Methode wird
 * wenn notwendig die DB-Connection geschlossen.
 * Anschließend Methode beenden. */
          rollbackAndCloseDBConnection(bol_structDBConOpenedInThisMethod,
                                       bol_autocommit);
          return;
        }
        else {
/* DBA-Objekt meldet einen Fehler;
 * Status-Code setzen und Fehler-Meldung aus dem DBA-Objekt übernehmen. */
          StatusCode = CONST_DB_SYSTEM_ERROR;
          StatusMsg = structJS_ProjAssist_ProjLang_DBA.ErrorMsg;
/* Rollback ist nicht notwendig - aber in der aufgerufenen Methode wird
 * wenn notwendig die DB-Connection geschlossen.
 * Anschließend Methode beenden. */
          rollbackAndCloseDBConnection(bol_structDBConOpenedInThisMethod,
                                       bol_autocommit);
          return;
        }
      }
    }
/* 
 * METHODE zum Selektieren des aktuell gültigen Datensatzes mit der
 * Anwender-bekannten Identifikation.
 * 'Aktuell gültig' bedeutet, daß die Gültigkeit des Datensatzes mit dem
 * im Minimalen Set von Parametern übergebenen Arbeitsdatum übereinstimmt.
 * Es kann nur ein Datensatz gefunden werden – dieser ist Teil eines Business-Objektes (BO). */
    public void selectByUserKnownKey(String parmProjectCode, String parmLanguageCode) {
/* Lokales Flag setzen, daß in dieser Methode keine Änderungen auf der DB-Tabelle erfolgen.
 * Damit erfolgt auch kein 'commit' durch den implementierten Code.
 * Zur Verbesserung der Performanz des DB-Systems wird damit 'autocommit' erlaubt. */
      boolean bol_autocommit = true;
/* Variable für den Status auf OK (fehlerfrei) setzen. */
      this.StatusCode = CONST_OK;
      this.StatusMsg = "";
/* 
 * Der folgende Code prüft, ob beim construct dieses Objektes bereits eine geöffnete
 * Verbindung zur Datenbank als Parameter übergeben wurde oder nicht und führt
 * entsprechende Verarbeitungen aus. */
/* Lokales Flag zum Merken ob die Verbindung zur Datenbank in dieser Methode eröffnet wird. */
      boolean bol_structDBConOpenedInThisMethod = false;
/* Prüfen ob die Verbindung zur Datenbank noch nicht eröffnet ist.
 * Sie könnte als Parameter einer Constructor-Methode übergeben worden sein. */
      if (! bol_structDBConEstablished) {
/* Methode, die die Verbindung zur Datenbank herstellt, aufrufen. */
        bol_structDBConOpenedInThisMethod = getDatabaseConnection(bol_autocommit);
      }
/*
 * Prüfen ob eine Verbindung zur Datenbank hergestellt werden konnte.
 * Eine Referenz-Nummer gleich oder größer '0' bedeutet eine ordnungsgemäße Verbindung zur DB. */
      if (intDBConReference < 0) {
/* Verbindung zur Datenbank konnte nicht hergestellt werden.
 * Status-Code (auf Fehler) setzen und Fehlermeldung übernehmen. */
        StatusCode = CONST_DB_SYSTEM_ERROR;
        StatusMsg = structJSBS_DB_ConnectionManager.StatusMsg;
/*
 * Weitere Verarbeitung abbrechen;
 * Aufrufende Methode bekommt Fehler über StatusCode signalisiert. */
        return;
      }
/*
 * Datenbank-Zugriff über das DBA-Objekt ausführen. */
      if (structJS_ProjAssist_ProjLang_DBA.selectByUserKnownKey(
              structDBCon, structJSBS_MinimalParameters, parmProjectCode, parmLanguageCode)) {
/* Datensatz existiert und wurde fehlerfrei gelesen.
 * Attributs-Werte auf die Variablen dieses BO übertragen. */
        getDBAAttributes(structJS_ProjAssist_ProjLang_DBA);
/* Commit ist nicht notwendig - aber in der aufgerufenen Methode wird
 * wenn notwendig die DB-Connection geschlossen.
 * Anschließend Methode beenden. */
        commitAndCloseDBConnection(bol_structDBConOpenedInThisMethod,
                                   bol_autocommit);
        return;
      }
      else {
/* Kein entsprechender Datensatz gefunden; könnte aber auch ein Fehler beim DB-Zugriff sein. */
        if (structJS_ProjAssist_ProjLang_DBA.ErrorMsg.length() < 0) {
/* DBA-Objekt meldet keinen Fehler; d.h. ein passender Datensatz wurde nicht gefunden.
 * Status-Code setzen und Fehler-Meldung leer lassen. */
          StatusCode = CONST_NOT_FOUND;
          StatusMsg = "";
/* Rollback ist nicht notwendig - aber in der aufgerufenen Methode wird
 * wenn notwendig die DB-Connection geschlossen.
 * Anschließend Methode beenden. */
          rollbackAndCloseDBConnection(bol_structDBConOpenedInThisMethod,
                                       bol_autocommit);
          return;
        }
        else {
/* DBA-Objekt meldet einen Fehler;
 * Status-Code setzen und Fehler-Meldung aus dem DBA-Objekt übernehmen. */
          StatusCode = CONST_DB_SYSTEM_ERROR;
          StatusMsg = structJS_ProjAssist_ProjLang_DBA.ErrorMsg;
/* Rollback ist nicht notwendig - aber in der aufgerufenen Methode wird
 * wenn notwendig die DB-Connection geschlossen.
 * Anschließend Methode beenden. */
          rollbackAndCloseDBConnection(bol_structDBConOpenedInThisMethod,
                                       bol_autocommit);
          return;
        }
      }
    }
}

▲ zum Inhaltsverzeichnis

Weitere Schritte und verwandte Dokumentation

▲ zum Inhaltsverzeichnis