Muster-Code für die BO-Klassen zur Implementierung der Währung (JSBS_Currency_BOx)

Dieses Dokument enthält Code-Muster für die Klassen des BO (Business-Object) zur Verwaltung von Währungen (Currencies).
Die Muster-Codes erben die Attribute und Methoden der im JavaScout BaseSystem (JSBS) implementierten Klassen für das BO zur Verwaltung der Währungen.

In diesem Dokument ist beschrieben, wie in den erbenden Klassen die Funktionalität zum Prüfen ob die Währung ein Fremdschlüssel in anderen BO ist, implementiert wird.

Inhaltsverzeichnis:

Vorbemerkung 
Vorbedingung 

Muster-Code für die (Java-)Interface mit den Status-Codes 
Muster-Code für die BOS-Klasse 
Muster-Code für die BOC-Klasse 
Zusätzlicher Code in der EJB-Klasse (bei Client/Server Anwendungen) 

Anleitung zur Adaptierung in allen Klassen 
* Änderung des Namens des Java-Packages 
* Änderung des Namens der Klassen 
* Adaptieren der Kommentare 

Anleitung zur Adaptierung in der Interface mit den Status-Codes 

Anleitung zur Adaptierung in der BOS-Klasse 
* Methode isReferenced() adaptieren 

Anleitung zur Adaptierung in der BOC-Klasse 
* Änderung des Namens der Klasse des CommandCenters 
* Entfernen der Kommentare 
* Einsetzen der verwendeten Klasse für die Verbindung zum JAS 

Anleitung zur Adaptierung in der EJB-Klasse 
* Einfügen der Methode im (Java-)Interface für das EJB 
* Eventuelles Ergänzen der (Java-)Interface um das Package für die Klasse des BO für die Währung 
* Einfügen der Methode in die Klasse für das EJB 

Weitere Schritte und verwandte Dokumentation 

Vorbemerkung

Die hier vorgestellten Muster-Codes nutzen das Prinzip der 'Vererbung' in Java.
Eine Skizze über die Wirkungsweise von 'vererbten' Variablen und Methoden finden Sie unter Leitfaden für die Entwicklung von Heavyweight-Clients mit dem JS-FCF – Verwendung der BO-Klassen (aus dem Basis-System) für Land, Sprache und Währung in einem Anwendungsprogramm > Überblick.

Im JavaScout Base-System (JSBS) sind bereits Klassen für Business-Objects (BO) für die Abbildung von Währungen (JSBS_Currency_BO und weitere) enthalten.

Üblicherweise wird eine Währung als Attribut in einem anwendungs-spezifischen Business Object verwendet – der Währungscode ist in diesem BO dann ein Fremdschlüssel.
Deswegen muss bei einem Deaktivieren (logischem Löschen) einer Währung geprüft werden, ob der Code dieser Währung nicht mehr in einem aktiven BO verwendet wird.

Naturgemäß kann diese Prüfung nicht in der Basisklasse für die Währung erfolgen – weil ja die anwendungs-spezifischen BO individuell für eine Anwendung entwickelt wird.
Für die Prüfung auf Fremdschlüssel werden die dafür vorgesehenen Methoden in Klassen, die spezifisch für die geforderte Anwendung entwickelt werden (Muster-Codes in diesem Dokumnet) überschrieben und in den überschreibenden Methoden wird auf Verwendung in einem anwendungs-spezifischen BO geprüft.

▲ zum Inhaltsverzeichnis

Vorbedingung:

• Kenntnisse und Übung in der Codierung von Business-Objects.
  Den Leitfaden mit ausführlicher Anleitung 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.

▲ zum Inhaltsverzeichnis

Muster-Code für die (Java-)Interface mit den Status-Codes

Welche Platzhalter durch Bezeichnungen des eigentlichen Projektes zu ersetzen sind finden Sie in den Abschnitten
Anleitung zur Adaptierung in allen Klassen  und
Anleitung zur Adaptierung in der Interface mit den Status-Codes . 

package application_package.bo;
/**
 * 
 * @author name[at]company
 * @date 20xx-xx-xx
 *
 * @description
 *  Interface mit den Status-Codes für die Gründe, warum ein BO nicht 'deaktiviert'
 *  (logisch gelöscht) werden kann.
 *  Das 'Auslagern' dieser Stati in diese Interface ist notwendig, weil Java eine
 *  Mehrfach-Vererbung (Multi Inheritance) nicht erlaubt und die BOS- und BOC-Klasse
 *  bereits die Basisklassen für die Währung erben.
 *  Die zusätzlichen Status-Codes werden über diese Interface einmalig definiert.
 * 
 * @change-log
 * when          who                       why
 * -----------------------------------------------------------------
 * 
 */
public interface application_Currency_BO_Interface {
/*
 * Diese Interface enthält nur 'Fehler' die das 'Deaktivieren' des BO verhindern.
 * --------------------- */
/* 
 * Beschreibung warum das BO nicht deaktiviert werden kann . */
    public static final int CONST_DEAKTIVATE_INHIBIT_REASON_Reason = 60;
}

▲ zum Inhaltsverzeichnis

Muster-Code für die BOS-Klasse

Welche Platzhalter durch Bezeichnungen des eigentlichen Projektes zu ersetzen sind finden Sie in den Abschnitten
Anleitung zur Adaptierung in allen Klassen  und
Anleitung zur Adaptierung in der BOS-Klasse . 

package application_package.bos;
/*
 * Package für die Verbindung zur Datenbank. */
import java.sql.*;
/*
 * Basis-Klasse mit dem Minimalen Set an Parametern. Diese enthalten das Arbeitsdatum.
 * Das Arbeitsdatum wird für verschiedene Abfragen gebraucht. */
import js_base.structures.JSBS_MinimalParameters;
/*
 * Geerbte Basisklassen für die Währung. */
import js_base.bo.JSBS_Currency_BO;
import js_base.bos.JSBS_Currency_BOS;
/*
 * Interface mit den Status-Codes warum ein BO nicht 'deaktiviert'
 * (logisch gelöscht) werden darf. */
import application_package.bo.application_Currency_BO_Interface;
/*
 * Package mit den BO; in diesem sind die Klassen für die referenzierenden BO enthalten. */
import application_package.bo.*;
/**
 * 
 * @author name[at]company
 * @date 20xx-xx-xx
 *
 * @description
 *  Server-Seitige Klasse für ein Anwendungs-spezifisches Business-Object
 *  für die Währung (Currency).
 *  Variablen dieses BO und die Anwender-bekannte Identifikation sind in der
 *  Basisklasse JSBS_Currency_BO dokumentiert.
 * 
 * @change-log
 * when          who                       why
 * -----------------------------------------------------------------
 * 
 */
public class application_Currency_BOS extends JSBS_Currency_BOS
                                      implements application_Currency_BO_Interface {
/* --------------------
 * CONSTRUCTOR-METHODEN */
/* --------------------
 * Im 'Constructor' werden Parameter beim Erstellen eines Objektes dieser Klasse
 * übergeben.
 * Damit eine BOS-Klasse (BOS: Business Object, Server-Side) auch innerhalb eines
 * EJB (Enterprise Java Bean) verwendet werden kann, muss bereits eine Connection
 * zur Datenbank als Parameter an den 'Constructor' übergeben werden.
 * Für ein 'Set' ist es nicht erforderlich, einen 'Constructor' zu implementieren mit
 * dem auch die Werte eines anderen Objektes übernommen werden können. */
/* --------------------- */
/*
 * Constructor-Methode mit Minimal-Parametern und geöffneter DB-Connection als Parameter. */
    public application_Currency_BOS(
                JSBS_MinimalParameters parmMinParm,
                Connection parmDBCon) {
/*
 * Aufruf der Constructor-Methode der geerbten Klasse. */
      super(parmMinParm, parmDBCon);
    }
/*
 * Constructor-Methode mit Minimal-Parametern, geöffneter DB-Connection und
 * Flag, ob das Objekt von einem anderen BOS konstruiert wird, als Parameter. */
    public application_Currency_BOS(
                JSBS_MinimalParameters parmMinParm,
                Connection parmDBCon,
                boolean parmObjectConstructedByBOC_or_EJB) {
/*
 * Aufruf der Constructor-Methode der geerbten Klasse. */
      super(parmMinParm, parmDBCon, parmObjectConstructedByBOC_or_EJB);
    }
/*
 * Constructor-Methode mit Minimal-Parametern, geöffneter DB-Connection und
 * einem BO der gleichen Klasse (aus dem die Werte übernommen werden) als Parameter. */
    public application_Currency_BOS(
                JSBS_MinimalParameters parmMinParm,
                Connection parmDBCon,
                JSBS_Currency_BO parmJSBS_Currency_BO) {
/*
 * Aufruf der Constructor-Methode der geerbten Klasse. */
      super(parmMinParm, parmDBCon, parmJSBS_Currency_BO);
    }
/*
 * Constructor-Methode mit Minimal-Parametern, geöffneter DB-Connection,
 * einem BO der gleichen Klasse (aus dem die Werte übernommen werden) als Parameter
 * und Flag, ob das Objekt von einem anderen BOS konstruiert wird, als Parameter. */
    public application_Currency_BOS(
                JSBS_MinimalParameters parmMinParm,
                Connection parmDBCon,
                JSBS_Currency_BO parmJSBS_Currency_BO ,
                boolean parmObjectConstructedByBOC_or_EJB) {
/*
 * Aufruf der Constructor-Methode der geerbten Klasse. */
      super(parmMinParm, parmDBCon, parmJSBS_Currency_BO, parmObjectConstructedByBOC_or_EJB);
    }
/* -----------------------------
 * METHODE zum Prüfen ob auf dieses BO in einem anderen BO eine Referenz vorhanden ist.
 * Diese Methode dient dazu, zu prüfen ob das BO deaktiviert werden darf oder nicht
 * deaktiviert werden darf weil sonst in einem anderen BO eine Inkonsistenz entsteht. */
    public boolean isReferenced() {
/*
 * Spezielle Prüfung ob das BO nur die Bezeichnung der Währung in einer zusätzlichen Sprache
 * enthält. So ein BO kann ohne weitere Prüfung gelöscht werden weil immer noch der Haupteintrag
 * (erkennbar an einer leeren Zeichenkette im Attribut 'LanguageCodeForLabelling') mit der
 * Standard-Bezeichnung vorhanden ist. */
        if (this.LanguageCodeForLabelling.trim().length() > 0) return false;
/*
 * Prüfung auf Referenzierungen in der geerbten Klasse. */
        if (super.isReferenced()) return true;
/* ***********
 * Voraussetzung für den folgenden Muster-Code ist, dass im referenzierenden BO (implementiert in
 * der Klasse 'BOS-Set') eine Methode vorhanden ist, die alle zum aktuellen Datum und in Zukunft
 * gültigen BOs selektiert, die das hier zu löschende BO für die Währung als Fremdschlüssel
 * referenzieren. */
/*
 * Der folgende Muster-Code muss für jede referenzierende BO-Klasse implementiert (das heisst
 * kopiert und adaptiert) werden. */
/*
 * ***** FOLGENDER MUSTER-CODE MUSS GELÖSCHT WERDEN WENN NICHT AUF REFERENZEN GEPRÜFT WIRD. *****
 * Oder er kann für das Prüfen einer weiteren Referenz kopiert werden.   */
/*
 * Ein BOS-Set definieren mit dem später geprüft werden kann, ob eine Referenz auf das hier
 * zu deaktivierende BO vorhanden ist. */
        referencing_app_entity_BOS_Set structreferencing_app_entity_BOS_Set =
          new referencing_app_entity_BOS_Set(structJSBS_MinimalParameters, structDBCon, true);
/* Methode zum Selektieren der Liste mit den referenzierenden BOs. */
        structreferencing_app_entity_BOS_Set.selectValidAndFutureByCurrencyCode(this.ISOCurrencyCode);
/* 
 * Prüfen ob die Datenbank-Operation fehlerfrei war; dazu den Status-Code des
 * BOS-Set abfragen. */
        switch(structreferencing_app_entity_BOS_Set.StatusCode) {
          case CONST_OK:
/* Dieses BO wird referenziert; zur Sicherheit prüfen ob auch wirklich BOs
 * im Vector vorhanden sind. */
            if(structreferencing_app_entity_BOS_Set.vecRecordSet.size() > 0) { 
/* Entsprechenden Status-Code setzen; dieser ist in der Interface 'application_Currency_BO_Interface'
 * definiert. */
              this.StatusCode = CONST_DEAKTIVATE_INHIBIT_REASON_Reason;
/* Zur Information des Anwenders die Anwender-bekannte Identifikation aus dem ersten
 * BO der Liste extrahieren und in der Status-Message zurückliefern. */
              referencing_app_entity_BO structreferencing_app_entity_BO =
                (referencing_app_entity_BO)
                  structreferencing_app_entity_BOS_Set.vecRecordSet.elementAt(0);
              this.StatusMsg = structreferencing_app_entity_BO.UserKnownKeyVariable1
                       + "/" + structreferencing_app_entity_BO.UserKnownKeyVariable2;
/* 'true' als Flag zurückliefern damit dieses BO nicht deaktiviert wird. */
              return true;
            }  
            break;
          case CONST_NOT_FOUND:
/* Dieses BO wird nicht referenziert; 'case' implementiert damit bei diesem Status
 * nicht ein Fehler 'gemeldet' wird. */
            break;
          default:
/* Ein anderer Fehler ist beim Selektieren aufgetreten.
 * Status-Code und Status-Message in die Variablen dieses BO übernehmen und
 * 'true' zurückliefern damit (zur Sicherheit) dieses BO nicht deaktiviert wird. */
            this.StatusCode = structreferencing_app_entity_BOS_Set.StatusCode;
            this.StatusMsg = structreferencing_app_entity_BOS_Set.StatusMsg;
            return true;
        }  
/*
 * ***** ENDE DES ZU LÖSCHENDEN ODER KOPIERENDEN MUSTER-CODE. *****  */
/* -----------
 * Wenn notwendig hier weitere Prüfungen ob dieses BO referenziert wird einfügen.
 * Dazu den Muster-Code von oben kopieren. */
/*
 * ----------- */ 
/*
 * Wenn diese Methode nicht mit einem Algorithmus gefüllt wird oder die Abfrage auf,
 * Referenzen kein 'true' ergibt, dann wird 'false' zurückgeliefert.
 * das ist das Signal, dass dieses BO nicht von einem anderen BO referenziert wird. */
      return false;
    }
}

▲ zum Inhaltsverzeichnis

Muster-Code für die BOC-Klasse

Welche Platzhalter durch Bezeichnungen des eigentlichen Projektes zu ersetzen sind finden Sie in den Abschnitten
Anleitung zur Adaptierung in allen Klassen  und
Anleitung zur Adaptierung in der BOC-Klasse . 

package application_package.boc;
/*
 * Basisklasse für Status-Codes. */
import js_base.bo.JSBS_BO;
/*
 * Geerbte Basisklassen für die Währung. */
import js_base.bo.JSBS_Currency_BO;
import js_base.boc.JSBS_Currency_BOC;
/*
 * Package mit den Basisklassen für StartFrame (CommandCenter) und
 * TaskFrame (Basis aller Geschäftsfall-Anwendungen). */
import js_base.frame.*;
/*
 * Interface mit den Status-Codes warum ein BO nicht 'deaktiviert'
 * (logisch gelöscht) werden darf. */
import application_package.bo.application_Currency_BO_Interface;
/*
 * 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.*;
/*
 * Klasse für das CommandCenter (Start-Frame) der Anwendung. */
import application_package.client.application_CommandCenter;
/**
 * 
 * @author name[at]company
 * @date 20xx-xx-xx
 *
 * @description
 *  Client-Seitige Klasse für ein Anwendungs-spezifisches Business-Object
 *  für die Währung (Currency).
 *  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_Currency_BOC extends JSBS_Currency_BOC
                                      implements application_Currency_BO_Interface {
/* ---------------------
 * VARIABLE dieser Klasse.
 * --------------------- */
/* 
 * 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;
/* ---------------------
 * CONSTRUCTOR-METHODE */
/* ---------------------
 * Als Parameter des 'Constructors' sind das aufrufende Task-Frame und
 * das 'CommandCenter' (Start-Frame) erforderlich. */
    public application_Currency_BOC(application_CommandCenter parmfrmCC, JSBS_TaskFrame parmfrmTask) {
/*
 * Aufruf der Constructor-Methode der geerbten Klasse. */
      super(parmfrmCC, parmfrmTask);
/*
 * Die im Parameter übergebene Referenz auf das Start-Frame werden in der Variable
 * dieser Klasse 'aufgehoben'. */
      this.frmCC = parmfrmCC;
    }
/* ---------------------
 * METHODE zum Deaktivieren eines BO. */
/* 
 * Zuerst die Methode für den direkten Zugriff auf die Datenbank. */
    public 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. */
      super.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_Currency_BOS bosapplication_Currency_BOS =
          new application_Currency_BOS(frmTask.structMinParm,
                                     structDBCon,
                                     this, true);
/*
 * Methode zum Deaktivieren des BO aufrufen. */
        bosapplication_Currency_BOS.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 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_Currency_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. */
        copyFromJSBS_Currency_BO(bosapplication_Currency_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 Lesen der Daten über den JAS (Java Application Server). */
    public 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. */
        JSBS_Currency_BO locbo = new JSBS_Currency_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.copyFromJSBS_Currency_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_Currency_BO__deactivate(frmTask.structMinParm, locbo);
/*
 * Werte des zurück gelieferten BO auf dieses BOC (Client-seitiger Teil des BO) übertragen. */
//          this.copyFromJSBS_Currency_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. */
                  super.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 unterbrochen; als 'offline'-Lösung die Operation auf der lokalen Datenbank ausführen. */
              deactivate_DB();
          }
/* *** */
          break;
      }
    }
}

▲ zum Inhaltsverzeichnis

Zusätzlicher Code in der EJB-Klasse (bei Client/Server Anwendungen)

Der bestehende Code der Klassen für 'Interface' und 'Bean' muss um die Methode für das 'deactivate' des BO für eine Währung ergänzt werden.

Welche Platzhalter durch Bezeichnungen des eigentlichen Projektes zu ersetzen sind finden Sie in den Abschnitten
Anleitung zur Adaptierung in allen Klassen  und
Anleitung zur Adaptierung in der EJB-Klasse . 

Muster-Code für die Ergänzung in der Interface für das EJB (Enterprise Java Bean):

package application_package.ejb.interfaces.remote;
. . . . .
. . . . .
public interface application_StandardBeanRemote extends JSBS_StandardEJBBeanRemote {
. . . . .
. . . . .
    public JSBS_Currency_BO application_Currency_BO__deactivate(
                                            JSBS_MinimalParameters parmMinBO,
                                            JSBS_Currency_BO parmBO);
. . . . .
. . . . .
}

Muster-Code für die Ergänzung in der Klasse für das EJB (Enterprise Java Bean):

package application_package.ejb.bean;
. . . . .
. . . . .
public class application_StandardBean extends JSBS_StandardEJBBean
         implements application_StandardBeanLocal, application_StandardBeanRemote {
. . . . .
. . . . .
/* ---------------------------------------- */
    public synchronized JSBS_Currency_BO application_Currency_BO__deactivate(
                                            JSBS_MinimalParameters parmMinParm,
                                            JSBS_Currency_BO parmBO) {
/*
 * BO, das an die aufrufende Methode zurückgeliefert wird, definieren und konstruieren. */
      JSBS_Currency_BO boapplication_Currency_BO = new JSBS_Currency_BO();
/*
 * Variable für die Verbindung (Connection) zur Datenbank definieren und Methode zum
 * Erstellen der Verbindung aufrufen. */
      Connection DBCon = establishDBConnection();
/*
 * Prüfen ob eine Verbindung zur Datenbank hergestellt werden konnte. */
      if (DBCon == null) {
/*
 * Status und Fehler-Nachricht in den jeweiligen Variablen des BO setzen
 * und das BO an die aufrufende Methode zurück liefern. */
        boapplication_Currency_BO.StatusCode = JSBS_BO.CONST_DB_SYSTEM_ERROR;
        boapplication_Currency_BO.StatusMsg = "Database connection failed within the EJB.";
        return boapplication_Currency_BO;
      }
/*
 * Für Methoden, die Daten verändern darf 'autocommit' nicht verwendet werden.
 * Nur so kann bei einem Fehler ein 'rollback' ausgeführt werden. */
      try {
/*
 * 'Autocommit' für die Verbindung zur Datenbank nicht setzen. */
        DBCon.setAutoCommit(false);
      }
      catch (Exception e) {
/*
 * Setzen von 'autocommit' führte zu einem Fehler; diesen an die aufrufende Methode
 * zurück liefern und die Datenbank-Operation nicht ausführen. */
        boapplication_Currency_BO.StatusCode = JSBS_BO.CONST_DB_SYSTEM_ERROR;
        boapplication_Currency_BO.StatusMsg = "Disabling 'autocommit' failed within the EJB.";
        return boapplication_Currency_BO;
      }
/*
 * DB-Connection wurde fehlerfrei erstellt.
 * Ein Server-Side Business Object konstruieren (instanziieren).
 * Dabei gleich die Werte des übergebenen BO übernehmen.
 * Danach die 'deactivate'-Operation auf die Datenbank ausführen. */
      application_Currency_BOS bosapplication_Currency_BOS =
        new application_Currency_BOS(parmMinParm, DBCon, parmBO, true);
      bosapplication_Currency_BOS.deactivate();
/*
 * Kopieren des gerade für die Datenbank-Operation genutzten Server-Side BO auf das
 * für die Rücklieferung an die aufrufende Methode vorgesehene BO (generelle Klasse).
 * Durch das Kopieren werden auch eventuell aufgetretene Status-Code und -Nachrichten
 * auf das Generelle BO übertragen. */
      boapplication_Currency_BO.copyFromJSBS_Currency_BO(bosapplication_Currency_BOS);
/* 
 * 'Commit' oder 'Rollback' ausführen und Schliessen der Verbindung (Connection) zur Datenbank.
 * Das muss innerhalb einer 'try/catch'-Logik erfolgen auch wenn es keine Möglichkeit gibt,
 * bei einem Fehler eine Korrektur vorzunehmen.
 * Aber alle ausgereiften Java Application Server (JAS) können eine solche Situation bereinigen. */
      try {
        if (bosapplication_Currency_BOS.StatusCode == JSBS_BO.CONST_OK) DBCon.commit();
        else DBCon.rollback();
        DBCon.close();
      }
      catch (Exception e){
/*
 * Status und Fehler-Nachricht in den jeweiligen Variablen des BO setzen
 * und das BO an die aufrufende Methode zurück liefern. */
        boapplication_Currency_BO.StatusCode = JSBS_BO.CONST_DB_SYSTEM_ERROR;
        boapplication_Currency_BO.StatusMsg = "Close of database-connection failed within the EJB.";
      }
/* 
 * BO mit den selektierten Daten - oder mit dem entsprechenden Status - an die aufrufende  
 * Methode zurück liefern. */
      return boapplication_Currency_BO;
    }
/* ***** */ 
. . . . .
. . . . .
}

▲ zum Inhaltsverzeichnis

Anleitung zur Adaptierung in allen Klassen

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

Für diesen Muster-Code gibt es keine Möglichkeit, gleichartige Änderungen durch 'Replace' vorzunehmen.
Die 'Find'-Funktion ist aber hilfreich zum Finden der beschriebenen 'Platzhalter'.

▲ zum Inhaltsverzeichnis

Änderung des Namens des Java-Packages

package application_package.bo;
/*

Der Name application_package kommt mehrmals in der Interface und den Klassen für BOS und BOC vor.
Suchen Sie nach diesem Begriff und ersetzen Sie ihn durch Ihren gewählten Namen für das Package.

▲ zum Inhaltsverzeichnis

Änderung des Namens der Klassen

In der Interface :
*/
public interface application_Currency_BO_Interface {
/*

In der Klasse für das BOS:
*/
public class application_Currency_BOS extends JSBS_Currency_BOS
                                      implements application_Currency_BO_Interface {
/*

In der Klasse für das BOC:
*/
public class application_Currency_BOC extends JSBS_Currency_BOC
                                      implements application_Currency_BO_Interface {
/*

Durch das Ersetzen des Platzhalters application_Currency_BO durch den für Ihre Anwendung gewählten Namensteil (z.B. JSProjAssist_Currency_BO) kann in der Interface und den Klassen für BOS und BOC der jeweils richtige Namen eingesetzt werden.
Durch die gewählte Namens-Konvention in den Muster-Codes werden auch die Referenzen auf verbundene Klassen richtig gestellt.

▲ zum Inhaltsverzeichnis

Adaptieren der Kommentare

Im Muster-Code ist eine allgemeine Beschreibung im Kommentar enthalten.
Vorgesehen ist, dass das Erstellungs-Datum der Interface oder Klasse und der Name eingesetzt wird.
/**
 * 
 * @author name[at]company
 * @date 20xx-xx-xx
 *
 * @description

Eine Ergänzung des Kommentars bleibt Ihnen unbenommen – besonders wenn Sie den Code entsprechend Ihrer Anforderungen modifizieren.

▲ zum Inhaltsverzeichnis

Anleitung zur Adaptierung in der Interface mit den Status-Codes 

Einziger Zweck der Interface ist, die Status-Codes für die Gründe, warum ein BO nicht deaktiviert werden darf, an zentraler Stelle festzulegen.
Kopieren Sie die Musterzeile für jeden möglichen Hinderungsgrund.
/* 
 * Beschreibung warum das BO nicht deaktiviert werden kann . */
    public static final int CONST_DEAKTIVATE_INHIBIT_REASON_Reason = 60;

▲ zum Inhaltsverzeichnis

Anleitung zur Adaptierung in der BOS-Klasse 

Methode isReferenced() adaptieren

Voraussetzung für das Implementieren der Prüfungen in dieser Methode ist, dass eine Methode zum Selektieren der referenzierenden Business-Objects implementiert ist (Beschreibung im Dokument Muster-Code für ein BOS_Set (Liste mit Business-Objects, Server-Side-Klasse)) und eine zugehörige Konstante für den Status-Code definiert ist (Beschreibung im Abschnitt Anleitung zur Adaptierung in der Interface mit den Status-Codes).

Wenn nicht auf eine Referenz geprüft werden muss, dann ist der Code innerhalb der Hinweise im Kommentar zu löschen.

Im Muster-Code ist die Prüfung auf die mögliche Referenzierung durch Business-Objects einer anderen Klasse dargestellt. 
Im 'wirklichen Leben' können wahrscheinlich Business-Objects mehr als einer anderen Klasse eine Referenz auf dieses BO enthalten.

Für jede Klasse eines möglicherweise referenzierenden BO ist der Muster-Code für die Prüfung zu kopieren und zu adaptieren.

• Der Code zwischen den Kommentarzeilen
/*
 * ***** FOLGENDER MUSTER-CODE MUSS GELÖSCHT WERDEN WENN NICHT AUF REFERENZEN GEPRÜFT WIRD. *****
 * Oder er kann für das Prüfen einer weiteren Referenz kopiert werden.   */
/*
 * Ein BOS-Set definieren mit dem später geprüft werden kann, ob eine Referenz auf das hier
 * zu deaktivierende BO vorhanden ist. */
        referencing_app_entity_BOS_Set structreferencing_app_entity_BOS_Set =
und
            return true;
        }  
/*
 * ***** ENDE DES ZU LÖSCHENDEN ODER KOPIERENDEN MUSTER-CODE. *****  */
/* -----------
muss für jede referenzierende Business-Object-Klasse einmal vorhanden sein; kopieren Sie den Code entsprechend oft.
• Innerhalb eines jeden kopierten Code-Blocks ist der Platzhalters referencing_app_entity_BO durch die BOS-Klasse, die die Währung referenziert (z.B. JS_HSepp_Produkt_BO) zu ersetzen.

/*
 * Ein BOS-Set definieren mit dem später geprüft werden kann, ob eine Referenz auf das hier
 * zu deaktivierende BO vorhanden ist. */
        referencing_app_entity_BOS_Set structreferencing_app_entity_BOS_Set =
          new referencing_app_entity_BOS_Set(structJSBS_MinimalParameters, structDBCon, true);
/* Methode zum Selektieren der Liste mit den referenzierenden BOs. */
        structreferencing_app_entity_BOS_Set.selectValidAndFutureByCurrencyCode(this.ISOCurrencyCode);
/* 
 * Prüfen ob die Datenbank-Operation fehlerfrei war; dazu den Status-Code des
 * BOC-Set abfragen. */
        switch(structreferencing_app_entity_BOS_Set.StatusCode) {

Die Klasse und das Objekt kommen mehrmals in der Methode vor; im obigen Code-Ausschnitt wird das Auftreten nur zu Beginn des Muster-Codes gezeigt.
• Im Muster-Code hat die Methode zum Selektieren der BO mit der referenzierenden Währung den Namen selectValidAndFutureByCurrencyCode.
Wenn Sie in Ihrer Anwendung einen anderen Namen für die Methode gewählt haben, ersetzen Sie den Namen im Muster-Code.
• Wird noch ein referenzierendes BO gefunden, dann ist der dafür festgelegte Status-Code einzusetzen.
Der jeweils gültige Code wurde in der Interface (im Abschnitt Anleitung zur Adaptierung in der Interface mit den Status-Codes beschrieben) definiert.

              this.StatusCode = CONST_DEAKTIVATE_INHIBIT_REASON_Reason;
• In der Status-Message wird die Anwender-bekannte Identifikation des ersten referenzierenden BO eingesetzt. Damit kann der Anwender darauf hingewiesen werden, warum ein deaktivieren der Währung nicht möglich ist.
Im Muster-Code besteht die Anwender-bekannte Identifikation aus 2 Variablen; die Zahl der Variablen kann bei Ihrer konkreten Anwendung anders sein.

/* Zur Information des Anwenders die Anwender-bekannte Identifikation aus dem ersten
 * BO der Liste extrahieren und in der Status-Message zurückliefern. */
              referencing_app_entity_BO structreferencing_app_entity_BO =
                (referencing_app_entity_BO)
                  structreferencing_app_entity_BOS_Set.vecRecordSet.elementAt(0);
              this.StatusMsg = structreferencing_app_entity_BO.UserKnownKeyVariable1
                       + "/" + structreferencing_app_entity_BO.UserKnownKeyVariable2;
/* 'true' als Flag zurückliefern damit dieses BO nicht deaktiviert wird. */
• Wenn auf eine Referenz geprüft wird, dann wird die Anweisung für das Zurückliefern von false am Ende des Codes nicht mehr erreicht und der Compiler meldet dies als Fehler.
Zur Vermeidung des Fehlers kann die Anweisung gelöscht oder 'auskommentiert' werden.

/*
 * ***** ENDE DES ZU LÖSCHENDEN ODER KOPIERENDEN MUSTER-CODE. *****  */
/* -----------
 * Wenn notwendig hier weitere Prüfungen ob dieses BO referenziert wird einfügen. */
/*
 * ----------- */ 
/*
 * Wenn diese Methode nicht mit einem Algorithmus gefüllt wird, wird 'false' zurückgeliefert.
 * das ist das Signal, dass dieses BO nicht von einem anderen BO referenziert wird. */
//      return false;
    }

▲ zum Inhaltsverzeichnis

Anleitung zur Adaptierung in der BOC-Klasse 

Änderung des Namens der Klasse des CommandCenters

import application_package.bos.*;
/*
 * Klasse für das CommandCenter (Start-Frame) der Anwendung. */
import application_package.client.application_CommandCenter;
/**
 * 
 * @author name[at]company

Der Name dieser Klasse kommt mehrmals im Muster-Code vor.
Wenn Sie 'Find/Replace' zum Ersetzen verwenden, geben Sie bitte den Text application_CommandCenter als Suchbegriff ein; damit wird nur der Name dieser Klasse ersetzt und nicht auch Teile anderer 'Platzhalter' die application enthalten.

▲ zum Inhaltsverzeichnis

Wenn Ihre Anwendung nur als Einzelplatz-Version (mit der lokalen Datenbank) entwickelt wird dann ist die Adaptierung der BOC-Klasse abgeschlossen.

Als Vorbereitung für eine Client-Server- oder MobileClient-Version entwickelt wird, führen Sie bitte zuerst die Tätigkeiten im Abschnitt Anleitung zur Adaptierung in der EJB-Klasse aus und anschließend die folgenden Tätigkeiten zur Adaptierung der BOC-Klasse.

Entfernen der Kommentare

Entfernen Sie die Kommentare vor den Anweisungen zum Instanziieren des EJB, zum Aufrufen der Methoden und zur Fehlerbehandlung.
. . . . . . . . .
. . . . . . . . .
/*
 * 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_Currency_BO__deactivate(frmTask.structMinParm, locbo);
/*
 * Werte des zurück gelieferten BO auf dieses BOC (Client-seitiger Teil des BO) übertragen. */
//          this.copyFromJSBS_Currency_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();
//        }
    }
/* 
. . . . . . . . .
. . . . . . . . .

▲ zum Inhaltsverzeichnis

Einsetzen der verwendeten Klasse für die Verbindung zum JAS

Der Platzhalter application_StandardBeanRemote muss durch den Namen der Klasse für die Verbindung (des im JAS / Java Application Server) ausgeführten EJB (vergeben in den im Dokument Muster-Codes für die Klasse eines EJB (Enterprise Java Bean) mit Datenbankzugriff beschriebenen Tätigkeiten) ersetzt werden.

Beim Instanziieren des EJB ist die entsprechende EJB-Klasse und die Methode zum 'Holen' eines Objekts der EJB-Klasse manuell zu adaptieren:
. . . . . . . . .
. . . . . . . . .
 * 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();
/*
. . . . . . . . .
. . . . . . . . .

▲ zum Inhaltsverzeichnis

Anleitung zur Adaptierung in der EJB-Klasse 

Einfügen der Methode im (Java-)Interface für das EJB

Die (Java-)Interface für die in Ihrem Anwendungsprogramm entwickelte Klasse für das EJB (Enterprise Java Bean) muss um die Methode zum Deaktivieren der Währung ergänzt werden.

package application_package.ejb.interfaces.remote;
. . . . .
. . . . .
public interface application_StandardBeanRemote extends JSBS_StandardEJBBeanRemote {
. . . . .
. . . . .
    public JSBS_Currency_BO application_Currency_BO__deactivate(
                                            JSBS_MinimalParameters parmMinBO,
                                            JSBS_Currency_BO parmBO);
. . . . .
. . . . .
}

Ersetzen Sie bitte den Platzhalter application_Currency_BO durch den für Ihre Anwendung gewählten Namen für das BO für die Währung.

▲ zum Inhaltsverzeichnis

Eventuelles Ergänzen der (Java-)Interface um das Package für die Klasse des BO für die Währung

Wenn in dem Interface noch keine Klasse für ein BO (Business Object) aus dem JSBS (JavaScout Base-System) definiert ist, dann muss die folgende import-Deklaration eingefügt werden:

package application_package.ejb.interfaces.remote;
. . . . .
. . . . .
/*
 * Import der Interface für das 'Standard'-EJB der Basisklasse.
 * Die Erklärung des 'Standard'-EJB finden Sie unter @description (etwas weiter unten). */
import js_base.ejb.interfaces.local.JSBS_StandardEJBBeanLocal;
/*
 * Import der Klassen jener BO die im JavaScout BaseSystem implementiert sind. */
import js_base.bo.*;
/*
 * Packages mit den Generellen Klassen für die Business-Objects (BO) importieren. */
import application_package.bo.*;
. . . . .
. . . . .
public interface application_StandardBeanRemote extends JSBS_StandardEJBBeanRemote {
. . . . .
. . . . .

▲ zum Inhaltsverzeichnis

Einfügen der Methode in die Klasse für das EJB

Die in Ihrem Anwendungsprogramm entwickelte Klasse für das EJB (Enterprise Java Bean) muss um die Methode zum Deaktivieren der Währung ergänzt werden.
Den Muster-Code für die Methode finden Sie im Abschnitt Zusätzlicher Code in der EJB-Klasse (bei Client/Server Anwendungen) in diesem Dokument.

Ersetzen Sie bitte den Platzhalter application_Currency_BO durch den für Ihre Anwendung gewählten Namen für das BO für die Währung.

▲ zum Inhaltsverzeichnis

Weitere Schritte und verwandte Dokumentation