12

Muster-Code für ein BOC (Client-Side Klasse eines Business-Object)

Dieses Dokument enthält Code-Muster für eine einfache Client-Side-Klasse eines BO (Business-Object) und Erweiterungen, die entsprechend den jeweiligen Anforderungen zusätzlich implementiert werden können.

Inhaltsverzeichnis:

Vorbedingung 

Einfacher Muster-Code für ein BOC 

Anleitung zur Adaptierung 
* Änderung des Namens der Java-Packages der Anwendung 
* Änderung des Namens der Klasse des CommandCenters 
* Adaptieren des Kommentars 
* Änderung des Namens der Klasse und der 'Constructor'-Methoden 
* Methoden getFrom GUI(...) und setToGUI(...) adaptieren 

* Vorbereitende Tätigkeiten bei Entwicklung einer 'MobileClient' Version des Anwendungsprogramms 

* Generelle Tätigkeiten bei Verwendung von EJB (Client-Server-Architektur) 

* Aufruf der Methoden store() und deactivate() des BOS adaptieren 
* Aufruf der Methoden store() und deactivate() des EJB adaptieren 
* Aufruf der Methoden select...(...) des BOS adaptieren 
* Aufruf der Methoden select...(...) des EJB adaptieren 

Weitere Schritte und verwandte Dokumentation 

Vorbedingung:

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

• Datenmodell fertig ausgearbeitet.

• Generelle Klasse für das BO erstellt; siehe Muster-Code für ein BO (Generelle Klasse eine Business-Object).

• Wenn das Anwendungsprogramm als Client/Server-Anwendung konzipiert ist, ist es hilfreich, zuerst das EJB und die Klasse für die Verbindung zum JAS (Java Application Server) zu codieren.
  Die Anleitung für das Entwickeln der Klasse mit dem Standard-EJB finden Sie unter Leitfaden für die Entwicklung von Heavyweight-Clients mit dem JS-FCF – Alle Schritte zur Entwicklung von DBA (DataBase-Access) und BO (Business-Object) Klassen > Leitfaden - EJB.
  Die Anleitung für das Entwickeln der Klasse für die Verbindung zum JAS finden Sie unter Leitfaden für die Entwicklung von Heavyweight-Clients mit dem JS-FCF – Alle Schritte zur Entwicklung des Start-Frames > Leitfaden – Schritte bei einer Client/Server Version.

▲ zum Inhaltsverzeichnis

Einfacher Muster-Code für ein BOC

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

package application_package.boc;
/*
 * Package und Klasse für die Herstellung der Connection zur Datenbank. */
import java.sql.Connection;
/*
 * Package und Klasse die beim Auftreten von Fehlern bei der Verbindung zum JAS
 * (Java Application Server) benötigt wird. */
import java.rmi.RemoteException;
/*
 * Package mit der Bibliothek der GUI-Elemente. */
import javax.swing.*;
/*
 * Basis-Klasse mit unterstützenden Methoden für die Verarbeitung von BO. */
import js_base.bo.*;
/*
 * Package mit der Basisklasse für Start- und Task-Frame. */
import js_base.frame.*;
/*
 * Basisklasse zum Foramtieren von numerischen Werten für die Anzeige. */
import js_base.utilities.JSBS_Formatter;
/*
 * Klasse für das CommandCenter (Start-Frame) der Anwendung. */
import application_package.client.application_CommandCenter;
/*
 * Geerbte Generelle Klasse des BO. */
import application_package.bo.*;
/*
 * Server-Side-Klasse des BO.
 * Die Methoden in dieser Klasse führen bei einer direkten Verbindung zur Datenbank
 * die Zugriffe auf die Datenbank-Tabelle(n) aus. */
import application_package.bos.*;
/**
 * 
 * @author name[at]company
 * @date 20xx-xx-xx
 *
 * @description
 *  Client-Side Klasse für ein Business-Object (BO).
 *  Variablen dieses BO und Anwender-bekannte-Identifikation sind in der
 *  (geerbten) Generellen Klasse für das BO dokumentiert.
 * 
 * @change-log
 * when          who                       why
 * -----------------------------------------------------------------
 * 
 */
/* */
public class application_entity_BOC extends application_entity_BO {
/* ---------------------
 * VARIABLE dieser Klasse.
 * --------------------- */
/* 
 * Referenz auf das Task-Frame, das das Objekt dieser Klasse 'konstruiert' hat.
 * Über diese Referenz werden jene Parameter abgefragt, die bestimmen, ob der zugehörige
 * Server-Side Teil des BO direkt 'konstruiert' werden soll (bei einer StandAlone / Einzelplatz-
 * Version) oder ein EJB (Enterprise-Java_Bean) aufgerufen werden muß (bei einer
 * Client/Server-Version). */
    private JSBS_TaskFrame frmTask = null;
/* 
 * Referenz auf das CommandCenter (Start-Frame) der Anwendung.
 * Die Referenz auf diese Klasse wird gebraucht, weil dort die 'Home interface(s)'
 * der EJB (Enterprise Java Beans) implementiert sind.
 * Diese(s) EJB sind speziell für die Anwendung entwickelt.
 * Damit kann nicht über die Basisklassen auf die (auf der Client-Seite) implementierte(n)
 * 'Home interface(s)' zugegriffen werden. */
    private application_CommandCenter frmCC = null;
/* 
 * Referenz zu der in diesem Objekt geöffnete DB-Connection.
 * Dieser Wert ist notwendig wenn das Anwendungsprogramm im Einzelplatz-Modus (stand-alone)
 * konfiguriert ist. */
    private Connection structDBCon = null;
/* 
 * Nummer der in diesem Objekt geöffneten 'Connection' zur Datenbank. */
    private int intDBConReference = 0;
/* 
 * Objekt für den Abgleich bei einer 'MobileClient' Version.
 * In der Klasse ist implementiert, wie die Daten eines mobilen Client mit den Daten
 * am Server abgeglichen werden wenn der mobile Client wieder mit dem Server verbunden ist.
 * Wenn eine 'MobileClient' Version implementiert ist dann muss die folgende Zeile
 * 'auskommentiert' werden. */
//    private application_entity_BO_Synchronizer structapplication_entity_BO_Synchronizer = null;
/* ---------------------
 * CONSTRUCTOR-METHODE */
/* ---------------------
 * Als Parameter des 'Constructors' sind das aufrufende Task-Frame und
 * das 'CommandCenter' (Start-Frame) erforderlich. */
    public application_entity_BOC(application_CommandCenter parmfrmCC, JSBS_TaskFrame parmfrmTask) {
/*
 * Die im Parameter übergebenen Referenzen auf Start-Frame und Task-Frame
 * werden in den Variablen dieser Klasse'aufgehoben'. */
      frmCC = parmfrmCC;
      frmTask = parmfrmTask;
    }
/* --------------------------- */
/* 
 * 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.
 *
 * Der 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 =
          frmCC.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 = frmCC.structJSBS_DB_ConnectionManager.StatusMsg;
/*
 * Fehler an aufrufende Methode signalisieren. */
        return false;
      }
/*
 * Anfordern einer DB-Verbindung war fehlerfrei;
 * Referenz auf die DB-Verbindung in die Variable der Klasse übernehmen und
 * erfolgreiche Anforderung an aufrufende Methode signalisieren. */
      structDBCon =
          frmCC.structJSBS_DB_ConnectionManager.getReservedConnection(this, intDBConReference);
      return true;
    }
/* ---------------------
 * METHODEN zum Übertragen der Werte zwischen diesem BO und den GUI-Elementen. */
/* ---------------------
 * METHODE zum Übertragen der Werte aus den als Parameter übergebenen GUI-Elementen
 * in die Variablen dieses Objektes. */
    public void getFromGUI(JTextField parmGUIElement_String,
                           JTextField parmGUIElement_Integer,
                           JTextField parmGUIElement_Short,
                           JTextField parmGUIElement_BigDecimal,
                           JTextArea parmGUIElement_TextArea,
                           JComboBox parmGUIElement_ComboBox,
                           JCheckBox parmGUIElement_CheckBox,
                           JRadioButton parmGUIElement_RadioButtonA,
                           JRadioButton parmGUIElement_RadioButtonB,
                           JSBS_ImagePane parmGUIElement_ImagePane) {
/*
 * Anschließend sind Muster für das Übertragen verschiedener Datentypen von einem Eingabefeld
 * auf die Variablen des Business Object.
 * Zuerst wird geprüft ob überhaupt ein Wert übergeben wurde; dann wird die passende Methode
 * für den Transfer aufgerufen. */
      if (parmGUIElement_String != null) {
        this.BO_Variable_of_Type_String = JSBS_GUIServices.getTextFromJTextField(parmGUIElement_String);
      }
/* ***** */
      if (parmGUIElement_Integer != null) {
        this.BO_Variable_of_Type_Integer = JSBS_GUIServices.getInteger(parmGUIElement_Integer, frmTask);
      }
/* ***** */
      if (parmGUIElement_Short != null) {
        this.BO_Variable_of_Type_Short = JSBS_GUIServices.getShort(parmGUIElement_Short, frmTask);
      }
/* ***** */
      if (parmGUIElement_BigDecimal != null) {
        this.BO_Variable_of_Type_BigDecimal = JSBS_GUIServices.getBigDecimal(parmGUIElement_BigDecimal, frmTask);
      }
/* ***** */
      if (parmGUIElement_TextArea != null) {
        this.BO_Variable_of_Type_String = JSBS_GUIServices.getTextFromJTextArea(parmGUIElement_TextArea);
      }
/* ***** */
      if (parmGUIElement_ComboBox != null) {
        this.BO_Variable_of_Type_String = JSBS_GUIServices.getSelectedTextFromJComboBox(parmGUIElement_ComboBox);
      }
/* Alternative zum Auslesen eines Codes.
 * Die Zeichenkette für das Trennzeichen muss gleich jener sein, die beim Füllen der Combobox verwendet wurde. */
      if (parmGUIElement_ComboBox != null) {
        this.BO_Variable_of_Type_String = JSBS_GUIServices.getSelectedCodeFromJComboBox(parmGUIElement_ComboBox,
                                                                                        " - ");
      }
/* ***** */
      if (parmGUIElement_CheckBox != null) {
/* Abhängig von der Auswahl wird ein vordefinierter Wert übernommen */
        if (parmGUIElement_CheckBox.isSelected()) this.BO_Variable_of_any_Type = application_entity_BO.CONST_Predefined_Value1;
        else this.BO_Variable_of_any_Type = application_entity_BO.CONST_Predefined_Value2;
      }
/* ***** */
      if (parmGUIElement_RadioButtonA != null) {
/* Abhängig von der Auswahl wird ein vordefinierter Wert übernommen */
        if (parmGUIElement_RadioButtonA.isSelected()) this.BO_Variable_of_any_Type = application_entity_BO.CONST_Predefined_ValueA;
      }
/* ***** */
      if (parmGUIElement_RadioButtonB != null) {
/* Abhängig von der Auswahl wird ein vordefinierter Wert übernommen */
        if (parmGUIElement_RadioButtonB.isSelected()) this.BO_Variable_of_any_Type = application_entity_BO.CONST_Predefined_ValueB;
      }
/* ***** */
      if (parmGUIElement_JSBS_ImagePane != null) {
/* Bei einem grafischen Image (Foto, Zeichnung) werden das Array der Daten und das Format ausgelesen. */
        this.BO_Variable_of_Type_ByteArray = parmGUIElement_ImagePane.getImageAsByteArray();
        this.BO_Variable_of_Type_String = parmGUIElement_ImagePane.getGraphicsFormat();
      }
/* ***** */
    }
/* ---------------------
 * METHODE zum Übertragen der Werte aus den Variablen dieses BO in die GUI-Elemente,
 * die als Parameter übergeben werden. */
    public void setToGUI(JTextField parmGUIElement_String,
                         JTextField parmGUIElement_Integer,
                         JTextField parmGUIElement_Short,
                         JTextField parmGUIElement_BigDecimal,
                         JTextArea parmGUIElement_TextArea,
                         JComboBox parmGUIElement_ComboBox,
                         JCheckBox parmGUIElement_CheckBox,
                         JRadioButton parmGUIElement_RadioButtonA,
                         JRadioButton parmGUIElement_RadioButtonB,
                         JSBS_ImagePane parmGUIElement_ImagePane) {
/*
 * Anschließend sind Muster für das Übertragen verschiedener Datentypen von einer
 * Variablen des Business Object in das jeweilige Eingabefeld.
 * Zuerst wird geprüft ob überhaupt ein Wert übergeben wurde; dann wird die passende Methode
 * für den Transfer aufgerufen. */
      if (parmGUIElement_String != null) {
        JSBS_GUIServices.setTextToJTextField(parmGUIElement_String, this.BO_Variable_of_Type_String);
      }
/* ***** */
      if (parmGUIElement_Integer != null) {
        JSBS_GUIServices.setTextToJTextField (parmGUIElement_Integer, 
                                              JSBS_Formatter.toFormattedString(this.BO_Variable_of_Type_Integer));
      }
/* ***** */
      if (parmGUIElement_Short != null) {
        JSBS_GUIServices.setTextToJTextField (parmGUIElement_Shortr, 
                                              JSBS_Formatter.toFormattedString(this.BO_Variable_of_Type_Short));
      }
/* ***** */
      if (parmGUIElement_BigDecimal != null) {
        JSBS_GUIServices.setTextToJTextField (parmGUIElement_BigDecimal, 
                                              JSBS_Formatter.toFormattedString(this.BO_Variable_of_Type_BigDecimal, 
                                              frmTask.frmCC.structJSBS_UniversalParameters.strLanguageDependantDecimalPoint.charAt(0), 
                                              DecimalPlacesAfterDecimalPoint));
      }
/* ***** */
      if (parmGUIElement_TextArea != null) {
        JSBS_GUIServices.setStringWithNewLineToJTextArea(parmGUIElement_TextArea, this.BO_Variable_of_Type_String);
      }
/* ***** */
      if (parmGUIElement_ComboBox != null) {
        JSBS_GUIServices.setJComboBoxItem(parmGUIElement_ComboBox, this.BO_Variable_of_Type_String,
                                          frmTask.frmCC.structJSBS_UniversalParameters, true);
      }
/* ***** */
      if (parmGUIElement_CheckBox != null) {
        parmGUIElement_CheckBox.setSelected(this.BO_Variable_of_Type_String.equals(application_entity_BO.CONST_Predefined_Value1));
      }
/* ***** */
      if (parmGUIElement_RadioButtonA != null) {
        parmGUIElement_RadioButtonA.setSelected(this.BO_Variable_of_Type_String.equals(application_entity_BO.CONST_Predefined_ValueA));
      }
/* ***** */
      if (parmGUIElement_RadioButtonB != null) {
        parmGUIElement_RadioButtonB.setSelected(this.BO_Variable_of_Type_String.equals(application_entity_BO.CONST_Predefined_ValueB));
      }
/* ***** */
      if (parmGUIElement_JSBS_ImagePane != null) {
/* Für die Anzeige der Grafik ist der Bytestream und das Grafikformat erforderlich. */
        parmGUIElement_ImagePane.setImage(this.BO_Variable_of_Type_ByteArray, this.BO_Variable_of_Type_String);
      }
/* ***** */
    }
/* ---------------------
 * METHODEN, die für das Synchronisieren der Daten zwischen einem mobilen Client und dem Server.
 * notwendig sind.
 * 
 * Der Muster-Code setzt voraus, dass bereits die Methoden für den Zugriff auf das (lokale)
 * Datenbanksystem und auf die Daten am Server implementiert sind.
 * Ist das gesamte Anwendungsprogramm nur für den Zugriff auf eine lokale Datenbank entworfen,
 * dann können die Methoden für den Zugriff auf den Server gelöscht werden. */
/*
 * --------------------
 * METHODE zum Aufrufen der speziellen Klasse für das Abgleichen von BO
 * wenn das Anwendungsprogramm in der Version 'MobileClient' läuft.
 * Soll eine 'MobileClient' Version nicht implementiert werden dann muss diese Methode
 * gelöscht werden. */
    private void synchronizeBO() {
/*
 * Zuerst Prüfen ob schon ein Objekt für den nebenläufigen Prozess (Thread) existiert.
 * Bei Bedarf ein Objekt 'konstruieren'.
 * Hinweis:
 * Im Muster ist die Variablendeklaration für die Synchronizer-Klasse auskommentiert. */
        if (structapplication_entity_BO_Synchronizer == null)
          structapplication_entity_BO_Synchronizer = new application_entity_BO_Synchronizer(frmCC, frmTask);
/*
 * Dieses BO-Set (gesamtes Objekt) an das Synchronizer-Objekt übergeben.
 * Der asynchrone Prozess wird in der aufgerufenen Methode gestartet. */
        structapplication_entity_BO_Synchronizer.passBO(this);
    }
/*
 * --------------------
 * METHODE zum Vergleichen von zwei BO und Übernehmen der jeweils neuesten Version
 * eines BO in die Attribute dieses Objekts. */
    private void getNewestBO(application_entity_BO parmapplication_entity_BO_1,
                             application_entity_BO parmapplication_entity_BO_2) {
/*
 * Zuerst Prüfen ob gültige Werte in den Parametern vorhanden sind. */
        if (parmapplication_entity_BO_1 == null) {
          this.StatusCode = JSBS_BO.CONST_INCONSISTENT_DATA;
          this.StatusMsg = "getNewestBO: parmapplication_entity_BO_1 is 'null'";
        }
        if (parmapplication_entity_BO_2 == null) {
          this.StatusCode = JSBS_BO.CONST_INCONSISTENT_DATA;
          this.StatusMsg = "getNewestBO: parmapplication_entity_BO_2 is 'null'";
        }
/*
 * Prüfen, welcher Datensatz später geändert wurde;
 * die Werte von diesem werden in dieses BO übertragen. */
        if (parmapplication_entity_BO_1.ChangedAt.after(parmapplication_entity_BO_2.ChangedAt))
          this.copyFromapplication_entity_BO(parmapplication_entity_BO_1);
        else
          this.copyFromapplication_entity_BO(parmapplication_entity_BO_2);
    }
/* ---------------------
 * METHODE zum Selektieren eines einzelnen Datensatzes (als Teil der Historie eines BO).
 * Dieses Selektieren wird üblicherweise nur gebraucht wenn die Daten eines mobilen Clients
 * mit den Daten des Servers synchronisiert werden müssen.
 * Dann wird mit dieser Methode geprüft, ob ein auf dem Server vergebener Wert für den DataSetID
 * nicht schon zufällig auch auf der lokalen Datenbank des mobilen Clients vergeben wurde. */
    protected void selectByDataSetID_DB(double parmDataSetID) {
/* Methode, die die Verbindung zur Datenbank herstellt, aufrufen.
 * Weil in dieser Methode nur gelesen wird, wird als Parameter 'autocommit' (read-only) festgelegt. */
      getDatabaseConnection(true);
/*
 * 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 = frmCC.structJSBS_DB_ConnectionManager.StatusMsg;
/*
 * Weitere Verarbeitung abbrechen;
 * Aufrufende Methode bekommt Fehler über StatusCode signalisiert. */
        return;
      }
/*
 * Einzelplatz-Version bzw. Datenbank-Zugriff über TCP/IP-Netzwerk.
 * Server-Side-BO 'konstruieren'. */
        application_entity_BOS bosapplication_entity =
          new application_entity_BOS(frmTask.structMinParm,
                                     structDBCon, true);
/*
 * Methode zum Selektieren der Werte aufrufen. */
        bosapplication_entity.selectByDataSetID(parmDataSetID);
/*
 * Neue Werte des BOS wieder in dieses BOC übertragen.
 * Damit sind geschäfts-spezifische Attribute, Common-Attributes, Status-Code
 * und Status-Message in diesem BOC verfügbar. */
        copyFromapplication_entity_BO(bosapplication_entity);
/*
 * DB-Connection an den Connection-Manager zurück geben – der Connection-Manager verwaltet
 * die offene DB-Connection und verwendet sie wieder bei der nächsten Anforderung. */
        frmCC.structJSBS_DB_ConnectionManager.returnReservedConnection(this, intDBConReference);
/* */
    }
/* ---------------------
 * METHODE zum Speichern eines einzelnen Datensatzes (als Teil der Historie eines BO)
 * auf der lokalen Datenbank eines mobilen Clients.
 * Dieses Speichern wird gebraucht wenn die Daten eines mobilen Clients mit den Daten des Servers
 * synchronisiert werden müssen.
 * Wenn der Wert des Parameters parmDataSetIDToSelect den Wert '0' hat wird jener Datensatz geändert
 * geändert, dessen DataSetID dem Wert des DataSetID dieses BO entspricht bzw. es wird ein neuer
 * Datensatz in die DB-Tabelle eingefügt.
 * Wenn ein Wert (ungleich '0') als Parameter übergeben wird, dann wird jener Datensatz, dessen
 * DataSetID dem Wert des übergebenen Parameters entspricht, geändert.
 * Das bedeutet, dass auch der Primärschlüssel (DataSetID) geändert wird. */
    protected void synchronizedStore_DB(double parmDataSetIDToSelect) {
/* Methode, die die Verbindung zur Datenbank herstellt, aufrufen.
 * Weil in dieser Methode Änderungen auf der Datenbank ausgeführt werden,
 * wird als Parameter 'read-write' - nicht 'autocommit' (read-only) - festgelegt. */
      getDatabaseConnection(false);
/*
 * 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 = frmCC.structJSBS_DB_ConnectionManager.StatusMsg;
/*
 * Weitere Verarbeitung abbrechen;
 * Aufrufende Methode bekommt Fehler über StatusCode signalisiert. */
        return;
      }
/*
 * Einzelplatz-Version bzw. Datenbank-Zugriff über TCP/IP-Netzwerk.
 * Server-Side-BO 'konstruieren' und dabei dieses Client-Side-BO als Parameter
 * übergeben damit die Werte der geschäfts-spezifischen Variablen kopiert werden können. */
        application_entity_BOS locapplication_entity_BOS =
          new application_entity_BOS(frmTask.structMinParm,
                                     structDBCon,
                                     this, true);
/*
 * Methode zum Speichern der Werte aufrufen. */
        locapplication_entity_BOS.synchronizedStore(parmDataSetIDToSelect);
/*
 * Fehlerbehandlung wenn das 'store' nicht ordnungsgemäß beendet wurde.
 * Rollback ausführen und Verbindung zur Datenbank schließen.
 * Nebenbemerkung:
 * In der Methode 'returnReservedConnection' (etwas weiter unten) wird
 * geprüft, ob die Verbindung zur Datenbank (DB-Connection) noch 'offen' ist.
 * Wenn die DB-Connection noch offen ist, wird in der Methode 'returnReservedConnection'
 * ein 'commit' ausgeführt und die DB-Connection geschlossen. */
        if (locapplication_entity_BOS.StatusCode != JSBS_BO.CONST_OK) {
/*
 * Sowohl 'rollback' als auch 'close' liefern im Fehlerfall eine 'Exception'. */
          try {
            structDBCon.rollback();
            structDBCon.close();
          }
          catch (Exception e) {
/*
 * Blöde Situation wenn 'rollback' oder 'close' in der Situation auch nicht mehr
 * funktionieren.
 * Nachdem das Speichern der neuen Daten nicht funktioniert hat, ist es aber
 * Aufgabe der aufrufenden Methode, eine Fehlerbehandlung auszuführen. */
          }
        }
/*
 * Neue Werte des BOS wieder in dieses BOC übertragen.
 * Damit sind geänderte Common-Attributes, Status-Code und Status-Message in diesem BOC verfügbar. */
        copyFromapplication_entity_BO(locapplication_entity_BOS); 
/*
 * DB-Connection an den Connection-Manager zurück geben – der Connection-Manager verwaltet
 * die offene DB-Connection und verwendet sie wieder bei der nächsten Anforderung. */
        frmCC.structJSBS_DB_ConnectionManager.returnReservedConnection(this, intDBConReference);
/* */
    }
/* ---------------------
 * METHODE zum Speichern eines einzelnen Datensatzes (als Teil der Historie eines BO)
 * auf der Datenbank des Servers.
 * Dieses Speichern wird gebraucht wenn die Daten eines mobilen Clients mit den Daten des Servers
 * synchronisiert werden müssen.
 * Im Gegensatz zu der entsprechenden Methode für das Speichern auf der lokalen Datenbank des Client
 * kann der Primärschlüssel (DataSetID) auf dem Server nicht durch den Client geändert werden.
 * Wurde der gleiche Primärschlüssel bereits auf dem Server vergeben dann erfolgt der 'Tausch' des
 * DataSetID auf der 'Server-Seite' des BO (BOS). */
    protected void synchronizedStore_JAS() {
/*
 * Client-Server-Version mit Zugriff auf die Datenbank über den EJB-Mechanismus. */
/*
 * Zuerst ein BO konstruieren mit dem die Werte zum EJB übertragen werden und das 
 * danach die neuen Werte nach dem 'store()' enthält. */
        application_entity_BO locbo =
          new application_entity_BO();
/*
 * Die Werte dieses BOC in das BO übertragen.
 * Das ist notwendig weil beim Aufruf der Methode des EJB so wenig Daten wie möglich
 * übertragen werden sollen. */
        locbo.copyFromapplication_entity_BO(this);
/*
 * Der Datenbankzugriff über den EJB-Mechanismus muss in einer try/catch-Logik erfolgen 
 * um Fehler beim Aufruf der Methode des EJB behandeln zu können. */
        try {
/*
 * Instanziieren (Konstruieren) des Client-seitigen Objekts ('Remote interface') für
 * den Aufruf von Methoden des EJB. Die Methode zum Instanziieren ist im Start-Frame implementiert.
 * In diesem Muster wird das Standard-EJB verwendet. 
 *
 * Sollte die Methode für den Datenbankzugriff in einem anderen EJB enthalten sein
 * ist das passende EJB zu instanziieren. */
          application_package.ejb.interfaces.remote.application_StandardBeanRemote instanceStandardEJB =
            frmCC.structapplication_CommandCenter__JASConnections.get_application_StandardBeanRemote();
/*
 * Aufrufen der 'Wrapper'-Methode des EJB. In dieser 'Wrapper'-Methode wird die - zu dieser
 * BOC-Methode - passende Server-seitige Methode aufgerufen.
 * Neue Werte des BO und eventuelle Fehlermeldungen sind im zurückgelieferten BO enthalten.  */
          locbo = instanceStandardEJB.
            application_entity_BO__synchronizedStore(frmTask.structMinParm, locbo);
/*
 * Werte des zurück gelieferten BO auf dieses BOC (Client-seitiger Teil des BO) übertragen. */
          this.copyFromapplication_entity_BO(locbo);
        }
        catch (Exception e) {
/*
 * Fehler beim Instanziieren des EJB oder beim Ausführen der Methode des EJB.
 * Fehlermeldung aus der Exception übernehmen und Status setzen */
          this.StatusCode = JSBS_BO.CONST_DB_UNKNOWN_ERROR;
          this.StatusMsg = e.getMessage();
        }
    }
/* ---------------------
 * METHODEN zum Aufrufen der Geschäfts-spezifischen Datenbank-Operationen.
 * In diesem Muster sind nur die 'case'-Zweige für 'Stand-Alone' und 'Fat-Client'
 * Versionen enthalten.
 * 
 * Der Abgleich der Daten zwischen lokaler Datenbank und Server bei der 'Mobile-Client'
 * Version erfordert eine genaue Analyse, wann Daten der lokalen Datenbank verwendet
 * werden können und wann nicht.
 * Daher kann kein allgemein gültiger Algorithmus als Muster vorgegeben werden. */
/* ---------------------
 * METHODE zum Speichern der neu eingegebenen oder geänderten Variablen dieses BO. */
/* 
 * Zuerst die Methode für den direkten Zugriff auf die Datenbank. */
    private void store_DB() {
/* Methode, die die Verbindung zur Datenbank herstellt, aufrufen.
 * Weil in dieser Methode Änderungen auf der Datenbank ausgeführt werden,
 * wird als Parameter 'read-write' - nicht 'autocommit' - festgelegt. */
      getDatabaseConnection(false);
/*
 * 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 = frmCC.structJSBS_DB_ConnectionManager.StatusMsg;
/*
 * Weitere Verarbeitung abbrechen;
 * Aufrufende Methode bekommt Fehler über StatusCode signalisiert. */
        return;
      }
/*
 * Einzelplatz-Version bzw. Datenbank-Zugriff über TCP/IP-Netzwerk.
 * Server-Side-BO 'konstruieren' und dabei dieses Client-Side-BO als Parameter
 * übergeben damit die Werte der geschäfts-spezifischen Variablen kopiert werden können. */
        application_entity_BOS bosapplication_entity =
          new application_entity_BOS(frmTask.structMinParm,
                                     structDBCon,
                                     this, true);
/*
 * Methode zum Speichern der Werte aufrufen. */
        bosapplication_entity.store();
/*
 * Fehlerbehandlung wenn das 'store' nicht ordnungsgemäß beendet wurde.
 * Rollback ausführen und Verbindung zur Datenbank schließen.
 * Nebenbemerkung:
 * In der Methode 'returnReservedConnection' (etwas weiter unten) wird
 * geprüft, ob die Verbindung zur Datenbank (DB-Connection) noch 'offen' ist.
 * Wenn die DB-Connection noch offen ist, wird in der Methode 'returnReservedConnection'
 * ein 'commit' ausgeführt und die DB-Connection geschlossen. */
        if (bosapplication_entity.StatusCode != JSBS_BO.CONST_OK) {
/*
 * Sowohl 'rollback' als auch 'close' liefern im Fehlerfall eine 'Exception'. */
          try {
            structDBCon.rollback();
            structDBCon.close();
          }
          catch (Exception e) {
/*
 * Blöde Situation wenn 'rollback' oder 'close' in der Situation auch nicht mehr
 * funktionieren.
 * Nachdem das Speichern der neuen Daten nicht funktioniert hat, ist es aber
 * Aufgabe der aufrufenden Methode, eine Fehlerbehandlung auszuführen. */
          }
        }
/*
 * Neue Werte des BOS wieder in dieses BOC übertragen.
 * Damit sind geänderte Common-Attributes, Status-Code und Status-Message in diesem BOC verfügbar. */
        copyFromapplication_entity_BO(bosapplication_entity); 
/*
 * DB-Connection an den Connection-Manager zurück geben – der Connection-Manager verwaltet
 * die offene DB-Connection und verwendet sie wieder bei der nächsten Anforderung. */
        frmCC.structJSBS_DB_ConnectionManager.returnReservedConnection(this, intDBConReference);
/* */
    }
/* 
 * Methode zum Lesen der Daten über den JAS (Java Application Server). */
    private void store_JAS() {
/*
 * Client-Server-Version mit Zugriff auf die Datenbank über den EJB-Mechanismus. */
/*
 * Zuerst ein BO konstruieren mit dem die Werte zum EJB übertragen werden und das 
 * danach die neuen Werte nach dem 'store()' enthält. */
        application_entity_BO locbo =
          new application_entity_BO();
/*
 * Die Werte dieses BOC in das BO übertragen.
 * Das ist notwendig weil beim Aufruf der Methode des EJB so wenig Daten wie möglich
 * übertragen werden sollen. */
        locbo.copyFromapplication_entity_BO(this);
/*
 * Der Datenbankzugriff über den EJB-Mechanismus muss in einer try/catch-Logik erfolgen 
 * um Fehler beim Aufruf der Methode des EJB behandeln zu können. */
//        try {
/*
 * Instanziieren (Konstruieren) des Client-seitigen Objekts ('Remote interface') für
 * den Aufruf von Methoden des EJB. Die Methode zum Instanziieren ist im Start-Frame implementiert.
 * In diesem Muster wird das Standard-EJB verwendet. 
 *
 * Sollte die Methode für den Datenbankzugriff in einem anderen EJB enthalten sein
 * ist das passende EJB zu instanziieren. */
//          application_package.ejb.interfaces.remote.application_StandardBeanRemote instanceStandardEJB =
//            frmCC.structapplication_CommandCenter__JASConnections.get_application_StandardBeanRemote();
/*
 * Aufrufen der 'Wrapper'-Methode des EJB. In dieser 'Wrapper'-Methode wird die - zu dieser
 * BOC-Methode - passende Server-seitige Methode aufgerufen.
 * Neue Werte des BO und eventuelle Fehlermeldungen sind im zurückgelieferten BO enthalten.  */
//          locbo = instanceStandardEJB.
//            application_entity_BO__store(frmTask.structMinParm, locbo);
/*
 * Werte des zurück gelieferten BO auf dieses BOC (Client-seitiger Teil des BO) übertragen. */
//          this.copyFromapplication_entity_BO(locbo);
//        }
//        catch (Exception e) {
/*
 * Fehler beim Instanziieren des EJB oder beim Ausführen der Methode des EJB.
 * Fehlermeldung aus der Exception übernehmen und Status setzen */
//          this.StatusCode = JSBS_BO.CONST_DB_UNKNOWN_ERROR;
//          this.StatusMsg = e.getMessage();
//        }
    }
/* 
 * Methode die abhängig von der Version des Anwendungsprogramms die entsprechende(n)
 * Methode(n) mit dem Code, der die wirkliche Arbeit macht, aufruft. */
    public void store() {
/*
 * Entscheiden, ob diese Application als Einzelplatz-Version (StandAlone) oder
 * Client/Server-Version (FatClient) implementiert ist. */
      switch (frmTask.frmCC.RunVersion) {
      case JSBS_StartFrame.CONST_StandAlone:
/* Einzelplatzversion. Datenbank läuft auf der lokalen Maschine; Spezielle Methode aufrufen. */
        store_DB();
        break;
/* */
      case JSBS_StartFrame.CONST_FatClient:
/* Client-Server-Version.
 * Datenzugriff erfolgt über den EJB-Mechanismus und JAS (Java Application Server); spezielle Methode aufrufen. */
        store_JAS();
        break;
/* */
      case JSBS_StartFrame.CONST_MobileClient:
/*
 * Für diese Version folgt jetzt ein generelles Muster.
 * Es ist im Einzelfall zu analysieren und zu entscheiden, welcher Algorithmus (welches Vorgehen)
 * möglich ist wenn der Mobile Client (z.B. Notebook) keine Verbindung zum Server aufbauen kann.
 * Wenn eine 'MobileClient' Version nicht für das Anwendungsprogramm vorgesehen ist, dann kann
 * der Code innerhalb dieses 'case' gelöscht werden.
 * Damit wird vermieden, dass nicht vorhandene Klassen und Methoden 'auskommentiert' werden müssen. */
/*
 * Prüfen, ob die Verbindung zum JAS existiert. Abhängig davon erfolgt die weitere Verarbeitung. */
          if (frmCC.testJASConnection()) {
/* Daten vom JAS abfragen. */
              store_JAS();
/* Prüfen, ob die Operation am JAS wie erwartet geendet hat. */
              if (this.StatusCode == JSBS_BO.CONST_OK) {
/* Operation am JAS wie erwartet; jetzt noch Methode zum Prüfen, ob die Daten zwischen Server und
 * mobilem Client abgeglichen werden müssen, und zum eventuell notwendigen Abgleichen, aufrufen. */
                  synchronizeBO();
              }
/* Fehler bei der Operation auf dem JAS - Methode beenden.
 * Damit ist der Status-Code für die aufrufende Methode abfragbar. */
              else return;
          }
          else {
/* Verbindung zum JAS unterbroche; als 'offline'-Lösung die Operation auf der lokalen Datenbank ausführen. */
              store_DB();
          }
/* *** */
          break;
      }
    }
/* ---------------------
 * METHODE zum Deaktivieren eines BO. */
/* 
 * Zuerst die Methode für den direkten Zugriff auf die Datenbank. */
    private void deactivate_DB() {
/* Methode, die die Verbindung zur Datenbank herstellt, aufrufen.
 * Weil in dieser Methode Änderungen auf der Datenbank ausgeführt werden,
 * wird als Parameter 'read-write' - nicht 'autocommit' - festgelegt. */
      getDatabaseConnection(false);
/*
 * 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 = frmCC.structJSBS_DB_ConnectionManager.StatusMsg;
/*
 * Weitere Verarbeitung abbrechen;
 * Aufrufende Methode bekommt Fehler über StatusCode signalisiert. */
        return;
      }
/*
 * Einzelplatz-Version bzw. Datenbank-Zugriff über TCP/IP-Netzwerk.
 * Server-Side-BO 'konstruieren'. */
        application_entity_BOS bosapplication_entity =
          new application_entity_BOS(frmTask.structMinParm,
                                     structDBCon,
                                     this, true);
/*
 * Methode zum Deaktivieren des BO aufrufen. */
        bosapplication_entity.deactivate();
/*
 * Fehlerbehandlung wenn das 'deactivate' nicht ordnungsgemäß beendet wurde.
 * Rollback ausführen und Verbindung zur Datenbank schließen.
 * Nebenbemerkung:
 * In der Methode 'returnReservedConnection' (etwas weiter unten) wird
 * geprüft, ob die Verbindnung zur Datenbank (DB-Connection) noch 'offen' ist.
 * Wenn die DB-Connection noch offen ist, wird in der Methode 'returnReservedConnection'
 * ein 'commit' ausgeführt und die DB-Connection geschlossen. */
        if (bosapplication_entity.StatusCode != JSBS_BO.CONST_OK) {
/*
 * Sowohl 'rollback' als auch 'close' liefern im Fehlerfall eine 'Exception'. */
          try {
            structDBCon.rollback();
            structDBCon.close();
          }
          catch (Exception e) {
/*
 * Blöde Situation wenn 'rollback' oder 'close' in der Situation auch nicht mehr
 * funktionieren.
 * Nachdem das Speichern der neuen Daten nicht funktioniert hat, ist es aber
 * Aufgabe der aufrufenden Methode, eine Fehlerbehandlung auszuführen. */
          }
        }
/*
 * Neue Werte des BOS wieder in dieses BOC übertragen.
 * Damit sind geänderte Common-Attributes, Status-Code und Status-Message in diesem BOC verfügbar. */
        copyFromapplication_entity_BO(bosapplication_entity); 
/*
 * DB-Connection an den Connection-Manager zurück geben – der Connection-Manager verwaltet
 * die offene DB-Connection und verwendet sie wieder bei der nächsten Anforderung. */
        frmCC.structJSBS_DB_ConnectionManager.returnReservedConnection(this, intDBConReference);
    }
/* 
 * Methode zum Lesen der Daten über den JAS (Java Application Server). */
    private void deactivate_JAS() {
/*
 * Zuerst ein BO konstruieren mit dem die Werte zum EJB übertragen werden und das 
 * danach die neuen Werte nach dem 'deactivate()' enthält. */
        application_entity_BO locbo = new application_entity_BO();
/*
 * Die Werte dieses BOC in das BO übertragen.
 * Das ist notwendig weil beim Aufruf der Methode des EJB so wenig Daten wie möglich
 * übertragen werden sollen. */
        locbo.copyFromapplication_entity_BO(this);
/*
 * Der Datenbankzugriff über den EJB-Mechanismus muss in einer try/catch-Logik erfolgen 
 * um Fehler beim Aufruf der Methode des EJB behandeln zu können. */
//        try {
/*
 * Instanziieren (Konstruieren) des Client-seitigen Objekts ('Remote interface') für
 * den Aufruf von Methoden des EJB. Die Methode zum Instanziieren ist im Start-Frame implementiert.
 * In diesem Muster wird das Standard-EJB verwendet. 
 *
 * Sollte die Methode für den Datenbankzugriff in einem anderen EJB enthalten sein
 * ist das passende EJB zu instanziieren. */
//          application_package.ejb.interfaces.remote.application_StandardBeanRemote instanceStandardEJB =
//            frmCC.structapplication_CommandCenter__JASConnections.get_application_StandardBeanRemote();
/*
 * Aufrufen der 'Wrapper'-Methode des EJB. In dieser 'Wrapper'-Methode wird die - zu dieser
 * BOC-Methode - passende Server-seitige Methode aufgerufen.
 * Neue Werte des BO und eventuelle Fehlermeldungen sind im zurückgelieferten BO enthalten.  */
//          locbo = instanceStandardEJB.
//            application_entity_BO__deactivate(frmTask.structMinParm, locbo);
/*
 * Werte des zurück gelieferten BO auf dieses BOC (Client-seitiger Teil des BO) übertragen. */
//          this.copyFromapplication_entity_BO(locbo);
//        }
//        catch (Exception e) {
/*
 * Fehler beim Instanziieren des EJB oder beim Ausführen der Methode des EJB.
 * Fehlermeldung aus der Exception übernehmen und Status setzen */
//          this.StatusCode = JSBS_BO.CONST_DB_UNKNOWN_ERROR;
//          this.StatusMsg = e.getMessage();
//        }
    }
/* 
 * Methode die abhängig von der Version des Anwendungsprogramms die entsprechende(n)
 * Methode(n) mit dem Code, der die wirkliche Arbeit macht, aufruft. */
    public void deactivate() {
/*
 * Entscheiden, ob diese Application als Einzelplatz-Version (StandAlone) oder
 * Client/Server-Version (FatClient) implementiert ist. */
      switch (frmTask.frmCC.RunVersion) {
      case JSBS_StartFrame.CONST_StandAlone:
/* Einzelplatzversion. Datenbank läuft auf der lokalen Maschine; Spezielle Methode aufrufen. */
        deactivate_DB();
        break;
/* */
      case JSBS_StartFrame.CONST_FatClient:
/* Client-Server-Version.
 * Datenzugriff erfolgt über den EJB-Mechanismus und JAS (Java Application Server); spezielle Methode aufrufen. */
        deactivate_JAS();
        break;
/* */
      case JSBS_StartFrame.CONST_MobileClient:
/*
 * Für diese Version folgt jetzt ein generelles Muster.
 * Es ist im Einzelfall zu analysieren und zu entscheiden, welcher Algorithmus (welches Vorgehen)
 * möglich ist wenn der Mobile Client (z.B. Notebook) keine Verbindung zum Server aufbauen kann.
 * Wenn eine 'MobileClient' Version nicht für das Anwendungsprogramm vorgesehen ist, dann kann
 * der Code innerhalb dieses 'case' gelöscht werden.
 * Damit wird vermieden, dass nicht vorhandene Klassen und Methoden 'auskommentiert' werden müssen. */
/*
 * Prüfen, ob die Verbindung zum JAS existiert. Abhängig davon erfolgt die weitere Verarbeitung. */
          if (frmCC.testJASConnection()) {
/* Daten vom JAS abfragen. */
              deactivate_JAS();
/* Prüfen, ob die Operation am JAS wie erwartet geendet hat. */
              if (this.StatusCode == JSBS_BO.CONST_OK) {
/* Operation am JAS wie erwartet; jetzt noch Methode zum Prüfen, ob die Daten zwischen Server und
 * mobilem Client abgeglichen werden müssen, und zum eventuell notwendigen Abgleichen, aufrufen. */
                  synchronizeBO();
              }
/* Fehler bei der Operation auf dem JAS - Methode beenden.
 * Damit ist der Status-Code für die aufrufende Methode abfragbar. */
              else return;
          }
          else {
/* Verbindung zum JAS unterbroche; als 'offline'-Lösung die Operation auf der lokalen Datenbank ausführen. */
              deactivate_DB();
          }
/* *** */
          break;
      }
    }
/* ---------------------
 * METHODE zum Selektieren jenes BO, dessen Anwender-bekannte Identifikation
 * in der Reihenfolge nach der Identifikation, der in den Parametern übergeben wird kommt. */
/* 
 * Zuerst die Methode für den direkten Zugriff auf die Datenbank. */
    private void selectNext_DB(String parmKeyVariable_1,
                              String parmKeyVariable_2) {
/* Methode, die die Verbindung zur Datenbank herstellt, aufrufen.
 * Weil in dieser Methode nur gelesen wird, wird als Parameter 'autocommit' (read-only) festgelegt. */
      getDatabaseConnection(true);
/*
 * 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 = frmCC.structJSBS_DB_ConnectionManager.StatusMsg;
/*
 * Weitere Verarbeitung abbrechen;
 * Aufrufende Methode bekommt Fehler über StatusCode signalisiert. */
        return;
      }
/*
 * Einzelplatz-Version bzw. Datenbank-Zugriff über TCP/IP-Netzwerk.
 * Server-Side-BO 'konstruieren'. */
        application_entity_BOS bosapplication_entity =
          new application_entity_BOS(frmTask.structMinParm,
                                     structDBCon, true);
/*
 * Methode zum Selektieren der Werte aufrufen. */
        bosapplication_entity.selectNext(parmKeyVariable_1,
                                         parmKeyVariable_2);
/*
 * Neue Werte des BOS wieder in dieses BOC übertragen.
 * Damit sind geschäfts-spezifische Attribute, Common-Attributes, Status-Code
 * und Status-Message in diesem BOC verfügbar. */
        copyFromapplication_entity_BO(bosapplication_entity);
/*
 * DB-Connection an den Connection-Manager zurück geben – der Connection-Manager verwaltet
 * die offene DB-Connection und verwendet sie wieder bei der nächsten Anforderung. */
        frmCC.structJSBS_DB_ConnectionManager.returnReservedConnection(this, intDBConReference);
/* */
    }
/* 
 * Methode zum Lesen der Daten über den JAS (Java Application Server). */
    private void selectNext_JAS(String parmKeyVariable_1,
                               String parmKeyVariable_2) {
/*
 * Client-Server-Version mit Zugriff auf die Datenbank über den EJB-Mechanismus. */
/*
 * Der Datenbankzugriff über den EJB-Mechanismus muss in einer try/catch-Logik erfolgen 
 * um Fehler beim Aufruf der Methode des EJB behandeln zu können. */
//        try {
/*
 * Instanziieren (Konstruieren) des Client-seitigen Objekts ('Remote interface') für
 * den Aufruf von Methoden des EJB. Die Methode zum Instanziieren ist im Start-Frame implementiert.
 * In diesem Muster wird das Standard-EJB verwendet. 
 *
 * Sollte die Methode für den Datenbankzugriff in einem anderen EJB enthalten sein
 * ist das passende EJB zu instanziieren. */
//          application_package.ejb.interfaces.remote.application_StandardBeanRemote instanceStandardEJB =
//            frmCC.structapplication_CommandCenter__JASConnections.get_application_StandardBeanRemote();
/*
 * Aufrufen der 'Warapper'-Methode des EJB. In dieser 'Wrapper'-Methode wird die - zu dieser
 * BOC-Methode - passende Server-seitige Methode aufgerufen.
 * Neue Werte des BO und eventuelle Fehlermeldungen sind im zurückgelieferten BO enthalten.  */
//          application_entity_BO locbo = instanceStandardEJB.
//            application_entity_BO__selectNext(frmTask.structMinParm,
//                                              parmKeyVariable_1,
//                                              parmKeyVariable_2);
/*
 * Werte des zurück gelieferten BO auf dieses BOC (Client-seitiger Teil des BO) übertragen. */
//          this.copyFromapplication_entity_BO(locbo);
//        }
//        catch (Exception e) {
/*
 * Fehler beim Instanziieren des EJB oder beim Ausführen der Methode des EJB.
 * Fehlermeldung aus der Exception übernehmen und Status setzen */
//          this.StatusCode = JSBS_BO.CONST_DB_UNKNOWN_ERROR;
//          this.StatusMsg = e.getMessage();
//        }
    }
/* 
 * Methode die abhängig von der Version des Anwendungsprogramms die entsprechende(n)
 * Methode(n) mit dem Code, der die wirkliche Arbeit macht, aufruft. */
    public void selectNext(String parmKeyVariable_1,
                           String parmKeyVariable_2) {
/* Prüfen, ob die Werte 'null' sind (kann unter gewissen Umständen passieren) und in diesem Fall
 * die Werte durch eine leere Zeichenkette oder einen numerischen Wert ersetzen. */
      if (parmKeyVariable_1 == null) parmKeyVariable_1 = "";
      if (parmKeyVariable_2 == null) parmKeyVariable_2 = "";
/*
 * Entscheiden, ob diese Application als Einzelplatz-Version (StandAlone) oder
 * Client/Server-Version (FatClient) implementiert ist. */
      switch (frmTask.frmCC.RunVersion) {
      case JSBS_StartFrame.CONST_StandAlone:
/* Einzelplatzversion. Datenbank läuft auf der lokalen Maschine; Spezielle Methode aufrufen. */
        selectNext_DB(parmKeyVariable_1, parmKeyVariable_2);
        break;
/* */
      case JSBS_StartFrame.CONST_FatClient:
/* Client-Server-Version.
 * Datenzugriff erfolgt über den EJB-Mechanismus und JAS (Java Application Server); spezielle Methode aufrufen. */
        selectNext_JAS(parmKeyVariable_1, parmKeyVariable_2);
        break;
/* */
      case JSBS_StartFrame.CONST_MobileClient:
/*
 * Für diese Version folgt jetzt ein generelles Muster.
 * Es ist im Einzelfall zu analysieren und zu entscheiden, welcher Algorithmus (welches Vorgehen)
 * möglich ist wenn der Mobile Client (z.B. Notebook) keine Verbindung zum Server aufbauen kann.
 * Wenn eine 'MobileClient' Version nicht für das Anwendungsprogramm vorgesehen ist, dann kann
 * der Code innerhalb dieses 'case' gelöscht werden.
 * Damit wird vermieden, dass nicht vorhandene Klassen und Methoden 'auskommentiert' werden müssen. */
/*
 * Zuerst die Daten von der lokalen Datenbank abfragen. Per Definition muss das immer möglich sein. */
          selectNext_DB(parmKeyVariable_1, parmKeyVariable_2);
/* Prüfen, ob ein Fehler bei der Abfrage auf der lokalen Datenbank aufgetreten ist. In diesem Fall die
 * Methode beenden - damit ist der Status für die aufrufende Methode verfügbar. */
          if ((this.StatusCode == JSBS_BO.CONST_OK) || (this.StatusCode == JSBS_BO.CONST_NOT_FOUND)) {
/* 'Erlaubte' Status-Codes für die Abfrage von der lokalen Datenbank. */
          }
          else return;
/* Prüfen, ob die Verbindung zum JAS existiert. Abhängig davon erfolgt die weitere Verarbeitung. */
          if (frmCC.testJASConnection()) {
/* BO für die Daten der lokalen Datenbank und den Daten vom JAS konstruieren.
 * Damit können später die jeweiligen Daten verglichen und Unterschiede behandelt werden. */
              application_entity_BO structapplication_entity_BO_Local = new application_entity_BO();
              application_entity_BO structapplication_entity_BO_JAS = new application_entity_BO();
/* Ergebnis der Abfrage der lokalen Datenbank auf die dafür vorgesehene Variable übertragen. */
              structapplication_entity_BO_Local.copyFromapplication_entity_BO(this);
/* Daten vom JAS abfragen. */
              selectNext_JAS(parmKeyVariable_1, parmKeyVariable_2);
/* Prüfen, ob ein Fehler bei der Abfrage vom JAS aufgetreten ist. In diesem Fall die
 * Methode beenden - damit ist der Status für die aufrufende Methode verfügbar. */
              if ((this.StatusCode == JSBS_BO.CONST_OK) || (this.StatusCode == JSBS_BO.CONST_NOT_FOUND)) {
/* 'Erlaubte' Status-Codes für die Abfrage vom JAS. */
              }
              else return;
/* Ergebnis der Abfrage über den JAS auf die dafür vorgesehene Variable übertragen. */
              structapplication_entity_BO_JAS.copyFromapplication_entity_BO(this);
/* Methode zum Abgleich der Daten von beiden Quellen aufrufen. */
              getNewestBO(structapplication_entity_BO_Local, structapplication_entity_BO_JAS);
/* Methode zum Prüfen, ob die Daten zwischen Server und mobilem Client abgeglichen werden müssen,
 * und zum eventuell notwendigen Abgleichen aufrufen. */
              synchronizeBO();
          }
/* *** */
          break;
      }
    }
/* ---------------------
 * METHODE zum Selektieren jenes BO, dessen Anwender-bekannte Identifikation
 * in der Reihenfolge vor der Identifikation, die in den Parametern übergeben wird kommt. */
/* 
 * Zuerst die Methode für den direkten Zugriff auf die Datenbank. */
    private void selectPrevious_DB(String parmKeyVariable_1,
                                  String parmKeyVariable_2) {
/* Methode, die die Verbindung zur Datenbank herstellt, aufrufen.
 * Weil in dieser Methode nur gelesen wird, wird als Parameter 'autocommit' (read-only) festgelegt. */
      getDatabaseConnection(true);
/*
 * 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 = frmCC.structJSBS_DB_ConnectionManager.StatusMsg;
/*
 * Weitere Verarbeitung abbrechen;
 * Aufrufende Methode bekommt Fehler über StatusCode signalisiert. */
        return;
      }
/*
 * Einzelplatz-Version bzw. Datenbank-Zugriff über TCP/IP-Netzwerk.
 * Server-Side-BO 'konstruieren'. */
        application_entity_BOS bosapplication_entity =
          new application_entity_BOS(frmTask.structMinParm,
                                     structDBCon, true);
/*
 * Methode zum Selektieren der Werte aufrufen. */
        bosapplication_entity.selectPrevious(parmKeyVariable_1,
                                             parmKeyVariable_2);
/*
 * Neue Werte des BOS wieder in dieses BOC übertragen.
 * Damit sind geschäfts-spezifische Attribute, Common-Attributes, Status-Code
 * und Status-Message in diesem BOC verfügbar. */
        copyFromapplication_entity_BO(bosapplication_entity);
/*
 * DB-Connection an den Connection-Manager zurück geben – der Connection-Manager verwaltet
 * die offene DB-Connection und verwendet sie wieder bei der nächsten Anforderung. */
        frmCC.structJSBS_DB_ConnectionManager.returnReservedConnection(this, intDBConReference);
/* */
    }
/* 
 * Methode zum Lesen der Daten über den JAS (Java Application Server). */
    private void selectPrevious_JAS(String parmKeyVariable_1,
                                   String parmKeyVariable_2) {
/*
 * Client-Server-Version mit Zugriff auf die Datenbank über den EJB-Mechanismus. */
/*
 * Der Datenbankzugriff über den EJB-Mechanismus muss in einer try/catch-Logik erfolgen 
 * um Fehler beim Aufruf der Methode des EJB behandeln zu können. */
//        try {
/*
 * Instanziieren (Konstruieren) des Client-seitigen Objekts ('Remote interface') für
 * den Aufruf von Methoden des EJB. Die Methode zum Instanziieren ist im Start-Frame implementiert.
 * In diesem Muster wird das Standard-EJB verwendet. 
 *
 * Sollte die Methode für den Datenbankzugriff in einem anderen EJB enthalten sein
 * ist das passende EJB zu instanziieren. */
//          application_package.ejb.interfaces.remote.application_StandardBeanRemote instanceStandardEJB =
//            frmCC.structapplication_CommandCenter__JASConnections.get_application_StandardBeanRemote();
/*
 * Aufrufen der 'Warapper'-Methode des EJB. In dieser 'Wrapper'-Methode wird die - zu dieser
 * BOC-Methode - passende Server-seitige Methode aufgerufen.
 * Neue Werte des BO und eventuelle Fehlermeldungen sind im zurückgelieferten BO enthalten.  */
//          application_entity_BO locbo = instanceStandardEJB.
//            application_entity_BO__selectPrevious(frmTask.structMinParm,
//                                                  parmKeyVariable_1,
//                                                  parmKeyVariable_2);
/*
 * Werte des zurück gelieferten BO auf dieses BOC (Client-seitiger Teil des BO) übertragen. */
//          this.copyFromapplication_entity_BO(locbo);
//        }
//        catch (Exception e) {
/*
 * Fehler beim Instanziieren des EJB oder beim Ausführen der Methode des EJB.
 * Fehlermeldung aus der Exception übernehmen und Status setzen */
//          this.StatusCode = JSBS_BO.CONST_DB_UNKNOWN_ERROR;
//          this.StatusMsg = e.getMessage();
//        }
    }
/* 
 * Methode die abhängig von der Version des Anwendungsprogramms die entsprechende(n)
 * Methode(n) mit dem Code, der die wirkliche Arbeit macht, aufruft. */
    public void selectPrevious(String parmKeyVariable_1,
                               String parmKeyVariable_2) {
/* Prüfen, ob die Werte 'null' sind (kann unter gewissen Umständen passieren) und in diesem Fall
 * die Werte durch eine leere Zeichenkette oder einen numerischen Wert ersetzen. */
      if (parmKeyVariable_1 == null) parmKeyVariable_1 = "";
      if (parmKeyVariable_2 == null) parmKeyVariable_2 = "";
/*
 * Entscheiden, ob diese Application als Einzelplatz-Version (StandAlone) oder
 * Client/Server-Version (FatClient) implementiert ist. */
      switch (frmTask.frmCC.RunVersion) {
      case JSBS_StartFrame.CONST_StandAlone:
/* Einzelplatzversion. Datenbank läuft auf der lokalen Maschine; Spezielle Methode aufrufen. */
        selectPrevious_DB(parmKeyVariable_1, parmKeyVariable_2);
        break;
/* */
      case JSBS_StartFrame.CONST_FatClient:
/* Client-Server-Version.
 * Datenzugriff erfolgt über den EJB-Mechanismus und JAS (Java Application Server); spezielle Methode aufrufen. */
        selectPrevious_JAS(parmKeyVariable_1, parmKeyVariable_2);
        break;
/* */
      case JSBS_StartFrame.CONST_MobileClient:
/*
 * Für diese Version folgt jetzt ein generelles Muster.
 * Es ist im Einzelfall zu analysieren und zu entscheiden, welcher Algorithmus (welches Vorgehen)
 * möglich ist wenn der Mobile Client (z.B. Notebook) keine Verbindung zum Server aufbauen kann.
 * Wenn eine 'MobileClient' Version nicht für das Anwendungsprogramm vorgesehen ist, dann kann
 * der Code innerhalb dieses 'case' gelöscht werden.
 * Damit wird vermieden, dass nicht vorhandene Klassen und Methoden 'auskommentiert' werden müssen. */
/*
 * Zuerst die Daten von der lokalen Datenbank abfragen. Per Definition muss das immer möglich sein. */
          selectPrevious_DB(parmKeyVariable_1, parmKeyVariable_2);
/* Prüfen, ob ein Fehler bei der Abfrage auf der lokalen Datenbank aufgetreten ist. In diesem Fall die
 * Methode beenden - damit ist der Status für die aufrufende Methode verfügbar. */
          if ((this.StatusCode == JSBS_BO.CONST_OK) || (this.StatusCode == JSBS_BO.CONST_NOT_FOUND)) {
/* 'Erlaubte' Status-Codes für die Abfrage von der lokalen Datenbank. */
          }
          else return;
/* Prüfen, ob die Verbindung zum JAS existiert. Abhängig davon erfolgt die weitere Verarbeitung. */
          if (frmCC.testJASConnection()) {
/* BO für die Daten der lokalen Datenbank und den Daten vom JAS konstruieren.
 * Damit können später die jeweiligen Daten verglichen und Unterschiede behandelt werden. */
              application_entity_BO structapplication_entity_BO_Local = new application_entity_BO();
              application_entity_BO structapplication_entity_BO_JAS = new application_entity_BO();
/* Ergebnis der Abfrage der lokalen Datenbank auf die dafür vorgesehene Variable übertragen. */
              structapplication_entity_BO_Local.copyFromapplication_entity_BO(this);
/* Daten vom JAS abfragen. */
              selectPrevious_JAS(parmKeyVariable_1, parmKeyVariable_2);
/* Prüfen, ob ein Fehler bei der Abfrage vom JAS aufgetreten ist. In diesem Fall die
 * Methode beenden - damit ist der Status für die aufrufende Methode verfügbar. */
              if ((this.StatusCode == JSBS_BO.CONST_OK) || (this.StatusCode == JSBS_BO.CONST_NOT_FOUND)) {
/* 'Erlaubte' Status-Codes für die Abfrage vom JAS. */
              }
              else return;
/* Ergebnis der Abfrage über den JAS auf die dafür vorgesehene Variable übertragen. */
              structapplication_entity_BO_JAS.copyFromapplication_entity_BO(this);
/* Methode zum Abgleich der Daten von beiden Quellen aufrufen. */
              getNewestBO(structapplication_entity_BO_Local, structapplication_entity_BO_JAS);
/* Methode zum Prüfen, ob die Daten zwischen Server und mobilem Client abgeglichen werden müssen,
 * und zum eventuell notwendigen Abgleichen aufrufen. */
              synchronizeBO();
/* *** */
          }
          break;
      }
    }
/* ---------------------
 * METHODE zum Selektieren eines aktuell gültigen BO mit der Anwender-bekannten Identifikation.
 * 'Aktuell gültig' bedeutet, dass die Gültigkeit des Datensatzes mit dem
 * im Minimalen Set von Parametern übergebenen Arbeitsdatum übereinstimmt. */
/* 
 * Zuerst die Methode für den direkten Zugriff auf die Datenbank. */
    private void selectByUserKnownKey_DB(String parmKeyVariable_1,
                                        String parmKeyVariable_2) {
/* Methode, die die Verbindung zur Datenbank herstellt, aufrufen.
 * Weil in dieser Methode nur gelesen wird, wird als Parameter 'autocommit' (read-only) festgelegt. */
      getDatabaseConnection(true);
/*
 * 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 = frmCC.structJSBS_DB_ConnectionManager.StatusMsg;
/*
 * Weitere Verarbeitung abbrechen;
 * Aufrufende Methode bekommt Fehler über StatusCode signalisiert. */
        return;
      }
/*
 * Einzelplatz-Version bzw. Datenbank-Zugriff über TCP/IP-Netzwerk.
 * Server-Side-BO 'konstruieren'. */
        application_entity_BOS bosapplication_entity =
          new application_entity_BOS(frmTask.structMinParm,
                                     structDBCon, true);
/*
 * Methode zum Selektieren der Werte aufrufen. */
        bosapplication_entity.selectByUserKnownKey(parmKeyVariable_1,
                                                   parmKeyVariable_2);
/*
 * Neue Werte des BOS wieder in dieses BOC übertragen.
 * Damit sind geschäfts-spezifische Attribute, Common-Attributes, Status-Code
 * und Status-Message in diesem BOC verfügbar. */
        copyFromapplication_entity_BO(bosapplication_entity);
/*
 * DB-Connection an den Connection-Manager zurück geben – der Connection-Manager verwaltet
 * die offene DB-Connection und verwendet sie wieder bei der nächsten Anforderung. */
        frmCC.structJSBS_DB_ConnectionManager.returnReservedConnection(this, intDBConReference);
/* */
    }
/* 
 * Methode zum Lesen der Daten über den JAS (Java Application Server). */
    private void selectByUserKnownKey_JAS(String parmKeyVariable_1,
                                         String parmKeyVariable_2) {
/*
 * Client-Server-Version mit Zugriff auf die Datenbank über den EJB-Mechanismus. */
/*
 * Der Datenbankzugriff über den EJB-Mechanismus muss in einer try/catch-Logik erfolgen 
 * um Fehler beim Aufruf der Methode des EJB behandeln zu können. */
//        try {
/*
 * Instanziieren (Konstruieren) des Client-seitigen Objekts ('Remote interface') für
 * den Aufruf von Methoden des EJB. Die Methode zum Instanziieren ist im Start-Frame implementiert.
 * In diesem Muster wird das Standard-EJB verwendet. 
 *
 * Sollte die Methode für den Datenbankzugriff in einem anderen EJB enthalten sein
 * ist das passende EJB zu instanziieren. */
//          application_package.ejb.interfaces.remote.application_StandardBeanRemote instanceStandardEJB =
//            frmCC.structapplication_CommandCenter__JASConnections.get_application_StandardBeanRemote();
/*
 * Aufrufen der 'Warapper'-Methode des EJB. In dieser 'Wrapper'-Methode wird die - zu dieser
 * BOC-Methode - passende Server-seitige Methode aufgerufen.
 * Neue Werte des BO und eventuelle Fehlermeldungen sind im zurückgelieferten BO enthalten.  */
//          application_entity_BO locbo = instanceStandardEJB.
//            application_entity_BO__selectByUserKnownKey(frmTask.structMinParm,
//                                                        parmKeyVariable_1,
//                                                        parmKeyVariable_2);
/*
 * Werte des zurück gelieferten BO auf dieses BOC (Client-seitiger Teil des BO) übertragen. */
//          this.copyFromapplication_entity_BO(locbo);
//        }
//        catch (Exception e) {
/*
 * Fehler beim Instanziieren des EJB oder beim Ausführen der Methode des EJB.
 * Fehlermeldung aus der Exception übernehmen und Status setzen */
//          this.StatusCode = JSBS_BO.CONST_DB_UNKNOWN_ERROR;
//          this.StatusMsg = e.getMessage();
//        }
    }
/* 
 * Methode die abhängig von der Version des Anwendungsprogramms die entsprechende(n)
 * Methode(n) mit dem Code, der die wirkliche Arbeit macht, aufruft. */
    public void selectByUserKnownKey(String parmKeyVariable_1,
                                     String parmKeyVariable_2) {
/*
 * Entscheiden, ob diese Application als Einzelplatz-Version (StandAlone) oder
 * Client/Server-Version (FatClient) implementiert ist. */
      switch (frmTask.frmCC.RunVersion) {
      case JSBS_StartFrame.CONST_StandAlone:
/* Einzelplatzversion. Datenbank läuft auf der lokalen Maschine; Spezielle Methode aufrufen. */
        selectByUserKnownKey_DB(parmKeyVariable_1, parmKeyVariable_2);
        break;
/* */
      case JSBS_StartFrame.CONST_FatClient:
/* Client-Server-Version.
 * Datenzugriff erfolgt über den EJB-Mechanismus und JAS (Java Application Server); spezielle Methode aufrufen. */
        selectByUserKnownKey_JAS(parmKeyVariable_1, parmKeyVariable_2);
        break;
/* */
      case JSBS_StartFrame.CONST_MobileClient:
/*
 * Für diese Version folgt jetzt ein generelles Muster.
 * Es ist im Einzelfall zu analysieren und zu entscheiden, welcher Algorithmus (welches Vorgehen)
 * möglich ist wenn der Mobile Client (z.B. Notebook) keine Verbindung zum Server aufbauen kann.
 * Wenn eine 'MobileClient' Version nicht für das Anwendungsprogramm vorgesehen ist, dann kann
 * der Code innerhalb dieses 'case' gelöscht werden.
 * Damit wird vermieden, dass nicht vorhandene Klassen und Methoden 'auskommentiert' werden müssen. */
/*
 * Zuerst die Daten von der lokalen Datenbank abfragen. Per Definition muss das immer möglich sein. */
          selectByUserKnownKey_DB(parmKeyVariable_1, parmKeyVariable_2);
/* Prüfen, ob ein Fehler bei der Abfrage auf der lokalen Datenbank aufgetreten ist. In diesem Fall die
 * Methode beenden - damit ist der Status für die aufrufende Methode verfügbar. */
          if ((this.StatusCode == JSBS_BO.CONST_OK) || (this.StatusCode == JSBS_BO.CONST_NOT_FOUND)) {
/* 'Erlaubte' Status-Codes für die Abfrage von der lokalen Datenbank. */
          }
          else return;
/* Prüfen, ob die Verbindung zum JAS existiert. Abhängig davon erfolgt die weitere Verarbeitung. */
          if (frmCC.testJASConnection()) {
/* BO für die Daten der lokalen Datenbank und den Daten vom JAS konstruieren.
 * Damit können später die jeweiligen Daten verglichen und Unterschiede behandelt werden. */
              application_entity_BO structapplication_entity_BO_Local = new application_entity_BO();
              application_entity_BO structapplication_entity_BO_JAS = new application_entity_BO();
/* Ergebnis der Abfrage der lokalen Datenbank auf die dafür vorgesehene Variable übertragen. */
              structapplication_entity_BO_Local.copyFromapplication_entity_BO(this);
/* Daten vom JAS abfragen. */
              selectByUserKnownKey_JAS(parmKeyVariable_1, parmKeyVariable_2);
/* Prüfen, ob ein Fehler bei der Abfrage vom JAS aufgetreten ist. In diesem Fall die
 * Methode beenden - damit ist der Status für die aufrufende Methode verfügbar. */
              if ((this.StatusCode == JSBS_BO.CONST_OK) || (this.StatusCode == JSBS_BO.CONST_NOT_FOUND)) {
/* 'Erlaubte' Status-Codes für die Abfrage vom JAS. */
              }
              else return;
/* Ergebnis der Abfrage über den JAS auf die dafür vorgesehene Variable übertragen. */
              structapplication_entity_BO_JAS.copyFromapplication_entity_BO(this);
/* Methode zum Abgleich der Daten von beiden Quellen aufrufen. */
              getNewestBO(structapplication_entity_BO_Local, structapplication_entity_BO_JAS);
/* Methode zum Prüfen, ob die Daten zwischen Server und mobilem Client abgeglichen werden müssen,
 * und zum eventuell notwendigen Abgleichen aufrufen. */
              synchronizeBO();
/* *** */
          }
          break;
      }
    }
}