Methode 1 wird eingesetzt, um die WrapperSimpleApp Helper-Klasse für den Anwendungsstart zu benutzen.
Dies ist bei weitem der einfachste Weg, um den Wrapper zu integrieren, und wo möglich, wird dieser auch sehr empfohlen.
Es gibt jedoch ein paar Dinge, auf die beim Benutzen dieser Methode geachtet werden sollte.
Wenn der Wrapper die JVM beendet, gibt es keinen direkten Aufruf in der Anwendung, die ein ordnungsgemäßes Beenden ermöglicht.
Viel mehr beendet der Wrapper die JVM durch das Aufrufen von System.exit() innerhalb der JVM.
Falls die Anwendung ihren eigenen "Shutdown Hook" registriert hat, wird dieser aufgerufen werden, und gibt so der Anwendung eine Möglichkeit, sich ordnungsgemäß zu beenden.
Wenn andererseits kein Shutdown Hook registriert ist,
wird die Anwendung plötzlich beendet, gleich dem Drücken von STRG-C in der Konsole (Kommandofenster).
Beide Fälle, mit und ohne Shutdown Hook, liefern das genau gleiche Verhalten, als ob die Anwendung ohne den Wrapper laufen würde.
Methode 1 wird eingesetzt, um die WrapperSimpleApp Helper-Klasse statt der main-Klasse zu benutzen..
Dies ermöglicht es der WrapperSimpleApp-Klasse,
den WrapperManager sofort zu initialisieren und die JVM mit dem Wrapper zu registrieren.
Die WrapperSimpleApp-Klasse regelt dann den gesamten Austausch mit dem Wrapper sowie den Lebenszyklus einer Anwendung.
Wenn der Wrapper eine Start-Nachricht an die JVM via WrapperManager sendet,
wird die Main-Methode der aktuellen Main-Klasse der Anwendung aufgerufen.
Die WrapperSimpleApp Helper-Klasse wird darüber informiert, wie die Anwendung durch Übergabe des Main-Klasse-Namens,
gefolgt durch beliebige zusätzliche Anwendungsparameter an die Main-Methode der WrapperSimpleApp zu starten ist.
Detaillierte Anweisungen
Dieser Abschnitt enthält eine detaillierte Beschreibung davon, wie eine einfache HelloWorld-Anwendung
zu konfigurieren ist, um diese innerhalb des Wrappers auszuführen.
Die meisten anderen Anwendungen können durch das Ausführen der gleichen Schritte eingebunden werden.
HelloWorld-Anwendung
Dieses Tutorial startet mit einer einfachen Anwendung HelloWorld, die einfach nur "Hello world" ausgibt.
Der Pfad zu dieser Anwendung ist /usr/lib/helloworld - und hat den Referenznamen {MYAPP_HOME}.
Ein paar zusätzliche Ordner (bin, lib, conf und logs), in denen Dateien des Wrappers kopiert werden, müssen existieren.
Installation der Wrapper-Dateien
Es gibt vier Verzeichnisse, die eine Konfiguration erfordern, um den Wrapper nutzen zu können.
NOTE
Bitte stellen Sie sicher, dass Sie die passenden Wrapper- und libwrapper.so-Dateien benutzen,
die für die auszuführende Plattform erstellt wurden.
Es mag offensichtlich erscheinen, aber die Linux-Version des Wrappers wird zum Beispiel auf Solaris nicht funktionieren.
bin-Verzeichnis
Der Wrapper wird mit einem Shell-Skript ausgeliefert, (sh)
welches genutzt werden kann, um zuverlässig jede Java-Anwendung starten und beenden zu können, die
vom Java Service Wrapper gesteuert wird.
Kopieren Sie zunächst bitte die folgenden Dateien in das HelloWorld bin-Verzeichnis (in älteren Wrapper-Versionen hieß diese Datei 'sh.script.in'):
Benennen Sie die Skript-Datei um, so dass sie ihren Anwendungsnamen wiedergibt.
{MYAPP_HOME}/bin/helloworld
Öffnen Sie nun das Skript in einem Editorprogramm.
Wir müssen lange und kurze Namen festlegen, um richtig wiederzugeben, dass das Skript genutzt wird, um HelloWorld zu starten.
Sie werden die zwei Variablen sofort hinter dem Skriptheader sehen
APP_NAME und APP_LONG_NAME.
Vorgeschlagene Werte für diese Variablen werden unten angezeigt.
APP_NAME="helloworld"
APP_LONG_NAME="Hello World"
Das Skript sollte keine zusätzliche Abänderung erfordern.
Jedoch geht es davon aus, dass die wrapper.conf-Datei
sich innerhalb eines conf-Verzeichnis (one level up, ../conf/wrapper.conf) befindet.
Wenn Sie die wrapper.conf-Datei woanders ablegen möchten, ist es erforderlich, dass die
WRAPPER_CONF-Variable im Skript entsprechend angepasst wird.
NOTE
Wichtig! Bevor Sie fortfahren, stellen Sie bitte sicher, dass für alle Dateien, die in das
bin-Verzeichnis kopiert wurden, das ausführbare Bit gesetzt wurde.
lib-Verzeichnis
Kopieren Sie die native Bibliothek und die Wrapper jar-Datei ins HelloWorld lib-Verzeichnis:
Die libwrapper.so-Datei ist eine
native Bibliotheksdatei,
die von dem Teil des Wrappers benötigt wird, der innerhalb der JVM läuft.
Die wrapper.jar-Datei beinhaltet alle Wrapper-Klassen.
NOTE
Beachten Sie bitte, dass die native Bibliothek auf ein paar
Plattformen geringfügig unterschiedlichen Namensgebungsregeln folgt. Mögliche Namen beinhalten:
libwrapper.a,
libwrapper.sl,
libwrapper.so,
und libwrapper.jnilib.
In jedem Fall sollte die Datei kopiert werden, ohne dass die Dateiendung sich ändert.
conf-Verzeichnis
Sämtliche Konfigurationseinstellungen des Wrappers erfolgen über die Datei
wrapper.conf.
Der Standard-Ablageort für diese Datei befindet sich in einem conf-Verzeichnis im Home-Verzeichnis der Anwendung.
Bitte kopieren Sie die folgende Vorlagendatei wrapper.conf.in
in das conf-Verzeichnis von HelloWorld.
{WRAPPER_HOME}/src/conf/wrapper.conf.in
Stellen Sie dabei sicher, die Endung .in zu entfernen, so dass
die Datei wrapper.conf heißt.
Sie sollten nun Folgendes haben:
{MYAPP_HOME}/conf/wrapper.conf
Wenn Sie die Konfigurationsdatei wrapper.conf in ein anderes Verzeichnis verschieben möchten, können Sie dies tun.
Sie müssen die Skript-Dateien, die in das oben genannte bin-Verzeichnis kopiert wurden, ändern, damit der neue Speicherort richtig wiedergegeben wird.
logs-Verzeichnis
Die Standard-Konfigurationsdatei wrapper.conf wird eine
wrapper.log-Datei in ein logs-Verzeichnis unterhalb des Home-Verzeichnisses der Anwendung ablegen.
Stellen Sie sicher, dass Sie folgendes Verzeichnis erstellt haben:
{MYAPP_HOME}/logs
Wenn Sie die wrapper.log-Datei an einem anderen Ort ablegen möchten,
müssen Sie die wrapper.conf-Datei editieren
und die Eigenschaften wrapper.logfile abändern,
um den neuen Ort richtig widerzuspiegeln.
lang-Verzeichnis
Ab der Wrapper-Version 3.5.0
kann der Wrapper lokalisiert werden.
Die Dateien für die Sprachenressourcen befinden sich im
lang-Verzeichnis.
Erstellen Sie bei Bedarf ein lang-Verzeichnis im
Home-Verzeichnis der Anwendung und kopieren Sie diese Dateien dorthin:
Wenn Sie die Sprachenressourcen-Dateien *.mo an einem anderen Ort ablegen möchten,
müssen Sie die wrapper.conf-Datei editieren
und die Eigenschaft wrapper.lang.folder abändern, um den neuen Ort widerzuspiegeln.
Gehen Sie in die Java-Befehlszeile der Anwendung
Bevor der Wrapper dafür konfiguriert werden kann, eine Anwendung zu starten,
müssen Sie den kompletten Java-Befehl kennen, der normalerweise benutzt wird,
um die Anwendung zu starten.
Die meisten Anwendungen verwenden Skripte, um die tatsächliche Befehlszeile zu erstellen.
Diese Skripte neigen dazu, recht unhandlich zu werden,
daher ist die Möglichkeit, nicht mit ihnen zu arbeiten,
einer der Vorteile der Verwendung des Wrappers.
Die Mehrheit des Skripts hat die Aufgabe systemspezifische Informationen zu sammeln,
diese Informationen in den Umgebungsvariablen zu speichern und abschließend den Java-Befehl auszuführen.
Um den Wrapper zu konfigurieren, ist alles, was wirklich benötigt wird, die letzte Java-Befehlszeile.
Im Fall unserer einfachen HelloWorld-Anwendung wird kein Skript benötigt. Der auszuführende Befehl
würde wie folgt aussehen:
java com.tanukisoftware.HelloWorld
Ein komplexerer Befehl, um eine Java-Anwendung zu starten, würde wie folgt aussehen:
Um die obengenannte Java-Befehlszeile mit dem Wrapper nutzen zu können,
müssen wir die Komponenten der Befehlszeile in eine Konfigurationsdatei aufteilen.
Öffnen Sie hierfür die wrapper.conf-Datei
in einem Editor und nehmen Sie die unten stehenden Änderungen vor.
NOTE
Wo unten Eigenschaften genannt werden, werden Links zu ihren Beschreibungen bereitgestellt.
Nehmen Sie sich bitte die Zeit, die Beschreibungen von jeglichen Eigenschaften anzuschauen, die verändert wurden.
In vielen Fällen gibt es weitere Beschreibungen bezüglich ihres Einsatzes, die hier nicht aufgeführt werden.
Umgebungsvariable:
Für eine einfachere Konfiguration wird empfohlen das HOME-Verzeichnis von HelloWorld und Java
in die Umgebungsvariablen der Konfigurationsdatei zu speichern.
Dadurch ist die conf-Datei wesentlich einfacher zu lesen und zu warten, im Fall, dass ein Verzeichnispfad geändert wird.
Ist dies in der Konfigurationsdatei eingestellt, setzt der Wrapper die Umgebungsvariablen jedes Mal wenn er gestartet wird:
Zuerst wird die Java-Programmdatei extrahiert und der Verzeichnispfad der
wrapper.java.command-Eigenschaft zugewiesen:
wrapper.java.command=%JAVA_HOME%/bin/java
Java-Argumente
Die meisten Anwendungen liefern der Java-Programmdatei eine Reihe von Parametern, wenn diese gestartet wird.
Der Wrapper liefert besondere Konfigurationseigenschaften für Dinge wie Speicher sowie Klassen- und Verzeichnis-Pfade.
Diese werden weiter unten behandelt. Jedoch werden alle anderen Einstellungen durch den Einsatz der
wrapper.java.additional.<n>-Folge an Eigenschaften konfiguriert.
Die HelloWorld-Anwendung übernimmt 2 zusätzliche Java-Argumente.
Die ursprüngliche und maximale Speichergröße der JVM, die durch -Xms128M (ursprünglich) und -Xmx512M (maximal) bestimmt wird,
kann auch unter Einsatz der wrapper.java.initmemory und
wrapper.java.maxmemory-Eigenschaften definiert werden.
# Initial Java Heap Size (in MB)
wrapper.java.initmemory=128
# Maximum Java Heap Size (in MB)
wrapper.java.maxmemory=512
Classpath
Als Nächstes kommt der Classpath, der unter Einsatz der
wrapper.java.classpath.<n>-Eigenschaften konfiguriert wird.
Der Wrapper erfordert, dass der Classpath in seine individuellen Teile aufgeteilt wird.
Da wir auch den Wrapper benutzen, ist es dann notwendig, auch die
wrapper.jar-Datei einzuschließen:
Um eine Kommunikation zwischen HelloWorld und dem Wrapper zu erstellen,
ist der Einsatz der Helper-Klasse WrapperSimpleApp
als Main-Klasse notwendig.
Die Main-Klasse, die von Java beim Start ausgeführt wird, wird durch die
wrapper.java.mainclass-Eigenschaft festgelegt.
Die HelloWorld-Main-Klasse wird dann als der erste Anwendungsparamter festgelegt (siehe Abschnitt unten).
Anwendungsparameter werden unter Benutzung der
wrapper.app.parameter.<n>-Eigenschaften gesetzt.
Anwendungsparameter erscheinen in der Java-Befehlszeile direkt hinter der Main-Klasse.
Wie oben erwähnt, ist es notwendig als ersten Parameter die HelloWorld Main-Klasse festzulegen. Andere
Parameter kommen danach.
Um den Wrapper einzusetzen, gibt es eine weitere Eigenschaft, die gesetzt werden muss.
Der Wrapper benutzt eine native Bibliothek, um den Austausch mit dem System zu steuern.
Diese Bibliotheksdateilibwrapper.so muss
im Bibliothekspfad bestimmt werden, der gegenüber der JVM angegeben wird.
set.MYAPP_HOME=/usr/lib/helloworld
set.JAVA_HOME=/usr/lib/jvm/java-8-openjdk
wrapper.java.command=%JAVA_HOME%/bin/java
# Java Main class.
wrapper.java.mainclass=org.tanukisoftware.wrapper.WrapperSimpleApp
# Java Classpath (include wrapper.jar)
wrapper.java.classpath.1=%MYAPP_HOME%/lib/wrapper.jar
wrapper.java.classpath.2=%MYAPP_HOME%/bin/myjar.jar
# Java Library Path (location of Wrapper.DLL or libwrapper.so)
wrapper.java.library.path.1=%MYAPP_HOME%/lib
# Java Bits. On applicable platforms, tells the JVM to run in 32 or 64-bit mode.
wrapper.java.additional.auto_bits=TRUE
# JVM settings
wrapper.java.additional.1=-Xms128M
wrapper.java.additional.2=-Xmx512M
# Initial Java Heap Size (in MB)
#wrapper.java.initmemory=128
# Maximum Java Heap Size (in MB)
#wrapper.java.maxmemory=512
# Application parameters. Add parameters as needed starting from 1
wrapper.app.parameter.1=com.tanukisoftware.HelloWorld
wrapper.app.parameter.2=arg1
wrapper.app.parameter.3=arg2
Testen
HelloWorld kann nun durch einfaches Ausführen des Skriptes bin/helloworld console gestartet werden.
Aufgrund der Art, wie der Wrapper sein aktuelles Verzeichnis festlegt, ist es nicht notwendig, das Skript innerhalb des
bin-Verzeichnisses auszuführen.
Wie Sie sehen werden, wenn Sie einen Befehl auslassen, sind die mit dem Wrapper ausgelieferten Skripte, ziemliche Standard-Daemon-Skripte.
Sie akzeptieren console, start, stop,
restart und dump-Befehle.
Die start, stop und restart-Befehle
sind den meisten Daemon-Skripten geläufig und werden benutzt, um den Wrapper und seine Anwendung als Daemon-Prozess zu steuern.
Der status-Befehl kann genutzt werden, um herauszufinden, ob der Wrapper gegenwärtig läuft oder nicht.
Der console-Befehl startet den Wrapper in der aktuellen Shell,
und macht es so möglich, dass die Anwendung mit STRG-C beendet werden kann.
Der letzte Befehl, dump, sendet ein kill -3-
Signal zum Wrapper, welcher seine JVM veranlasst, einen vollständigen Thread-Dump zu erstellen.
Herzlichen Glückwunsch! Ihre Anwendung sollte jetzt laufen.
Wenn Sie Probleme hatten, finden Sie im Abschnitt
Troubleshooting
Hilfe, zur Lösung des Problems.
Erweiterte Informationen
Tuning des Hochstartens
Standardmäßig wartet die
WrapperSimpleApp-
Klasse 2 Sekunden auf die Fertigstellung der Main-Methode der User-Anwendung.
Danach nimmt sie an, dass die Anwendung gestartet wurde und erstattet einen Bericht an den Wrapper-Prozess.
Dies wird gemacht, weil viele User-Anwendungen mit Main-Methoden geschrieben sind, die während der Ausführung der Anwendung keinen Wert zurückgeben.
In solchen Fällen gibt es keinen zuverlässigen Weg für die WrapperSimpleApp-Klasse, mitzuteilen
wann und ob die Anwendung das Hochstarten fertiggestellt hat.
Wenn jedoch bekannt ist, dass die Main-Methode der Anwendung einen Wert zurückgibt, sobald die Anwendung gestartet wurde,
wäre es für den Wrapper am besten, zu warten bis dies abgeschlossen ist, bevor er die Ausführung fortsetzt.
waitForStartMain Systemeigenschaft:
Für Main-Methoden, die auf diese Art Werte zurückgeben, sucht die WrapperSimpleApp nach der
org.tanukisoftware.wrapper.WrapperSimpleApp.waitForStartMain
Systemeigenschaft.
Wenn sie auf TRUE eingestellt ist, wird die WrapperSimpleApp unbegrenzt auf die Fertigstellung der Main-Methode warten.
Unendlich zu warten ist eine vorteilhafte Option,
wenn gewiss ist, dass die Main-Methode zeitnah antworten wird.
Andererseits wird der Wrapper während er unbegrenzt wartet,
während des Hochfahrens niemals aufgeben, unabhängig davon, wie lange es dauert.
Wenn die Möglichkeit besteht, dass der Hochstarten-Vorgang hängen könnte, ist es besser, die
org.tanukisoftware.wrapper.WrapperSimpleApp.maxStartMainWait
Systemeigenschaft auf die maximale Wartezeit einzustellen.
Zum Beispiel um bis zu 5 Minuten (300 Sekunden) auf die Fertigstellung der Main-Methode beim Hochstarten zu warten, stellen Sie die Eigenschaft wie folgt auf 300 ein:
Die Main-Methoden vieler Anwendungen sind darauf ausgelegt, keinen Wert zurückzugeben.
In diesen Fällen müssen Sie sich entweder an die üblichen 2-Sekunden-Timeoutzeit beim Hochstarten halten oder ein etwas längeres Timeout festlegen, indem Sie die
maxStartMainWait-Eigenschaft nutzen, um die Zeit zu simulieren, die Ihre Anwendung zum Hochstarten benötigt.
WARNING
Wenn TRUE in der waitForStartMain für eine Anwendung festgelegt ist,
deren start-Methode niemals einen Wert zurückgibt, erscheint der Wrapper zu Anfang korrekt zu funktionieren.
Der Wrapper befindet sich dann jedoch in einem ewig andauernden Wartestatus und wird nie in einen Start-Modus kommen, in dem Ihre Anwendung überwacht werden kann.