Blog Technique d'Infin-IT

Git : comment passer à travers un proxy bloquant (push et pull)

Jean-Philippe Briend — Fri, 15 Jul 2011 11:36:59 +0000

Voici la configuration que j’applique lorsque mon poste de développement se situe derrière un proxy ultra-restrictif. Je pars du principe que vous êtes dans une entreprise, donc vous avez hélas un poste sous Windows.

Le principe est d’utiliser plink au lieu de la commande ssh fournie par défaut par msysgit.
Plink va permettre d’utiliser une clef stockée par pageant et de faire un tunnel SSH vers le repository git.

1ère étape : Télécharger plink, pageant et putty

Allez sur le site de putty et téléchargez les exécutables suivants :

putty.exe
plink.exe
pageant.exe
puttygen.exe

2ième étape : installer msysgit

Téléchargez la dernière version de msysgit sur le site officiel.
Suivez la procédure très bien décrite chez Github : Setup Git for Windows.
Rien de particulier à signaler ici.

3ième étape : changer l’agent SSH

Nous allons maintenant changer l’agent SSH utilisé par msysgit : ajoutez la variable d’environnement GIT_SSH et mettez en valeur le chemin vers plink.exe (exemple : C:\Program Files (x86)\PuTTY\plink.exe).

4ième étape : ppk-iser sa clé SSH

Je pars du principe que vous avez une clé SSH générée. Elle se présente sous la forme d’une paire de fichiers (par défaut id_rsa et id_rsa.pub) contenant votre clé privée et la clé publique associée.
A l’aide de puttygen, nous allons packager la clé au format .ppk (géré par pageant).

Lancez puttygen :

Utilisez le menu Conversions puis Import key.
Sélectionnez votre clé privée (par défaut id_rsa). Puttygen vous demande alors la passphrase pour accéder à votre clé.

Cliquez sur le bouton Save private key pour sauvegarder votre clé au format ppk.

5ième étape : charger sa clé dans pageant

Pageant doit tourner pour que plink puisse l’utiliser.
A chaque redémarrage du la machine, il faut rajouter la clé à pageant.

Lancer pageant : une icône apparait dans la barre des tâches.
Un clic droit dessus vous permet de rajouter une clé (Add key).
Sélectionnez votre clé au format ppk, entrez la passphrase et c’est tout.

6ième étape : ajouter ssh.github.com à putty

Maintenant, il faut configurer putty pour lui rajouter le site ssh.github.com.

Lancez putty et configurez le comme suit :

Host name : ssh.github.com
Port : 443
Dans l’onglet Proxy, entrez les informations relatives à votre proxy : hostname, port et éventuellement login/password.
Dans l’onglet Connection – SSH – Auth, chargez votre clé privé à l’aide du bouton Browse
Revenez sur l’onglet Session et sauvegardez cette session avec un nom précis (par exemple gitproxy).

La configuration dans putty suffit.
Par contre, il faut se connecter une fois au serveur pour accepter la clé SSH du serveur : ouvrez une connection ssh avec putty grâce à la configuration précédemment créée et acceptez le certificat. Ceci n’est à faire qu’une seule fois.

7ième étape : cloner un repo dans Git ou ajouter un repo distant

La procédure est quasiment la même :

Pour cloner un repository Git, récupérez l’URL du repository utilisant le protocole git (et non le http). Cette URL est au format : git@github.com:username/myRepo.git.
Exécutez la commande suivante pour faire le clone Git : git clone git@gitproxy:username/myRepo.git. Notez le remplacement de github.com par le nom de la configuration Putty.

C’est tout : vous pouvez puller et pusher sur ce repository.
N’oubliez pas que pour que ceci fonctionne, il faut que pageant tourne et ait votre clé privée chargée.

L’astuce est dans le fait que lors d’une commande Git, ce dernier va exécuter plink pour se connecter en SSH au repository distant. Plink va alors regarder l’adresse dans l’URL, et chercher dans putty si une configuration existe avec ce nom. Comme c’est le cas, il va utiliser la configuration putty pour se connecter.

Pour ajouter un repository distant, faites de même avec :
git remote add monRepo git@gitproxy:username/myRepo.git
N’oubliez pas de substituer github.com par gitproxy.

Une application Play! sur Google AppEngine

Jean-Philippe Briend — Mon, 27 Dec 2010 12:18:56 +0000

Dans cet article, je vais vous montrer comment créer une application Play! et comment la déployer sur Google AppEngine.

Google AppEngine (GAE) propose une solution d’hébergement d’applications gratuites très pratiques pour des applications Java. La liste des fonctionnalités offertes par GAE peut-être consultée ici.
Le framework Play! fournit un module extrêmement bien fait pour déployer des applications sur Gae et un autre module est disponible pour gérer le Datastore Gae : Siena.

Google AppEngine

Google fournit un SDK complet pour développer des applications destinées à être hébergées par GAE. Dans le cas d’une application Play!, ce SDK est intégré au module GAE et le SDK n’est nécessaire que pour le déploiement final.
Il faut récupérer ce SDK à cette adresse : http://code.google.com/appengine/downloads.html.
La version Windows nécessite d’installer aussi Python (un lien est fourni via l’installeur du SDK).

Attaquons-nous à la partie applicative de cet article !

Play! Framework

Tout d’abord, il faut installer les modules GAE et Siena de Play! :
play install gae play install siena
Une fois ces installations terminées, créons notre future application test-gae
play new test-gae
Enrichissons le conf/application.conf nouvellement créé avec les 2 modules précédents :
# ---- MODULES ---- module.gae=${play.path}/modules/gae-1.4 module.siena=${play.path}/modules/siena-1.3

Le Modèle

GAE sans stocker des données dans le Datastore, ça ne sert pas à grand chose.
Nous allons donc créer un objet modèle très simple que l’on retrouve dans quasiment toutes les applications : User !

package models;

import java.util.List;
import siena.Column;
import siena.Generator;
import siena.Id;
import siena.Max;
import siena.Model;
import siena.NotNull;
import siena.Query;

public class User extends Model {

    @Id(Generator.AUTO_INCREMENT)
    public Long id;

    @Column("login")
    @Max(15) @NotNull
    public String login;

    @Column("nickname")
    @Max(15) @NotNull
    public String nickname;
    ...
    ...
}

Il y a plusieurs choses importantes à noter :

La classe User étend la classe siena.Model et non plus la classe play.Model du framework Play!.
Logique : play.Model est destiné à JPA qui n’est pas utilisé par GAE.
Il faut mettre un Id ! L’annotation @Id est obligatoire et elle doit pointer sur une variable de type Long nommée id.
Les autres annotations sont optionnelles. Par défaut, la table créée prendra le nom de la classe et les colonnes prendront le nom des variables sur lesquelles elles pointent.

Il va maintenant falloir ajouter des méthodes à notre modèle afin de pouvoir récupérer des données :

...
static Query all() {
    return Model.all(User.class);
}

public static List findAll() {
    return all().fetch();
}

public static User findById(Long id) {
    return all().filter("id", id).get();
}

public static User findByLogin(String login) {
    return all().filter("login", login).get();
}

Nous avons ajouté une méthode protected all() qui créé une Query qui ramènera tous les Users.
A partir de cette méthode, nous allons appliquer différents filtres pour ramener les données qui nous intéressent :

fetch() pour ramener toutes les données d’une Query.
filter(“id”, id).get() pour filtrer les données dont l’attribut id est égal à id.
filter(“login”, login).get() pour filtrer les données dont l’attribut login est égal à login.

Nous avons maintenant un petit modèle. Attaquons-nous au contrôleur dédié à User !

Le Contrôleur

Pour faire le plus simple possible, utilisons le contrôleur créé par défaut par Play! : Application.

package controllers;

import java.util.List;

import models.User;
import play.mvc.Controller;

public class Application extends Controller {

    public static void index() {
        List users = User.findAll();
        render(users);
    }

    public static void add(String login, String nickname) {
        User add = new User();
        add.login = login;
        add.nickname = nickname;
        add.insert();

        index();
    }

    public static void delete(Long id) {
        notFoundIfNull(id);
        User toRemove = User.findById(id);
        toRemove.delete();

        index();
    }
}

Il s’agit d’un contrôleur tout ce qu’il y a de plus classique en Play!.
Une des méthodes va ramener la liste des Users, une autre va permettre d’en ajouter un et enfin la dernière permet d’en supprimer un.

Notre contrôleur est prêt, ajoutons-lui une page html pour pouvoir jouer avec !

La Vue

Contentons-nous d’utiliser le fichier index.html du contrôleur Application :

#{extends 'main.html' /}
#{set title:'Home' /}


Liste des Users :
  #{list items:users, as:'user'}
    [${user.id}] ${user.login} (${user.nickname})#{a @Application.delete(user.id)}Delete#{/a}
  #{/list}



#{form @Application.add()}
Add a User :

  Login :
  



  Nickname :
  


  

#{/form}

Rien que du très classique Play! : une liste pour afficher tous les Users, un lien pour supprimer un User et enfin un formulaire pour créer un User.

Notre application est désormais prête à être déployée sur Google AppEngine !
Vous pouvez la tester avec un play run, elle devrait tourner parfaitement.

Le déploiement sur Google AppEngine

Lorsque nous avons créé l’application avec un play new test-gae, le module GAE a créé un répertoire war à la racine de notre application.
Celui-ci contient un fichier généré automatiquement : web.xml.
Il va être important de le modifier pour pouvoir déployer correctement sur GAE.

La balise application doit contenir l’ID de votre application Google AppEengine.
Pour le déterminer, il faut créer une application dans Google AppEngine.

Créer une application dans Google AppEngine

Rendez-vous sur https://appengine.google.com/.
Vous devez vous identifier avec votre compte Gmail.
Lors de la création de votre première application, il vous demandera sûrement un numéro de téléphone portable pour vous envoyer un code.
Une fois cette étape passée, vous devriez pouvoir créer une application Google AppEngine :

C’est le champ Application Identifier qui contient l’id de votre application à mettre dans votre fichier web.xml.

Hop, votre application a dûe être déclarée dans Google AppEngine !

Déployer l’application sur Google AppEngine

Ma petite soeur peut le faire : en se plaçant dans le répertoire de notre application, il suffit de lancer :
play gae:deploy --gae={path_to_gae_sdk}
path_to_gae_sdk indique votre installation du SDK Google AppEngine.

Vous devriez voir Play! précompiler les classes, assembler un war puis tenter d’uploader votre application.
Il vous demanderas sûrement votre login et mot de passe Gmail pour vous identifier sur votre compte.
Une fois l’upload terminé, vous pouvez administrer votre application grâce à la console AppEngine :
https://appengine.google.com

Votre application est disponible à l’url indiquée par la console d’administration :

Voici l’archive du projet, prête à l’emploi : Zip.

Play! Framework : enrichir votre application avec un éditeur riche Textile

Jean-Philippe Briend — Thu, 16 Dec 2010 17:34:37 +0000

Voici un billet un peu plus pratique utilisant le framework Play!.
Contrairement à mon billet précédent, celui-ci s’adresse avant tout aux développeurs.

L’objectif est d’intégrer dans une page un éditeur de texte riche au format Textile. Cette syntaxe est très simple à appréhender et la génération de code HTML à partir de code Textile est native dans Play! grâce à la librairie Wikitext.

En ce qui concerne l’éditeur en tant que tel, nous allons utiliser l’excellent MarkItUp. Il est basé sur jQuery, lui même nativement embarqué par Play!. MarkItUp propose un éditeur modulaire, permettant de gérer plusieurs syntaxes. L’ajout de syntaxes se fait par des sets.

MarkItUp

Commençons par télécharger MarkItUp! pack sur la page des téléchargements.
Il faut aussi prendre le Basic Textile Set.
L’archive MarkItUp contient un répertoire markitup : c’est celui-ci qu’il faut décompresser dans le répertoire public de votre application Play!.
Il faut ensuite décompresser l’archive contenant le Basic Textile Set dans le répertoire public/markitup/sets : un nouveau répertoire textile a dû apparaître.

L’installation des fichiers de MarkItUp est désormais terminée. Nous reviendrons plus tard pour la configuration et la customisation de l’éditeur.

Générateur Wikitext

Nous allons avoir besoin de 2 méthodes :

une 1ère méthode pour générer le code destiné à l’iframe Preview. Qui dit iframe dit qu’il va falloir rajouter les feuilles css au code HTML généré.
une 2ième méthode destinée à générer le code qui sera faire le rendu du code Textile saisi par l’utilisateur. Cette fois-ci, il ne faut pas que les css soient inclues dans le code html généré.

J’ai décidé de créer ces 2 méthodes dans un Controler :

package controllers;

import java.io.StringWriter;

import jj.play.org.eclipse.mylyn.wikitext.core.parser.MarkupParser;
import jj.play.org.eclipse.mylyn.wikitext.core.parser.builder.HtmlDocumentBuilder;
import jj.play.org.eclipse.mylyn.wikitext.core.parser.builder.HtmlDocumentBuilder.Stylesheet;
import jj.play.org.eclipse.mylyn.wikitext.textile.core.TextileLanguage;
import play.mvc.Controller;

public class Wikitext extends Controller {

    // Controller classique Play! qui sera appelé par l'iframe Preview de MarkItUp.
    public static void renderPreview(String wiki) {
        StringWriter writer = new StringWriter();
        HtmlDocumentBuilder builder = new HtmlDocumentBuilder(writer);

        // Ajout de mes 2 css.
        Stylesheet css = new Stylesheet("/public/stylesheets/main.css");
        builder.addCssStylesheet(css);
        css = new Stylesheet("/public/stylesheets/wiki.css");
        builder.addCssStylesheet(css);

        // Création du parser Textile
        MarkupParser parser = new MarkupParser(new TextileLanguage());
        parser.setBuilder(builder);
        parser.parse(wiki);

        String htmlContent = writer.toString();
        renderText(htmlContent);
    }

    // Méthode qui sera appelée par les templates Groovy de Play!.
    public static String render(String wiki) {
        StringWriter writer = new StringWriter();
        HtmlDocumentBuilder builder = new HtmlDocumentBuilder(writer);
        // Empêche la génération des balises html et body.
        builder.setEmitAsDocument(false);

        // Création du parser Textile
        MarkupParser parser = new MarkupParser(new TextileLanguage());
        parser.setBuilder(builder);
        parser.parse(wiki);

        return writer.toString();
    }
}

Ces 2 méthodes n’ont rien de spécial : elles utilisent Wikitext qui parse le code Textile de l’utilisateur et en fait un rendu HTML.
Notez dans l’une l’ajout de mes 2 css alors que l’autre méthode ne génère pas les tags html et body.

Afin de rendre ce controller un peu plus sexy, ajoutons lui une route pour le rendu de Preview :


*       /wikitext/renderPreview                 Wikitext.renderPreview

Installation de markItUp dans nos templates

Tout d’abord, il faut ajouter dans la page que vous voulez enrichier de notre éditeur riche le code suivant qui chargera markItUp :

Attention à modifier le code ci-dessus pour que l’identifiant ‘#wiki’ pointe bien vers l’id du textarea que vous voulez enrichir avec markItUp.
De plus, notez la variable mySettings. Celle-ci contient la configuration du plugin markItUp sous format JSON.

Voici un exemple de textarea qui va être enrichi par le plugin markItUp :

    Bla Bla ...

Configuration et customisation de markItUp

Il va falloir maintenant configurer et customiser markItUp.

Pour cela, il va falloir commencer par éditer le fichier public/markitup/sets/textile/set.js :

mySettings = {
	previewParserPath:	'/wikitext/renderPreview', // path to your Wiki parser
	previewParserVar:	'wiki',
	onShiftEnter:		{keepDefault:false, replaceWith:'\n\n'},
	markupSet: [
		{name:'Heading 1', key:'1', openWith:'h1(!(([![Class]!]))!). ', placeHolder:'Your title here...' },
		{name:'Heading 2', key:'2', openWith:'h2(!(([![Class]!]))!). ', placeHolder:'Your title here...' },
		{name:'Heading 3', key:'3', openWith:'h3(!(([![Class]!]))!). ', placeHolder:'Your title here...' },
		{name:'Heading 4', key:'4', openWith:'h4(!(([![Class]!]))!). ', placeHolder:'Your title here...' },
		{name:'Heading 5', key:'5', openWith:'h5(!(([![Class]!]))!). ', placeHolder:'Your title here...' },
		{name:'Heading 6', key:'6', openWith:'h6(!(([![Class]!]))!). ', placeHolder:'Your title here...' },
		{name:'Paragraph', key:'P', openWith:'p(!(([![Class]!]))!). '},
		{separator:'---------------' },
		{name:'Bold', key:'B', closeWith:'*', openWith:'*'},
		{name:'Italic', key:'I', closeWith:'_', openWith:'_'},
		{name:'Stroke through', key:'S', closeWith:'-', openWith:'-'},
		{separator:'---------------' },
		{name:'Bulleted list', openWith:'(!(* |!|*)!)'},
		{name:'Numeric list', openWith:'(!(# |!|#)!)'},
		{separator:'---------------' },
		{name:'Picture', replaceWith:'![![Source:!:http://]!]([![Alternative text]!])!'},
		{name:'Link', openWith:'"', closeWith:'([![Title]!])":[![Link:!:http://]!]', placeHolder:'Your text to link here...' },
		{separator:'---------------' },
		{name:'Quotes', openWith:'bq(!(([![Class]!]))!). '},
		{name:'Code', openWith:'@', closeWith:'@'},
		{separator:'---------------' },
		{name:'Preview', call:'preview', className:'preview'}
	]
}

J’ai fais les modifications suivantes :

Remplissage de la variable previewParserPath : on pointe vers le controller que nous avons écrit plus tôt.
Ajout de la variable previewParserVar pour donner le nom du paramètre HTTP contenant le code à envoyer au controller.

Le reste du fichier sert à configurer l’apparence et les boutons de markItUp. Je vous laisse le soin de fouiller la documentation de ce plugin si vous le souhaitez.

Il ne reste qu’à terminer par un peu de customisation via une CSS.
J’ai modifié le fichier public/markitup/sets/textile/style.css et j’ai rajouté les lignes suivantes :

.markItUp  {
    width:500px;
}

.markItUpEditor {
    width:443px;
    height:220px;
}

Ces surcharges me servent uniquement à redimensionner markItUp.

Et voilà !
En une petite dizaine de minutes, nous avons réussi à transformer un simple Textarea en un éditeur riche supportant Textile avec un rendu aux petits oignons. Soignez votre CSS de rendu et vous êtes le roi du pétrole !

Bonus : Voici un projet Play! contenant le code de cet article. Lancez-le avec un play run et ça marche !
Télécharger le code.

Play! Framework / Intégration Continue : retour d’expérience

Jean-Philippe Briend — Wed, 15 Dec 2010 08:42:10 +0000

Depuis le 2 novembre, la version 1.1 du framework Play! est disponible.
Je ne vous ferai pas une présentation de ce framework, il en existe plusieurs dont celle du Touilleur Express (Play! Framework).

Je vais plutôt vous faire un retour d’expérience de la mise en place des outils nécessaires pour intégrer des applications Play! à notre usine d’Intégration Continue.

Commençons par la description de notre environnement, très classique :

tous les projets Java sont mavenisés (Maven 2).
tous les projets définissent des tests unitaires (JUnit).
certains projets ont des tests Selenium.
tous les projets ont des builds lancés automatiquement par Bamboo.
tous les projets sont analysés par Sonar chaque nuit

La tâche est de faire rentrer les futures applications écrites avec Play! dans cette chaîne d’Intégration Continue.

Mavenisation d’une application Play!

Il s’agit de l’étape qui fut la plus compliquée et surtout la plus longue. Le cahier des charges est le suivant :

Gestion des dépendances applicatives (ie: remplir le répertoire /lib avec les dependencies Maven du projet).
Gestion des librairies inclues dans le framework Play! (afin que la phase compile se passe correctement).
Maven doit pouvoir faire exécuter les tests unitaires et en récupérer un rapport Surefire.
Maven doit pouvoir exécuter Cobertura sur l’application et en extraire un rapport (à destination de Sonar).
Une analyse Sonar doit être effectuée sur l’application.

Gestion des dépendances applicatives

Avec un peu de configuration Maven, (plugin dependency), il est assez facile de faire exporter les librairies applicatives dans le répertoires lib de l’application, ainsi que de les supprimer lors d’un mvn clean.

  
        org.apache.maven.plugins
        maven-dependency-plugin
        2.1
        
          
            default-cli
            
              ,sources
              lib/
              provided
              
              false
              play-runtime,play
            
         ...

Gestion des dépendances du framework Play!

Là, le boulot est un peu plus long car j’ai dû référencer toutes les librairies du framework. Cependant les versions sont très standard (mis à part un patch sur Hibernate), donc le boulot se fait bien.
Petit écueil : certaines librairies n’existent pas dans les repository standards. Il y en a donc certaines qui doivent être uploadées dans votre Nexus d’entreprise.

Ces 2 étapes doivent vous permettre de compiler un projet Play! sous Maven sans encombre.

Maintenant que la compilation fonctionne, préparons l’exécution des tests unitaires via le runtime de Play!

Le Runtime de Play! pour les Tests unitaires

Je sais que la pratique suivante fera bondir certains, mais le runtime de Play! est tout simplement beaucoup trop puissant pour que l’on puisse s’en passer !
Nous ne voulions pas devoir gérer l’installation du runtime sur les différents environnements où les agents Bamboo sont déployés. Il faut donc le packager sous forme de ressources avec ses modules intégrés dans le repository Maven. Une tâche Ant se chargera de le dézipper afin que la commande play soit accessible.

  
    org.play
    play-runtime
    1.1
    zip

Les tests unitaires

Les tests unitaires de Play! framework sont des tests JUnit mais lancés par le runtime Play!.

La commande auto-test permet de lancer les tests unitaires et les tests Selenium automatiquement. Un reporting sous forme de fichier html est généré. J’ai donc dû enrichir le framework pour générer un rapport au format Surefire. Ce rapport contient le nombre de tests unitaires joués, le nombre d’erreurs, d’echecs, le temps passé ainsi qu’un détail des erreurs.
Un script ant permet de faire lancer par Maven le framework Play! en mode auto-test.

Voici une exécution Maven du plugin mavent-antrun-plugin :

L’étape des Tests Unitaires est désormais ok !

L’analyse Cobertura

Que serait une analyse Sonar sans le plugin Cobertura !

Heureusement, il existe un module Cobertura pour la framework Play! Il est très bien intégré puisqu’il suffit de le configurer dans votre application.conf et il l’analyse Cobertura sera effectuée durant la phase des tests unitaires. Un rapport est généré. Le seul travail à faire est de référencer dans Sonar l’emplacement de ce rapport pour que ce dernier puisse l’exploiter.

Je vous conseille la documentation de ce très bon module Play! : Documentation module Cobertura.

Le packaging

Un gros morceau là aussi.

Le packaging d’une application Play! doit être fait sous forme de war pour pouvoir être uploadé dans un repository Maven.
L’idée retenue est que l’on va laisser Maven exécuter sa phase package qui buildera un war non fonctionnel, puis une tâche Ant branchée sur cette même phase va générer grâce à la commande play war un fichier war Play! fonctionnel. Le principal soucis rencontré fût l’exclusion du répertoire target du packaging fait par Play! (notre target contient notamment le runtime Play!). Un développement soumis sur Github nous a permis de rajouter un paramètre –exclude à la ligne de commande play war et d’exclure les répertoires que nous ne voulions pas builder.

Voici l’exécution Maven du plugin Antrun :

Nous avons donc les tests unitaires, l’analyse Cobertura, le packaging en War et le déploiement dans un repo Maven qui fonctionnent. Il ne nous reste plus qu’à attaquer l’analyse Sonar.

L’analyse Sonar

Avec un peu de configuration (emplacement des sources, des fichiers Surefire, Cobertura, etc…), la configuration du plugin Sonar s’est passée sans encombres.

Nous avons donc réussi à intégrer les applications Play! à notre usine d’Intégration Continue.
Les projets ont donc uniquement besoin d’un pom avec les bonnes dépendances pour pouvoir commencer leurs développements et qu’ils soient compatibles Usine de Développement.

Conclusion : malgré quelques difficultés, l’intégration du framework Play! s’est faite sans gros soucis. Nous avons ainsi pu rentrer dans le code du framework, autant du côté Python que du côté Java. Quelques Pull Request chez Github et nous sommes pleinement fonctionnels !

Merci à Play! framework et à toute son équipe !

Update 16/12/2010 :
Suite aux commentaires, voici le contenu du pom parent pour la version 1.1 de Play! :


  4.0.0
  org.play
  play-parent
  1.1
  pom
  Play's parent POM

  
    
    
      infin-it
      http://nexus.infin-it.fr/content/groups/public
      
        true
      
      
        false
      
    
    

  
    1.1
  

  
    
      javax.activation
      activation
      1.1.1
      provided
    
    
      antlr
      antlr
      2.7.6
      provided
    
    
      com.ning
      async-http-client
      1.2.0
      provided
    
    
      org.bouncycastle
      bcprov-jdk15
      1.45
      provided
    
    
      c3p0
      c3p0
      0.9.1.2
      provided
    
    
      cglib
      cglib-nodep
      2.2
      provided
    
    
      commons-beanutils
      commons-beanutils
      1.8.3
      provided
    
    
      commons-codec
      commons-codec
      1.4
      provided
    
    
      commons-collections
      commons-collections
      3.1
      provided
    
    
      org.apache.commons
      commons-email
      1.2
      provided
    
    
      commons-fileupload
      commons-fileupload
      1.2
      provided
    
    
      commons-io
      commons-io
      1.4
      provided
    
    
      commons-lang
      commons-lang
      2.5
      provided
    
    
      commons-logging
      commons-logging
      1.1.1
      provided
    
    
      dom4j
      dom4j
      1.6.1
      provided
    
    
      net.sf.ehcache
      ehcache-core
      2.0.0
      provided
    
    
      net.sf.ezmorph
      ezmorph
      1.0.3
      provided
    
    
      org.codehaus.groovy
      groovy-all
      1.7.1
      provided
    
    
      com.google.code.gson
      gson
      1.4
      provided
    
    
      org.hibernate
      hibernate-core
      3.5.6-Final
      provided
    
    
      org.hibernate
      hibernate-annotations
      3.5.6-Final
      provided
    
    
      org.hibernate
      hibernate-commons-annotations
      3.2.0.Final
      provided
    
    
      org.hibernate
      hibernate-entitymanager
      3.5.6-Final
      provided
    
    
      org.hibernate.javax.persistence
      hibernate-jpa-2.0-api
      1.0.0.Final
      provided
    
    
    
      hsqldb
      hsqldb
      1.8.1.2
      provided
    
    
    
      com.jamonapi
      jamon
      2.7
      provided
    
    
      javax.mail
      mail
      1.4.3
      provided
    
    
      javassist
      javassist
      3.9.0.GA
      provided
    
    
      jaxen
      jaxen
      1.1
      provided
    
    
    
      org.play.jj
      imaging
      1.1
      provided
    
    
    
      org.play.jj
      simple-captcha
      1.1
      provided
    
    
    
      org.play.jj
      textile
      1.1
      provided
    
    
    
      org.play.jj
      wikitext
      1.1
      provided
    
    
      joda-time
      joda-time
      1.6
      provided
    
    
    
      jregex
      jregex
      1.2_01
      provided
    
    
      net.sf.jsr107cache
      jsr107cache
      1.0
      provided
    
    
      javax.transaction
      jta
      1.1
      provided
    
    
      junit
      junit
      4.8.1
      provided
    
    
      log4j
      log4j
      1.2.16
      provided
    
    
    
      net.spy
      memcached
      2.4.2
      provided
    
    
      mysql
      mysql-connector-java
      5.1.13
      provided
    
    
      org.jboss.netty
      netty
      3.2.2.Final
      provided
    
    
    
      org.play
      org.eclipse.jdt.core
      3.6.0
      provided
    
    
      net.sf.oval
      oval
      1.50
      provided
    
    
      org.apache.geronimo.specs
      geronimo-servlet_2.5_spec
      1.2
      provided
    
    
      oauth.signpost
      signpost-core
      1.2
      provided
    
    
      org.slf4j
      slf4j-api
      1.6.1
      provided
    
    
      org.slf4j
      slf4j-log4j12
      1.6.1
      provided
    
    
      org.yaml
      snakeyaml
      1.6
      provided
    

    
    
      org.play
      play
      1.1
    

    
      org.play
      play-runtime
      1.1
      zip
    
  

  
    app
    
      
        
          org.apache.maven.plugins
          maven-war-plugin
          2.1.1
          
            false
          
        

        
          org.apache.maven.plugins
          maven-dependency-plugin
          2.1
          
            
              default-cli
              
                ,sources
                lib/
                provided
                
                false
                play-runtime,play
              
            
            
              packaging
              package
              
                copy-dependencies
              
              
                play-runtime
              
            
          
        

        
          org.apache.maven.plugins
          maven-antrun-plugin
          1.6
          
            
              package
              
                
                  
                  
                  

                  
                  
                  

                  
                  
                  

                  
                    
                      
                        
                      
                    
                  

                  
                  
                  

                  
                  
                  
                  
                  

                  
                  
                    
                      
                    
                  
                  
                    
                      
                    
                  
                  
                    
                  

                  
                  
                    
                      
                    
                  
                  
                    
                      
                    
                  
                  
                    
                    
                    
                    
                    
                  
                
              
              
                run
              
            
          
        

        
          org.apache.maven.plugins
          maven-clean-plugin
          2.4.1
          
            
              
                ${project.basedir}/lib
                
                  **/*.jar
                  **/*.zip
                
                false
              
            
          
        

        
          org.apache.maven.plugins
          maven-compiler-plugin
          2.3.1
          
            1.5
            1.5

Aggrégateur JMX

Jean-Philippe Briend — Thu, 05 Aug 2010 10:28:54 +0000

JMX (Java Management Extensions) est très pratique pour le monitoring d’une application.
Malheureusement, lorsque l’application grandit et que, par exemple, des traitements nocturnes apparaissent, ces derniers tournent dans des machines virtuelles distinctes.

A ce moment là, JMX pose problème pour la remontée d’informations.

L’idée que je vais vous proposer est la suivante :

Une JVM hébergeant un MBeanServer tourne en continu (éventuellement hébergé dans un serveur d’application).
Chacun des traitements se connectera à cette JVM en utilisant un JMX Connector et invoquera à distance des Notifications JMX à destination du MBeanServer.

Grâce à cette architecture, les ports des JVM ‘clientes’ ne sont plus un problème : on laisse le mécanisme par défaut de JMX se débrouiller pour en trouver un libre.

Les personnes souhaitant monitorer ces traitements n’ont qu’à lancer JConsole et se connecter sur la JVM ‘serveur’ qui héberge le MBeanServer.

Le schéma suivant présente le principe :

Cliquez pour agrandir

JMX Notifier va être un objet faisant appel au NotificationPublisher de JMX.
Ce NotificationPublisher envoi des notifications au serveur MBean.

Le JMX Notifier va être exposé par des JMX Connectors aux clients et sera proxyfié.
Le traitement peut alors utiliser de façon invisible cet objet pour envoyer des évènements à la JVM distante.

Passons maintenant au code !

JMX Notifier (serveur) :

@ManagedResource(objectName="batch:name=BatchJMX", description="JMX Notifier")
public class JmxNotifierImpl implements JmxNotifier, NotificationPublisherAware {

  protected NotificationPublisher publisher;

  @ManagedOperation(description="Annonce Début batch.")
  @ManagedOperationParameters(
  @ManagedOperationParameter(name="id", description= "Batch ID."))
  public void annonceDebut(String id) {
    super.publisher.sendNotification(
                    new Notification("Debut du Batch " + id,
                                           this,
                                           0,
                                           Calendar.getInstance().getTimeInMillis()));
  }

  public void setNotificationPublisher(NotificationPublisher publisher) {
    this.publisher = publisher;
  }
}

On notera l’utilisation de l’interface NotificationPublisherAware afin de se faire injecter le NotificationPublisher par Spring.

JMX Notifier Service (client) :

public class JmxNotifierServiceImpl implements InitializingBean {

  private String objectName;
  private String url;
  private JMXConnector jmxConnector;
  private JmxNotifier notifier;

  public void afterPropertiesSet() {
    try {
      ObjectName objectName = new ObjectName(this.objectName);
      JMXServiceURL jmxUrl = new JMXServiceURL(this.url);
      this.jmxConnector = JMXConnectorFactory.connect(jmxUrl);
      MBeanServerConnection mbsc = this.jmxConnector.getMBeanServerConnection();

      this.notifier = (JmxNotifier)MBeanServerInvocationHandler.newProxyInstance(
                                                                                           mbsc,
                                                                                           objectName,
                                                                                           JmxNotifier.class,
                                                                                           false);
    } catch (MalformedObjectNameException e) {
      System.err.println("Warning : could not connect to
                                     JMX server. JMX Notifications will not be sent.");
      System.err.println("Reason : " + e.getMessage());
    } catch (MalformedURLException e) {
      System.err.println("Warning : could not connect to
                                     JMX server. JMX Notifications will not be sent.");
      System.err.println("Reason : " + e.getMessage());
    } catch (IOException e) {
     System.err.println("Warning : could not connect to
                                     JMX server. JMX Notifications will not be sent.");
     System.err.println("It seems that remote server is
                                     not up and not running.");
    }
  }
}

  public void close() throws IOException {
    if ( this.jmxConnector != null ) {
      this.jmxConnector.close();
  }

  public void annonceDebu(String id) {
    if ( this.notifier != null ) {
      this.notifier.annonceDebut(id);
    }
  }
}

Une meilleure gestion des exceptions levées permettrait de gérer les cas où le serveur distant n’est pas disponible.

Côté serveur, il va vous falloir la configuration Spring suivante :

Les points marquants sont la présence de la MBeanServerFactory, la ConnectorServerFactoryBean et la RMIRegistryFactoryBean.

Et c’est tout !
Votre code n’a plus qu’à appeler JMXNotifierService.
Après, à vous d’enrichir les 2 JMX Notifier en fonction du fonctionnel de votre application.

Les équipes responsables du monitoring n’ont qu’à connecter leur JConsole sur la JVM contenant le MBeanServer.

Sample : génération de document PDF avec iText (1ère partie)

Jean-Philippe Briend — Thu, 05 Aug 2010 09:51:36 +0000

Après avoir étudié les différents frameworks Java en vue de la génération de documents PDF (ici), entrainons-nous maintenant 2 exemples simples d’implémentation de la librairie iText.

Ce sample se divise en 2 parties :

la 1ère montre un exemple de génération de document PDF from scratch.
la 2ième partie va générer un document à partir d’un template que nous allons créer dans Open-Office.

Générer un document PDF ‘from scratch’ :

1ère étape : générer un projet Java.

Pour cela, utilisons la commande mvn archetype:generate et choisissons de créer un maven-archetype-quickstart.
Dans notre exemple, le projet est configuré comme suit :

  fr.infinit.sample.generationpdf
  generationpdf
  1.0.0-SNAPSHOT
  Sample Generation PDF

2ième étape : ajouter la dépendance Maven à iText.

Ajoutons le repository iText ainsi que la dépendance pour iText :


  
    itextpdf.com
    Maven Repository for iText
    http://maven.itextpdf.com/


  
    com.itextpdf
    itextpdf
    5.0.2
    compile

3ième étape : Créer un document PDF vide.

Nous allons utiliser la classe com.itextpdf.text.Document :

    /**
     * Crée un Document vide.
     *
     * @param file Chemin du fichier à créer.
     * @return Document s'il n'y a pas eu d'erreur.
     * @throws IOException s'il y a eu une erreur avec le nom de fichier fourni.
     * @throws DocumentException s'il y a eu une erreur côté iText.
     */
    private Document creerDocument(String file) throws DocumentException, IOException {
        Document document = new Document();

        PdfWriter pdfWriter = PdfWriter.getInstance(document, new FileOutputStream(file));
        pdfWriter.setPageEvent(this);
        // Préférence de lecture : 2 pages en colonne.
        pdfWriter.setViewerPreferences(PdfWriter.PageLayoutTwoColumnLeft);
        document.open();

        return document;
    }

Attention à ne pas oublier de fermer l’objet Document après avoir travaillé sur cet objet !

4ième étape : Ajouter des informations Metadata.

L’ajout de ces informations se fait via la classe com.itextpdf.text.Document :

    /**
     * Ajout de données de type Metadata au document.
     *
     * @param document Document auquel il faut rajouter les metadatas.
     */
    private void addMetaData(Document document) {
        document.addTitle("Sample PDF");
        document.addSubject("Utilisant iText");
        document.addKeywords("Java, PDF, iText");
        document.addAuthor(System.getProperty("user.name"));
        document.addCreator(System.getProperty("user.name"));
    }

5ième étape : Ajouter des lignes vides.

L’ajout de lignes vides se fait en ajoutant des paragraphes avec des espaces :

    /**
     * Ajoute une ligne vide number fois dans le Paragraph passé en paramètre.
     *
     * @param paragraph A remplir avec les lignes vides.
     * @param number Nombre de lignes vides à ajouter.
     */
    private void ajouterLigneVide(Paragraph paragraph, int number) {
        for (int i = 0; i < number; i++) {
            paragraph.add(new Paragraph(" "));
        }
    }

6ième étape : Ajouter des paragraphes avec des polices différentes.

Commençons par définir différentes polices :

    /** Times Roman 18 Bold */
    private static final Font CATFONT = new Font(Font.getFamily("TIMES_ROMAN"), 18, Font.BOLD);

    /** Times Roman 12 Normal */
    private static final Font REDFONT = new Font(Font.getFamily("TIMES_ROMAN"), 12, Font.NORMAL);

    /** Times Roman 16 Bold */
    private static final Font SUBFONT = new Font(Font.getFamily("TIMES_ROMAN"), 16, Font.BOLD);

    /** Times Roman 12 Bold */
    private static final Font SMALLBOLD = new Font(Font.getFamily("TIMES_ROMAN"), 12, Font.BOLD);

Ensuite, ajoutons différents paragraphes à notre document :

    /**
     * Ajoute 4 paragraphes / - Titre du document. - Rapport généré par ... - Ce
     * document décrit ... - Ce document est ...
     *
     * @param document Document à enrichir
     * @throws DocumentException Si un problème survient lors de l'ajout des
     *             données.
     */
    private void addTitlePage(Document document) throws DocumentException {
        Paragraph preface = new Paragraph();

        // Ajout d'une ligne vide
        ajouterLigneVide(preface, 1);

        // Ecriture du header
        preface.add(new Paragraph("Titre du document", CATFONT));
        ajouterLigneVide(preface, 1);

        preface.add(new Paragraph("Rapport généré par: " + System.getProperty("user.name") + ", " + new Date(), SMALLBOLD));
        ajouterLigneVide(preface, 3);

        preface.add(new Paragraph("Ce document décrit quelque chose de très important ", SMALLBOLD));
        ajouterLigneVide(preface, 8);

        preface.add(new Paragraph("Ce document est une version préliminaire et n'est sujet à aucune restriction.", REDFONT));
        document.add(preface);

        // Debut d'une nouvelle page
        document.newPage();
    }

7ième étape : Ajouter du contenu (Chapitre, Section, Sous-section, Anchor).

Les objets Anchor, Chapter, Section permettent de définir différentes zones de contenu dans un document.

Anchor anchor = new Anchor("Premier Chapitre", CATFONT);
anchor.setName("Premier Chapitre");

// Le 2ième paramètre est le numero du chapitre
Chapter catPart = new Chapter(new Paragraph(anchor), 1);

Paragraph subPara = new Paragraph("Sous-Catégorie 1", SUBFONT);
Section subCatPart = catPart.addSection(subPara);
subCatPart.add(new Paragraph("Coucou (pour ne pas mettre toto...)."));

subPara = new Paragraph("Sous-catégorie 2", SUBFONT);
subCatPart = catPart.addSection(subPara);
subCatPart.add(new Paragraph("Paragraphe 1"));
subCatPart.add(new Paragraph("Paragraphe 2"));
subCatPart.add(new Paragraph("Paragraphe 3"));

8ième étape : Ajouter un tableau.

Un tableau se créé avec la classe com.itextpdf.text.pdf.PdfPTable.
Il se compose de com.itextpdf.text.pdf.PdfPCell :

/**
 * Crée un tableau de 3 colonnes et l'ajoute à la Section passée en
 * paramètre.
 *
 * @param subCatPart Section à remplir avec le tableau.
 * @throws BadElementException Si une erreur survient lors de l'ajout d'un
 *             élément dans la PdfPTable.
 */
private void createTable(Section subCatPart) throws BadElementException {
    // Creation d'une PdfPTable avec 3 colonnes
    final PdfPTable table = new PdfPTable(3);

    // Creation d'une PdfPCell avec un paragraphe
    final PdfPCell cell = new PdfPCell(new Paragraph("header with colspan 3"));

    // Changement du colspan de la PdfCell
    cell.setColspan(3);

    // Ajout de la PdfCell custom à la PdfPTable
    table.addCell(cell);

    // Ajout d'objets String à la PdfPTable
    table.addCell("1.1");
    table.addCell("2.1");
    table.addCell("3.1");
    table.addCell("1.2");
    table.addCell("2.2");
    table.addCell("3.2");

    // Ajout d'un espace entre la PdfPTable et l'élément précédent.
    table.setSpacingBefore(15f);

    subCatPart.add(table);
}

9ième étape : Ajouter une liste à puce.

Une liste à puce dans un document PDF se créé avec l’objet com.itextpdf.text.List.
En voici un exemple :

/**
 * Crée une liste et l'ajoute dans la Section passée en paramètre.
 *
 * @param subCatPart Section à remplir avec la liste.
 */
private void createList(Section subCatPart) {
    final List list = new List(true, false, 10);
    list.add(new ListItem("Premier point"));
    list.add(new ListItem("Deuxième point"));
    list.add(new ListItem("Troisième point"));
    subCatPart.add(list);
}

10ième étape : Ajouter des numéros de pages.

L’ajout des numéros de page se fait en utilisant la classe com.itextpdf.text.pdf.PdfPageEventHelper.
Elle s’utilise en l’ajoutant comme PageEvent sur le PdfWriter (méthode setPageEvent).
Il suffit ensuite de surcharger les méthodes que l’on souhaite utiliser : onOpenDocument, onEndPage, etc…

Dans notre exemple, la méthode onOpenDocument est utilisée pour créer un com.itextpdf.text.pdf.PdfTemplate qui contiendra le texte des numéros de page.

/**
 * Création du template destiné à recevoir les numéros de page.
 *
 * @param writer PdfWriter à utiliser.
 * @param document Document à enrichir.
 */
@Override
public void onOpenDocument(PdfWriter writer, Document document) {
    total = writer.getDirectContent().createTemplate(100, 100);
    total.setBoundingBox(new Rectangle(-20, -20, 100, 100));
    try {
        helv = BaseFont.createFont(BaseFont.HELVETICA, BaseFont.WINANSI, BaseFont.NOT_EMBEDDED);
    } catch (DocumentException e) {
        LOG.error(e.getMessage(), e);
        // TODO : gérer l'exception.
    } catch (IOException e) {
        LOG.error(e.getMessage(), e);
        // TODO : gérer l'exception.
    }
}

Note : total est un com.itextpdf.text.pdf.PdfTemplate.

La méthode onEndPage est responsable du remplissage du PdfTemplate pour chaque page via un com.itextpdf.text.pdf.PdfContentByte.

Dans l’exemple suivant, les numéros de page paires sont écrits en bas à gauche et les impaires sont écrits en bas à droite :

/**
 * Ajoute des numeros de page automatiquement. Les numeros paires sont mis
 * en bas à gauche. Les numéros impaires sont mis en bas à droite.
 *
 * @param writer Pdfwriter à utiliser.
 * @param document Document à utiliser.
 */
@Override
public void onEndPage(PdfWriter writer, Document document) {
    LOG.info("Generation des numeros de page ...");
    final PdfContentByte directcontent = writer.getDirectContent();

    directcontent.saveState();
    final String text = "Page " + writer.getPageNumber();
    final float textBase = document.bottom() - 20;
    final float textSize = helv.getWidthPoint(text, 12);

    directcontent.beginText();
    directcontent.setFontAndSize(helv, 11);

    // Ecriture du numero de page a gauche pour les pages impaires.
    if ((writer.getPageNumber() % 2) == 1) {
        directcontent.setTextMatrix(document.left(), textBase);
        directcontent.showText(text);
        directcontent.endText();
        directcontent.addTemplate(total, document.left() + textSize, textBase);
    } else {
        // Ecriture du numero de page a droite pour les pages paires.
        final float adjust = helv.getWidthPoint("0", 12);
        directcontent.setTextMatrix(document.right() - textSize - adjust, textBase);
        directcontent.showText(text);
        directcontent.endText();
        directcontent.addTemplate(total, document.right() - adjust, textBase);
    }
    directcontent.restoreState();
}

Comparatif des librairies PDF en Java

Jean-Philippe Briend — Tue, 20 Jul 2010 18:25:49 +0000

Il existe diverses outils pour générer ou travailler sur des fichiers PDF de nos jours.
Intéressons-nous plus particulièrement aux librairies Java permettant de générer ou de parser des PDF sans avoir besoin d’un quelconque outil d’Adobe.

Aspose

Aspose est une société commerciale proposant 2 solutions payantes gravitant autour des problématiques PDF.
La 1ère, Aspose.Pdf for Java, conviendra a la plus part des utilisateurs. Cette librairie permet de lire, écrire ou manipuler des documents PDF. Celle-ci est limitée a la création de documents PDF : l’édition de documents existants n’est pas possible.
La 2ième, Aspose.Pdf.Kit for Java, englobe les fonctionnalités de la précédente mais l’enrichit de fonctionnalités avancées : gestion des champs des formulaires embarqués dans des documents PDF, édition de documents existants, etc…

Ces 2 solutions s’inscrivent dans une gamme de produits plus larges (documents Word, documents Excel, etc ..).

Points positifs :

2 produits à des tarifs différents pour des utilisations différentes.
Intégration à une gamme de produits variés (Word, Excel, Powerpoint, etc…).

Points négatifs :

Produits payants, surtout la version ‘basique’ qui ne nécessite pas forcément une solution commerciale.

iText

iText est une solution Open-Source par Bruno Lowagie. Cette solution offre toutes les fonctionnalités classiques de génération de documents PDF, ainsi que la possibilité d’éditer des documents existants. Elle permet aussi de remplir les formulaires intégrés aux PDFs.
Attention : la licence d’iText a changé depuis Décembre 2009 (version 5.0). Désormais iText est sous licence Affero General Public License (AGPL).

Points positifs :

Le produit permet de faire tout ce qu’on attend d’une API de gestion des documents PDF.
Produit ayant une grande expérience (1998).
iText est très bon pour la génération de documents.

Points négatifs :

Documentation difficile à trouver: les tutoriaux ont été supprimés, désormais il faut acheter le livre ‘iText in Action’.
L’extraction de données n’est pas le fort d’iText.

PDFBox

PDFBox est un projet de la fondation Apache. Il permet la création de nouveaux documents PDF, la manipulation de documents existants et la possibilité d’en extraire des données.
Il ne permet pas de modifier ou de remplir les formulaires des documents PDF.

Points positifs :

Très bon en extraction de données (avec notamment une intégration Lucene Search Engine).
License Apache License v2.0.
Documentation nettement plus fournie qu’iText.

Points négatifs :

Ne gère pas les formulaires PDF.

Conclusion

Si votre projet utilise déjà un produit Aspose, autant garder votre environnement technique homogène.
Si votre principale activité est l’extraction de données (par exemple extraire des données de documents pour un moteur de recherche), alors jetez vous sur PDFBox qui est fait pour vous.
Si vous voulez rester ouvert à toutes les possibilités, prenez iText qui résoudras 95% de vous contraintes.

Spring Batch : les pièges à éviter

Jean-Philippe Briend — Wed, 03 Feb 2010 19:28:24 +0000

Suite à la mise en place de Spring Batch 2.1 chez un client, voici quelques recommandations afin d’éviter une catastrophe technique.

Est-ce que votre traitement est un Batch ?

Il faut savoir que Spring Batch a été développé dans la logique des Batchs tels qu’ils existaient dans les gros systèmes : un Batch est une répétition en très grand nombre d’opérations unitaires (work unit).
Le mode de fonctionnement de Spring Batch est très lié à ce modèle.
Il est donc complètement inutile de se lancer dans l’implémentation de ce framework si l’organisation de votre traitement ne suit pas ce modèle.
Je pense notamment à des traitements qui executeraient des updates SQL massifs : il ne sert à rien de construire une suite de Steps qui lanceront chacunes un update massif. Il faut construire une Step unique qui lancera un traitement complet sur un élément unitaire (appelé chunk dans le langage Spring Batch).

Avez-vous une gestion de la Persistance ‘Maison’ ?

Pour bénéficier de la puissance de Spring Batch, il est important que votre couche de persistance soit homogène : elle doit être full Hibernate, full iBatis ou full Spring JDBC et ne pas comporter d’éléments ‘homemade’.
La gestion des transactions dans le batch est déléguée au TransactionManager, le développeur n’a plus la main dessus.

Envie de paralléliser des exécutions de requêtes SQL ?

Attention !
Si vous souhaitez multithreader des requêtes potentiellement longues avec Spring Batch, il vous faudra mettre en place du JTA. En effet, votre TransactionManager va devoir gérer une transaction ‘chapeau’ qui gèrera elle-même une transaction par thread.
D’où JTA. Ceci est dû au fait qu’une connection à la base de données ne peut pas être accédée simultanément par plusieurs threads (l’objet Connection n’est pas thread-safe).

Importer plusieurs projets Maven dans Eclipse

Jean-Philippe Briend — Wed, 23 Dec 2009 17:20:25 +0000

Lorsque l’on utilise Eclipse et Maven, il est très courant d’utiliser le plugin Maven Eclipse.

Je ne compte plus les fois où je dois travailler avec plusieurs versions d’un même projet Eclipse dans le même workspace Eclipse. Or Eclipse interdit d’importer 2 fois un projet du même nom.

Voici un paramètre du plugin permettant de choisir le nom du projet Eclipse généré à partir de Maven :

mvn -Declipse.projectNameTemplate=[artifactId]-1.3 eclipse:eclipse

Cette commande va créer un projet nommé toto-1.3 où toto est le nom du projet maven.
Vous pouvez aussi utiliser les balises [groupId] et [version].