mercredi 28 mai 2014

Initialiser un projet dans Eclipse à partir de GitHub


Environnement utilisé : GitHub, Eclipse Kepler (4.3) avec eGit

1) Sur GitHub

Sélectionner le repository à cloner et copier son URL dans le presse papier
2) Dans Eclipse

Dans le workspace : Import  /  Git  /  Projects from Git


Clone URI


L'URI du repository s'affiche (URI copiée dans le presse papier), sinon Ctrl-V


Sélection de la branche à cloner ( en général c'est la branche "master" que l'on souhaite récupérer )


Définition de la destination locale :

Le plugin eGit va créer un repository Git local qui sera le "clone" de celui de GitHub et il va en extraire les sources dans un répertoire situé au même niveau.
Par défaut il propose de tout localiser dans le répertoire Git qui a été défini pour le poste, les fichiers du projet seront donc situés hors du workspace (ce qui ne pose pas de problème mais ça peut vite devenir compliqué à gérer)


Si on souhaite localiser le tout dans le répertoire du workspace courant il est possible de changer la destination en utilisant "Browse".
Exemple après avoir sélectionner l'emplacement du workspace "myworkspace"


Mais c'est là qu'il y a une subtilité :

Dans un premier temps eGit va cloner le projet dans le répertoire de destination.
Ensuite le wizard d'import tente d'importer le projet dans le workspace, mais
si le projet est situé à la racine du workspace on obtient un erreur du type
"D:\myworkspace\myproject overlaps the location of another project: 'myproject'"

Alors il va falloir laisser le projet hors du workspace ?  :-( 
Non, il suffit de créer un répertoire intermédiaire, par exemple "gitprojects"
et de demander à eGit de localiser la destination dans ce répertoire.


Et ainsi tout se passe bien, le projet est cloné par eGit et correctement importé dans le workspace d'Eclipse. Le répertoire intermédiaire n'étant pas visible dans l'environnement Eclipse il ne gêne en rien
et tous les projets du workspace sont bien regroupés dans le même répertoire.

Pour l'import, le plus simple est de prendre systématiquement l'option "Import as general project" et de convertir ensuite le projet dans le type approprié (Java, Maven, etc)


NB: si un fichier ".project" est présent parmi les fichiers provenant de GitHub l'import va lever une erreur du type "A .project file already exists in directory D:\myworkspace\git-projects\xxxx"
Dans ce cas supprimer le fichier ".project" du répertoire (hors d'Eclipse avec l'explorateur du système d'exploitation) faire "Back" et relancer l'import (c'est le .project de GitHub qui sera donc importé)


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 :

    jeudi 12 décembre 2013

    vendredi 6 décembre 2013

    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...

    mercredi 23 octobre 2013

    Cours en ligne

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




    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 :



    lundi 19 août 2013

    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