> Inhalt: JavaScout-Fat-Client-Framework (JS-FCF) 

> Verzeichnis der Dokumente mit den Muster-Codes 

Muster-Codes für die Klasse eines EJB (Enterprise Java Bean) mit Datenbankzugriff

* Bitte beachten Sie die Hinweise und Bestimmungen bezüglich Urheberrecht, Haftungsausschluß und geschützte Marken oder Warenzeichen die für dieses Web-Dokument und möglicherweise auch für 'verlinkte' Dokumente gelten.

  • Der Betreiber dieser Web-Site (www.javascout.biz) ist nicht verantwortlich für den Inhalt von Web-Sites, die innerhalb dieses Web-Dokumentes oder anderer Dokumente von www.javascout.biz verlinkt sind.

  • Wenn dieses Web-Dokument oder andere Dokumente dieser Web-Site (www.javascout.biz) Rechte von Ihnen verletzen, oder sie glauben, dass Rechte Anderer (Dritter Personen) dadurch verletzt werden, informieren Sie bitte den Betreiber dieser Web-Site.
    Eine E-Mail können Sie ganz einfach durch anklicken des Symbols oder Textes im Frame rechts oben senden.

Dieses Dokument drucken.

 Letzte Bearbeitung dieses  Dokuments:
2012-03-18

Voraussetzungen für das Verständnis dieses Dokuments:

Grundkenntnisse der Struktur von Enterprise Java Beans und deren Verwendung.

Ungefährer Zeitbedarf zum Durcharbeiten dieses Dokuments:

Arbeitszeit:
Abhängig von der Anzahl der Methoden in der zu entwickelnden EJB-Klasse.
Mit einiger Routine sind ca. 15 Minuten für allgemeine Arbeiten (Eröffnen der Klasse) und ca. 10 Minuten pro Methode zu kalkulieren.

Dieses Dokument enthält Code-Muster für die Klasse eines Enterprise Java Bean (EJB).

EJB sind spezielle Klassen, die von einem Java Application Server (JAS) verwaltet werden.
Die Methoden in der EJB-Klasse können von Client-Programmen auf entfernten Computern aufgerufen werden.
Damit ist es einfach eine Client-Server Architektur für ein Anwendungsprogramm zu entwerfen und zu implementieren.

Inhaltsverzeichnis:

Vorbedingung 

Muster-Code für die Local-Interface für das Standard-EJB 
Muster-Code für die Remote-Interface für das Standard-EJB 
Muster-Code für die Klasse für das Standard-EJB 

Muster-Code für eine 'High Volume' EJB-Klasse

Anleitung zur Adaptierung 
* Änderung des Namens der Java-Packages der Anwendung 
* Adaptieren des Kommentars 
* Änderung des 'name' und des 'mappedName' der Klasse des EJB 
* Änderung des Namens der Interfaces und der Klasse 
* Festlegen eines eindeutigen ID für die Klasse 
* 'Datasource'-Namen festlegen 

* Methoden für die Datenzugriffe adaptieren - generell 
* Methoden für die Datenzugriffe adaptieren – keine zusätzlichen Änderungen in store und deactivate 
* Methoden für die Datenzugriffe adaptieren – Anpassen der Parameter für den Anwender-bekannten Schlüssel in selectNext, selectPrevious und selectByUserKnownKey 
* Methoden für die Datenzugriffe adaptieren – Anpassen der Parameter für Datenbank-Abfragen die eine Liste von BO zurück liefern; Muster entsprechend selectByFurtherSpecification 

Packen der Dateien in JAR (Java ARchiv) und EAR (Enterprise ARchive) 
* Konfigurationdateien für das JAR 
* Packaging Configuration für das JAR 
* Konfigurationdateien für das EAR 
* Packaging Configuration für das EAR 

Packen der Remote-Interface in eine JAR (Java ARchiv) Datei für die Verwendung in Client-Programmen 

Weitere Schritte und verwandte Dokumentation 

Vorbedingung:

▲ zum Inhaltsverzeichnis

Muster-Code für die Local-Interface für das Standard-EJB des Anwendungsprogramms

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

package application_package.ejb.interfaces.local;
/*
 * Package mit den 'klassischen' Methoden für Datenbank-Zugriff. */
import java.sql.*;
/*
 * Package aus dem JavaScout-Base-Systems (JSBS) mit den Klassen für die Datenstrukturen in denen
 * Parameter-Werte übergeben werden. */
import js_base.structures.*;
/*
 * 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;
/*
 * Packages mit den Generellen Klassen für die Business-Objects (BO) importieren. */
import application_package.bo.*;
/*
 * Import der Klasse für die Definition dieser Interface als 'Local' und dazu gehörende 'Injection'. */
import javax.ejb.Local;
@Local
/**
 * 
 * @author name[at]company
 * @date 20xx-xx-xx
 *
 * -------------------
 *
 * @description
 * 'Local' Interface für ein 'Standard'-EJB.
 * 'Local' bedeutet, dass die Methoden, die in dieser Interface definiert sind, nur aus
 * Methoden von EJB, die innerhalb des gleichen JAS laufen, aufgerufen werden können.
 *
 * 'Standard' (im Zusammenhang mit dem JavaScout Base-System / JSBS) bedeutet, dass dieses
 * EJB das in den Basisklassen des JSBS enthaltene EJB JSBS_StandardEJBBean und dessen Interfaces
 * durch 'Vererbung' übernimmt.
 * Im EJB der Basisklasse ist die Funktionalität enthalten um die Größe und Position eines Fensters
 * auf der Datenbank speichern und wieder lesen zu können.
 * 
 * @change-log
 * when          who                       why
 * -----------------------------------------------------------------
 * 
 */
public interface application_StandardBeanLocal extends JSBS_StandardEJBBeanLocal {
/*
 * Anschließend folgen die Methodendeklarationen für die Standard-Zugriffe auf die Datenbank.
 * Der Algorithmus für die Methoden ist in der Klasse für das Bean (application_StandardBean). */
    public Application_Entity_BO Application_Entity_BO__synchronizedStore(
                                            JSBS_MinimalParameters parmMinParm,
                                            Application_Entity_BO parmBO);
/* */
    public Application_Entity_BO Application_Entity_BO__store(
                                            JSBS_MinimalParameters parmMinParm,
                                            Application_Entity_BO parmBO);
/* */
    public Application_Entity_BO Application_Entity_BO__deactivate(
                                            JSBS_MinimalParameters parmMinParm,
                                            Application_Entity_BO parmBO);
/* */
    public Application_Entity_BO Application_Entity_BO__selectNext(
                                            JSBS_MinimalParameters parmMinParm,
                                            type_or_class parameter_variable1);
/* */
    public Application_Entity_BO Application_Entity_BO__selectPrevious(
                                            JSBS_MinimalParameters parmMinParm,
                                            type_or_class parameter_variable1);
/* */
    public Application_Entity_BO Application_Entity_BO__selectByUserKnownKey(
                                            JSBS_MinimalParameters parmMinParm,
                                            type_or_class parameter_variable1);
/* *** */
    public Application_Entity_BO_Set Application_Entity_BO_Set__selectAllByObjectID(
                                            JSBS_MinimalParameters parmMinParm,
                                            double parmObjectID);
/* */
    public Application_Entity_BO_Set Application_Entity_BO_Set__selectAllByChangedAt(
                                            JSBS_MinimalParameters parmMinParm,
                                            Timestamp parmYoungestChangedAt, short parmNumberOfRecords);
/* */
    public Application_Entity_BO_Set Application_Entity_BO_Set__selectByFurtherSpecification(
                                            JSBS_MinimalParameters parmMinParm,
                                            type_or_class parameter_variable1);
/* ***** */
}

▲ zum Inhaltsverzeichnis

Muster-Code für die Remote-Interface für das Standard-EJB des Anwendungsprogramms

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

package application_package.ejb.interfaces.remote;
/*
 * Package mit den 'klassischen' Methoden für Datenbank-Zugriff. */
import java.sql.*;
/*
 * Package aus dem JavaScout-Base-Systems (JSBS) mit den Klassen für die Datenstrukturen in denen
 * Parameter-Werte übergeben werden. */
import js_base.structures.*;
/*
 * 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.remote.JSBS_StandardEJBBeanRemote;
/*
 * Packages mit den Generellen Klassen für die Business-Objects (BO) importieren. */
import application_package.bo.*;
/*
 * Import der Klasse für die Definition dieser Interface als 'Remote' und dazu gehörende 'Injection'. */
import javax.ejb.Remote;
@Remote
/**
 * 
 * @author name[at]domain
 * @date 20xx-xx-xx
 *
 * -------------------
 *
 * @description
 * 'Remote' Interface für ein 'Standard'-EJB.
 * 'Remote' bedeutet, dass die Methoden, die in dieser Interface definiert sind, aus
 * Methoden in (Java-)Klassen, die außerhalb des gleichen JAS laufen, aufgerufen werden können –
 * nicht aber von Methoden, die innerhalb des JAS laufen.
 *
 * 'Standard' (im Zusammenhang mit dem JavaScout Base-System / JSBS) bedeutet, dass dieses
 * EJB das in den Basisklassen des JSBS enthaltene EJB JSBS_StandardEJBBean und dessen Interfaces
 * durch 'Vererbung' übernimmt.
 * Im EJB der Basisklasse ist die Funktionalität enthalten um die Größe und Position eines Fensters
 * auf der Datenbank speichern und wieder lesen zu können.
 * 
 * @change-log
 * when          who                       why
 * -----------------------------------------------------------------
 * 
 */
public interface application_StandardBeanRemote extends JSBS_StandardEJBBeanRemote {
/*
 * Anschließend folgen die Methodendeklarationen für die Standard-Zugriffe auf die Datenbank.
 * Der Algorithmus für die Methoden ist in der Klasse für das Bean (application_StandardBean). */
    public Application_Entity_BO Application_Entity_BO__synchronizedStore(
                                            JSBS_MinimalParameters parmMinParm,
                                            Application_Entity_BO parmBO);
/* */
    public Application_Entity_BO Application_Entity_BO__store(
                                            JSBS_MinimalParameters parmMinParm,
                                            Application_Entity_BO parmBO);
/* */
    public Application_Entity_BO Application_Entity_BO__deactivate(
                                            JSBS_MinimalParameters parmMinParm,
                                            Application_Entity_BO parmBO);
/* */
    public Application_Entity_BO Application_Entity_BO__selectNext(
                                            JSBS_MinimalParameters parmMinParm,
                                            type_or_class parameter_variable1);
/* */
    public Application_Entity_BO Application_Entity_BO__selectPrevious(
                                            JSBS_MinimalParameters parmMinParm,
                                            type_or_class parameter_variable1);
/* */
    public Application_Entity_BO Application_Entity_BO__selectByUserKnownKey(
                                            JSBS_MinimalParameters parmMinParm,
                                            type_or_class parameter_variable1);
/* *** */
    public Application_Entity_BO_Set Application_Entity_BO_Set__selectAllByObjectID(
                                            JSBS_MinimalParameters parmMinParm,
                                            double parmObjectID);
/* */
    public Application_Entity_BO_Set Application_Entity_BO_Set__selectAllByChangedAt(
                                            JSBS_MinimalParameters parmMinParm,
                                            Timestamp parmYoungestChangedAt, short parmNumberOfRecords);
/* */
    public Application_Entity_BO_Set Application_Entity_BO_Set__selectByFurtherSpecification(
                                            JSBS_MinimalParameters parmMinParm,
                                            type_or_class parameter_variable1);
/* ***** */
}

▲ zum Inhaltsverzeichnis

Muster-Code für die Standard-EJB-Klasse des Anwendungsprogramms

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

package application_package.ejb.bean;
/*
 * Package aus dem JavaScout-Base-Systems (JSBS) mit den Klassen für Business-Objects. */
import js_base.bo.*;
/*
 * Package aus dem JavaScout-Base-Systems (JSBS) mit den Klassen für die Datenstrukturen in denen
 * Parameter-Werte übergeben werden. */
import js_base.structures.*;
/*
 * Import der Basisklasse für das 'Standard'-EJB der Basisklasse.
 * Die Erklärung des 'Standard'-EJB finden Sie unter @description (etwas weiter unten). */
import js_base.ejb.beans.JSBS_StandardEJBBean;
/*
 * Klasse für eine Verbindung zu einer Datenquelle.
 * Datenquelle ('data-source') ist ein Überbegriff für alle Verbindungen des EJB,
 * über die Daten ausgetauscht werden.
 * Üblicherweise erfolgt diese Verbindung zu einem Datenbanksystem;
 * möglich ist aber auch jede andere Datenverbindung – z.B. eine Schnittstelle.
 * Mit welcher Datenquelle das EJB verbunden wird ist in Konfigurationsdateien festgelegt.
 * Eine davon ist 'ejb-jar.xml'; weitere hängen vom verwendeten JAS (Java Application Server)
 * und der Art der Datenquelle ab. */
import javax.annotation.Resource;
/*
 * Package mit den 'klassischen' Methoden für Datenbank-Zugriff. */
import java.sql.*;
/*
 * Package mit den Methoden, wie eine Datenbank über die
 * JNDI-Referenz eingebunden werden kann. */
import javax.sql.*;
/*
 * Interfaces mit den Methoden die für 'lokalen' und 'entfernten / remote' Aufruf freigegeben sind. */
import application_package.ejb.interfaces.local.*;
import application_package.ejb.interfaces.remote.*;
/*
 * Packages mit den Generellen und Server-seitigen Klassen für die Business-Objects (BO) importieren. */
import application_package.bo.*;
import application_package.bos.*;
/*
 * Import der Klasse für die Definition dieser Klasse als 'Stateless' und dazu gehörende 'Injection'. */
import javax.ejb.Stateless;
@Stateless(name="application_StandardEJB", mappedName="ejb/application_StandardEJBJNDI")
/**
 * 
 * @author name[at]domain
 * @date 20xx-xx-xx
 *
 * -------------------
 *
 * @description
 *  Klasse für das 'Standard'-Session-Bean mit Datenbank-Zugriff.
 * 
 *  'Standard' bedeutet, dass in diesem EJB alle Datenbank-Zugriffe enthalten sind,
 *  * die nicht in großer Zahl parallel ausgeführt werden (dafür ist das
 *    'High-Volume' Muster vorgesehen)
 *  oder
 *  * die extrem lange Zeit in Anspruch nehmen (dafür ist ein abgewandeltes Art
 *  * dieses Muster-Codes vorhanden).
 *
 *  Dieses 'Standard' EJB erbt die Basisklasse JSBS_StandardEJBBean; in dieser ist die
 *  Funktionalität enthalten um die Größe und Position eines Fensters auf der Datenbank speichern
 *  und wieder lesen zu können.
 * 
 * @change-log
 * when          who                       why
 * -----------------------------------------------------------------
 * 
 */
public class application_StandardBean extends JSBS_StandardEJBBean
        implements application_StandardBeanLocal, application_StandardBeanRemote {
/*
 * Eindeutige Identifizierung der Klasse.
 * Empfehlung: Jahr (einstellig), Monat, Tag, Stunde, Minute. */
    static final long serialVersionUID = ymmddhhmm;
/*
 * Festlegen der 'Datasource' (üblicherweise eine Datenbank) mit der 'Injection'.
 * Der 'mappedName' in diesem Muster ist für dein JBoss JAS gewählt; mit diesem Wert
 * kann die in JBoss integrierte Hypesonic Datenbank verwendet werden.
 * Entsprechend Ihrer Test-Umgebung kann dieser Wert verändert werden.
 * Für den Echt-Einsatz wird der 'mappedName' in einer JAS-spezifischen Datei
 * (z.B. 'jboss.xml' für JBoss oder 'sun-ejb-jar' für JAS von SUN. */
@Resource(name="ds/application_DS", mappedName="java:/DefaultDS")
/*
 * Variable für die Verbindung zur Datenquelle – üblicherweise eine Datenbank.
 * Der Wert für diese Variable wird durch die 'Injection' '@Resource' zugewiesen. */
    private DataSource jdbcFactory = null;
/*
 * METHODE zum 'Holen' einer Verbindung zur DataSource (üblicherweise eine Datenbank).
 * Diese Methode überschreibt auch die gleichnamige Methode der geerbten Basisklasse
 * damit die Methoden (zum Speichern und Lesen der Größe und Position eines Fensters)
 * in der Basisklasse auf die Datenbank zugreifen können.
 * Durch '@Override' wird sicher gestellt, dass die Methode der geerbten Klasse auch
 * sicher überschrieben wird und nicht (durch einen möglichen Tippfehler) unterbleibt.
 * --------------------- */
@Override
    public synchronized Connection establishDBConnection() {
/*
 * Variable für die (Datenbank-)Connection. */
      Connection DBCon = null;
/*
 * 'Holen' der Connection von der DataSource.
 * Im Hintergrund wird vom JAS (Java Application Server) eine Connection zur Datenbank eröffnet.
 * Welche Datenbank verbunden wird ist über '@Resource(name="ds/.....' in externen Dateien definiert. */
      try {
        DBCon = jdbcFactory.getConnection();
      }
      catch (Exception e) {
/*
 * Keine Fehlerbehandlung in dieser Methode.
 * Wenn die Datenbank-Connection nicht erstellt werden konnte wird das über den Wert 'null' signalisiert. */
      return null;
      }
/*
 * Connection zur Datenbank zurück liefern bzw. den Wert 'null' wenn keine Connection erstellt
 * werden konnte. */
      return DBCon;
    }
/* 
 * ====================
 * METHODEN für ein Business-Objects (BO) zum Speichern, Löschen (Deaktivieren) und
 * Lesen eines einzelnen BO und eines Sets (Liste) von mehreren BOs. 
 *
 * Die folgenden Muster-Methoden können beliebig oft kopiert
 * und für jedes BO adaptiert werden. */
/* ---------------------------------------- */
    public synchronized Application_Entity_BO Application_Entity_BO__synchronizedStore(
                                      JSBS_MinimalParameters parmMinParm,
                                      Application_Entity_BO parmBO) {
/*
 * BO, das an die aufrufende Methode zurückgeliefert wird, definieren und konstruieren. */
      Application_Entity_BO boApplication_Entity_BO = new Application_Entity_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_Entity_BO.StatusCode = Application_Entity_BO.CONST_DB_SYSTEM_ERROR;
        boApplication_Entity_BO.StatusMsg = "Database connection failed within the EJB.";
        return boApplication_Entity_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_Entity_BO.StatusCode = Application_Entity_BO.CONST_DB_SYSTEM_ERROR;
        boApplication_Entity_BO.StatusMsg = "Disabling 'autocommit' failed within the EJB.";
        return boApplication_Entity_BO;
      }
/*
 * DB-Connection wurde fehlerfrei erstellt.
 * Ein Server-Side Business Object konstruieren (instanziieren).
 * Dabei gleich die Werte des übergebenen BO übernehmen. */
      Application_Entity_BOS bosApplication_Entity_BOS =
        new Application_Entity_BOS(parmMinParm, DBCon, parmBO, true);
/*
 * 'synchronizedStore'-Operation auf die Datenbank ausführen.
 * Per Definition darf der Primärschlüssel (DataSetID) des Datensatzes auf dem Server
 * nicht vom Client aus geändert werden. Aus diesem Grund wird der Parameter mit dem
 * Wert '0' versorgt.
 * Wenn zufällig auf der Datenbank des Servers der Primärschlüssel bereits verwendet wird,
 * wird im BOS ein neuer Primärschlüssel generiert.
 * Anmerkung:
 * Dieser neue Primärschlüssel wird an den Client zurück geliefert und dort muss der
 * Datensatz auf der lokalen Datenbank geändert werden. */
      bosApplication_Entity_BOS.synchronizedStore(0);
/*
 * 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
 * (z.B. 'Duplicate Key') auf das Generelle BO übertragen. */
      boApplication_Entity_BO.copyFromApplication_Entity_BO(bosApplication_Entity_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_Entity_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_Entity_BO.StatusCode = Application_Entity_BO.CONST_DB_SYSTEM_ERROR;
        boApplication_Entity_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_Entity_BO;
    }
/* ---------------------------------------- */
    public synchronized Application_Entity_BO Application_Entity_BO__store(
                                      JSBS_MinimalParameters parmMinParm,
                                      Application_Entity_BO parmBO) {
/*
 * BO, das an die aufrufende Methode zurückgeliefert wird, definieren und konstruieren. */
      Application_Entity_BO boApplication_Entity_BO = new Application_Entity_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_Entity_BO.StatusCode = Application_Entity_BO.CONST_DB_SYSTEM_ERROR;
        boApplication_Entity_BO.StatusMsg = "Database connection failed within the EJB.";
        return boApplication_Entity_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_Entity_BO.StatusCode = Application_Entity_BO.CONST_DB_SYSTEM_ERROR;
        boApplication_Entity_BO.StatusMsg = "Disabling 'autocommit' failed within the EJB.";
        return boApplication_Entity_BO;
      }
/*
 * DB-Connection wurde fehlerfrei erstellt.
 * Ein Server-Side Business Object konstruieren (instanziieren).
 * Dabei gleich die Werte des übergebenen BO übernehmen.
 * Danach die 'store'-Operation auf die Datenbank ausführen. */
      Application_Entity_BOS bosApplication_Entity_BOS =
        new Application_Entity_BOS(parmMinParm, DBCon, parmBO, true);
      bosApplication_Entity_BOS.store();
/*
 * 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
 * (z.B. 'Duplicate Key') auf das Generelle BO übertragen. */
      boApplication_Entity_BO.copyFromApplication_Entity_BO(bosApplication_Entity_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_Entity_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_Entity_BO.StatusCode = Application_Entity_BO.CONST_DB_SYSTEM_ERROR;
        boApplication_Entity_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_Entity_BO;
    }
/* ---------------------------------------- */
    public synchronized Application_Entity_BO Application_Entity_BO__deactivate(
                                      JSBS_MinimalParameters parmMinParm,
                                      Application_Entity_BO parmBO) {
/*
 * BO, das an die aufrufende Methode zurückgeliefert wird, definieren und konstruieren. */
      Application_Entity_BO boApplication_Entity_BO = new Application_Entity_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_Entity_BO.StatusCode = Application_Entity_BO.CONST_DB_SYSTEM_ERROR;
        boApplication_Entity_BO.StatusMsg = "Database connection failed within the EJB.";
        return boApplication_Entity_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_Entity_BO.StatusCode = Application_Entity_BO.CONST_DB_SYSTEM_ERROR;
        boApplication_Entity_BO.StatusMsg = "Disabling 'autocommit' failed within the EJB.";
        return boApplication_Entity_BO;
      }
/*
 * DB-Connection wurde fehlerfrei erstellt.
 * Ein Server-Side Business Object konstruieren (instanziieren).
 * Dabei gleich die Werte des übergebenen BO übernehmen.
 * Danach die 'store'-Operation auf die Datenbank ausführen. */
      Application_Entity_BOS bosApplication_Entity_BOS =
        new Application_Entity_BOS(parmMinParm, DBCon, parmBO, true);
      bosApplication_Entity_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_Entity_BO.copyFromApplication_Entity_BO(bosApplication_Entity_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_Entity_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_Entity_BO.StatusCode = Application_Entity_BO.CONST_DB_SYSTEM_ERROR;
        boApplication_Entity_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_Entity_BO;
    }
/* 
 * ----------------------------------------
 * Die folgenden Methoden enthalten Muster-Code für Selektionen, die per Definition
 * maximal ein BO auswählen können. */
    public synchronized Application_Entity_BO Application_Entity_BO__selectNext(
                                      JSBS_MinimalParameters parmMinParm,
                                      type_or_class parameter_variable1) {
/*
 * Ein Business Object (generelle Klasse) konstruieren (instanziieren).
 * Dieses wird mit dem gewählten BO (oder leer) von dieser Methode zurück geliefert. */
      Application_Entity_BO boApplication_Entity_BO =
        new Application_Entity_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_Entity_BO.StatusCode = Application_Entity_BO.CONST_DB_SYSTEM_ERROR;
        boApplication_Entity_BO.StatusMsg = "Database connection failed within the EJB.";
        return boApplication_Entity_BO;
      }
/*
 * **********
 * TEMPORÄRE ÄNDERUNG WEGEN EINES FEHLERS BEIM VERWENDEN VON GLASSFISH UND MYSQL.
 * Zum Zeitpunkt des Schreibens dieses Musters (Dezember 2009) tritt in der
 * Kombination von MySQL und Glassfish-JAS ein Fehler auf, wenn die Verbindung zur
 * Datenbank auf 'autocommit gesetzt' ist. Deswegen sind die Anweisungen zum
 * 'Einschalten' von 'autocommit' unter Kommentar gesetzt.
 * Wenn bei Ihrer Infrastruktur 'autocommit' verwendet werden kann entfernen Sie bitte
 * die Kommentare um den Zugriff auf die Datenbank zu beschleunigen.
 * ********** */
/*
 * Für Methoden, die Daten nicht verändern wird 'autocommit' gesetzt.
 * Damit wird der Zugriff auf die Datenbank beschleunigt. */
//      try {
/*
 * 'Autocommit' für die Verbindung zur Datenbank setzen. */
//        DBCon.setAutoCommit(true);
//      }
//      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_Entity_BO.StatusCode = Application_Entity_BO.CONST_DB_SYSTEM_ERROR;
//        boApplication_Entity_BO.StatusMsg = "Setting 'autocommit' failed within the EJB.";
//        return boApplication_Entity_BO;
//      }
/*
 * DB-Connection wurde fehlerfrei erstellt.
 * Ein Server-Side Business Object konstruieren (instanziieren) und
 * die 'selection'-Operation auf die Datenbank ausführen. */
      Application_Entity_BOS bosApplication_Entity_BOS =
        new Application_Entity_BOS(parmMinParm, DBCon, true);
      bosApplication_Entity_BOS.selectNext(parameter_variable1);
/*
 * 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
 * (z.B. 'Not Found') auf das Generelle BO übertragen. */
      boApplication_Entity_BO.copyFromApplication_Entity_BO(bosApplication_Entity_BOS);
/* 
 * 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 {DBCon.close();}
      catch (Exception e){}
/* 
 * BO mit den selektierten Daten - oder mit dem entsprechenden Status - an die aufrufende  
 * Methode zurück liefern. */
      return boApplication_Entity_BO;
    }
/* ***** */ 
    public synchronized Application_Entity_BO Application_Entity_BO__selectPrevious(
                                      JSBS_MinimalParameters parmMinParm,
                                      type_or_class parameter_variable1) {
/*
 * Ein Business Object (generelle Klasse) konstruieren (instanziieren).
 * Dieses wird mit dem gewählten BO (oder leer) von dieser Methode zurück geliefert. */
      Application_Entity_BO boApplication_Entity_BO =
        new Application_Entity_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_Entity_BO.StatusCode = Application_Entity_BO.CONST_DB_SYSTEM_ERROR;
        boApplication_Entity_BO.StatusMsg = "Database connection failed within the EJB.";
        return boApplication_Entity_BO;
      }
/*
 * **********
 * TEMPORÄRE ÄNDERUNG WEGEN EINES FEHLERS BEIM VERWENDEN VON GLASSFISH UND MYSQL.
 * Zum Zeitpunkt des Schreibens dieses Musters (Dezember 2009) tritt in der
 * Kombination von MySQL und Glassfish-JAS ein Fehler auf, wenn die Verbindung zur
 * Datenbank auf 'autocommit gesetzt' ist. Deswegen sind die Anweisungen zum
 * 'Einschalten' von 'autocommit' unter Kommentar gesetzt.
 * Wenn bei Ihrer Infrastruktur 'autocommit' verwendet werden kann entfernen Sie bitte
 * die Kommentare um den Zugriff auf die Datenbank zu beschleunigen.
 * ********** */
/*
 * Für Methoden, die Daten nicht verändern wird 'autocommit' gesetzt.
 * Damit wird der Zugriff auf die Datenbank beschleunigt. */
//      try {
/*
 * 'Autocommit' für die Verbindung zur Datenbank setzen. */
//        DBCon.setAutoCommit(true);
//      }
//      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_Entity_BO.StatusCode = Application_Entity_BO.CONST_DB_SYSTEM_ERROR;
//        boApplication_Entity_BO.StatusMsg = "Setting 'autocommit' failed within the EJB.";
//        return boApplication_Entity_BO;
//      }
/*
 * DB-Connection wurde fehlerfrei erstellt.
 * Ein Server-Side Business Object konstruieren (instanziieren) und
 * die 'selection'-Operation auf die Datenbank ausführen. */
      Application_Entity_BOS bosApplication_Entity_BOS =
        new Application_Entity_BOS(parmMinParm, DBCon, true);
      bosApplication_Entity_BOS.selectPrevious(parameter_variable1);
/*
 * 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
 * (z.B. 'Not Found') auf das Generelle BO übertragen. */
      boApplication_Entity_BO.copyFromApplication_Entity_BO(bosApplication_Entity_BOS);
/* 
 * 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 {DBCon.close();}
      catch (Exception e){}
/* 
 * BO mit den selektierten Daten - oder mit dem entsprechenden Status - an die aufrufende  
 * Methode zurück liefern. */
      return boApplication_Entity_BO;
    }
/* ***** */ 
    public synchronized Application_Entity_BO Application_Entity_BO__selectByUserKnownKey(
                                      JSBS_MinimalParameters parmMinParm,
                                      type_or_class parameter_variable1) {
/*
 * Ein Business Object (generelle Klasse) konstruieren (instanziieren).
 * Dieses wird mit dem gewählten BO (oder leer) von dieser Methode zurück geliefert. */
      Application_Entity_BO boApplication_Entity_BO =
        new Application_Entity_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_Entity_BO.StatusCode = Application_Entity_BO.CONST_DB_SYSTEM_ERROR;
        boApplication_Entity_BO.StatusMsg = "Database connection failed within the EJB.";
        return boApplication_Entity_BO;
      }
/*
 * **********
 * TEMPORÄRE ÄNDERUNG WEGEN EINES FEHLERS BEIM VERWENDEN VON GLASSFISH UND MYSQL.
 * Zum Zeitpunkt des Schreibens dieses Musters (Dezember 2009) tritt in der
 * Kombination von MySQL und Glassfish-JAS ein Fehler auf, wenn die Verbindung zur
 * Datenbank auf 'autocommit gesetzt' ist. Deswegen sind die Anweisungen zum
 * 'Einschalten' von 'autocommit' unter Kommentar gesetzt.
 * Wenn bei Ihrer Infrastruktur 'autocommit' verwendet werden kann entfernen Sie bitte
 * die Kommentare um den Zugriff auf die Datenbank zu beschleunigen.
 * ********** */
/*
 * Für Methoden, die Daten nicht verändern wird 'autocommit' gesetzt.
 * Damit wird der Zugriff auf die Datenbank beschleunigt. */
//      try {
/*
 * 'Autocommit' für die Verbindung zur Datenbank setzen. */
//        DBCon.setAutoCommit(true);
//      }
//      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_Entity_BO.StatusCode = Application_Entity_BO.CONST_DB_SYSTEM_ERROR;
//        boApplication_Entity_BO.StatusMsg = "Setting 'autocommit' failed within the EJB.";
//        return boApplication_Entity_BO;
//      }
/*
 * DB-Connection wurde fehlerfrei erstellt.
 * Ein Server-Side Business Object konstruieren (instanziieren) und
 * die 'selection'-Operation auf die Datenbank ausführen. */
      Application_Entity_BOS bosApplication_Entity_BOS =
        new Application_Entity_BOS(parmMinParm, DBCon, true);
      bosApplication_Entity_BOS.selectByUserKnownKey(parameter_variable1);
/*
 * 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
 * (z.B. 'Not Found') auf das Generelle BO übertragen. */
      boApplication_Entity_BO.copyFromApplication_Entity_BO(bosApplication_Entity_BOS);
/* 
 * 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 {DBCon.close();}
      catch (Exception e){}
/* 
 * BO mit den selektierten Daten - oder mit dem entsprechenden Status - an die aufrufende  
 * Methode zurück liefern. */
      return boApplication_Entity_BO;
    }
/* ***** */ 
/* 
 * ----------------------------------------
 * Diese Methode enthält den Muster-Code für das Selektieren einer bestimmten Anzahl Datensätze
 * die gleich alt oder älter sind als der im Parameter 'parmYoungestChangestAt' übergebene Wert.
 * Diese Methode wird zum Abgleichen der Daten bei einer 'MobileClient' Version verwendet. */
    public synchronized Application_Entity_BO_Set Application_Entity_BO_Set__selectAllByChangedAt(
                                            JSBS_MinimalParameters parmMinParm,
                                            Timestamp parmYoungestChangedAt, short parmNumberOfRecords) {
/*
 * Eine generelle Klasse für die Liste mit BO konstruieren (instanziieren).
 * Dieses wird mit den gewählten BO (oder leer) von dieser Methode zurück geliefert. */
      Application_Entity_BO_Set boApplication_Entity_BO_Set =
        new Application_Entity_BO_Set();
/*
 * 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_Entity_BO_Set.StatusCode = Application_Entity_BO.CONST_DB_SYSTEM_ERROR;
        boApplication_Entity_BO_Set.StatusMsg = "Database connection failed within the EJB.";
        return boApplication_Entity_BO_Set;
      }
/*
 * **********
 * TEMPORÄRE ÄNDERUNG WEGEN EINES FEHLERS BEIM VERWENDEN VON GLASSFISH UND MYSQL.
 * Zum Zeitpunkt des Schreibens dieses Musters (Dezember 2009) tritt in der
 * Kombination von MySQL und Glassfish-JAS ein Fehler auf, wenn die Verbindung zur
 * Datenbank auf 'autocommit gesetzt' ist. Deswegen sind die Anweisungen zum
 * 'Einschalten' von 'autocommit' unter Kommentar gesetzt.
 * Wenn bei Ihrer Infrastruktur 'autocommit' verwendet werden kann entfernen Sie bitte
 * die Kommentare um den Zugriff auf die Datenbank zu beschleunigen.
 * ********** */
/*
 * Für Methoden, die Daten nicht verändern wird 'autocommit' gesetzt.
 * Damit wird der Zugriff auf die Datenbank beschleunigt. */
//      try {
/*
 * 'Autocommit' für die Verbindung zur Datenbank setzen. */
//        DBCon.setAutoCommit(true);
//      }
//      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_Entity_BO.StatusCode = Application_Entity_BO.CONST_DB_SYSTEM_ERROR;
//        boApplication_Entity_BO.StatusMsg = "Setting 'autocommit' failed within the EJB.";
//        return boApplication_Entity_BO;
//      }
/*
 * DB-Connection wurde fehlerfrei erstellt.
 * Ein Server-Side Business Object konstruieren (instanziieren) und
 * die 'selection'-Operation auf die Datenbank ausführen. */
      Application_Entity_BOS_Set bosApplication_Entity_BOS_Set =
        new Application_Entity_BOS_Set(parmMinParm, DBCon, true);
      bosApplication_Entity_BOS_Set.selectAllByChangedAt(parmYoungestChangedAt, parmNumberOfRecords);
/*
 * Kopieren des gerade für die Datenbank-Operation genutzten Server-Side BO-Set 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
 * (z.B. 'Not Found') auf das Generelle BO übertragen. */
      boApplication_Entity_BO_Set.copyFromApplication_Entity_BO_Set(bosApplication_Entity_BOS_Set);
/* 
 * 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 {DBCon.close();}
      catch (Exception e){}
/* 
 * BO-Set mit den selektierten Daten - oder mit dem entsprechenden Status - an die aufrufende  
 * Methode zurück liefern. */
      return boApplication_Entity_BO_Set;
    }
/* *** */ 
/* 
 * ----------------------------------------
 * Diese Methode enthält den Muster-Code für das Selektieren aller Datensätze für einen gegebenen
 * ObjectID. Diese Methode wird zum Anzeigen von Veränderungen (History) des BO und zum
 * Abgleichen der Daten bei einer 'MobileClient' Version verwendet.
 * Weiters wird damit beim 'deaktivieren' des BO festgestellt, welche Datensätze noch über das
 * aktuelle Datum hinaus gültig sind. */
    public synchronized Application_Entity_BO_Set Application_Entity_BO_Set__selectAllByObjectID(
                                      JSBS_MinimalParameters parmMinParm,
                                      double parmObjectID) {
/*
 * Eine generelle Klasse für die Liste mit BO konstruieren (instanziieren).
 * Dieses wird mit den gewählten BO (oder leer) von dieser Methode zurück geliefert. */
      Application_Entity_BO_Set boApplication_Entity_BO_Set =
        new Application_Entity_BO_Set();
/*
 * 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_Entity_BO_Set.StatusCode = Application_Entity_BO.CONST_DB_SYSTEM_ERROR;
        boApplication_Entity_BO_Set.StatusMsg = "Database connection failed within the EJB.";
        return boApplication_Entity_BO_Set;
      }
/*
 * **********
 * TEMPORÄRE ÄNDERUNG WEGEN EINES FEHLERS BEIM VERWENDEN VON GLASSFISH UND MYSQL.
 * Zum Zeitpunkt des Schreibens dieses Musters (Dezember 2009) tritt in der
 * Kombination von MySQL und Glassfish-JAS ein Fehler auf, wenn die Verbindung zur
 * Datenbank auf 'autocommit gesetzt' ist. Deswegen sind die Anweisungen zum
 * 'Einschalten' von 'autocommit' unter Kommentar gesetzt.
 * Wenn bei Ihrer Infrastruktur 'autocommit' verwendet werden kann entfernen Sie bitte
 * die Kommentare um den Zugriff auf die Datenbank zu beschleunigen.
 * ********** */
/*
 * Für Methoden, die Daten nicht verändern wird 'autocommit' gesetzt.
 * Damit wird der Zugriff auf die Datenbank beschleunigt. */
//      try {
/*
 * 'Autocommit' für die Verbindung zur Datenbank setzen. */
//        DBCon.setAutoCommit(true);
//      }
//      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_Entity_BO.StatusCode = Application_Entity_BO.CONST_DB_SYSTEM_ERROR;
//        boApplication_Entity_BO.StatusMsg = "Setting 'autocommit' failed within the EJB.";
//        return boApplication_Entity_BO;
//      }
/*
 * DB-Connection wurde fehlerfrei erstellt.
 * Ein Server-Side Business Object konstruieren (instanziieren) und
 * die 'selection'-Operation auf die Datenbank ausführen. */
      Application_Entity_BOS_Set bosApplication_Entity_BOS_Set =
        new Application_Entity_BOS_Set(parmMinParm, DBCon, true);
      bosApplication_Entity_BOS_Set.selectAllByObjectID(parmObjectID);
/*
 * Kopieren des gerade für die Datenbank-Operation genutzten Server-Side BO-Set 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
 * (z.B. 'Not Found') auf das Generelle BO übertragen. */
      boApplication_Entity_BO_Set.copyFromApplication_Entity_BO_Set(bosApplication_Entity_BOS_Set);
/* 
 * 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 {DBCon.close();}
      catch (Exception e){}
/* 
 * BO-Set mit den selektierten Daten - oder mit dem entsprechenden Status - an die aufrufende  
 * Methode zurück liefern. */
      return boApplication_Entity_BO_Set;
    }
/* *** */ 
/* 
 * ----------------------------------------
 * Diese Methode enthält den Muster-Code für Selektionen, die mehr als ein BO (ein BO-Set)
 * auswählen können. */
    public synchronized Application_Entity_BO_Set Application_Entity_BO_Set__selectByFurtherSpecification(
                                      JSBS_MinimalParameters parmMinParm,
                                      type_or_class parameter_variable1) {
/*
 * Eine generelle Klasse für die Liste mit BO konstruieren (instanziieren).
 * Dieses wird mit den gewählten BO (oder leer) von dieser Methode zurück geliefert. */
      Application_Entity_BO_Set boApplication_Entity_BO_Set =
        new Application_Entity_BO_Set();
/*
 * 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_Entity_BO_Set.StatusCode = Application_Entity_BO.CONST_DB_SYSTEM_ERROR;
        boApplication_Entity_BO_Set.StatusMsg = "Database connection failed within the EJB.";
        return boApplication_Entity_BO_Set;
      }
/*
 * **********
 * TEMPORÄRE ÄNDERUNG WEGEN EINES FEHLERS BEIM VERWENDEN VON GLASSFISH UND MYSQL.
 * Zum Zeitpunkt des Schreibens dieses Musters (Dezember 2009) tritt in der
 * Kombination von MySQL und Glassfish-JAS ein Fehler auf, wenn die Verbindung zur
 * Datenbank auf 'autocommit gesetzt' ist. Deswegen sind die Anweisungen zum
 * 'Einschalten' von 'autocommit' unter Kommentar gesetzt.
 * Wenn bei Ihrer Infrastruktur 'autocommit' verwendet werden kann entfernen Sie bitte
 * die Kommentare um den Zugriff auf die Datenbank zu beschleunigen.
 * ********** */
/*
 * Für Methoden, die Daten nicht verändern wird 'autocommit' gesetzt.
 * Damit wird der Zugriff auf die Datenbank beschleunigt. */
//      try {
/*
 * 'Autocommit' für die Verbindung zur Datenbank setzen. */
//        DBCon.setAutoCommit(true);
//      }
//      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_Entity_BO.StatusCode = Application_Entity_BO.CONST_DB_SYSTEM_ERROR;
//        boApplication_Entity_BO.StatusMsg = "Setting 'autocommit' failed within the EJB.";
//        return boApplication_Entity_BO;
//      }
/*
 * DB-Connection wurde fehlerfrei erstellt.
 * Ein Server-Side Business Object konstruieren (instanziieren) und
 * die 'selection'-Operation auf die Datenbank ausführen. */
      Application_Entity_BOS_Set bosApplication_Entity_BOS_Set =
        new Application_Entity_BOS_Set(parmMinParm, DBCon, true);
      bosApplication_Entity_BOS_Set.selectBySelectionCriteria(parameter_variable1);
/*
 * Kopieren des gerade für die Datenbank-Operation genutzten Server-Side BO-Set 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
 * (z.B. 'Not Found') auf das Generelle BO übertragen. */
      boApplication_Entity_BO_Set.copyFromApplication_Entity_BO_Set(bosApplication_Entity_BOS_Set);
/* 
 * 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 {DBCon.close();}
      catch (Exception e){}
/* 
 * BO-Set mit den selektierten Daten - oder mit dem entsprechenden Status - an die aufrufende  
 * Methode zurück liefern. */
      return boApplication_Entity_BO_Set;
    }
/* ***** */ 
}

▲ zum Inhaltsverzeichnis

Muster-Codes für eine 'High Volume' EJB-Klasse

Unterschiede zum StandardEJB dokumentieren

package application_package.ejb.bean;

▲ zum Inhaltsverzeichnis

Anleitung zur Adaptierung

In den folgenden Beispielen werden nur die Änderungen in der Klasse für die 'Bean' gezeigt – die Änderungen sind aber auch in der Interfaces (Local und Remote) durchzuführen. Wenn einzelne Änderungen nicht auf die Interfaces zutreffen wird in der Beschreibung darauf hingewiesen.

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

Wenn vorher der zu ersetzende Text markiert wurde, wird er zu findende Text von der Suchfunktion übernommen.

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 der Java-Packages der Anwendung

package application_package.ejb.bean;
. . . . .
. . . . .

Der Name dieses Packages kommt in den Interfaces und in der Klasse für das EJB in der ersten Zeile vor.

In den Interfaces ist weiters ein import-Statement für das BO:
import application_package.bo.*;

Bei der Klasse für das EJB werden auch die Platzhalter bei den import-Statements für die 'Interfaces' des EJB und für die 'BO' (Business Objects, allgemeine Klassen) und 'BOS' (Business Objects, server-seitige Derivate der BO-Klassen) durch den aktuellen Namen des Packages ersetzt:
 * JNDI-Referenz eingebunden werden kann. */
import javax.sql.*;
/*
 * Interfaces mit den Methoden die für 'lokalen' und 'entfernten / remote' Aufruf freigegeben sind. */
import application_package.ejb.interfaces.local.*;
import application_package.ejb.interfaces.remote.*;
/*
 * Packages mit den Generellen und Server-seitigen Klassen für die Business-Objects (BO) importieren. */
import application_package.bo.*;
import application_package.bos.*;
/*

Wenn den Namenskonventionen gefolgt wurden, dann ist auch der Name des Packages mit den BO- und BOS-Klassen im ersten Teil gleich.

▲ zum Inhaltsverzeichnis

Adaptieren des Kommentars

'Kein Kommentar ist besser als ein falscher'.

Aus diesem Grund ist im Muster-Code auch keine Hintergrund-Information über Entwurfs-Entscheidungen vorhanden.
Nachdem das EJB nur eine 'Hülle' für den Aufruf von Methoden der einzelnen BO ist, reicht es aus, auf die Beschreibungen bei den jeweiligen BO zu verweisen.

▲ zum Inhaltsverzeichnis

Änderung des 'name' und des 'mappedName' der Klasse des EJB

Diese Anweisung gilt nicht für die Interfaces.

In der Java-Klasse für das EJB sind Vorgaben der Namen für das EJB und des in der JNDI (Java Naming and Directory Interface) des JAS (Java Application Server) eingetragenen Namens ('mapped name'); in diesen muss auch der Platzhalter gegen den Namen der Anwendung ausgetauscht werden.
Nur dann ist der Name des EJB innerhalb des JAS eindeutig !

/*
 * Import der Klasse für die Definition dieser Klasse als 'Stateless' und dazu gehörende 'Injection'. */
import javax.ejb.Stateless;
@Stateless(name="application_StandardEJB", mappedName="ejb/application_StandardEJBJNDI")
/**

Bitte markieren Sie beim Find/Replace die Checkbox [x] Case sensitive !

Grund dafür ist, dass auch in den Platzhaltern für die Business Objects (BO) die Zeichenkette vorkommt – allerdings mit Großbuchstaben.
Durch das Markieren von [x] Case sensitive werden die Platzhalter für die BO jetzt nicht ersetzt.



▲ zum Inhaltsverzeichnis

Änderung des Namens der Interfaces und der Klasse

Dieser Name muss mit dem Namen der Interface bzw. der Klasse für das EJB übereinstimmen, der beim Eröffnen der Klasse gewählt wurde:

 */
public class application_StandardBean extends JSBS_StandardEJBBean {
/* .

Diese Änderung kann durch das gleiche Find/Replace wie im Abschnitt Änderung des 'name' und des 'mappedName' der Klasse des EJB ausgeführt werden.

▲ zum Inhaltsverzeichnis

Festlegen eines eindeutigen ID für die Klasse

Diese Anweisung gilt nicht für die Interfaces.

public class application_StandardBean extends JSBS_StandardEJBBean {
/*
 * Eindeutige Identifizierung der Klasse.
 * Empfehlung: Jahr (einstellig), Monat, Tag, Stunde, Minute. */
    static final long serialVersionUID = ymmddhhmm;
/*
 * Festlegen der 'DataSource' (üblicherweise eine ....

Der Java Application Server (JAS) erwartet unter der Variable serialVersionUID einen eindeutigen Wert.
Um nicht zufällig den gleichen Wert an mehr als eine Klasse zu vergeben ist es sinnvoll, Datum und Uhrzeit der Erstellung der Klasse zu verwenden.
Das sollte eindeutig sein - außer Sie arbeiten so schnell und eröffnen mehr als eine EJB-Klasse innerhalb einer Minute ;-).

Hier ein Beispiel eines realen Wertes:
    static final long serialVersionUID = 810141112;

▲ zum Inhaltsverzeichnis

'Datasource'-Namen festlegen

Diese Anweisung gilt nicht für die Interfaces.

In der Java-Klasse für das EJB sind Vorgaben den internen Namen für die 'Datasource' innerhalb des EJB und des in der JNDI des JAS eingetragenen Namens ('mapped name').
Es ist sinnvoll, den Platzhalter für den internen Namen der Datasource (@Resource(name="ds/application_DS", . . .) durch einen 'sprechenden' Namen zu ersetzen – z.B. den Namen der Anwendung.

Der 'mappedName' (. . ., mappedName="java:/DefaultDS")) ist der innerhalb des JAS registrierte Name der 'Datasource'.
Abhängig von der Konfiguration Ihres JAS für den Test während der Entwicklung kann dieser Wert der im JAS bereits definierten 'Datasource' angepasst werden.

Der im Muster-Code verwendete Name ist jener, der im JBoss JAS bereits vorkonfiguriert ist.

 * Für den Echt-Einsatz wird der 'mappedName' in einer JAS-spezifischen Datei
 * (z.B. 'jboss.xml' für JBoss oder 'sun-ejb-jar' für JAS von SUN. */
@Resource(name="ds/application_DS", mappedName="java:/DefaultDS")

Diese Änderung kann durch das gleiche Find/Replace wie im Abschnitt Änderung des 'name' und des 'mappedName' der Klasse des EJB ausgeführt werden.

▲ zum Inhaltsverzeichnis

Methoden für die Datenzugriffe adaptieren - generell

Zur Steigerung der Effizienz werden Datenzugriffe für mehrere Business Objects (BO) in eine Klasse für ein EJB – besonders in das 'Standard'-EJB eines Anwendungsprogramms – 'gepackt'.
Theoretische Erläuterungen dazu finden Die im Dokument Überlegungen zum Entwurf von EJB (Enterprise Java Beans).

Im Muster-Code für die Interfaces und die Klasse für das EJB sind die Standard Methoden für ein BO enthalten.

Wenn Sie ein weiteres BOS erstellt haben, kann der Muster-Code für die Zugriffe auf dessen Methoden kopiert werden.
Innerhalb der Interfaces ist der zusätzliche Muster-Code leicht zu erkennen; er besteht nur aus der Methodendeklaration:
    public Application_Entity_BO Application_Entity_BO__store(
                                            JSBS_MinimalParameters parmMinParm,
                                            Application_Entity_BO parmBO);
/* */
    public Application_Entity_BO Application_Entity_BO__deactivate(
                                            JSBS_MinimalParameters parmMinParm,
                                            Application_Entity_BO parmBO);
/* */
    public Application_Entity_BO Application_Entity_BO__selectNext(
                                            JSBS_MinimalParameters parmMinParm,
                                            type_or_class parameter_variable1);
/* */
    public Application_Entity_BO Application_Entity_BO__selectPrevious(
                                            JSBS_MinimalParameters parmMinParm,
                                            type_or_class parameter_variable1);
/* */
    public Application_Entity_BO Application_Entity_BO__selectByUserKnownKey(
                                            JSBS_MinimalParameters parmMinParm,
                                            type_or_class parameter_variable1);
/* *** */
    public Application_Entity_BO_Set Application_Entity_BO_Set__selectByFurtherSpecification(
                                            JSBS_MinimalParameters parmMinParm,
                                            type_or_class parameter_variable1);
/* ***** */

In der Klasse für das Bean können ebenfalls die Standard-Methoden für jedes BO kopiert werden.
Anschließend finden Sie die Abgrenzungen für den Muster-Code für ein BO:

/* 
 * ====================
 * METHODEN für ein Business-Objects (BO) zum Speichern, Löschen (Deaktivieren) und
 * Lesen eines einzelnen BO und eines Sets (Liste) von mehreren BOs. 
 *
 * Die folgenden Muster-Methoden können beliebig oft kopiert
 * und für jedes BO adaptiert werden. */
/* ---------------------------------------- */
    public synchronized Application_Entity_BO Application_Entity_BO__store(
                                      JSBS_MinimalParameters parmMinParm,
                                      Application_Entity_BO parmBO) {
/*
 * BO, das an die aufrufende Methode zurückgeliefert wird, definieren und konstruieren. */
      Application_Entity_BO boApplication_Entity_BO = new Application_Entity_BO();
/*
 * Variable für die Verbindung (Connection) zur Datenbank definieren und Methode zum
. . . . . .
. . . . . .
      try {DBCon.close();}
      catch (Exception e){}
/* 
 * BO-Set mit den selektierten Daten - oder mit dem entsprechenden Status - an die aufrufende  
 * Methode zurück liefern. */
      return boApplication_Entity_BO_Set;
    }
/* ***** */ 
}


Für alle Methoden für den Zugriff auf die Datenbank kann der Platzhalter durch 'Find/Replace' ersetzt werden.

Dieses Vorgehen kann bei den Interfaces und der Klasse für das EJB angewandt werden.

In den folgenden Abschnitten werden Erläuterungen für das Adaptieren innerhalb der einzelnen Methoden dokumentiert.

▲ zum Inhaltsverzeichnis

Methoden für die Datenzugriffe adaptieren – keine zusätzlichen Änderungen in store und deactivate

▲ zum Inhaltsverzeichnis

Methoden für die Datenzugriffe adaptieren – Anpassen der Parameter für den Anwender-bekannten Schlüssel in selectNext, selectPrevious und selectByUserKnownKey

▲ zum Inhaltsverzeichnis

Methoden für die Datenzugriffe adaptieren – Anpassen der Parameter für Datenbank-Abfragen die eine Liste von BO zurück liefern; Muster entsprechend selectByFurtherSpecification

▲ zum Inhaltsverzeichnis

Packen der Dateien in JAR (Java ARchiv) und EAR (Enterprise ARchiv)

Für die endgültige Auslieferung des EJB ist eine Datei im EAR-Format vorgesehen.

Die Anleitung für das Erstellen der Datei finden Sie unter Leitfaden für die Entwicklung von Heavyweight-Clients mit dem JS-FCF – Packen der Anwendung in JAR-Dateien > Packen für die Client-Server-Version.
Während der Entwicklungs- und Test-Phase des Anwendungsprogramms können – abhängig von der Konfiguration Ihres JAS (Java Application Server) – einzelne der folgenden Abschnitte nicht notwendig sein.

Aus Erfahrung empfehle ich, zu einem frühen Zeitpunkt die komplette Konfiguration für das Packen zu erstellen.
Die Konfiguration muss bei einer Weiterentwicklung des EJB (z.B. zusätzlich Klassen für Datenbankzugriffe) nicht mehr geändert werden.
Es ist nur notwendig, ein neues 'Packen' der Archiv-Dateien auszuführen.

▲ zum Inhaltsverzeichnis

Die Beschreibungen in den folgenden Abschnitten werden nicht mehr aktualisiert – sie bleiben nur mehr aus dokumentarischen Gründen in diesem Dokument !

Konfigurationsdateien für das JAR

In diesen Dateien wird

Diese Dateien sind im Verzeichnis 'META-INF' innerhalb der JAR-Datei enthalten.
Weil dieses Verzeichnis einmal pro EJB (in der JAR-Datei) und auch in der EAR-Datei vorkommt (siehe Abschnitt Konfigurationsdateien für das EAR) wird innerhalb des Eclipse-Projects jedes META-INF Verzeichnis für ein EJB durch eine Erweiterung im Namen eindeutig gekennzeichnet.

Zum Erstellen eines Verzeichnisses wird das Project mit der rechten Maustaste angeklickt und aus dem Kontext-Menu New > Folder ausgewählt.

  
  

Im anschließend geöffneten Fenster (New Folder) wird der Name des Verzeichnisses eingegeben und die Schaltfläche [  Finish  ] mit der linken Maustaste angeklickt.

Hier wurde als Name des Verzeichnisses 'META-INF_Standard' gewählt.
Damit kann bei mehreren EJB, die eventuell innerhalb eines Eclipse-Project erstellt werden, unterschieden werden, in welche JAR-Datei die Dateien in diesem Verzeichnis gepackt werden müssen.

Zusätzlich wird später (im Abschnitt Konfigurationsdateien für das EAR) ein weiteres 'META-INF' Verzeichnis für die EAR-Datei erstellt.

  
  

Das gerade erstellte Verzeichnis ist in der Struktur des Package Explorers sichtbar.

  
  

Zum Erstellen einer Datei innerhalb des Verzeichnisses wird das Verzeichnis mit der rechten Maustaste angeklickt und aus dem Kontext-Menu New > File ausgewählt.

  
  

Im anschließend geöffneten Fenster (New File) wird überprüft, ob das korrekte Verzeichnis eingetragen ist, der Name der Datei eingegeben und die Schaltfläche [  Finish  ] mit der linken Maustaste angeklickt.

  
  

Die gerade erstellte Datei ist in der Struktur des Package Explorers sichtbar und für das Erfassen des Inhalts geöffnet.

  
  

Im angelegten Verzeichnis sind zwei Arten von Dateien enthalten:

▲ zum Inhaltsverzeichnis

Packaging Configuration für das JAR

Eine detaillierte Anleitung für das Anlegen von Project-Archives mit zahlreichen Abbildungen finden Sie unter Tutorial: Einfache Session Bean, EJB3-Standard (Java_EJB_05) – Packen der Dateien in Java-Archive (JAR) und 'deploy' > 'Project archive' anlegen und den folgenden Abschnitten des Tutorials.
Deswegen sind die grundlegenden Tätigkeiten für das 'Packen' in diesem Dokument nur in Kurzform beschrieben:
* View für die 'Project archives' eröffnen – wenn noch nicht geschehen.
  Window > Show View > Other; 'Project archives' innerhalb der Gruppe 'JBoss Tools'.
* Project auswählen für das ein 'Project archive' angelegt werden soll.

Innerhalb des Bereichs 'Project archives' wird das Project mit der rechten Maustaste angeklickt und aus dem Kontext-Menu New Archive > EJB JAR ausgewählt.

  
  

Im anschließend geöffneten Fenster (New EJB JAR) werden die vorgegebenen Einstellungen beibehalten und die Schaltfläche [  Next >  ] mit der linken Maustaste angeklickt.

  
  

Im folgenden Fenster wird eine Vorschau auf die Verzeichnis-Struktur innerhalb der JAR-Datei angezeigt.
Diese ist derzeit leer weil noch keine Verzeichnisse und Dateien ausgewählt wurden.
Das Fenster wird durch anklicken der Schaltfläche [  Finish  ] geschlossen.

  
  

Im Bereich des 'Project archives' ist dann sichtbar, welche Dateien für das packen in die JAR-Datei ausgewählt sind – derzeit noch keine.

Die Struktur für die JAR-Datei kann durch Anklicken des kleinen Dreiecks links neben den Datei- bzw. Verzeichnis-Namen angezeigt oder verborgen werden.

  
  

Als Nächstes wird ein Verzeichnis (META-INF) definiert.

Dazu wird die Packaging Configuration für das JAR angeklickt, mit der rechten Maustaste das Kontext-Menu aufgerufen und daraus New Folder ausgewählt.

  
  

Im nachfolgend geöffneten Fenster (Create a folder) wird der Name des Verzeichnisses ('META-INF') erfasst und durch Anklicken der Schaltfläche [  OK  ] bestätigt.
Damit wird das Fenster wieder geschlossen.

  
  

Im Bereich des 'Project archives' ist dann das erstellte Verzeichnis sichtbar.

Die Struktur für die JAR-Datei kann durch Anklicken des kleinen Dreiecks links neben den Datei- bzw. Verzeichnis-Namen angezeigt oder verborgen werden.

  
  

Als Nächstes wird definiert, welche Dateien und eventuell Unterverzeichnisse (samt Dateien und weiteren Unterverzeichnissen) in das Verzeichnis 'META-INF' der zu erstellenden Archiv-Datei aufgenommen werden.

Dazu wird der gerade erstellte Eintrag für das Unterverzeichnis angeklickt, mit der rechten Maustaste das Kontext-Menu aufgerufen und daraus New Fileset ausgewählt.

  
  

Im folgenden Fenster (Fileset Wizard) wird festgelegt, welche Dateien (und eventuell weitere Unterverzeichnisse mit Dateien) in die Archiv-Datei aufgenommen werden.

Zum Auswählen des Unterverzeichnisses mit der/den Quell-Datei(en) wird die Schaltfläche [ Workspace... ] angeklickt.

 
 

Im neu geöffneten Fenster (Select a destination) wird zum Unterverzeichnis mit der/den zu packenden Datei(en) manövriert (Wenn Sie dem Vorschlag im Abschnitt Konfigurationsdateien für das JAR gefolgt sind: 'META-INF_Standard') und die Auswahl durch Anklicken der Schaltfläche [  OK  ] bestätigt.

Nach dem Anklicken der Schaltfläche wird das Fenster wieder geschlossen.

 
 

Im Fenster 'File Wizard' sehen Sie, dass die Auswahl der Dateien eingeschränkt wurde; die Auswahl ist im Feld 'Preview' gelistet.

Als Filter für die ausgewählten Dateien wird im Eingabefeld 'Includes' der Wert */** eingegeben.

*/** bedeutet, dass alle Dateien im Unterverzeichnis und eventuell vorhandene Unterverzeichnisse mit den enthaltenen Dateien in die Archiv-Datei gepackt werden.

Die Auswahl wird durch Anklicken der Schaltfläche [ Finish ] bestätigt.

Wichtiger Hinweis:
In der Abbildung fehlt eine Konfigurationsdatei für die Zuordnung der 'Datasource'.
Der Namen der Datei und auch der Inhalt (XML-Struktur) werden durch den verwendeten JAS (Java Application Server) bestimmt. Aus diesem Grund wurde verzichtet, speziell auf einzelne JAS 'abgestimmte' Dateien in die Abbildung aufzunehmen.

Sobald Sie aber eine oder mehrere Konfigurationsdateien in das Verzeichnis (im Beispiel: 'META-INF_Standard') aufnehmen, werden diese Dateien in die Archiv-Datei gepackt ohne das die Packaging Configuration geändert werden muss.

Nach dem Anklicken der Schaltfläche wird das Fenster wieder geschlossen.

 
 

Im Bereich des 'Project archives' ist dann sichtbar, welche Filter-Kriterien für das Packen von Dateien in die Archiv-Datei angewendet werden.

Die Struktur für die JAR-Datei kann durch Anklicken des kleinen Dreiecks links neben den Datei- bzw. Verzeichnis-Namen angezeigt oder verborgen werden.

  
  

Als Nächstes werden die Java-Klassen inklusive der durch die Java-'package's definierten Verzeichnis-Struktur in das EJB aufgenommen.

Für das Hinzufügen von Dateien (inklusive der Verzeichnis-Struktur) wird die Packaging Configuration für das JAR mit der rechten Maustaste angeklickt und aus dem Kontext-Menu New Fileset ausgewählt.

  
  

Im folgenden Fenster (Fileset Wizard) wird durch Anklicken der Schaltfläche [ Workspace... ] (über dem Eingabefeld 'Includes') ein eigenes Fenster geöffnet, in dem als Nächstes jenes Verzeichnis, in dem die Dateien mit den Java-Klassen – inlusive der Verzeichnis-Struktur für die Java-'package's – sind, ausgewählt werden kann.

  
  

Im erscheinenden Auswahl-Fenster ('Select a destination') wird zu jenem Verzeichnis manövriert, in dem die Dateien mit den Java-Klassen liegen.
Dieses Verzeichnis wurde unter Leitfaden für die Entwicklung von Heavyweight-Clients mit dem JS-FCF – Vorbereitung > Vorbereitung eines Projects definiert.

Die Verzeichnis-Struktur wird angezeigt bzw. verborgen, wenn das kleine Dreieck links neben einem Verzeichnis-Namen angeklickt wird.

Die Auswahl wird durch Anklicken der Schaltfläche [  OK  ] bestätigt und damit wird auch das Fenster geschlossen.

  
  

Im Fenster 'Fileset Wizard' werden dann die Filter-Kriterien für die Dateien, die in die JAR-Datei aufgenommen werden sollen, im Feld 'Includes' festgelegt: **/*.class.

**/ bedeutet, dass alle Verzeichnisse in der Struktur auf Dateien mit einem passenden Namen durchsucht werden.

*.class bedeutet, dass alle Dateien, deren Namen mit .class endet, in die JAR-Datei gepackt werden sollen.

Da im Project auch Java-Packages, die nur auf der Client-Seite des Anwendungsprogramms gebraucht werden, wird im Feld 'Excludes' festgelegt, welche Packages nicht in die Archiv-Datei aufgenommen werden sollen.
Diese Liste der auszuschließenden Java-Packages ist individuell für Ihr Project.
Die Java-Klassen innerhalb der packages .../client/* und .../boc/* gehören aber nicht in die Archiv-Datei für das EJB.

Nach Eingabe der Filter-Kriterien ist im Feld 'Preview' zu sehen, welche Dateien ausgewählt sind.

Die Definition wird durch Anklicken der Schaltfläche [  Finish  ] abgeschlossen und damit wird auch das Fenster geschlossen.

  
  

Im Bereich des 'Project archives' ist dann sichtbar, welche Dateien für das Packen in die JAR-Datei ausgewählt sind.

Die Struktur für die JAR-Datei kann durch Anklicken des kleinen Dreiecks links neben den Datei- bzw. Verzeichnis-Namen angezeigt oder verborgen werden.

  
  



▲ zum Inhaltsverzeichnis

Konfigurationsdateien für das EAR

In dieser (üblicherweise einen) Datei wird

Diese Dateien sind im Verzeichnis 'META-INF' innerhalb der EAR-Datei enthalten.

Zum Erstellen eines Verzeichnisses wird das Project mit der rechten Maustaste angeklickt und aus dem Kontext-Menu New > Folder ausgewählt.

  
  

Im anschließend geöffneten Fenster (New Folder) wird der Name des Verzeichnisses ('META-INF') eingegeben und die Schaltfläche [  Finish  ] mit der linken Maustaste angeklickt.

  
  

Das gerade erstellte Verzeichnis ist in der Struktur des Package Explorers sichtbar.

  
  

Zum Erstellen einer Datei innerhalb des Verzeichnisses wird das Verzeichnis mit der rechten Maustaste angeklickt und aus dem Kontext-Menu New > File ausgewählt.

  
  

Im anschließend geöffneten Fenster (New File) wird überprüft, ob das korrekte Verzeichnis eingetragen ist, der Name der Datei ('application.xml') eingegeben und die Schaltfläche [  Finish  ] mit der linken Maustaste angeklickt.

  
  

Die gerade erstellte Datei ist in der Struktur des Package Explorers sichtbar und für das Erfassen des Inhalts geöffnet.

  
  

Die Datei 'application.xml' enthält folgende XML-Struktur (Beispiel):

<?xml version="1.0" encoding="UTF-8"?>
<application>
  <display-name>In der Übersicht des JAS angezeigter Name</display-name>
    <module>
      <ejb>JAR-Dateiname_des_EJB.jar</ejb>
    </module>
    <module>
      <ejb>JAR-Dateiname_weiteres_EJB.jar</ejb>
    </module>
    <module>
      <java>JSBS_For_EJB.jar</java>
    </module>
    <module>
      <java>JAR-Dateiname_einer_weiteren_Bibliothek.jar</java>
    </module>
</application>

Die kursiv und fett geschriebenen Teile sind durch die entsprechenden Namen Ihrer speziellen Anwendung zu ersetzen.

Eine Erklärung der Einträge in der XML-Struktur finden Sie unter Tutorial: Einfache Session Bean, EJB-Standard (Java_EJB_05) – Packen in EAR-Datei und Ändern des JNDI-Namens > Konfigurationsdatei application.xml erstellen.

Zusätzlich ist in der Beispiel-Datei ein neuer Typ eines Eintrags enthalten:

▲ zum Inhaltsverzeichnis

Packaging Configuration für das EAR

Die Erstellung der Packaging Configuration für das EAR (Enterprise ARchive) unterscheidet sich nicht wesentlich von der im Abschnitt Packaging Configuration für das JAR beschriebenen Vorgangsweise.

Innerhalb des Bereichs 'Project archives' wird das Project mit der rechten Maustaste angeklickt und aus dem Kontext-Menu New Archive > EAR ausgewählt.

  
  

Im anschließend geöffneten Fenster (New EAR) werden die vorgegebenen Einstellungen beibehalten und die Schaltfläche [  Next >  ] mit der linken Maustaste angeklickt.

  
  

Im folgenden Fenster wird eine Vorschau auf die Verzeichnis-Struktur innerhalb der JAR-Datei angezeigt.

Ob das Verzeichnis 'META-INF' mit den enthaltenen Dateien in die Packaging Configuration aufgenommen wurde hängt von der Version von Eclipse und dem JBoss-IDE Plugin ab.
Wenn das Verzeichnis nicht automatisch aufgenommen wurde, definieren Sie es bitte manuell.
Das Vorgehen ist analog wie im Abschnitt Packaging Configuration für das JAR beschrieben.

Das Fenster wird durch anklicken der Schaltfläche [  Finish  ] geschlossen.

  
  

Im Bereich des 'Project archives' ist dann sichtbar, welche Dateien für das packen in die EAR-Datei ausgewählt sind.

Die Struktur für die JAR-Datei kann durch Anklicken des kleinen Dreiecks links neben den Datei- bzw. Verzeichnis-Namen angezeigt oder verborgen werden.

  
  

Als Nächstes werden die JAR- (Java ARchiv-) Dateien, die in die EAR- (Enterprise ARchiv-) Datei gepackt werden, festgelegt.

Für das Hinzufügen von Dateien wird die Packaging Configuration für das EAR mit der rechten Maustaste angeklickt und aus dem Kontext-Menu New Fileset ausgewählt.

  
  

Im anschließend geöffneten Fenster (Fileset Wizard) wird das die Filter-Kriterium für die JAR-Datei die in die EAR-Datei aufgenommen werden soll, im Feld 'Includes' festgelegt.
Der Name der Datei in der Abbildung (GroceryList.jar) ist ein Beispiel und bei Ihrem konkreten Project durch den Namen der Datei mit den Klassen für das EJB zu ersetzen.

Nach Eingabe des 'Filter-Kriteriums' ist im Feld 'Preview' zu sehen, welche Datei ausgewählt ist.

Die Definition wird durch Anklicken der Schaltfläche [  Finish  ] abgeschlossen und damit wird auch das Fenster geschlossen.

Anmerkung:
Es ist auch möglich, durch das Filterkriterium *.jar alle zu packenden Dateien mit Java-Klassen auszuwählen.
Dann muss allerdings die (im Abschnitt Packen der Remote-Interface in eine JAR (Java ARchiv) Datei für die Verwendung in Client-Programmen) erstellte JAR-Datei im Feld 'Excludes' erfasst werden – sonst wird sie ebenfalls in das EAR gepackt.
Das hat zwar keine negativen Auswirkungen, ist aber sinnlos und braucht etwas Kapazität der Festplatte des JAS (Java Application Server).

  
  

Im Bereich des 'Project archives' ist dann sichtbar, welche Dateien für das Packen in die JAR-Datei ausgewählt sind.

Die Struktur für die JAR-Datei kann durch Anklicken des kleinen Dreiecks links neben den Datei- bzw. Verzeichnis-Namen angezeigt oder verborgen werden.

  
  

Weitere in die EAR-Datei zu packende Dateien werden nach dem gleichen Schema ausgewählt.
Ab hier werden noch die Tätigkeiten beschrieben, wie die JavaScout Basisklassen in die EAR-Datei aufgenommen werden.
Wenn Sie die JAR-Datei mit den Basisklassen noch nicht heruntergeladen haben:
Folgen Sie diesem Link und speichern Sie die Datei in einem Verzeichnis Ihrer Wahl.


Für das Hinzufügen weiterer Dateien wird wieder die Packaging Configuration für das EAR mit der rechten Maustaste angeklickt und aus dem Kontext-Menu New Fileset ausgewählt.

  
  

Im folgenden Fenster (Fileset Wizard) wird durch Anklicken der Schaltfläche [ Filesystem... ] (über dem Eingabefeld 'Includes') ein eigenes Fenster geöffnet, in dem als Nächstes jenes Verzeichnis, in dem die JAR-Datei mit den JavaScout Basisklassen ist, ausgewählt werden kann.

Die Schaltfläche [ Filesystem ] ist vorgesehen, um Verzeichnisse und Dateien 'außerhalb' des Verzeichnisses mit dem Eclipse-Project erreichen zu können.
Wenn Sie die JAR-Datei mit den JavaScout Basisklassen in einem Verzeichnis innerhalb des Eclipse-Project gespeichert haben, können Sie auch mit der Schaltfläche [ Workspace ] zum Verzeichnis manövrieren.

  
  

Im erscheinenden Auswahl-Fenster wird zu jenem Verzeichnis manövriert, in dem die JAR-Dateien mit den JavaScout Basisklassen nach dem herunter laden gespeichert wurde.

In der Abbildung ist das '/usr/JS_Data_eclipse_workspaces/external_jars' – bei Ihrer Installation wird das aber sicher ein anderes Verzeichnis sein !

Die Auswahl wird durch Anklicken der Schaltfläche [  OK  ] bestätigt und damit wird auch das Fenster geschlossen.

  
  

Im Fenster 'Fileset Wizard' wird dann die Datei als Filterkriterium im Feld 'Includes' festgelegt: JSBS_For_EJB.jar.

Nach Eingabe der Filter-Kriterien ist im Feld 'Preview' zu sehen, welche Datei ausgewählt ist.

Die Definition wird durch Anklicken der Schaltfläche [  Finish  ] abgeschlossen und damit wird auch das Fenster geschlossen.

  
  

Im Bereich des 'Project archives' ist dann sichtbar, dass auch die JAR-Datei mit den JavaScout Basisklassen in das EAR aufgenommen wird.

Die Struktur für die JAR-Datei kann durch Anklicken des kleinen Dreiecks links neben den Datei- bzw. Verzeichnis-Namen angezeigt oder verborgen werden.

  
  

▲ zum Inhaltsverzeichnis

Packen der Remote-Interface in eine JAR (Java ARchiv) Datei für die Verwendung in Client-Programmen

Eine detaillierte Beschreibung über den Zweck dieses Abschnitts finden Sie unter Tutorial: Einfache Session Bean, EJB3-Standard (Java_EJB_05) – Packen der Dateien in Java-Archive (JAR) und 'deploy' > JAR-Datei für Client-Programme erstellen.

Innerhalb des Bereichs 'Project archives' wird das Project mit der rechten Maustaste angeklickt und aus dem Kontext-Menu New Archive > JAR ausgewählt.

  
  

Der vorgegebene 'Archive name' – im Beispiel 'GroceryList.jar'; dieser wird aber bei Ihrem Project sicher anders lauten – existiert bereits für das JAR mit den Klassen des EJB.

Deswegen wird der Name der Datei wird um den Zusatz -client erweitert.

Anschließend wird die Eingabe des Dateinamens durch Anklicken der Schaltfläche [ Finish ] bestätigt.

  
  

Die neu erstellte Datei ist jetzt im Bereich des 'Project archives' gelistet.

In die Datei werden nur Dateien mit Java-Klassen, die von Client-Programmen importiert werden müssen, aufgenommen.

Für das Hinzufügen dieser Dateien wird die gerade angelegte Datei mit der rechten Maustaste angeklickt und aus dem Kontext-Menu New Fileset ausgewählt.


  

Im folgenden Fenster (Fileset Wizard) wird durch Anklicken der Schaltfläche [ Workspace... ] (über dem Eingabefeld 'Includes') ein weiteres Fenster geöffnet.

 
  

Im erscheinenden Auswahl-Fenster ('Select a destination') wird zu jenem Verzeichnis manövriert, in dem die Dateien mit den Java-Klassen liegen.
Dieses Verzeichnis wurde unter Leitfaden für die Entwicklung von Heavyweight-Clients mit dem JS-FCF – Vorbereitung > Vorbereitung eines Projects definiert.

Die Verzeichnis-Struktur wird angezeigt bzw. verborgen, wenn das kleine Dreieck links neben einem Verzeichnis-Namen angeklickt wird.

Die Auswahl wird durch Anklicken der Schaltfläche [  OK  ] bestätigt und damit wird auch das Fenster geschlossen.

  
  

Im Fenster für das 'New Fileset' werden dann noch im Feld 'Includes' die Filterkriterien **/remote/*.class für die Auswahl der Dateien festgelegt.

Die ausgewählte Datei (Interface für das EJB – oder auch mehrere EJB) ist dann im Bereich 'Preview' gelistet.

Die Auswahl wird durch Anklicken der Schaltfläche [ Finish ] bestätigt und damit wird auch das Fenster geschlossen.

  
  

Im Bereich des 'Project archives' ist dann sichtbar, welcher Filter für die Java-Klassen, die in die Archiv-Datei aufgenommen werden, wirksam ist.

Die Struktur für die JAR-Datei kann durch Anklicken des kleinen Dreiecks links neben den Datei- bzw. Verzeichnis-Namen angezeigt oder verborgen werden.

  
  



▲ zum Inhaltsverzeichnis

Weitere Schritte und verwandte Dokumentation

Dokument

Inhalt

Verzeichnis: Leitfaden für die Entwicklung von Heavyweight-Clients mit dem JS-FCF  

Dokument mit einer generellen Übersicht der notwendigen Teile für die Entwicklung von Anwendungsprogrammen nach dem JavaScout Fat-Client-Framework (JS-FCF).

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  

Dokument mit einer generellen Übersicht der Tätigkeiten für die Entwicklung der einzelnen Klassen für die Persistenz (dauerhafte Speicherung von Daten) und Zugriff auf die Daten durch Verwendung von EJB (Enterprise Java Beans).

Muster-Code für ein BOS (Server-Side-Klasse eines Business-Object)  

Muster-Code für die Server-Seitige BO-Klasse; diese Klassen werden im EJB aufgerufen und führen die SQL-Operationen für genau einen Datensatz (Speichern oder Lesen mit Kriterien, die maximal einen Datensatz auswählen können) auf die Datenbank durch.

Muster-Code für ein BOS_Set (Liste mit Business-Objects, Server-Side-Klasse)  

Muster-Code für die Server-Seitige Klasse mit einer Liste von BO; diese Klassen werden im EJB aufgerufen und führen die SQL-Operationen für das Abfragen mit der Möglichkeit mehrerer Datensätze als Ergebnis auf die Datenbank durch.

Leitfaden für die Entwicklung von Heavyweight-Clients mit dem JS-FCF – Packen der Anwendung in JAR-Dateien

Anleitung zum Erstellen der Archive-Dateien.

▲ zum Inhaltsverzeichnis