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 :

• Pour ceux qui ont la chance de travailler sous Linux :
  LightHttpd ( http://www.lighttpd.net/ )
  Il existe une version pour Windows ( "LightTPD" du projet WLMP http://en.wlmp-project.net/ ),
  mais qui embarque toutes les dll de Cygwin
  
• Pour Windows :
  TinyWeb ( http://www.ritlabs.com/en/products/tinyweb/ )
  Un simple exécutable de 70 ko à lancer en ligne de commande 

Blog de dev's: Couchbase - Installation & Utilisation en Java

Blog de dev's: Couchbase - Installation & Utilisation en Java: Couchbase est une base de données NoSQL orientée documents. Les documents peuvent être par exemple des données clés/valeurs au format ...

Blog de dev's: Maven - Créer un archetype

Blog de dev's: Maven - Créer un archetype: Un archetype Maven permet la création rapide d'un nouveau projet à partir d'un projet existant qui sert alors de modèle. L'ob...

Cours en ligne

Petite compilation de cours en ligne très didactiques (pour débutants) :

• CodeSchool (Ruby, JavaScript, HTML/CSS, iOS, Git)
   https://www.codeschool.com/
  
• CodeAcademy (jQuery, JavaScript, PHP, Python, Ruby, APIs)
   http://www.codecademy.com/
  
• TreeHouse (PHP, Ruby, Git)
   http://teamtreehouse.com/
  
• CodeAvangers ( Web: HTML, CSS, JavaScript)
   http://www.codeavengers.com/
  
• Udacity ( catégorie "Computer science" : Java, Test, ... )
   https://www.udacity.com/

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 :

- http://www.eclipse.org/m2e/ 

- http://www.eclipse.org/m2e-wtp/

Eclipse - Les principaux raccourcis

Avec la pratique chacun a ses raccourcis préférés, ils deviennent vite des réflexes conditionnés.
Même après des années d'utilisation on peut encore en découvrir de nouveaux. Voici donc mon "Best Of" des raccourcis Eclipse (évidemment incomplet), initialement destiné à mes étudiants mais pouvant intéresser  tous les développeurs Java utilisant Eclipse.
Cette liste ne demande qu'à être complétée, toutes les suggestions sont donc les bienvenues ...

---

Recherches (à partir de n'importe quelle vue) : 

 Ctrl - Shift - T    :  "Open Type"
Rechercher un "Type Java" (classe, interface, annotation, ... ) dans les sources (.java) et dans les .jar (.class)

 Ctrl - Shift - R    :  "Open Resource"
Rechercher un fichier dans le workspace (quel que soit le type du fichier)

Dans les deux cas différents patterns de recherche peuvent être utilisés :
Wilcards :
  *  n'importe quelle suite de caractères
  ?  n'importe quel caractère
  <  ou  "blanc" pour marquer la fin du pattern
Notation "camel case" :
Exemples :
  "TZ" : "TimeZone"
  "NuPoEx": java.lang.NullPointerException

---

Dans l'éditeur de code Java :

 Ctrl + S    :  "Save" 

Enregistre le fichier en cours d'édition

 Ctrl + ESPACE    :  "Content Assist" 

Propose une assistance à la saisie ("code completion")

 Ctrl + O    :  "Quick Outline" 

Affiche une fenêtre avec la liste des méthodes et des champs définis dans la classe en cours

Un deuxième "Ctrl+O" affiche toutes les méthodes et les champs (classe en cours + héritage )

 Ctrl + Shift + O   :  "Organize Imports"

Ajoute les imports nécessaires et réorganise la liste par ordre alphabétique

 Ctrl + Shift + F    :  "Format"

Formate le code (lignes de code sélectionnées ou toutes les lignes si aucune sélection)

 Ctrl + Shift + I    :  "Correct Indentation"

Corrige l'indentation du code pour les lignes sélectionnées.

 Alt + Shift + J    :  "Generate Comment"

Génère un bloc de commentaire de type JavaDoc pour la classe, la méthode ou le champ (en fonction de la position du curseur).

 Ctrl + Shift + /    :  "Add/Remove comment"

Ajoute ou supprime "//" au début de chacune des lignes sélectionnées

 Ctrl + T    :  "Quick Type Hierarchy" 

Affiche une fenêtre avec la hiérarchie de la classe en cours

Un deuxième "Ctrl+T" permet de changer le sens de la hiérarchie ( supertype / subtype )

 Ctrl + Alt + H    :  "Open Call Hierarchy" 

Affiche la vue "Call Hierarchy" pour la méthode sélectionnée

 Alt + Shift + B    :  "Show in Breadcrumb" 

Active le bandeau "breadcrum" dans les éditeurs de code Java
(pour désactiver le bandeau utiliser l'icône)

 Alt + Shift + O    :  "Mark Occurrences" 

Active le surlignage de toutes les occurrences identiques à celle qui est sélectionnée.
(raccourci de type "switch" : activation/désactivation)

 Ctrl + Shift + P    :  "Go to Matching Bracket"

Se place sur le { ou } correspondant à celui sur lequel se trouve le curseur 

 Shift + F2    :  "JavaDoc"

Affiche la JavaDoc pour le type sélectionné (ou la méthode sélectionnée) dans une vue de type navigateur.

---

Dans la vue "Package Explorer" :

 F4   :  Affiche la vue "Type Hierarchy" pour la classe sélectionnée (héritage)

---

Référence et déclaration Java :

Dans le code, sélectionner un type (classe, interface, ...), puis :

 F3   :  "Open Declaration"

Ouvre le fichier ".java" correspondant au type sélectionné

 Ctrl + G   pour rechercher la déclaration de ce type dans le workspace ( fichier ".java" dans les sources ou ".class" dans un .jar)

(ou click-droit + "Declarations") 

 Ctrl + Shift + G  pour rechercher les références à ce type dans le workspace

(ou click-droit + "References") 

---

Divers :

 Ctrl + M    :   pour passer la vue courante en taille maximale/normale (switch)

 Ctrl + F8    :   pour basculer vers une autre perspective

 Alt + Shift    :  bascule clavier français - clavier américain  (switch)

NB : Cette combinaison de touches est souvent utilisée par inadvertance ( notamment pour l'ajout de commentaires avec Alt+Shift+J ) 

---

Tous les raccourcis :

Enfin, pour connaitre tous les raccourcis disponibles, il suffit d'aller voir dans les préférences d'Eclipse :

Menu : "Window" - "Preferences",  Rubrique : "General" - "Keys" 

ou d'utiliser le raccourci   Ctrl + Shift + L 

---

Créer un launch Maven sous Eclipse avec le plugin m2e

Quand on utilise Maven en ligne de commande il est facile d’automatiser le lancement d’une tâche en créant un fichier de commande .sh ou .bat qui définira la configuration de la commande à lancer.
Exemple : mvn sonar:sonar sans les test, en mode debug , etc…

Mais dans Eclipse, qu’en est-il ?

De base le plugin « m2e » propose les lancements usuels de Maven ( build, clean, install, etc ) :

Ce qui permet de réaliser les opérations de base, mais elles se révèlent vite insuffisantes.

Puisqu’Eclipse utilise "Run as..." pour lancer Maven, il suffit de définir une nouvelle configuration pour pouvoir ensuite la lancer.

Remarque : "Run as..." est systématiquement disponible, pour tous les types de projets Eclipse, même pour un projet de type "General". Les configurations proposées varient en fonction du type de projet, mais on dispose toujours au moins de "Run Configurations…" qui donne accès aux différentes configurations définies dans le workspace.

1 - Définir une nouvelle configuration de lancement 

Il suffit donc de passer par "Run As / Run Configurations" pour obtenir la fenêtre suivante :

On y trouve toutes les configurations de lancement déjà définies, dont celles de Maven

Pour créer une configuration Maven :

• Sélectionner "Maven Build"
• Cliquer sur l’icône "New" pour créer une nouvelle configuration

Dans l’onglet "Main" indiquer

• le nom de la configuration
• le répertoire de base, utiliser une variable Eclipse plutôt qu’un chemin dans le filesystem ou dans le workspace,  ${project_loc} est la variable la mieux adaptée puisqu’elle contient le path absolu du projet sélectionné
• le goal (ou les goals), par exemple "sonar:sonar", "clean install", etc…

Dans l’onglet "JRE" il est important de sélectionner le JRE qui va servir à l’exécution de Maven et notamment à compiler les sources (il faut donc référencer un JDK complet incluant tools.jar qui contient le compilateur Java )
Pour être cohérent, ce JRE doit être le même que celui du projet Java dans Eclipse

Enregistrer la configuration avec "Apply"

Pour lancer la configuration, utiliser "Run As – Run Configuration", sélectionner la configuration qui vient d’être créée, puis "Run".

2 - Enregistrer une configuration de lancement dans un fichier

Créer une configuration spécifique c’est très bien, mais si on pouvait la conserver dans un fichier, lui-même enregistré dans le projet concerné, ça permettrait de recopier ce fichier en cas de besoin, de le stocker avec les sources dans SVN ou GIT, etc…

Pour ce faire :

• Ouvrir les configurations ( "Run As – Run Configuration" )
• Sélectionner la configuration à enregistrer
• Dans l’onglet "Commons" : 
• remplacer "Save as – Local file" par "Save as – Shared file", 
• utiliser "Browse" pour sélectionner le projet 
• le nom du fichier sera le nom de la configuration avec l’extension ".launch"

Utiliser "Apply" pour enregistrer dans le fichier

Le fichier  "nom_de_configuration.launch"  apparaît dans le projet

Si on l’ouvre par un "double-click" on constate qu’il s’agit d’un simple fichier XML.

Pour lancer la configuration à partir du fichier, il suffit de faire un "click-droit" + "Run As" et Eclipse propose immédiatement la configuration sélectionnée dans le menu contextuel.

Elle peut donc maintenant être lancée directement par le fichier.

Si le fichier ne contient aucune information spécifiquement liée au projet (chemin absolu, JRE particulier, etc) il pourra être copié d’un projet à autre, et réutilisé à volonté.

---
Tutoriel rédigé grâce aux conseils avisés de Stéphane (http://techasite.blogspot.fr/)