Muster-Code für die Klassen eines Start-Frames

Dieses Dokument enthält Code-Muster für die Klassen für ein Start-Frame und Erweiterungen, die entsprechend den jeweiligen Anforderungen zusätzlich implementiert werden können.

Inhaltsverzeichnis:

Vorbedingung 
Muster-Code für die Klasse für das Frame (GUI) 
Muster-Code für die Klasse für den ActionHandler 
Muster-Code für die Klasse für die Verbindung zu EJB (bei Konfiguration als Client/Server)

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

Anleitung zur Adaptierung bei Verwendung von Währungen in der Klasse für die GUI 
* Adaptieren in der Methode initialize_frame 
* Adaptieren in der Methode initialize_after_frame 

Anleitung zur Adaptierung bei Festlegung von erlaubten Sprachen in der Klasse für die GUI 

Anleitung zur Adaptierung in der Klasse für den ActionHandler 

Anleitung zur Adaptierung in der Klasse für die Verbindung zum EJB 
* Import der Klasse für das EJB 
* Änderung des Namens des verwendeten Standard-Bean 

Weitere Schritte und verwandte Dokumentation 

Vorbedingung:

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

▲ zum Inhaltsverzeichnis

Muster-Code für die Klasse für das Frame (GUI)

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

package application_package.client;
/*
 * Package mit den Klassen zum Bearbeiten von Events. */
import java.awt.event.*;
/*
 * Package mit den Klassen für GUI-Elemente.
 * Benötigt weil Typ JPanel explizit behandelt wird. */
import javax.swing.*;
/*
 * Package mit der Basisklasse für das StartFrame. */
import js_base.frame.*;
/*
 * Package mit der Basisklasse für die Struktur mit Parametern. */
import js_base.structures.*;
/*
 * Package mit der Basisklasse für die Bearbeitung von
 * Dateien mit XML-Strukturen. */
import js_base.xml.*;
/*
 * Package mit der Basisklasse für die Verbindungen zu Datenbank
 * und Java Application Server (JAS). */
import js_base.connections.*;
/**
 * 
 * @author name[at]company
 * @date 20xx-xx-xx
 *
 * @description
 *  Klasse für das Start-Frame (auch als CommandCenter bezeichnet)
 *  für die Anwendung (Application) XXXXXXXXXXXXXXXXXXXXXXXXXXXXXX.
 *
 *  Die Anwendung bietet folgende Möglichkeiten:
 *  XXXXXXXXXXXXXXXXXXXXXXXXXXXXXX.
 * 
 * @change-log
 * when          who                       why
 * -----------------------------------------------------------------
 * 
 */
public class application_CommandCenter extends JSBS_StartFrame {
/*
 * Klasse, die die Verbindung zu EJB herstellt.
 * Entfernen Sie den Kommentar wenn Sie das Anwendungsprogramm als
 * Client-Server-Version entwickeln.
 * Eine weitere Adaptierung (entfernung des Kommentars) bei einer CS-Version
 * ist in der Methode 'initialize_after_frame' notwendig. */
//    public application_CommandCenter__JASConnections
//               structapplication_CommandCenter__JASConnections;
/*
 * CONSTRUCTOR der Klasse.
 * Code darin wird aufgerufen wenn ein Objekt dieser Klasse erstellt wird. */
    public application_CommandCenter(String parmstrLanguageCode) {
/* 
 * Aufrufen des Constructors der geerbten Klasse;
 * Dort werden die Standard-Initialisierungen ausgeführt. */
      super();
/* 
 * Aufrufen der Methoden mit den individuellen Initialisierungen für diese Klasse. */
      initialize_before_frame(parmstrLanguageCode);
      initialize_frame();
      initialize_after_frame();
    }
/* 
 * METHODE mit den Initialisierungen die notwendig sind bevor das Frame (Window)
 * angezeigt wird. */
    private void initialize_before_frame(String parmstrLanguageCode) {
/* 
 * Festlegen mit welcher Art von Datenzugriff das Programm arbeitet.
 * Die Variable und die Konstanten sind in der geerbten Basisklasse (JSBS_StartFrame)
 * definiert. */
/*
 * Bitte versehen Sie die nicht verwendeten Möglichkeiten mit einem 'Kommentar' (//). */
      RunVersion = CONST_StandAlone;
//    RunVersion = CONST_FatClient;
//    RunVersion = CONST_MobileClient;
/* 
 * Initialisieren der Struktur mit den Parametern, die für die gesamte Applikation
 * (inklusive der Task-Frames) gelten.
 * Diese Struktur ist in der geerbten Klasse (JSBS_StartFrame) definiert. */
      structJSBS_UniversalParameters =
                 new JSBS_UniversalParameters(parmstrLanguageCode);
/* 
 * Wenn Sie die Farben (bei korrekter und fehlerhafter Eingabe) für den Hintergrund von Eingabefeldern
 * ändern wollen, kommentieren Sie bitte die folgenden Zeile aus und adaptieren die Farbe. */
//      structJSBS_UniversalParameters.clrNormalBackground = new java.awt.Color(200, 255, 200);
//      structJSBS_UniversalParameters.clrErrorBackground = new java.awt.Color(255, 200, 255);
/* 
 * 'Construct' der XML-Struktur mit den sprachabhängigen Texten für GUI-Elemente.
 * Im Constructor wird die XML-Struktur aus der Datei 'DisplayStrings.xml'
 * im Verzeichnis 'TEXT.ls' gelesen wobei 'ls' der ISO-Code der gewählten Sprache
 * (wurde als Parameter der Methode 'main' übergeben) ist. */
      structJSBS_XML_DisplayStrings =
                 new JSBS_XML_DisplayStrings(this);
/* 
 * Prüfen ob die XML-Struktur fehlerfrei gelesen werden konnte. */
      if (structJSBS_XML_DisplayStrings.StatusCode != JSBS_XML_Constants.CONST_OK) {
/* Fehler beim Einlesen der XML-Struktur; Fehlermeldung und Status-Code auf der Konsole ausgeben.
 * Eine Beschreibung des Fehler-Codes ist in der Interface JSBS_XML_Constants zu finden. */
        System.out.println("Error while building 'structJSBS_XML_DisplayStrings'; StatusCode: " +
                           Integer.toString(structJSBS_XML_DisplayStrings.StatusCode));
      }
/* 
 * 'Construct' der XML-Struktur mit den Tasks (Geschäftsanwendungen).
 * Im Constructor wird die XML-Struktur aus der Datei 'Tasks.xml'
 * im Verzeichnis 'TEXT.ls' gelesen wobei 'ls' der ISO-Code der gewählten Sprache
 * (als Parameter der Methode 'main' mitgegeben) ist. */
      structJSBS_XML_Tasks =
                 new JSBS_XML_Tasks(this);
/* 
 * Prüfen ob die XML-Struktur fehlerfrei gelesen werden konnte. */
      if (structJSBS_XML_Tasks.StatusCode != JSBS_XML_Constants.CONST_OK) {
/* Fehler beim Einlesen der XML-Struktur; Fehlermeldung und Status-Code auf der Konsole ausgeben.
 * Eine Beschreibung des Fehler-Codes ist in der Interface JSBS_XML_Constants zu finden. */
        System.out.println("Error while building 'structJSBS_XML_Tasks'; StatusCode: " +
                           Integer.toString(structJSBS_XML_Tasks.StatusCode));
      }
      else {
/* XML-Struktur ohne Fehler eingelesen; Methode zum 'bauen' eines JTree mit der
 * Task-Hierarchie aufrufen und den JTree auf das GUI-Element übertragen. */
        tree_SelectableTasks = structJSBS_XML_Tasks.getTaskTree();
      }
    }
/* 
 * METHODE mit der das Frame (Window) angezeigt wird. */
    private void initialize_frame() {
/* Frame (Window) sichtbar machen (anzeigen). */
      setVisible(true);
/* Anfangsgröße festlegen. */
      setSize(800, 600);
/* Grund-Panel mit den weiteren GUI-Elementen anzeigen.
 * Die GUI-Elemente und deren Anordnung sind in der geerbten Klasse
 * (JSBS_StartFrame) festgelegt. */
      setContentPane(get_pnl_Main());
/* 
 * Wenn in Ihrer Anwendung die Auswahl von Währungen möglich sein soll,
 * dann kommentieren Sie bitte die folgende Zeile aus und setzen die
 * Zeile oberhalb unter Kommentar. */
//      setContentPane(get_pnl_Main_With_Currency_Selection());
    }
/* 
 * METHODE mit den Initialisierungen die notwendig sind nachdem das Frame (Window)
 * angezeigt wird. */
    private void initialize_after_frame() {
/* 
 * 'Construct' der XML-Struktur mit der Zuordnung der Funktionstasten zu den Buttons
 * (Schaltflächen).
 * Im Constructor wird die XML-Struktur aus der Datei 'FunctionKeys.xml'
 * im Verzeichnis 'TEXT.ls' gelesen wobei 'ls' der ISO-Code der gewählten Sprache
 * (als Parameter der Methode 'main' mitgegeben) ist. */
      structJSBS_XML_FunctionKeys =
                 new JSBS_XML_FunctionKeys(this);
/* 
 * Prüfen ob die XML-Struktur fehlerfrei gelesen werden konnte. */
      if (structJSBS_XML_FunctionKeys.StatusCode != JSBS_XML_Constants.CONST_OK) {
/* Fehler beim Einlesen der XML-Struktur.
 * Nachdem die GUI bereits initialisiert ist wird die Graphische Warnungs- und Fehleranzeige
 * benutzt. */
           handleErrorEvent(this.getClass().getName(), "construct_JSBS_XML_FunctionKeys",
                 (new Integer(structJSBS_XML_FunctionKeys.StatusCode)).toString());
/* Über die Methode 'handleErrorEvent' wird das Programm auch beendet. */
      }
/* 
 * Methode aufrufen mit der alle (in der Datei 'DisplayStrings.xml' definierten)
 * GUI-Elemente mit Text, Font und ToolTipText versehen werden. */
      JSBS_GUIServices.processLanguageDependantElements(this);
/* 
 * Abfragen mit welcher Art von Datenzugriff das Programm arbeitet.
 * Für das Tutorial wird der direkte Zugriff auf die Datenbank verwendet.
 * Um den Code als Beispiel für später verwenden zu können wird trotzdem
 * mit der Abfrage der Datenzugriffs-Version gearbeitet – allerdings bleibt
 * der Teil für den Datenzugriff über eine Java Application Server noch ohne Code. */
      if ((RunVersion == CONST_StandAlone) || (RunVersion == CONST_MobileClient)) {
/* Direkter Zugriff auf die Datenbank notwendig: Connection-Manager konstruieren.
 * Dabei werden die Parameter für den Datenbankzugriff aus der Datei 'Connections.xml'
 * gelesen. */
        structJSBS_DB_ConnectionManager =
            new JSBS_DB_ConnectionManager(this);
/* Prüfen ob die Verbindung zur Datenbank fehlerfrei hergestellt werden konnte. */
        if (structJSBS_DB_ConnectionManager.StatusCode != JSBS_XML_Constants.CONST_OK) {
/* Fehler beim Verbinden zur Datenbank.
 * Nachdem die GUI bereits initialisiert ist wird die Graphische Warnungs- und Fehleranzeige
 * benutzt. */
           handleErrorEvent(this.getClass().getName(), "construct_JSBS_DB_ConnectionManager",
                 (new Integer(structJSBS_DB_ConnectionManager.StatusCode)).toString(),
                 structJSBS_DB_ConnectionManager.StatusMsg);
/* Über die Methode 'handleErrorEvent' wird das Programm auch beendet. */
        }
      }
      if ((RunVersion == CONST_FatClient) || (RunVersion == CONST_MobileClient)) {
/* Datenzugriff über JAS (Java Application Server) notwendig:
 * 'konstruieren' der Klasse mit der/den Verbindung/en zu EJB. */
//        structapplication_CommandCenter__JASConnections =
//          new application_CommandCenter__JASConnections(this);
/* Abhängig vom Design des Anwendungsprogramms kann es auch sinnvoll sein, gleich
 * Methoden des EJB auszuführen. Die Aufrufe dafür können anschließend eingefügt werden. */
      }
/* 
 * Im Modus 'MobileClient wird der Thread gestartet, der periodisch prüft ob die
 * Verbindung zum JAS (Java Application Server) noch aufrecht ist. */
      if (RunVersion == CONST_MobileClient) {
/* Nebenläufigen Prozess (Thread) starten.
 * Der zweite Parameter-Wert ist die Pause zwischen den Prüfungen; im Beispiel 120 Sekunden. */
          JSBS_StartFrame__JASMonitor_Thread threadJASMonitor =
              new JSBS_StartFrame__JASMonitor_Thread(this, 120);
          threadJASMonitor.start();
      }
/*
 * Mouse-Listener zu den Listen mit den wählbaren Geschäftsanwendungen und den
 * geöffneten Geschäftsanwendungen hinzufügen.
 * Damit wird bei einem Mausklick auf eine Auswahlmöglichkeit die entsprechende
 * Methode in den Basisklassen aufgerufen und der Code der wählbaren Geschäftsanwendung
 * oder die Nummer der geöffneten Geschäftsanwendung auf das JTextField für die
 * Auswahl (txt_Code) übertragen. */
      get_tree_SelectableTasks().addMouseListener(this);
      get_pnl_OpenTasksTable().addMouseListener(this);
/*
 * DocumentListener (Klasse aus den Basisklassen) 'konstruieren'. */
      structJSBS_StartFrame__DocumentListener = new JSBS_StartFrame__DocumentListener(this);
/*
 * Verschiedene 'Listener's zu den GUI-Elementen hinzufügen
 * Dazu wird die rekursive Methode der Basisklasse verwendet. */
      addListeners(this, structJSBS_StartFrame__DocumentListener);
/*
 * Border (Ränder der GUI-Elemente) einfärben damit sie besser sichtbar sind. */
/* Zuerst jenes Elemente vom Typ JPanel festlegen, das eingefärbt werden soll. */
      arrayJPanelBordersToBeColored = new JPanel[1];
      arrayJPanelBordersToBeColored[0] = get_pnl_Main();
/* 
 * Wenn in Ihrer Anwendung die Auswahl von Währungen möglich sein soll,
 * dann kommentieren Sie bitte die folgende Zeile aus und setzen die
 * Zeile oberhalb unter Kommentar. */
//      arrayJPanelBordersToBeColored[0] = get_pnl_Main_With_Currency_Selection();
/* Methode aufrufen mit der die 'Border' eingefärbt werden. */
      JSBS_GUIServices.processBorders(this);
/*
 * Methode zur Definition einer Schaltfläche als 'Default-Button'.
 * Mit der Enter-Taste (Keyboard) wird auf diesen Button ein 'Klick' ausgelöst. */
      setEnterTriggeredButton(get_btn_Continue());
/*
 * Setzen des Focus auf das Feld für die Eingabe des Auswahl-Codes für einen Task.
 * Damit wird dem Benutzer sofort ermöglicht, eine Auswahl einzugeben. */
      get_txt_Code().requestFocusInWindow();
/*
 * Deaktivieren (disable) der Schaltfläche [ Weiter ]. Diese Anweisung ist notwendig weil
 * nach dem Aufruf des Programms alle Schaltflächen (Buttons) aktiviert (enabled) sind
 * und eine Prüfung erst nach Eingabe eines Auswahl-Codes erfolgend würde. */
      structJSBS_StartFrame__DocumentListener.setButtonStatus();
/*
 * Methode aufrufen, die die Größe und Position des Fensters beim letzten Schließen
 * wieder herstellen.
 * Die dafür notwendige Datenstruktur und die aufgerufene Methode ist in der
 * geerbten Basisklasse codiert. */
      setFramePosition();
/*
 * Methode aufrufen, die die Combobox für die Auswahl der Währung füllt.
 * Wenn in Ihrer Anwendung die Auswahl von Währungen möglich sein soll,
 * dann kommentieren Sie bitte die folgende Zeile aus . */
//      fillComboBoxWithCurrencies(get_combo_CurrencySelection());
    }
/*
 * Methode main(); diese macht diese Klasse 'startbar'.
 * Diese Methode wird aufgerufen wenn ein Objekt dieser Klasse vom Java-Runtime-Environment
 * als 'Start-Klasse' aufgeruffen wird. */
    public static void main(String[] args) {
/*
 * Übernehmen des Wertes der als Parameter beim Start der Klasse mitgeliefert wurde. */
      String locstrLanguageCode = "";
      if (args.length > 0) locstrLanguageCode = args[0];
      try {
/*
 * 'Construct' eines Objekts dieser Klasse;
 * damit wird der übrige Code dieser Klasse ausgeführt. */
        application_CommandCenter aapplication_CommandCenter =
             new application_CommandCenter(locstrLanguageCode);
      }
      catch (Throwable Exc) {
/* Unerwarteter Fehler beim 'Construct' des Objekts; Fehlermeldung ausgeben. */
        System.out.println("Fehler beim 'construct' der Klasse 'application_CommandCenter'.");
        Exc.printStackTrace();
      }
    }
/*
 * METHODE die ausgeführt wird wenn ein Klick mit einer Maustaste
 * auf ein GUI-Element, dem der ActionListener hinzugefügt wurde, erfolgt. */
    public void actionPerformed(ActionEvent e) {
/*
 * Gleichnamige Methode in der geerbten Basisklasse aufrufen.
 * Damit werden die 'geerbten' Verarbeitungen (die für alle Anwendungsprogramme
 * gleich sein können) zuerst ausgeführt. */
      super.actionPerformed(e);
/*
 * Weitere Verarbeitung in einer eigenen Klasse mit statischen Methoden. */
      application_CommandCenter__ActionHandler.handleEvent(this, e);
    }
}

▲ zum Inhaltsverzeichnis

Muster-Code für die Klasse für den ActionHandler

Welche Platzhalter durch Bezeichnungen des eigentlichen Projektes zu ersetzen sind finden Sie im Abschnitt
Anleitung zur Adaptierung in allen Klassen und
Anleitung zur Adaptierung in der Klasse für den ActionHandler.

package application_package.client;
 
import java.awt.event.*;
/**
 * 
 * @author name[at]company
 * @date 20xx-xx-xx
 *
 * @description
 *  Klasse mit statischen Methoden die ausgeführt werden wenn ein 'event'
 *  (z.B. der Klick einer Maustaste auf eine Schaltfläche) aufgetreten ist.
 *  Detail-Dokumentation finden Sie bei den einzelnen Methoden.
 *
 * @change-log
 * when         who               why
 * --------------------------------------------------------
 *
 */
public class application_CommandCenter__ActionHandler {
/*
 * Methode die ermittelt, bei welchem GUI-Element ein 'ActionEvent' ausgelöst wurde
 * und die entsprechende Methode aufruft. */
    public static void handleEvent(application_CommandCenter parmCC,
                                   ActionEvent parmActionEvent) {
/* Zuerst wird die 'Identifikation' des GUI-Element aus dem ActionEvent extrahiert. */
      String cmd = parmActionEvent.getActionCommand().trim();
/* In diesem Stadium des Tutorials wird nur auf Anklicken der Schaltfläche
 * btn_Continue reagiert. */
      if(cmd.equals("btn_Continue")) {
/* Die Prüfung, welcher Code gewählt wurde erfolgt in einer eigenen Methode. */
        openBusinessTask(parmCC);
      }
    }
/*
 * Methode zum Auslesen des gewählten Codes und Aufrufen der Geschäftsanenwendung.
 * Einschränkungen in diesem Stadium des Tutorial:
 * * Es wird nur der Code einer 'wählbaren' Anwendung verarbeitet
 *   (es können noch keine Geschäftsanwendungen geöffnet sein).
 * * Es kann noch keine Anwendung gestartet werden – stattdessen wird der interne Code
 *   auf der Konsole ausgegeben.
 *   (Die Geschäftsanwendung wird erst im nächsten Schritt programmiert.) */
    public static void openBusinessTask(application_CommandCenter parmCC) {
/* 
 * Methode der Basisklassen verwenden um den Internen Code der gewählten Anwendung
 * zu ermitteln. */
      String strInternalCode =
          parmCC.structJSBS_XML_Tasks.processParameterFields(
              parmCC.get_txt_Code(),
              parmCC.get_lbl_Parameter1(), parmCC.get_txt_Parameter1(),
              parmCC.get_lbl_Parameter2(), parmCC.get_txt_Parameter2(),
              parmCC.get_lbl_Parameter3(), parmCC.get_txt_Parameter3());
/* 
 * Ab hier kommt der Programm-Code mit dem entsprechend dem 'strInternalCode'
 * die zugehörige Geschäftsanwendung gestartet wird.
 * Der Muster-Code für das Aufrufen einer Geschäftsanwendung (Business Task)
 * muss für jede weitere individuelle Geschäftsanwendung kopiert werden.
 * In der Kopie muss der interne Code und die aufzurufende Klasse adaptiert werden. */
      if (strInternalCode.equals("XX")) {
/* 
 * 'Konstruieren' des Objekts für die GUI der individuellen Geschäftsanwendung. */
       application_task frmapplication_task =
          new application_task(parmCC);
/* 
 * Anzeigen der GUI für die individuelle Geschäftsanwendung. */
       frmapplication_task.setVisible(true);
/* ***** */ 
     }
   }
}

▲ zum Inhaltsverzeichnis

Muster-Code für die Klasse für die Verbindung zu EJB

Welche Platzhalter durch Bezeichnungen des eigentlichen Projektes zu ersetzen sind finden Sie im Abschnitt
Anleitung zur Adaptierung in allen Klassen und
Anleitung zur Adaptierung in der Klasse für die Verbindung zu EJB.

package application_package.client;
/*
 * Package mit Basisklassen, die in dieser Klasse verwendet werden. */
import js_base.frame.*;
/*
 * Package und Remote-Interface für das Standard-EJB. */
import application_package.ejb.interfaces.remote.application_StandardBeanRemote ;
/*
 * Package und Klasse für Properties (Eigenschaften).
 * Diese 'Eigenschaften' definieren, zu welchem JAS die Verbindung hergestellt wird. */
import java.util.Properties;
/*
 * Package mit universellem und speziellem Context.
 * Im 'Context' ist die Verbindung zu einem JAS definiert und über den 'Context' kann eine
 * Verbindung zu einem EJB (das im spezifiziertem JAS 'läuft') hergestellt werden. */
import javax.naming.Context;
import javax.naming.InitialContext;
/*
 * Package und Klasse zum Einlesen der XML-Struktur, die die 'Properties' für die Verbindung zum JAS enthält. */
import js_base.xml.JSBS_XML_Connections;
/**
 * 
 * @author name[at]company
 * @date 20xx-xx-xx
 *
 * @description
 *  Klasse mit den Methoden zur Herstellung von Verbindungen zu EJB.
 *  Der Algorithmus der einzelnen Methoden ist im Kommentar zum Code beschrieben.
 *
 * @change-log
 * when         who               why
 * --------------------------------------------------------
 *
 */
public class application_CommandCenter__JASConnections extends JSBS_StartFrame__JASConnections {
/*
 * CONSTRUCTOR
 * --------------------
 * */
    public application_CommandCenter__JASConnections(JSBS_StartFrame parmCC) {
/*
 * Constructor der geerbten Basisklasse aufrufen.
 * Dort wird das Start-Frame, das dieses Objekt konstruiert hat (und als Parameter übergeben
 * wird), in die dafür vorgesehene Variable übernommen. */
      super (parmCC);
    }
/*
 * --------------------
 * METHODE zum Erstellen einer Verbindung zum Standard-EJB.
 * */
    public application_StandardBeanRemote get_application_StandardBeanRemote() {
/*
 * Prüfen ob bereits ein Initial-Context erstellt wurde.
 * Diese Variable ist in der geerbten Basisklasse definiert und enthält die Werte für eine Verbindung
 * zum JAS.
 * Wenn noch kein Context existiert, dann die Methode zum Erstellen (in der Basisklasse) aufrufen. */
      if (initialStandardContext == null) establishStandardInitialContext();
/*
 * Noch einmal prüfen ob der Initial-Context jetzt existiert; Methode beenden wenn nicht.
 * Die Fehlerbehandlung muss dann in der BOC-Klassedie diese Methode aufgerufen hat, erfolgen. */
      if (initialStandardContext == null) return null;
/*
 * Prüfen ob in der Konfigurationsdatei ('Connections.xml') ein JNDI-Name für das Standard-EJB
 * vorhanden ist. Dieser Wert wurde ebenfalls in der Methode 'establishStandarInitialContext()'
 * - implementiert in der geerbten Basisklasse – aus der Konfigurationsdatei ausgelesen.
 * Wenn dieser Wert nicht vorhanden ist, dann liegt ein permanentes Problem vor. */
      if (strStandardEJB_JNDI_Name == null) return null;
/*
 * In der folgenden try/catch-Logik wird die Verbindung zum Standard-EJB hergestellt. */
      try {
/*
 * Definieren der Interface des EJB die von dieser Methode zurück geliefert wird. */
        application_StandardBeanRemote remote_application_StandardBean;
/*
 * Verbinden zum EJB, das auf dem JAS (Java Application Server) läuft.
 * Die Werte für die Verbindungsdaten zum JAS sind in 'initialStandardContext' festgelegt; 
 * Der Wert für den 'JNDI-Name' unter dem das EJB auf dem JAS registriert ist, ist in
 * 'strStandardEJB_JNDI_Name' enthalten. Beide Variablen sind in der geerbten Basisklasse definiert. */
        remote_application_StandardBean = (application_StandardBeanRemote)
          initialStandardContext.lookup(strStandardEJB_JNDI_Name);
/*
 * Wenn das Programm diesen Punkt erreicht wurde die Verbindung zum EJB erstellt.
 * Remote-Interface zurück liefern. */
        return remote_application_StandardBean;
      }
      catch (Exception e) {
/*
 * Wenn die Verbindung zum EJB nicht hergestellt werden konnte dann muss die Fehlerbehandlung in der
 * BOC-Klasse, die diese Methode aufgerufen hat, erfolgen.
 * Nur in der BOC-Klasse kann entschieden werden, ob es ein schwerwiegender Fehler ist oder
 * ob bei einer Konfiguration des Anwendungsprogramms als 'Mobile Client' auf die lokale Datenbank
 * zugegriffen werden kann. */
        return null;
      }
    }
}

▲ 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 'Platzhalter', die nur einmalig im Muster-Code vorkommen ist die 'Find'-Funktion ist hilfreich zum Finden der beschriebenen 'Platzhalter'.

▲ zum Inhaltsverzeichnis

Änderung des Namens des Java-Packages

package application_package.client;
/*

Dieser Name kommt jeweils einmal in jeder Klasse vor.

▲ zum Inhaltsverzeichnis

Änderung des Namens der Klassen

Empfohlen ist das Verwenden der 'Search/Replace' Funktion.
Die 'Platzhalter' kommen mehrmals in allen Klassen vor.

Hier ein Beispiel für das 'CommandCenter':
*/
public class application_CommandCenter extends JSBS_StartFrame {
/*

Dieser Name muss mit dem Namen der Klasse übereinstimmen, der beim Eröffnen der Klasse gewählt wurde.
Durch das Ersetzen des Platzhalters application_CommandCenter durch den Namen der Klasse für das Frame (z.B. GroceryList_CommandCenter) kann in allen Klassen der jeweils richtige Namen eingesetzt werden.
Durch die gewählte Namens-Konvention in den Muster-Codes werden dadurch auch die Referenzen auf verbundene Klassen richtig gestellt.

▲ zum Inhaltsverzeichnis

Adaptieren der Kommentare

'Kein Kommentar ist besser als ein falscher'.

Aus diesem Grund ist in den Klassen für den 'ActionHandler' und den 'DocumentListener' auch nur ein Kommentar enthalten, der die Aufgabe der Klasse allgemein beschreibt und für die geschäfts-spezifischen Aufgaben auf die Klasse für das Frame verweist.

Meiner Erfahrung nach ist eine kurze Beschreibung der geschäfts-spezifischen Aufgaben in der Klasse für das Frame ausreichend.

▲ zum Inhaltsverzeichnis

Anleitung zur Adaptierung bei Verwendung von Währungen in der Klasse für die GUI 

Adaptieren in der Methode initialize_frame

In dieser Methode wird für das 'ContentPane' das bereits in der geerbten Basisklasse enthaltene pnl_Main_With_Currency_Selection verwendet.

Dazu wird im Muster-Code die entsprechende Zeile auskommentiert – und die davor stehende Zeile gelöscht oder unter 'Kommentar' gesetzt:


/* 
 * METHODE mit der das Frame (Window) angezeigt wird. */
. . . . .
 * (JSBS_StartFrame) festgelegt. */
//      setContentPane(get_pnl_Main());
/* 
 * Wenn in Ihrer Anwendung die Auswahl von Währungen möglich sein soll,
 * dann kommentieren Sie bitte die folgende Zeile aus und setzen die
 * Zeile oberhalb unter Kommentar. */
//      setContentPane(get_pnl_Main_With_Currency_Selection());
    }

▲ zum Inhaltsverzeichnis

Adaptieren in der Methode initialize_after_frame

In dieser Methode sind zwei Änderungen notwendig:

• Für das Einfärben der Ränder muss ebenfalls - das in der geerbten Basisklasse enthaltene - pnl_Main_With_Currency_Selection in das Array mit den einzufärbenden GUI-Elementen aufgenommen werden:

/*
 * Border (Ränder der GUI-Elemente) einfärben damit sie besser sichtbar sind. */
/* Zuerst jenes Elemente vom Typ JPanel festlegen, das eingefärbt werden soll. */
      arrayJPanelBordersToBeColored = new JPanel[1];
      arrayJPanelBordersToBeColored[0] = get_pnl_Main();
/* 
 * Wenn in Ihrer Anwendung die Auswahl von Währungen möglich sein soll,
 * dann kommentieren Sie bitte die folgende Zeile aus und setzen die
 * Zeile oberhalb unter Kommentar. */
//      arrayJPanelBordersToBeColored[0] = get_pnl_Main_With_Currency_Selection();
/* Methode aufrufen mit der die 'Border' eingefärbt werden. */
      JSBS_GUIServices.processBorders(this);

• Die Combobox für die Auswahl der Währung muss mit den festgelegten Währungen gefüllt werden:

 * Die dafür notwendige Datenstruktur und die aufgerufene Methode ist in der
 * geerbten Basisklasse codiert. */
      setFramePosition();
/*
 * Methode aufrufen, die die Combobox für die Auswahl der Währung füllt.
 * Wenn in Ihrer Anwendung die Auswahl von Währungen möglich sein soll,
 * dann kommentieren Sie bitte die folgende Zeile aus . */
//      fillComboBoxWithCurrencies(get_combo_CurrencySelection());
    }

▲ zum Inhaltsverzeichnis

Anleitung zur Adaptierung bei Festlegung von erlaubten Sprachen in der Klasse für die GUI 

Wenn das Anwendungsprogramm in mehreren Sprachen verfügbar sein soll, dann kann das Array arrayApplicationImplementedLanguages der Basisklasse JSBS_StartFrame überschrieben werden.
Die Festlegung der Sprachen in diesem Array kann z.B. verwendet werden, damit Mitarbeiter ihre bevorzugte Sprache auswählen können. Voraussetzung dafür ist aber, dass die Texte der GUI auch in die entsprechende Sprache übersetzt sind.
Ein Muster für die Verwaltung von Sprachen finden Sie im Dokument (Dokument mit dem Muster für die Vererbung von JSBS_Language noch zu schreiben).

• Das Überschreiben des Arrays wird sofort nach der Definition der Klasse eingefügt:
. . . . .
 */
public class application_CommandCenter extends JSBS_StartFrame {
/* 
 * Definition der im Anwendungsprogramm erlaubten Sprachen durch Überschreiben
 * der Variablen in der geerbten Basisklasse. */
    public String[] arrayApplicationImplementedLanguages = {"de", "en", "fr", "it", "es", "cz", "sk", "hu", "si"};
/*/
 * Klasse, die die Verbindung zum JAS herstellt.
. . . . .

▲ zum Inhaltsverzeichnis

Anleitung zur Adaptierung in der Klasse für den ActionHandler 

In der Klasse für den ActionHandler ist ein Muster-Code für den Aufruf eines 'Task', das ist ein Fenster für ein geschäfts-spezifisches Teilprogramm, enthalten.

Wenn Sie die Warnung des Compilers nicht stört, können Sie die – derzeit ungültigen – Platzhalter belassen.

Wenn Sie die Fehlermeldung stört dann versehen Sie die folgenden 3 Zeilen mit einem Kommentar:
/* 
 * 'Konstruieren' des Objekts für die GUI der individuellen Geschäftsanwendung. */
//       application_task frmapplication_task =
//          new application_task(parmCC);
/* 
 * Anzeigen der GUI für die individuelle Geschäftsanwendung. */
//       frmapplication_task.setVisible(true);
/* ***** */ 

▲ zum Inhaltsverzeichnis

Anleitung zur Adaptierung in der Klasse für die Verbindung zum EJB 

Import der Klasse für das EJB

Damit der Java-Compiler keinen Fehler meldet muss als Vorbedingung die Klasse für das Standard-EJB erstellt sein.
Den Leitfaden dazu 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.
Den Muster-Code mit ausführlichen Anleitungen finden Sie unter Muster-Codes für die Klasse eines EJB (Enterprise Java Bean) mit Datenbankzugriff.
Zum jetzigen Zeitpunkt reicht es aus, die Klasse und die Interfaces für das Standard-EJB ohne Methoden für die Verwendung der BOS- (Business Object, Server-Side) Klassen zu implementieren.

Der Import des Packages erfolgt gleich unterhalb dem Import für die Basiklasse für die 'JAS-Connection':
package application_package.client;
/*
 * Package mit Basisklassen, die in dieser Klasse verwendet werden. */
import js_base.frame.*;
/*
 * Package und Remote-Interface für das Standard-EJB. */
import application_package.ejb.interfaces.remote.application_StandardBeanRemote ;
/*
 * Package und Klasse für Properties (Eigenschaften).
 * Diese 'Eigenschaften' definieren, zu welchem JAS die Verbindung hergestellt wird. */
import java.util.Properties;

▲ zum Inhaltsverzeichnis

Änderung des Namens des verwendeten Standard-Bean

Empfohlen ist das Verwenden der 'Search/Replace' Funktion.
Als 'Platzhalter' wird verwendet:
/*
 * --------------------
 * METHODE zum Erstellen einer Verbindung zum Standard-EJB.
 * */
    public application_StandardBeanRemote get_application_StandardBeanRemote() {
/*
 * Prüfen ob bereits ein Initial-Context erstellt wurde.
 * Diese Variable ist in der geerbten Basisklasse definiert und enthält die Werte für eine Verbindung

Der ersetzte Name muss mit dem Namen der Klasse für das Standard-EJB übereinstimmen.

▲ zum Inhaltsverzeichnis

Adaptierungen bei Verwendung von High-Volume EJB sind noch zu schreiben (KG, 19.10.2009).

▲ zum Inhaltsverzeichnis

Weitere Schritte und verwandte Dokumentation

▲ zum Inhaltsverzeichnis