Affichage des articles dont le libellé est web. Afficher tous les articles
Affichage des articles dont le libellé est web. Afficher tous les articles

mardi 24 mai 2016

Externaliser la configuration d'une webapp


Comment permettre à une application web Java de récupérer un paramètre de configuration sans avoir à repackager le ".war" ?



Si on s'interdit de modifier le fichier ".war" ça veut dire que l'on ne peut plus utiliser les possibilités de configuration à partir des fichiers qu'il contient ( web.xml, fichiers properties, etc ).
Les paramètres de configuration devront donc être portés par les environnements d'exécution de l'application (et non par l'application elle même), c'est à dire le server d'applications ( Tomcat, Jetty, etc ) ou le système d'exploitation.
Les trois possibilités les plus courantes sont décrites ci-après...

1) Utiliser une variable d'environnement

- Définir la variable d'environnement au niveau du système d'exploitation
Exemple sous Linux  :
   export MYFOLDER=/tmp/foo

- Récupérer la valeur de cette variable dans le code Java,
  par exemple dans une classe de type  "ServletContextListener" :
    String value = System.getenv("MYFOLDER")

Cette solution est simple et applicable indépendamment type de serveur d'applications.
Mais elle nécessite une intervention au niveau "système d'exploitation" (pas toujours possible) et on ne peut avoir qu'une seule valeur pour toutes les instances de serveurs d'application sur un même OS.


2) Configurer une propriété de type "Java System property"

Il s'agit de définir une propriété pour la JVM au lancement du serveur d'applications.

- Définir la propriété pour un serveur d'applications particulier :
Soit avec l'option "-D" de la ligne de commande
Soit en utilisant les fichiers de configuration propres à chaque serveur d'application
Exemple pour Tomcat :
        Dans le fichier "catalina.properties" de Tomcat :
    myfolder=/tmp/foo
       
        NB : pour un lancement dans Eclipse utiliser le fichier "catalina.properties"
                 situé dans le workspace (dans  "Servers" )

- Récupérer la valeur de cette propriété dans le code Java :
    String value = System.getProperty("myfolder");


3) Configurer une "valeur nommée" accessible via JNDI

Une "ressource nommée" peut être définie au niveau du serveur d'applications, elle sera ensuite récupérée via JNDI.

- Définir la "ressource nommée" pour le serveur d'applications concerné

Pour Tomcat :
        Dans le fichier "web.xml" de Tomcat (fichier global pour toutes les webapps) :
      <env-entry>
          <env-entry-name>myTextValue</env-entry-name>
          <env-entry-type>java.lang.String</env-entry-type>
          <env-entry-value>foo</env-entry-value>
      </env-entry>
      <env-entry>
          <env-entry-name>myMaxValue</env-entry-name>
          <env-entry-type>java.lang.Integer</env-entry-type>
          <env-entry-value>10</env-entry-value>
      </env-entry>
        NB :
        - respecter l'ordre des tags "name/type/value"
        - pour un lancement dans Eclipse utiliser le fichier "web.xml" situé
          dans le workspace (dans  "Servers" )
       
        cf https://tomcat.apache.org/tomcat-7.0-doc/config/globalresources.html#Environment_Entries 

Pour Jetty :
        Dans le fichier "jetty.xml" ajouter une ressource avec une entrée du type :
     <New class="org.eclipse.jetty.plus.jndi.EnvEntry">
       <Arg></Arg> <!-- scope : empty = JVM scope-->
       <Arg>myTextValue</Arg> <!-- name -->
       <Arg type="java.lang.String">foo</Arg> <!-- value-->
       <Arg type="boolean">true</Arg>  
     </New>

        cf http://www.eclipse.org/jetty/documentation/current/using-jetty-jndi.html

- Récupérer la valeur de cette variable dans le code Java
  Exemple pour une chaine de caractères :

   String name = "myTextValue" ;
   try {
      Object value = InitialContext.doLookup("java:comp/env/"+name);
      System.out.println("JNDI OBJECT '"+ name + "' = '" + value + "'");
   } catch (NamingException e) {
      System.out.println("JNDI OBJECT ERROR : " + e.getMessage());
      e.printStackTrace();
   }


vendredi 11 avril 2014

Créer un projet web statique sous Eclipse

Bon, je sais, Eclipse n'est pas l'environnement idéal pour faire un projet web statique d'envergure, mais pour une démo ou des prototypes pourquoi pas...

Le principe est extrêmement simple :

  1. Créer un projet dans Eclipse pour gérer les ressources statiques du site
  2. Installer et lancer un petit serveur HTTP qui va tourner en permanence et qui fera référence au ressources du projet


1) Créer le projet sous Eclipse


Option 1 : créer un projet "Web Static" 
   New / Project... / Web / Static Web Project


Avec ce type de projet il faut spécifier un "Web content folder name" qui va contenir les ressources gérées par le serveur http ( ici "www" ), ce qui correspond à une bonne pratique, ça évite de mélanger les fichiers du site web et la configuration du projet Eclipse.


Option 2 : créer un projet banalisé 
   New  /  Project... /  General  /  Project


Dans ce cas il n'y a pas de notion de "Web content folder name" (puisque le projet n'est pas de type "web")
Ce qui permet de considérer la racine du projet comme la racine du serveur web (ce qui n'est pas conseillé car tous les fichiers du projet seront exposés par le serveur). On pourra éventuellement définir un répertoire servant de "document root" ultérieurement.


2) Installer le serveur http

La on a le choix... Evidemment on pense immédiatement à ce bon vieux Apache, mais pour un simple environnement de développement c'est un peu lourd. Heureusement il existe plein de petits serveurs http ultra légers. Mon préféré c'est "Mongoose" (à télécharger ici : http://cesanta.com/mongoose.shtml ).

La version Windows fait 136 ko ! C'est un simple fichier ".exe" qu'il suffit de poser dans n'importe quel répertoire, puis de le lancer par un double-click. 
Une fois lancé une icone apparaît dans la barre des tâches et le navigateur démarre sur une URL composée de l'adresse IP du poste et du port "8080". Le répertoire par défaut des ressources du site étant le répertoire dans lequel le ".exe" est situé, le navigateur affiche donc cette page :

Il suffirait de poser des fichiers ".html" dans ce répertoire pour y accéder à partir du navigateur, mais pour ne pas tout mélanger on va évidemment personnaliser la configuration du serveur. C'est très simple il suffit de cliquer sur l'icône de la barre des tâches et de sélectionner "Advanced settings" pour ouvrir la page de configuration dans le navigateur ( ou simplement d'invoquer l'URL "http://localhost:8080/__mc" ).

Dans la configuration deux paramètres nous intéressent plus particulièrement :




  • document_root =  le répertoire qui contient les documents gérés par le serveur
  • listening_port   =  le port sur lequel le serveur écoute


  • Pour le listening_port, on va le valoriser par exemple à 9090 (pour éviter les collisions éventuelles avec Tomcat ou tout autre serveur du même genre)
    Pour le document_root il va falloir le faire pointer sur le répertoire adéquat du projet Eclipse.
    Il suffit de faire un click-droit sur le répertoire voulu dans le projet Eclipse + "Properties" / "Resources" pour voir l'emplacement dans le filesystem ( cf "Location" ). Un simple copier/coller fera l'affaire.



    Ne pas oublier d'enregistrer par un click sur "Save settings to the config file" qui va créer le fichier de configuration "mongoose.conf".


    Il suffit maintenant de stopper Mongoose et le redémarrer.
    Invoquer l'URL  http://localhost:9090/ 

    Et voila! Le serveur http est prêt il sert les fichiers à partir du répertoire projet Eclipse et il écoute sur le port 9090. Toutes les modifications apportées aux fichiers dans le projet sont donc immédiatement visibles dans le navigateur.

    Pour réinitialiser le serveur Mongoose : 
    • stopper le serveur
    • supprimer le fichier "mongoose.conf"
    • redémarrer le serveur : il se retrouve dans son état initial (comme à la première installation)

    3) Autres serveurs http ultra léger

    Deux alternatives à Mongoose :

    lundi 26 août 2013

    Eclipse Kepler - Créer un projet web-maven avec WTP et M2E

    Après quelques années de galère à essayer de faire cohabiter les plugins WTP, M2E et Maven for WTP, les utilisateurs d'Eclipse commençaient à s'impatienter (surtout en voyant d'autres IDE dans lesquels tout ça était plutôt naturel et simple). Mais cette fois on y est, enfin presque (ouf !)


    Il aura fallu attendre Eclipse 4.3 ( "Eclipse Kepler" : http://www.eclipse.org/kepler/ ) pour que la distribution "Eclipse IDE for Java EE Developers" soit livrée avec les plugins Maven pré-installés.

    Kepler (qui pèse un peu plus de 250 Mb) arrive avec :
      - Maven Integration for Eclipse ( "m2e" )   ver 1.4.0
      - Maven Integration for Eclipse WTP    ver 1.0.0
    Ces même versions sont disponibles pour Eclipse Juno (mais à ajouter manuellement)

    Voici donc comment créer un projet web avec Maven et WTP ...

    1) Création du projet 


    Il s'agit dans un premier temps de créer directement un projet Maven (et non WTP)
    en utilisant l' archetype  "maven-archetype-webapp"

    File  /  New (ou Alt-Shift-N)  /  Maven project

    Sélection de l'archetype pour "web app" :



    Après création, le nouveau projet apparait dans le workspace.
    Le nom du projet est l' Artefact Id de Maven
    Pour changer le nom il suffit de faire  " Refactor / Rename "

    2) Structure du projet 


    La structure du projet est maintenant presque prête.


    Mais parfois il manque des répertoires standards de Maven qui n’ont pas été créés (ça semble se produire à partir du deuxième projet créé dans un même workspace).
    Ce qui provoque des erreurs au niveau du build path :



    Si c'est le cas, il suffit de les ajouter :
      - Dans « src/main » : new folder « java »
      - Dans « src » : new folder « test/java », et tant qu’on y est « test/resources »

    3) Configuration du "pom.xml"


    En ouvrant le fichier "pom.xml" on constate qu'il contient assez peu de chose.
    Trop peu, puisqu'il n'y a même pas les dépendances aux libraires Servlet/JSP.

    Il n'y a donc plus qu'à le compléter en fonction des besoins du projets

    Exemples :

    * Pour ajouter les JARs nécessaires aux Servlets 3.0 et au JSP 2.2 (Tomcat 7, Jetty 8, Java EE 6)
    dans "dependencies" :

    <dependency>
       <groupId>javax.servlet</groupId>
       <artifactId>javax.servlet-api</artifactId>
       <version>3.0.1</version>
       <scope>provided</scope>
    </dependency>
    <dependency>
       <groupId>javax.servlet.jsp</groupId>
       <artifactId>javax.servlet.jsp-api</artifactId>
       <version>2.2.1</version>
       <scope>provided</scope>
    </dependency>
    <dependency>
       <groupId>jstl</groupId>
       <artifactId>jstl</artifactId>
       <version>1.2</version>
    </dependency>

    Pour forcer la version de Java  (ici Java 7)
    dans "build/plugins"  :

    <plugin>
       <artifactId>maven-compiler-plugin</artifactId>
       <version>3.0</version>
       <configuration>
          <source>1.7</source>
          <target>1.7</target>
       </configuration>
    </plugin>

    * Pour configurer la production du « war »
    dans  "build/plugins" :

    <plugin>
       <artifactId>maven-war-plugin</artifactId>
       <version>2.3</version>
       <configuration>
          <failOnMissingWebXml>false</failOnMissingWebXml>
       </configuration>
    </plugin>

    Après avoir enregistrer les modifications du « pom.xml » ,
    faire " Maven / Update project… "
    pour répercuter la configuration du « pom.xml » sur le projet Eclipse

    Le projet doit finalement avoir la structure suivante :
    Et il ne doit plus y avoir aucune erreur nul part.

    4) Tester le fonctionnement 


    - Test avec une JSP :
    Lancer l’exécution comme s’il s’agissait d’un projet web WTP classique :
    Run as / Run on server 
    On arrive sur la page « Hello world » produite par la JSP « index.jsp »,
    si on modifie cette JSP il suffit de rafraîchir la page pour prendre en compte les modifications (comme dans tout projet WTP).

    - Test avec une servlet :
    Créer une nouvelle servlet dans  « src/main/java » 
    (avec les servlet 3.0 il n’est pas nécessaire de déclarer cette nouvelle servlet dans le web .xml, une annotation suffira)

    Conclusion


    Avec une installation Eclipse Kepler de base il est maintenant assez simple de gérer des projets web.
    Pour ceux qui veulent aller un peu plus loin il ne reste plus qu'à créer ses propres archetypes Maven...

    Pour plus d'informations :