Übersicht über die Java-Laufzeiteigenschaften

Ein mit EGL generiertes Java™-Programm bezieht die für die Laufzeitumgebung erforderlichen Informationen aus einer Gruppe von Eigenschaften. Die meisten dieser Java-Laufzeiteigenschaften werden mithilfe von Builddeskriptoroptionen definiert, denen Sie Werte zuordnen, indem Sie den Builddeskriptorabschnitt im EGL-Buildabschnittseditor bearbeiten.

Anmerkung: Die mit EGL generierten Java-VGWebTransaction-Programme stellen einen Sonderfall dar. Die Einstellung der Programmeigenschaft enableJ2EE bestimmt, ob sie in einer J2EE-Umgebung oder einer anderen Umgebung ausgeführt werden. (Der Standardwert ist NO.)Wenn Sie diesen Abschnitt lesen, weil Sie mit einem VGWebTransaction-Programm arbeiten, sind die hier enthaltenen Verweise auf die Builddeskriptoroption j2ee für Sie nicht relevant. Für Sie ist stattdessen die Programmeigenschaft enableJ2EE von Bedeutung.
Bei der Generierung werden die Werte der Builddeskriptoroptionen in den entsprechenden Java-Laufzeiteigenschaften gespeichert, die danach in einer der folgenden Dateien aufgelistet werden:

Sie können anschließend entweder den J2EE-Implementierungsdeskriptor oder die Java-Eigenschaftendatei aufrufen und die Werte der Laufzeiteigenschaften nach Bedarf bearbeiten, ohne den Code neu generieren zu müssen.

Sie müssen die Builddeskriptoroption genProperties mit PROGRAM oder GLOBAL definieren, damit EGL die Builddeskriptoroptionen zum Erstellen von Laufzeiteigenschaften verwendet.

Builddeskriptoren und Programmeigenschaften

Wenn Sie Java-Laufzeiteigenschaften generieren, werden die Eigenschaften wie in einem der folgenden Szenarios beschrieben erstellt und gespeichert:
  1. Gehen Sie zum Generieren von Java-Laufzeiteigenschaften im J2EE-Implementierungsdeskriptor wie folgt vor:
    1. Definieren Sie die Builddeskriptoroption j2ee mit YES.
    2. Definieren Sie die Builddeskriptoroption genProperties mit PROGRAM oder GLOBAL.
    3. Genieren Sie Ihren Code in ein J2EE-Projekt.
  2. Gehen Sie zum Generieren von Eigenschaften in eine J2EE-Umgebungsdatei wie folgt vor:
    1. Definieren Sie die Builddeskriptoroption j2ee mit YES.
    2. Definieren Sie die Builddeskriptoroption genProperties mit PROGRAM oder GLOBAL.
    3. Führen Sie eine der folgenden Aktionen durch:
      • Generieren Sie in ein Verzeichnis. In diesem Fall wird die Builddeskriptoroption genDirectory anstelle von genProject verwendet.
      • Generieren Sie in ein Nicht-J2EE-Projekt.
    Dabei ist zu beachten, dass die in der J2EE-Umgebungsdatei gespeicherten Eigenschaften beim Generieren nicht automatisch aktualisiert werden.
  3. Gehen Sie zum Generieren einer Programmeigenschaftendatei, die denselben Namen wie das zu generierende Projekt hat, wie folgt vor:
    1. Definieren Sie die Builddeskriptoroption j2ee mit NO.
    2. Definieren Sie die Builddeskriptoroption genProperties mit PROGRAM.
    3. Führen Sie eine der folgenden Aktionen durch:
      • Generieren Sie in ein Verzeichnis. Verwenden Sie dazu die Builddeskriptoroption genDirectory anstelle von genProject.
      • Generieren Sie in ein Nicht-J2EE-Projekt.
  4. Gehen Sie zum Generieren einer Programmeigenschaftendatei mit dem Namen rununit.properties wie folgt vor:
    1. Definieren Sie die Builddeskriptoroption j2ee mit NO.
    2. Definieren Sie die Builddeskriptoroption genProperties mit GLOBAL.
    3. Führen Sie eine der folgenden Aktionen durch:
      • Generieren Sie in ein Verzeichnis. In diesem Fall wird die Builddeskriptoroption genDirectory anstelle von genProject verwendet.
      • Generieren Sie in ein Nicht-J2EE-Projekt.
  5. Vermeiden Sie das Generieren von Eigenschaften, indem Sie die Eigenschaft genProperties mit NO definieren.

J2EE-Umgebung

Wenn Sie in ein Java-Programm generieren, das in einer J2EE-Umgebung ausgeführt wird, können die Java-Laufzeiteigenschaften auf eine der folgenden Weisen erstellt werden:
  • Sie können die Schritte des ersten Szenarios im vorherigen Abschnitt ausführen, um die Java-Laufzeiteigenschaften direkt in einen J2EE-Implementierungsdeskriptor zu generieren. In diesem Fall überschreibt EGL Eigenschaften, die bereits vorhanden sind, und hängt noch nicht vorhandene Eigenschaften an. Das generierte Java-Programm greift zur Laufzeit auf den J2EE-Implementierungsdeskriptor zu.
  • Sie können stattdessen auch die Schritte des zweiten Szenarios im vorherigen Abschnitt ausführen, um die Laufzeiteigenschaften in eine J2EE-Umgebungsdatei zu generieren. Sie können die Eigenschaften in dieser Datei anpassen und anschließend in den J2EE-Implementierungsdeskriptor kopieren.
  • Sie können auch die Schritte für das fünfte Szenario des vorherigen Abschnitts ausführen und die Builddeskriptoroption genProperties mit NO definieren, um das Generieren der Laufzeiteigenschaften vollständig zu umgehen. In diesem Fall müssen Sie alle erforderlichen Java-Laufzeiteigenschaften von Hand schreiben.

In einem J2EE-Model muss jedes einzelne Programm über dieselben Laufzeiteigenschaften verfügen, da der gesamte Code im Modul denselben J2EE-Implementierungsdeskriptor nutzt.

Bei J2EE-Servern werden Eigenschaften in Form von Tags für Umgebungseinträge (env-entry) in der Datei 'web.xml' angegeben, die dem Webprojekt zugeordnet ist. Dazu folgende Beispiele:
  <env-entry>
		  <env-entry-name>vgj.nls.code</env-entry-name>
    <env-entry-value>ENU</env-entry-value>
    <env-entry-type>java.lang.String</env-entry-type>
  </env-entry>

  <env-entry>
    <env-entry-name>vgj.nls.number.decimal</env-entry-name>
    <env-entry-value>.</env-entry-value>
    <env-entry-type>java.lang.String</env-entry-type>
  </env-entry>

Nicht-J2EE-Umgebung

Wenn Sie ein Java-Programm generieren, das außerhalb einer J2EE-Umgebung ausgeführt wird, können Sie die Builddeskriptoroption genProperties mit PROGRAM oder GLOBAL definieren. Die Laufzeiteigenschaften werden daraufhin von EGL in eine Programmeigenschaftendatei generiert. Sie können die Programmeigenschaftendatei jedoch stattdessen auch von Hand codieren. Die Programmeigenschaftendatei liefert die Informationen, die im Implementierungsdeskriptor verfügbar sind, die Eigenschaften weisen jedoch ein anderes Format auf.

In einer Nicht-J2EE-Java-Umgebung können Laufzeiteigenschaften in einer beliebigen Eigenschaftendatei angegeben sein, die in folgender Reihenfolge durchsucht werden:
  1. user.properties
  2. Eine Datei, die einen Namen im folgenden Format aufweist:
      Programmname.properties
    Dabei ist Programmname der Name des ersten Programms in der Ausführungseinheit.
  3. rununit.properties

Eine Verwendung von user.properties bietet sich an, wenn Sie Eigenschaften festlegen, die für einen bestimmten Benutzer gelten sollen. EGL generiert für diese Datei keinen Inhalt.

Eine Verwendung von rununit.properties ist vor allem dann sinnvoll, wenn das erste Programm der Ausführungseinheit nicht auf eine Datei oder eine Datenbank zugreift, jedoch Programme aufruft, die derartige Zugriffe ausführen. Beispiel:
  • Wenn Sie das aufrufende Programm generieren, können Sie eine Eigenschaftendatei mit einem Namen für das generierte Programm erstellen, deren Inhalt möglicherweise keine datenbank- oder dateibezogenen Eigenschaften einschließt.
  • Wenn Sie das aufgerufene Programm generieren, können Sie die Datei rununit.properties generieren, deren Inhalt dann für beide Programme verfügbar ist.

Keine der Eigenschaftendateien muss zwingend erstellt werden. Sie werden von einfachen Programmen nicht benötigt.

Regeln für die Implementierung von Nicht-J2EE-Code

Zur Implementierungszeit gelten folgende Regeln:
  • Die Benutzereigenschaftendatei user.properties befindet sich, soweit vorhanden, im Benutzerausgangsverzeichnis, das über die JavaSystemeigenschaft user.home bestimmt wird.
  • Die Position einer Programmeigenschaftendatei, soweit vorhanden, hängt davon ab, ob das Programm in einem Paket enthalten ist. Die Regeln lassen sich am besten anhand eines Beispiels veranschaulichen:
    • Wird Programm P aus dem Paket 'x.y.z' in 'MyProject/src' implementiert, muss sich die Programmeigenschaftendatei im Verzeichnis 'MyProject/src/x/y/z' befinden.
    • Ist das in 'MyProject/src' zu implementierende Programm P nicht in einem Paket enthalten, muss sich die Programmeigenschaftendatei (wie die Datei mit den globalen Eigenschaften) im Verzeichnis 'MyProject/src' befinden.

    In beiden Fällen muss 'MyProject/src' im Klassenpfad enthalten sein.

  • Die Datei mit den globalen Eigenschaften (rununit.properties) muss sich, soweit vorhanden, zusammen mit dem Programm in einem Verzeichnis befinden, das im Klassenpfad angegeben ist.

Wenn Sie Ausgabe in ein Java-Projekt generieren, stellt EGL die Eigenschaftendateien (mit Ausnahme von user.properties) in die entsprechenden Ordner.

Nähere Angaben zum Zugriff auf Laufzeiteigenschaften in Ihrem EGL-Code finden Sie in den Abschnitten zu 'getProperty()' und zur Ausführungseinheit in der EGL-Sprachreferenz.


Feedback