vendredi 10 octobre 2014

H2 : la base de données "de poche" au service des développeurs

H2 est une base de données relationnelle écrite en Java qui s'avère très utile pour les développeurs.

Cette base de données ultra-légère n'est pas conçue pour supporter de gros volumes de données ni un nombre important d'utilisateurs, mais elle est extrêmement pratique pour les développeurs Java qui ont besoin de tester des applications ou des composants nécessitants des requêtes SQL via JDBC.

H2 présente de nombreux avantages :

  • légèreté : elle tient dans un fichier "zip" de 7 mo (y compris les sources et la documentation) 
  • portabilité : elle est constituée d'un seul fichier "jar" qui peut être exécuté sur tout système d'exploitation disposant de Java
  • fonctionnalités :  H2 dispose des mêmes possibilités que les "grandes bases de données" (schémas multiples, contrôle d'intégrité référentielle, triggers, fonctions, procédures stockés, colonnes auto-incrémentées, séquences, etc)
  • différents modes de fonctionnement : client/serveur ou embarqué

Pour installer H2 :
  1. Télécharger le fichier "Platform-Independent.zip" ( exemple : "h2-2014-08-06.zip" ) à partir du site http://www.h2database.com/ 
  2. Décompresser le fichier "zip"
  3. Pour démarrer la base : dans "bin" lancer "start.sh" ou "start.bat" selon le système d'exploitation
  4. Et voilà, la base est prête à accepter des connexions, une IHM web est même lancée dans le navigateur

Emplacement de stockage des données 

H2 permet de stocker les données d'une base soit en mémoire (très utile pour des données temporaires par exemple pour des tests JUnit), soit sur disque.
L'emplacement est déterminé lors de la connexion par la dernière partie de l'URL JDBC 


Les différents modes de fonctionnement

1) Le mode "embarqué" ( "embedded" in english )
Dans ce mode le moteur H2 fonctionne dans la même JVM que l'application qui l'utilise. La "connexion" est donc réduite à sa plus simple expression puisqu'elle n'utilise pas le réseau. Le principal avantage de ce mode est qu'il n'est pas nécessaire de démarrer la base (en tant qu'application autonome) avant de s'y connecter, ce qui est extrêmement pratique pour des tests JUnit par exemple.



2) Le mode "client/serveur" ou "connexion à distance" (  "remote" ) 
Dans ce mode la base de données est lancée en tant qu'application de type "serveur" et elle va accepter des connexions de "clients" distants (comme une base de données Oracle, PostgreSQL, etc)




3) Le mode "mixte"
Il s'agit d'un mode dans lequel le moteur de la base de données est "embarqué" dans une application spécifique qui peut l'utiliser et le piloter (notamment le démarrer). Une fois lancé le moteur H2 peut être utilisé avec des connexions locales et/ou distantes.



Les différents types d'URL de connexion 
Avec H2 l'URL JDBC est fondamentale puisqu'elle indique dans quel mode on souhaite se connecter à la base ( "remote" ou "embedded") et l'emplacement ou sont stockées les données de la base (en mémoire ou sur disque dans un répertoire du filesystem).
Voici donc un tableau qui représente les différents cas possibles :



Pour plus d'informations, voir le site de référence ; http://www.h2database.com/ 


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 :