La Méthode 1 consiste à utiliser la classe d'aide WrapperSimpleApp pour lancer l'application.
C'est de loin la façon la plus simple de s'intégrer au Wrapper et, lorsque c'est possible, elle est fortement recommandée.
Il y a cependant quelques points à connaître lors de l'utilisation de cette méthode.
Lorsque le Wrapper arrête la JVM, il n'y a pas d'appel direct à une application lui demandant de s'arrêter proprement.
Le Wrapper quitte plutôt la JVM en appelant System.exit() depuis l'intérieur de la JVM.
Si l'application a enregistré son propre Shutdown Hook, celui-ci sera invoqué, donnant à l'application une chance de s'arrêter proprement.
Si, en revanche, un Shutdown Hook n'est pas
enregistré, alors l'application se terminera brusquement, comme lorsque l'on appuie sur CTRL-C dans la console (fenêtre de commande).
Dans les deux cas, avec et sans Shutdown Hook, le comportement est exactement le même que si l'application s'exécutait sans le Wrapper.
Lors de l'intégration avec cette Méthode 1, la
classe d'aide WrapperSimpleApp remplace la classe principale d'une application.
Cela donne à la classe WrapperSimpleApp l'occasion d'initialiser immédiatement
le WrapperManager et d'enregistrer la JVM auprès du Wrapper.
La classe WrapperSimpleApp gère ensuite toutes les interactions avec le Wrapper ainsi que le cycle de vie d'une application.
Lorsque le Wrapper envoie un message de démarrage à la JVM via le WrapperManager,
la méthode main de la véritable classe principale de l'application est appelée.
On indique à la classe d'aide WrapperSimpleApp comment lancer l'application en passant le nom de la
classe principale de l'application, suivi de tous les paramètres supplémentaires de l'application, à la méthode main de WrapperSimpleApp.
Instructions détaillées
Cette section vous guide à travers une explication détaillée de la façon de configurer
une application HelloWorld simple pour qu'elle s'exécute dans le Wrapper.
La plupart des autres applications peuvent être intégrées en suivant les mêmes étapes.
Application HelloWorld
Ce tutoriel lancera une application simple HelloWorld qui affiche simplement « Hello world ».
Le chemin vers cette application est d:\helloworld et sera référencé comme {MYAPP_HOME}.
Certains dossiers supplémentaires (bin, lib, conf et logs) doivent exister, dans lesquels les fichiers du Wrapper seront copiés.
Installation des fichiers du Wrapper
Il y a quatre répertoires qui doivent être configurés afin de pouvoir utiliser le Wrapper.
répertoire bin
Tout d'abord, copiez les fichiers suivants dans le répertoire bin de HelloWorld :
Renommez les trois fichiers batch pour qu'ils reflètent le nom de votre application comme suit.
Veillez à supprimer les extensions .in
afin que tous les fichiers se terminent par .bat.
(Selon la configuration de l'explorateur de fichiers de votre ordinateur, vous ne pourrez peut-être pas voir les extensions de fichiers.)
Le fichier wrapper.exe est l'exécutable réel du Wrapper.
Les trois fichiers batch sont utilisés pour exécuter HelloWorld dans une console et pour l'installer/désinstaller en tant que service Windows.
Ces fichiers batch ne devraient nécessiter aucune modification.
Ils supposent que le fichier wrapper.conf sera situé
dans un répertoire conf un niveau au-dessus, ../conf/wrapper.conf.
Si vous souhaitez placer le fichier wrapper.conf ailleurs,
alors les trois fichiers batch nécessiteront une modification appropriée.
répertoire lib
Copiez la bibliothèque native et le fichier jar du Wrapper dans le répertoire lib de HelloWorld :
Le fichier wrapper.dll est un fichier de bibliothèque native
requis par la partie du Wrapper qui s'exécute dans la JVM.
Le fichier wrapper.jar contient toutes les classes du Wrapper.
répertoire conf
Toutes les configurations du Wrapper sont effectuées dans
wrapper.conf.
L'emplacement standard de ce fichier est un répertoire conf dans le répertoire d'accueil de l'application.
Copiez le fichier modèle suivant wrapper.conf.in
dans le répertoire conf de HelloWorld.
{WRAPPER_HOME}\src\conf\wrapper.conf.in
Veillez à supprimer l'extension .in afin que
le fichier s'appelle wrapper.conf.
Vous devriez maintenant avoir :
{MYAPP_HOME}\conf\wrapper.conf
Si vous souhaitez déplacer le fichier de configuration wrapper.conf, vous êtes libre de le faire.
Vous devrez modifier les fichiers batch copiés dans le répertoire bin ci-dessus, afin de refléter le nouvel emplacement.
répertoire logs
Le fichier de configuration par défaut wrapper.conf placera un
fichier wrapper.log dans un répertoire logs sous le répertoire d'accueil de l'application.
Assurez-vous d'avoir créé le répertoire :
{MYAPP_HOME}\logs
Si vous souhaitez placer le fichier wrapper.log à un autre emplacement,
vous devrez modifier le fichier wrapper.conf et changer la
propriété wrapper.logfile pour refléter le nouvel emplacement.
répertoire lang
À partir de la version 3.5.0 du Wrapper,
le Wrapper peut être localisé.
Les fichiers de ressources linguistiques se trouvent dans le
répertoire lang.
Si nécessaire, créez un répertoire lang sous le
répertoire d'accueil de l'application et copiez-y ces fichiers :
Si vous souhaitez placer les fichiers *.mo à un autre emplacement, vous devrez
modifier le fichier wrapper.conf et changer la
propriété wrapper.lang.folder pour refléter le nouvel emplacement.
Localiser la ligne de commande Java de l'application
Avant de pouvoir configurer le Wrapper pour lancer une application,
vous devrez connaître la commande Java complète qui est normalement utilisée
pour lancer l'application.
La plupart des applications utilisent un script pour construire la ligne de commande réelle.
Ces scripts ont tendance à devenir assez encombrants,
mais en fait, la possibilité d'éviter d'avoir à travailler avec eux est
l'un des avantages de l'utilisation du Wrapper.
La majeure partie du script a pour tâche de collecter des informations spécifiques au système
et de stocker ces informations dans des variables d'environnement, puis d'exécuter la commande Java.
Pour configurer le Wrapper, tout ce dont on a réellement besoin est la ligne de commande Java finale.
Dans le cas de notre application HelloWorld simple, un script n'est pas nécessaire. La commande
pour la lancer ressemblerait à ceci :
java com.tanukisoftware.HelloWorld
Une commande plus complexe pour lancer une application Java ressemblerait à ceci :
Afin de pouvoir utiliser la ligne de commande Java ci-dessus avec le Wrapper,
nous devons décomposer les composants de la ligne de commande dans un fichier de configuration.
Ouvrez le fichier wrapper.conf dans un éditeur et effectuez les modifications ci-dessous.
NOTE
Lorsque des propriétés sont mentionnées ci-dessous, des liens vers leurs descriptions sont fournis.
Veuillez prendre le temps de consulter les descriptions de toutes les propriétés qui sont modifiées.
Dans de nombreux cas, il existe des détails supplémentaires sur leur utilisation qui ne sont pas mentionnés ici.
Variable d'environnement :
Pour une configuration aisée, il est recommandé de stocker le répertoire HOME
de HelloWorld et de Java dans des variables d'environnement dans le fichier de configuration.
Cela rendra le fichier conf plus facile à lire et à maintenir au cas où un chemin de répertoire serait modifié.
Le Java Service Wrapper définira ces variables d'environnement à chaque lancement :
La première étape consiste à extraire l'exécutable Java et à assigner le chemin d'emplacement à la
propriété wrapper.java.command :
wrapper.java.command=%JAVA_HOME%\bin\java
Arguments Java
La plupart des applications fournissent un certain nombre de paramètres à l'exécutable Java lors de son lancement.
Le Wrapper fournit des propriétés spéciales pour configurer des éléments tels que la mémoire, ainsi que les chemins de classes et de bibliothèques.
Ceux-ci seront traités ci-dessous ; toutefois, tous les autres paramètres sont configurés à l'aide de la
série de propriétés wrapper.java.additional.<n>.
L'application HelloWorld prend 2 arguments Java supplémentaires.
La taille mémoire initiale et maximale de la JVM spécifiée par -Xms128m (initiale) et -Xmx512m (maximale)
peut également être définie à l'aide des propriétés wrapper.java.initmemory
et wrapper.java.maxmemory.
# Initial Java Heap Size (in MB)
wrapper.java.initmemory=128
# Maximum Java Heap Size (in MB)
wrapper.java.maxmemory=512
Notez que la propriété complète a été copiée directement depuis la ligne de commande sans aucune modification.
Consultez la documentation des propriétés pour savoir comment gérer les propriétés contenant des espaces.
Jar du Wrapper
Le Wrapper exige que son wrapper.jar soit spécifié :
wrapper.jarfile=%MYAPP_HOME%\lib\wrapper.jar
AVERTISSEMENT
La propriété wrapper.jarfile a été introduite dans la version 3.5.55.
Lors de l'utilisation de versions antérieures du Wrapper, il est nécessaire d'inclure wrapper.jar dans le classpath :
Ensuite, les indices des éléments de classpath suivants doivent être ajustés afin que la propriété wrapper.java.classpath.1 ne soit pas répétée.
Classpath
Vient ensuite le classpath, qui est configuré à l'aide des
propriétés wrapper.java.classpath.<n>.
Le Wrapper exige que le classpath soit décomposé en ses éléments individuels.
Afin d'établir une communication entre HelloWorld et le Wrapper,
l'utilisation de la classe d'aide WrapperSimpleApp
comme classe principale est nécessaire.
La classe principale exécutée par Java au lancement est spécifiée à l'aide de la
propriété wrapper.java.mainclass.
La classe principale de HelloWorld est ensuite spécifiée comme premier paramètre de l'application (voir la section ci-dessous).
Les paramètres de l'application sont définis à l'aide des
propriétés wrapper.app.parameter.<n>.
Les paramètres de l'application apparaissent dans la ligne de commande Java directement après la classe principale.
Comme mentionné ci-dessus, il est nécessaire de définir le premier paramètre comme la classe principale de HelloWorld. Tous les autres
paramètres viennent ensuite.
Afin d'utiliser le Wrapper, une propriété supplémentaire doit être définie.
Le Wrapper utilise une bibliothèque native pour contrôler les interactions avec le système.
Ce fichier de bibliothèquewrapper.dll
doit être spécifié dans le chemin des bibliothèques fourni à la JVM.
wrapper.java.library.path.1=%MYAPP_HOME%\lib
Assembler le tout
En rassemblant le tout, nous obtenons ce qui suit :
set.MYAPP_HOME=d:\helloworld
set.JAVA_HOME=C:\Program Files\Java\jdk1.8.0_45
wrapper.java.command=%JAVA_HOME%\bin\java
# Java Main class.
wrapper.java.mainclass=org.tanukisoftware.wrapper.WrapperSimpleApp
# Wrapper Jar
wrapper.jarfile=%MYAPP_HOME%\lib\wrapper.jar
# Java Classpath
wrapper.java.classpath.1=%MYAPP_HOME%\lib\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
# Java Additional Parameters
# 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
La dernière étape consiste à définir les propriétés du service Windows.
Nous ne définirons que les propriétés qui doivent être modifiées, mais plusieurs autres sont disponibles.
Consultez la documentation pour plus de détails sur leur utilisation.
Les valeurs suggérées pour ces variables sont indiquées ci-dessous.
wrapper.ntservice.name=HelloWorld
wrapper.ntservice.displayname=Hello World
wrapper.ntservice.description=Hello World
Mise à l'essai
HelloWorld peut maintenant être exécuté simplement en lançant le fichier batch bin\helloworld.bat.
En raison de la façon dont le Wrapper définit son répertoire courant, il n'est pas nécessaire
d'exécuter ce fichier batch depuis le répertoire bin.
Veuillez essayer d'exécuter l'application une fois en tant qu'application console
afin de vérifier la configuration avant de tenter de l'exécuter en tant que service.
Félicitations. Votre application devrait maintenant être opérationnelle.
Si vous avez rencontré des problèmes, veuillez consulter la section Dépannage
pour obtenir de l'aide afin d'identifier le problème.
Avancé
Réglage du démarrage
Par défaut, la
classe WrapperSimpleApp
attendra 2 secondes que la méthode main de l'application utilisateur se termine.
Ensuite, elle suppose que l'application a démarré et le signale au processus Wrapper.
Cela est fait parce que de nombreuses applications utilisateur sont écrites avec des méthodes main qui ne retournent pas pendant toute la durée de vie de l'application.
Dans de tels cas, il n'y a aucun moyen fiable pour la classe WrapperSimpleApp
de savoir quand et si l'application a terminé son démarrage.
Si, toutefois, on sait que la méthode main de l'application retournera une fois l'application
démarrée, il serait idéal que le Wrapper attende que cela se produise avant de continuer.
Propriété système waitForStartMain :
Pour les méthodes main qui retournent de cette façon, WrapperSimpleApp recherche la
propriété système org.tanukisoftware.wrapper.WrapperSimpleApp.waitForStartMain.
Si elle est définie à TRUE, la classe WrapperSimpleApp
attendra indéfiniment que la méthode main se termine.
Attendre indéfiniment est une option avantageuse s'il est certain que la méthode main retournera dans un délai raisonnable.
Mais d'un autre côté, pendant qu'il attend éternellement, le Wrapper n'abandonnera jamais le processus de démarrage, quelle que soit sa durée.
Ainsi, s'il existe une quelconque possibilité que ce démarrage se bloque, alors la
propriété système org.tanukisoftware.wrapper.WrapperSimpleApp.maxStartMainWait
permettant de définir le temps d'attente maximal peut être une meilleure option.
Par exemple, pour attendre jusqu'à 5 minutes (300 secondes) que la méthode main de démarrage se termine,
définissez la propriété à 300 comme suit :
Les méthodes main de nombreuses applications sont conçues pour ne pas retourner.
Dans ces cas, vous devez soit conserver le délai d'attente de démarrage par défaut de 2 secondes,
soit spécifier un délai légèrement plus long.
Cela est possible à l'aide de la propriété maxStartMainWait,
afin de simuler le temps que met votre application à démarrer.
AVERTISSEMENT
Si TRUE est spécifié pour waitForStartMain pour une application
dont la méthode start ne retourne jamais, le Wrapper semblera d'abord fonctionner correctement.
Cependant, le Wrapper est en réalité dans un état d'attente éternel et n'entrera jamais dans un état running.
Cela signifie que le Gestionnaire de services Windows et plusieurs des mécanismes de récupération d'erreurs du Wrapper ne fonctionneront pas correctement.