Tutorial:
JavaScout ProjectAssist, Task-Frame Grundlagen (Java_Fatclient_01)) –
Server-Side BO-Set Klasse für eine Liste mit 'ProjectLanguage' Business-Objects

In diesem Dokument wird die Server-Seitige Klasse für eine Liste mit Business-Objects (BO) der Klasse 'ProjectLanguage' implementiert.
Diese Klasse 'erbt' von der Generellen Klasse und wird gemeinsam mit der Variation für die Client-Seite verwendet, wenn für die Selektion von BO Kriterien verwendet werden, die mehrere BO als zutreffend auswählen könnten.

Diese Klasse wird allgemein als BOS (Business-Object-Server) bezeichnet und sie steuert über den Aufruf von DBA--Set-Objekten die Datenbank-Abfragen 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-Set Klasse mit einer Liste für 'ProjectLanguage' Business-Objects 

Vorbemerkung 
Vorbedingungen 
BOS-Set-Klasse eröffnen 
Code für die BOS-Set-Klasse 
* Von Basisklasse erben 
* Importieren der Bibliotheken 
* Variablen der Klasse 
* Constructor-Methoden und Elementare Methoden für die Verwaltung der Verbindung zur Datenbank 
* Methoden select... 
Gesamter Code am Ende des Schrittes 
Klasse JS_ProjAssist_ProjectLanguage_BOS_Set 
Weitere Schritte und verwandte Dokumentation 

Nächster Schritt: Client-Side BO-Set Klasse für eine Liste mit 'ProjectLanguage' Business-Objects 

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-Set-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-Set (Liste mit Business-Objects, Server-Side Klasse) 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 (noch) 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-Set geerbt wird.

▲ zum Inhaltsverzeichnis

Vorbedingungen:

• Voriger Schritt General BO-Set Klasse mit einer Liste für 'ProjectLanguage' Business-Objects dieses Tutorials abgeschlossen.

• Überblicks-Kenntnisse über die theoretischen 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-Set-Klasse eröffnen

Diese Klasse wird im gleichen Java-Package erstellt wie die Server-Seitige BO-Klasse.

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_Set) 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-Set-Klasse

Der Code für die BOS-Set-Klasse folgt dem Schema wie es unter JavaScout ProjectAssist, Task-Frame Grundlagen (Java_Fatclient_01) – Server-Side BO (Business-Object) Klasse für 'ProjectLanguage' > Code für die BOS-Klasse vorgestellt wurde.

Der gesamte Code ist unter Klasse JS_ProjAssist_ProjectLanguage_BOS_Set 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;
. . . . . . . .
. . . . . . . .
/*
 * Package mit gerbten Generellen Klassen für BO und BO-Set. */
import js_projassist.bo.*;
. . . . . . . .
. . . . . . . .
public class JS_ProjAssist_ProjectLanguage_BOS_Set extends JS_ProjAssist_ProjectLanguage_BO_Set {
/*

Der 'Vector' für die Liste der BO und eine Methode zum Kopieren der Liste sind in der General BO-Set Klasse mit einer Liste für 'ProjectLanguage' Business-Objects 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

Die zu importierenden Bibliotheken sind weitest gehend identisch mit den Bibliotheken für die Klasse JS_ProjAssist_ProjectLanguage_BOS.
Bitte lesen sie in der dortigen Beschreibung Importieren der Bibliotheken nach oder beachten Sie den Kommentar beim betreffenden Code.

▲ zum Inhaltsverzeichnis

Variablen der Klasse

Neben dem Vector für die Liste mit den BO aus der Basisklasse JSBS_BO, die über die Generelle Klasse für eine Liste mit BO geerbt wurde (siehe Tutorial: JavaScout ProjectAssist, Task-Frame Grundlagen (Java_Fatclient_01) – General BO-Set Klasse für eine Liste mit 'ProjectLanguage' Business-Objects > Von Basisklasse erben), werden Varaibale 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 und Elementare Methoden für die Verwaltung der Verbindung zur Datenbank

Die Methoden sind gleich wie bei der Server-Side Klasse für das BO und wurden schon im Dokument Tutorial: JavaScout ProjectAssist, Task-Frame Grundlagen (Java_Fatclient_01) – Server-Side BO (Business-Object) Klasse für 'ProjectLanguage' > Constructor-Methoden bzw. > Elementare Methoden für die Verwaltung der Verbindung zur Datenbank beschrieben.

Bitte lesen Sie die Kommentare im Code für eine genauere Erklärung des Zwecks der jeweiligen 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_Set

package js_projassist.bos;
/*
 * Package für die Verbindung zur Datenbank. */
import java.sql.*;
/*
 * Basis-Klasse für BO mit Konstanten für Status-Codes. */
import js_base.bo.JSBS_BO;
/* 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;
/*
 * Package mit gerbten Generellen Klassen für BO und BO-Set. */
import js_projassist.bo.*;
/* DBA-Klassen für den Zugriff auf die DB-Tabelle. */
import js_projassist.dba.*;
/* */
public class JS_ProjAssist_ProjectLanguage_BOS_Set extends JS_ProjAssist_ProjectLanguage_BO_Set {
/*
 * 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;
/* --------------------
 * 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_Set(
                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_Set(
                JSBS_MinimalParameters parmMinParm,
                JSBS_DB_ConnectionManager parmJSBS_DB_ConnectionManager) {
/*
 * Aufruf der Unterstützungs-Methode zur Übernahme der Parameter-Werte. */
      constructionWithConnectionManager(parmMinParm, parmJSBS_DB_ConnectionManager);
    }
/* ---------------------
 * 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 = JSBS_BO.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 = JSBS_BO.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 = JSBS_BO.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 Übernehmen der Attribute der DBA (DataBase-Access) Objekte in der Liste
 * des DBA-Set Objekts auf die Geschäfts-spezifischen Variablen des BO und
 * Einfügen dieser BO in die Liste mit den BO in dieser Klasse. */
    private void getDBAAttributes(
                   JS_ProjAssist_ProjLang_DBA_Set parmJS_ProjAssist_ProjLang_DBA_Set) {
/* 
 * Prüfen, ob das DBA-Set leer ist; in diesem Fall einen 'Not Found' Status zurückliefern. */
      int intDBAVectorSize = parmJS_ProjAssist_ProjLang_DBA_Set.vecRecordSet.size();
      if (intDBAVectorSize < 1) {
        StatusCode = JSBS_BO.CONST_NOT_FOUND;
        return;
      }
/* 
 * Eine Variable für das zu bearbeitende DBA-Objekt (aus der Liste) definieren.
 * Durch ein eigenes DBA-Objekt ist das Übertragen der Werte auf das BO leichter zu verstehen. */
      JS_ProjAssist_ProjLang_DBA locJS_ProjAssist_ProjLang_DBA;
/* 
 * In einer for-Schleife jedes DBA-Objekt aus dem DBA-Set auslesen, ein passendes BO 'konstruieren',
 * die Werte aus dem DBA auf das BO übertragen und das BO in die Liste dieses BOS-Set einfügen. */
      int intDBAVectorIndex;
      for (intDBAVectorIndex = 0; intDBAVectorIndex < intDBAVectorSize; intDBAVectorIndex++) {
/* Einzelnes DBA-Objekt aus dem DBA-Set 'angreifen'. */
        locJS_ProjAssist_ProjLang_DBA = (JS_ProjAssist_ProjLang_DBA)
          parmJS_ProjAssist_ProjLang_DBA_Set.vecRecordSet.elementAt(intDBAVectorIndex);
/* Neues BO erstellen und die Werte des DBA übernehmen.
 * Für das 'Übernehmen' der Werte wird die Methode des BO verwendet. */
        JS_ProjAssist_ProjectLanguage_BO locBO = new JS_ProjAssist_ProjectLanguage_BO();
        locBO.getDBAAttributes(locJS_ProjAssist_ProjLang_DBA);
/* BO mit übernommenen Werten in die Liste dieses BOS-Set einfügen. */
        vecRecordSet.addElement(locBO);
      }
    }
/* ---------------------
 * 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 Methoden 'select....' führen eine Abfrage durch.
 * In dieser Klasse sind jene 'select...'-Methoden implementiert, die per Definition
 * mehr als einen Datensatz auswählen können.
 * Methoden die maximal einen Datensatz finden können, sind in der Klasse
 * JS_ProjAssist_ProjectLanguage_BOS implementiert.
 * --------------------- */
/* 
 * METHODE zum Selektieren aller aktuell gültigen Datensätze.
 * 'Aktuell gültig' bedeutet, daß die Gültigkeit des Datensatzes mit dem
 * im Minimalen Set von Parametern übergebenen Arbeitsdatum übereinstimmt. */
    public void selectAllProjectLanguageCombinations() {
/* 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 = JSBS_BO.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 = JSBS_BO.CONST_DB_SYSTEM_ERROR;
        StatusMsg = structJSBS_DB_ConnectionManager.StatusMsg;
/*
 * Weitere Verarbeitung abbrechen;
 * Aufrufende Methode bekommt Fehler über StatusCode signalisiert. */
        return;
      }
/*
 * DBA-Set-Objekt für den Zugriff auf die DB-Tabelle 'konstruieren'. */
      JS_ProjAssist_ProjLang_DBA_Set locJS_ProjAssist_ProjLang_DBA_Set =
        new JS_ProjAssist_ProjLang_DBA_Set();
/*
 * Datenbank-Zugriff über das DBA-Set-Objekt ausführen. */
      locJS_ProjAssist_ProjLang_DBA_Set.selectAllProjectLanguageCombinations(
              structDBCon, structJSBS_MinimalParameters);
/* 
 * Über die Länger des Textes mit einer eventuellen Fehler-Nachricht prüfen ob
 * die Datenbank-Abfrage fehlerfrei beendet wurde.. */
      if (locJS_ProjAssist_ProjLang_DBA_Set.ErrorMsg.length() < 1) {
/* 
 * Datensatz existiert und wurde fehlerfrei gelesen.
 * Attributs-Werte auf die Variablen dieses BOS-Set übertragen. */
        getDBAAttributes(locJS_ProjAssist_ProjLang_DBA_Set);
/* 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 {
/* DBA-Objekt meldet einen Fehler;
 * Status-Code setzen und Fehler-Meldung aus dem DBA-Objekt übernehmen. */
        StatusCode = JSBS_BO.CONST_DB_SYSTEM_ERROR;
        StatusMsg = locJS_ProjAssist_ProjLang_DBA_Set.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