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

In diesem Dokument wird die Klasse mit den Methoden für die Verarbeitung eines Business-Object (BO) auf der Client-Seite einer Geschäftsanwendung implementiert.
Diese Klasse wird allgemein als BOC (Business-Object-Client) bezeichnet.
Sie transferiert die Werte aus den Variablen des BO von/zu GUI-Elementen für die Anzeige und steuert das selektieren und speichern von Daten durch den Aufruf von Methoden eines Objektes der zugeordneten Server-Side Klasse.

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

Inhaltsverzeichnis:

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

Vorbemerkung 
Vorbedingungen 
BOC-Klasse eröffnen 
Code für die BOC-Klasse 
* Von Basisklasse erben 
* Importieren der Bibliotheken 
* Variablen der Klasse 
* Constructor-Methode 
* Methoden zum 'Setzen' und 'Holen' der Werte der GUI 
* Methoden zum Speichern und Selektieren der Daten 
Gesamter Code am Ende des Schrittes 
Klasse JS_ProjAssist_ProjectLanguage_BOC 
Weitere Schritte und verwandte Dokumentation 

Nächster Schritt: Daten erfassen und speichern 

Vorbemerkung

▲ zum Inhaltsverzeichnis

Vorbedingungen:

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

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

▲ zum Inhaltsverzeichnis

BOC-Klasse eröffnen

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

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

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

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

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

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

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

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

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

▲ zum Inhaltsverzeichnis

Code für die BOC-Klasse

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

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

▲ zum Inhaltsverzeichnis

Von Basisklasse erben

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

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

▲ zum Inhaltsverzeichnis

Importieren der Bibliotheken

package js_projassist.boc;
/*
 * Package mit der Bibliothek der GUI-Elemente. */
import javax.swing.*;
/*
 * Package mit der Basisklasse für Start- und Task-Frame. */
import js_base.frame.*;
/*
 * Packages mit den zugehörigen Klassen (Generelle Klasse und Server-Side-Klasse) dieses BO. */
import js_projassist.bo.JS_ProjAssist_ProjectLanguage_BO;
import js_projassist.bos.JS_ProjAssist_ProjectLanguage_BOS;
/* */
public class JS_ProjAssist_ProjectLanguage_BOC extends JS_ProjAssist_ProjectLanguage_BO {

Die BOC-Klasse stellt die oberste Ebene des Zugriffs auf persistente Daten dar.
Zusätzlich werden in der BOC-Klasse die Werte aus den Variablen von bzw. zu GUI-Elementen übertragen.
Die verwendeten Klassen aus anderen Bibliotheken beschränken sich deswegen auf jene, mit denen GUI-Elemente und das Task-Frame eingebunden werden kann und die Bibliothek mit der Server-Side Klasse für das BO.

• import java.swing.*;
ist die mit Java ausgelieferte Bibliothek mit den Klassen für die Elemente der Graphischen Benutzeroberfläche (GUI / Graphic User Interface).

• import js_base.frame.*;
enthält die Variablen zur Steuerung, ob lokal (auf dem eigenen Rechner bzw. über das TCP/IP-Netzwerk) auf die Datenbank zugegriffen wird oder ob der EJB-Mechanismus verwendet wird um auf einen Java-Application-Server (JAS) das Speichern und Selektieren der Daten auszuführen.

Einen Überblick über die Mechanismen der Zugriffe auf die Datenbank finden Sie im Dokument Business-Object – Überblick über die Funktion zum Abfragen und Speichern von Daten > Wie werden Daten eines BO über das Netzwerk 'kopiert'.

• import js_projassist.bos.JS_ProjAssist_ProjectLanguage_BOS;
wird in diesem Tutorial verwendet, weil der Zugriff auf persistente Daten 'lokal' erfolgt und die BOC-Klasse direkt die Methoden der BOS-Klasse aufruft – und nicht über den EJB-Mechanismus (Enterprise Java Bean).

▲ zum Inhaltsverzeichnis

Variablen der Klasse

. . . . . . . .
. . . . . . . .
/* ---------------------
 * VARIABLE dieser Klasse.
 * ---------------------
 * Einzige Variable ist eine 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;
/* ---------------------
. . . . . . . .
. . . . . . . .

Neben den Geschäfts-spezifischen Variablen, die mit der Generellen Klasse für das BO geerbt wurden (siehe Tutorial: JavaScout ProjectAssist, Task-Frame Grundlagen (Java_Fatclient_01) – General BO (Business-Object) Klasse für 'ProjectLanguage' > Variablen der Klasse) wird nur eine Variable definiert, die die Referenz auf das Task-Frame enthält, die diese BOC-Klasse 'konstruiert' hat.
Im referenzierten Task-Frame ist festgelegt, ob der Zugriff auf die persistenten Daten 'lokal' ober über einen EJB-Mechanismus über den Java-Application-Server (JAS) erfolgen soll.

Für diesen Schritt des Tutorial ist der 'lokale' Zugriff beschrieben.

▲ zum Inhaltsverzeichnis

Constructor-Methode

. . . . . . . .
. . . . . . . .
    private JSBS_TaskFrame frmTask = null;
/* ---------------------
 * CONSTRUCTOR-METHODE */
/* ---------------------
 * Als Parameter des 'Constructors' ist das aufrufende Task-Frame erforderlich. */
    public JS_ProjAssist_ProjectLanguage_BOC(JSBS_TaskFrame parmfrmTask) {
/*
 * Das im Parameter übergebenen JSBS_TaskFrame wird in der Variablen dieser Klasse
 * 'aufgehoben'. */
      frmTask = parmfrmTask;
    }
/* ---------------------
. . . . . . . .
. . . . . . . .

Die Constructor-Methode dieser Klasse enthält nur Code zur Übernahme der Referenz auf das 'konstruierende' Task-Frame auf die Variable dieser Klasse.

▲ zum Inhaltsverzeichnis

Methoden zum 'Setzen' und 'Holen' der Werte der GUI

Diese Methoden übertragen die Werte von den Variablen dieses BO (die Variablen sind in der geerbten Generellen BO-Klasse definiert) auf GUI-Elemente bzw. umgekehrt.

Die Lösung wurde deswegen gewählt, um möglichst einheitlichen Code im BOC implementieren zu können und die Klassen des Task-Frames nicht mit dem Code für das Übertragen von Werten zwischen GUI-Elementen und BO zu 'belasten'.

In diesem Tutorial kommen nur GUI-Elemente mit Zeichenketten (Text) vor; wenn Zahlen oder andere Arten (z.B. der Inhalt einer Check-Box oder Auswahl einer Combo-Box) übertragen werden sollen, kann die entsprechende Methode der Klasse JSBS_GUIServices verwendet werden.
Schlimmstenfalls (bei Verwendung von Radio-Buttons) ist der Code individuell zu entwerfen.

. . . . . . . .
. . . . . . . .
/* ---------------------
 * 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 parmProjectCode,
                           JTextField parmLanguageCode,
                           JTextField parmTargetDirectory) {
/*
 * Prüfen ob überhaupt ein Wert übergeben wurde und dann Auslesen des Textes aus dem
 * jeweiligen GUI-Element. */
      if (parmProjectCode != null) {
        ProjectCode = JSBS_GUIServices.getTextFromJTextField(parmProjectCode);
      }
      if (parmLanguageCode != null) {
        LanguageCode = JSBS_GUIServices.getTextFromJTextField(parmLanguageCode);
      }
      if (parmTargetDirectory != null) {
        TargetDirectory = JSBS_GUIServices.getTextFromJTextField(parmTargetDirectory);
      }
    }
/* ---------------------
 * METHODE zum Übertragen der Werte aus den Variablen dieses BO in die GUI-Elemente,
 * die als Parameter übergeben werden. */
    public void setToGUI(JTextField parmProjectCode,
                         JTextField parmLanguageCode,
                         JTextField parmTargetDirectory) {
/*
 * Prüfen ob überhaupt ein Wert übergeben wurde und dann Übertragen des Wertes aus
 * der jeweiligen Variables dieses BO in da zugehörige GUI-Element. */
      if (parmProjectCode != null) {
        JSBS_GUIServices.setTextToJTextField(parmProjectCode, ProjectCode);
      }
      if (parmLanguageCode != null) {
        JSBS_GUIServices.setTextToJTextField(parmLanguageCode, LanguageCode);
      }
      if (parmTargetDirectory != null) {
        JSBS_GUIServices.setTextToJTextField(parmTargetDirectory, TargetDirectory);
      }
    }
/* ---------------------
. . . . . . . .
. . . . . . . .

▲ zum Inhaltsverzeichnis

Methoden zum Speichern und Selektieren der Daten

Diese Methoden folgen folgendem Schema:

• Entscheiden, ob der Zugriff 'lokal' oder über den EJB-Meachanismus erfolgt.
Für diesen Schritt des Tutorials wird nur ein 'lokaler' Zugriff implementiert.
/*
 * Entscheiden, ob diese Application als Einzelplatz-Version (StandAlone) oder
 * Client/Server-Version (FatClient) implementiert ist. */
      switch (frmTask.frmCC.RunVersion) {
      case JSBS_StartFrame.CONST_StandAlone:
/*

• Ein Server-Side Business-Object (BOS-Klasse) 'konstruieren'.
Dabei wird dieses BO als Parameter übergeben (this) und damit die zu speichernden Daten.
Anschließend wird beim gerade 'konstruierten' BOS die Methode store() aufgerufen und damit die Daten auf der Datenbank-Tabelle gespeichert.
/*
 * 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. */
        JS_ProjAssist_ProjectLanguage_BOS bosJS_ProjAssist_ProjectLanguage =
          new JS_ProjAssist_ProjectLanguage_BOS(frmTask.structMinParm,
                                                frmTask.frmCC.structJSBS_DB_ConnectionManager,
                                                this);
/*
 * Methode zum Speichern der Werte aufrufen. */
        bosJS_ProjAssist_ProjectLanguage.store();
/*

• Zuletzt werden die Daten aus dem BOS wieder in das BOC kopiert.
Bei einem Selektieren werden damit die gefundenen Daten aus dem BOS in das BOC kopiert.
Beim Speichern von Daten wird das 'Kopieren' ausgeführt, um den Status (Erwartete Ausführung oder Fehler) und die Werte für ObjectID und DataSetID im Anwendungsprogramm verfügbar zu haben.
Mit break wird die Verarbeitung innerhalb der switch-Struktur abgebrochen.
/*
 * 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. */
        copyFromJS_ProjAssist_ProjectLanguage_BO(bosJS_ProjAssist_ProjectLanguage);
      break;

Als gesamtes Beispiel ist nur die Methode store() gelistet; alle Methoden zum Selektieren von Daten folgen dem gleichen Schema.

. . . . . . . .
. . . . . . . .
/* ---------------------
 * METHODEN zum Aufrufen der Geschäfts-spezifischen Datenbank-Operationen.
 * Für dieses Tutorial wird nur jener Code impementiert, der den Server-Side-Teil des BO
 * direkt in diesem Client-Side-Teil verwendet.
 * 
 * Die Client/Server-Version mit der Verwendung von EJB (Enterprise Java Beans) auf einem
 * JAS (Java Application Server) folgt in einem späteren Schritt des Tutorials. */
/* ---------------------
 * METHODE zum Speichern der neu eingegebenen oder geänderten Variablen dieses BO. */
    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:
/*
 * 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. */
        JS_ProjAssist_ProjectLanguage_BOS bosJS_ProjAssist_ProjectLanguage =
          new JS_ProjAssist_ProjectLanguage_BOS(frmTask.structMinParm,
                                                frmTask.frmCC.structJSBS_DB_ConnectionManager,
                                                this);
/*
 * Methode zum Speichern der Werte aufrufen. */
        bosJS_ProjAssist_ProjectLanguage.store();
/*
 * 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. */
        copyFromJS_ProjAssist_ProjectLanguage_BO(bosJS_ProjAssist_ProjectLanguage);
      break;
/* */
      case JSBS_StartFrame.CONST_FatClient:
/*
 * Client-Server-Version mit Aufruf des EJB wird in einem späteren Schritt implementiert. */
      break;
      }
    }
. . . . . . . .
. . . . . . . .

▲ zum Inhaltsverzeichnis

Gesamter Code am Ende des Schrittes

Klasse JS_ProjAssist_ProjectLanguage_BOC

package js_projassist.boc;
/*
 * Package mit der Bibliothek der GUI-Elemente. */
import javax.swing.*;
/*
 * Package mit der Basisklasse für Start- und Task-Frame. */
import js_base.frame.*;
/*
 * Packages mit den zugehörigen Klassen (Generelle Klasse und Server-Side-Klasse) dieses BO. */
import js_projassist.bo.JS_ProjAssist_ProjectLanguage_BO;
import js_projassist.bos.JS_ProjAssist_ProjectLanguage_BOS;
/* */
public class JS_ProjAssist_ProjectLanguage_BOC extends JS_ProjAssist_ProjectLanguage_BO {
/* ---------------------
 * VARIABLE dieser Klasse.
 * ---------------------
 * Einzige Variable ist eine 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;
/* ---------------------
 * CONSTRUCTOR-METHODE */
/* ---------------------
 * Als Parameter des 'Constructors' ist das aufrufende Task-Frame erforderlich. */
    public JS_ProjAssist_ProjectLanguage_BOC(JSBS_TaskFrame parmfrmTask) {
/*
 * Das im Parameter übergebenen JSBS_TaskFrame wird in der Variablen dieser Klasse
 * 'aufgehoben'. */
      frmTask = parmfrmTask;
    }
/* ---------------------
 * 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 parmProjectCode,
                           JTextField parmLanguageCode,
                           JTextField parmTargetDirectory) {
/*
 * Prüfen ob überhaupt ein Wert übergeben wurde und dann Auslesen des Textes aus dem
 * jeweiligen GUI-Element. */
      if (parmProjectCode != null) {
        ProjectCode = JSBS_GUIServices.getTextFromJTextField(parmProjectCode);
      }
      if (parmLanguageCode != null) {
        LanguageCode = JSBS_GUIServices.getTextFromJTextField(parmLanguageCode);
      }
      if (parmTargetDirectory != null) {
        TargetDirectory = JSBS_GUIServices.getTextFromJTextField(parmTargetDirectory);
      }
    }
/* ---------------------
 * METHODE zum Übertragen der Werte aus den Variablen dieses BO in die GUI-Elemente,
 * die als Parameter übergeben werden. */
    public void setToGUI(JTextField parmProjectCode,
                         JTextField parmLanguageCode,
                         JTextField parmTargetDirectory) {
/*
 * Prüfen ob überhaupt ein Wert übergeben wurde und dann Übertragen des Wertes aus
 * der jeweiligen Variables dieses BO in da zugehörige GUI-Element. */
      if (parmProjectCode != null) {
        JSBS_GUIServices.setTextToJTextField(parmProjectCode, ProjectCode);
      }
      if (parmLanguageCode != null) {
        JSBS_GUIServices.setTextToJTextField(parmLanguageCode, LanguageCode);
      }
      if (parmTargetDirectory != null) {
        JSBS_GUIServices.setTextToJTextField(parmTargetDirectory, TargetDirectory);
      }
    }
/* ---------------------
 * METHODEN zum Aufrufen der Geschäfts-spezifischen Datenbank-Operationen.
 * Für dieses Tutorial wird nur jener Code impementiert, der den Server-Side-Teil des BO
 * direkt in diesem Client-Side-Teil verwendet.
 * 
 * Die Client/Server-Version mit der Verwendung von EJB (Enterprise Java Beans) auf einem
 * JAS (Java Application Server) folgt in einem späteren Schritt des Tutorials. */
/* ---------------------
 * METHODE zum Speichern der neu eingegebenen oder geänderten Variablen dieses BO. */
    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:
/*
 * 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. */
        JS_ProjAssist_ProjectLanguage_BOS bosJS_ProjAssist_ProjectLanguage =
          new JS_ProjAssist_ProjectLanguage_BOS(frmTask.structMinParm,
                                                frmTask.frmCC.structJSBS_DB_ConnectionManager,
                                                this);
/*
 * Methode zum Speichern der Werte aufrufen. */
        bosJS_ProjAssist_ProjectLanguage.store();
/*
 * 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. */
        copyFromJS_ProjAssist_ProjectLanguage_BO(bosJS_ProjAssist_ProjectLanguage);
      break;
/* */
      case JSBS_StartFrame.CONST_FatClient:
/*
 * Client-Server-Version mit Aufruf des EJB wird in einem späteren Schritt implementiert. */
      break;
      }
    }
/* ---------------------
 * METHODE zum Selektieren eines Bo mit dem Anwender-bekannten Schlüssel. */
    public void selectByUserKnownKey(String parmProjectCode,
                                     String parmLanguageCode ) {
/*
 * Entscheiden, ob diese Application als Einzelplatz-Version (StandAlone) oder
 * Client/Server-Version (FatClient) implementiert ist. */
      switch (frmTask.frmCC.RunVersion) {
      case JSBS_StartFrame.CONST_StandAlone:
/*
 * Einzelplatz-Version bzw. Datenbank-Zugriff über TCP/IP-Netzwerk.
 * Server-Side-BO 'konstruieren'. */
        JS_ProjAssist_ProjectLanguage_BOS bosJS_ProjAssist_ProjectLanguage =
          new JS_ProjAssist_ProjectLanguage_BOS(frmTask.structMinParm,
                                                frmTask.frmCC.structJSBS_DB_ConnectionManager);
/*
 * Methode zum Selektieren der Werte aufrufen. */
        bosJS_ProjAssist_ProjectLanguage.selectByUserKnownKey(parmProjectCode,
                                                              parmLanguageCode);
/*
 * Neue Werte des BOS wieder in dieses BOC übertragen.
 * Damit sind geschäfts-spezifiesche Attribute, Common-Attributes, Status-Code
 * und Status-Message in diesem BOC verfügbar. */
        copyFromJS_ProjAssist_ProjectLanguage_BO(bosJS_ProjAssist_ProjectLanguage);
      break;
/* */
      case JSBS_StartFrame.CONST_FatClient:
/*
 * Client-Server-Version mit Aufruf des EJB wird in einem späteren Schritt implementiert. */
      break;
      }
    }
}

▲ zum Inhaltsverzeichnis

Weitere Schritte und verwandte Dokumentation

▲ zum Inhaltsverzeichnis