Création de projets Java EE avec Maven

Je développe des applications Web Java EE avec Eclipse depuis environ un an. Mon employeur n'utilise pas Maven, mais plus j'en lis, plus je suis convaincu que Maven + Hudson sera grandement bénéfique pour nous. Mais d'abord, je dois me familiariser avec ces technologies pendant mon temps libre, afin de pouvoir créer une preuve de concept.

En ce moment, je suis toujours un débutant Maven. Existe-t-il un ensemble de meilleures pratiques pour créer des applications Web Java EE avec Maven? Par exemple, je pourrais créer un projet avec un archétype de base, puis ajouter tous les fichiers JAR nécessaires en mettant des dépendances dans le POM pour le conteneur de servlet, EJB, EclipseLink, etc ... Cela pourrait fonctionner, mais ce ne serait pas le meilleur façon de le faire. J'apprécierais grandement tout conseil que vous pourriez fournir à ce sujet.

Ne vous embêtez pas avec les archétypes jusqu'à plus tard

Pour toutes les informations que vous devez savoir sur Maven, lisez quelques-uns des livres sur leur site Web . Cependant, c'est un peu exagéré pour ce que vous essayez de réaliser.

Pour commencer, disposez votre application Web en suivant la structure Maven standard pour les applications Web comme suit. (Vous n'avez pas besoin d'un archétype Maven pour cela, c'est juste un tas de dossiers standard, vous pouvez le faire en 2 minutes).

• src/main/java - contient votre code Java de production
• src/main/resources - contient vos ressources de chemin de classe de production (par exemple, les contextes Spring)
• src/main/webapp - (contient WEB-INF / web.xml mais pas de dossier lib)
• src/test/java - contient votre code Java de test
• src/test/resources - contient vos ressources de test (par exemple des exemples de flux XML pour les tests de services Web, etc.)

Plugins de base

L'étape suivante consiste à choisir un tas de plugins. Les suspects habituels sont, bien sûr, ceux qui supportent le nettoyage, la compilation et les ressources (font partie de Maven mais vous pouvez les configurer). Ensuite, vous aurez le testeur d'unité infaillible et le plugin WAR. Cela suffit pour créer une application Web très basique.

Plugins plus avancés

La prochaine étape consiste à introduire les Findbugs et les plugins PMD qui donneront à votre code une analyse approfondie et signaleront divers problèmes potentiels. Vous voudrez probablement disposer de JXR pour le croisement du code source, de la liste des balises pour le suivi des TODO et des balises REFACTOR, etc. Par dessus tout...

... Utilisez le plugin Jetty pour les applications web

Utilisez le plugin Jetty pour exécuter votre fichier WAR dans votre IDE pour un débogage facile. C'est rapide et petit et le travail est fait très rapidement. Avoir Jetty dans votre build Maven rend votre projet capable d'être testé sur n'importe quelle machine sans avoir besoin d'un IDE avec un panneau Serveurs complexe configuré. Il vous permet également de déclarer des dépendances sur d'autres fichiers WAR, ce qui signifie que vous pouvez générer un environnement de travail complet composé de plusieurs applications Web toutes avec une seule commande "mvn clean jetty: run". Cela fonctionne partout et vous pouvez même fournir une configuration JNDI de test afin que vos sources de données injectées par Spring soient toutes configurées en externe. Si vous combinez cette approche Jetty avec une page HTML de démonstration standard (src/test/resources/demo.html), vous économiserez des tonnes d'heures de développement pour essayer d'obtenir un environnement local fonctionnel. Une commande et vous avez terminé. Facile.

Configurer votre IDE

Avec Maven, c'est facile car tous les grands garçons le supportent: Eclipse, Netbeans et, bien sûr, mon préféré Intellij. Pointez simplement votre IDE vers le pom.xml et il s'occupera de faire tomber toutes les dépendances répertoriées pour vous. Plus de bouder avec WEB-INF/lib. Dans Eclipse, vous utilisez généralement Fichier | Importer ... | Projet Maven | pom.xml.

Intégration avec Hudson

Installez d'abord Hudson (c'est juste une webapp) puis ciblez votre système de contrôle de version pour qu'il vérifie la version appropriée. Votre dernière étape consiste à le configurer afin qu'il utilise Maven pour effectuer la génération. Évidemment, Maven devra être installé sur votre machine de build (en supposant que c'est différent de votre machine de développement).

Hudson ne fait que les snapshots

Demandez à Hudson d'effectuer des générations d'instantanés et de laisser les générations de versions à un processus manuel. L'utilisation de cette approche signifie que les développeurs peuvent partager leur code sous une révision d'instantané (par exemple 1.0.0-SNAPSHOT) et seulement s'il est capable de passer la construction, il sera partagé dans le référentiel d'équipe. En règle générale, Hudson exécute "mvn clean deploy" bien que l'inclusion de l'objectif "site" puisse également faire partie de votre processus car il créera un petit site Web de projet pour chaque build. Les développeurs de l'équipe verront la version de l'instantané mise à jour automatiquement incluse dans leur projet via le processus de gestion des dépendances Maven.

Hudson fournit une multitude de plugins qui peuvent prendre en charge toutes sortes de métriques. Mon préféré est de garder une trace du nombre de tests réussis par projet au fil du temps. C'est formidable de montrer à la direction que votre nombre de tests unitaires et votre couverture ne cessent d'augmenter.

Conseils de configuration générale

Répartissez vos référentiels dans au moins la structure suivante:

• team-release - Tous vos artefacts de production sortis vont ici
• team-snapshot - Tous vos artefacts de développement d'instantanés vont ici
• version tierce - Toutes vos bibliothèques tierces de support vont ici (par exemple Spring, Hibernate, etc.)

Les comptes utilisateur de développeur ne doivent pas pouvoir écrire dans les référentiels d'équipe, ni instantané ni version. Cela permettrait à un développeur de contourner Hudson s'il est pressé et deviendra rapidement la norme.

Assurez-vous de toujours télécharger la source, les javadocs et les signatures SHA pour tous vos tiers. Jarvana est un excellent explorateur de référentiel pour toutes ces classes difficiles à trouver.

Pensez à installer un gestionnaire de référentiel comme Nexus ou Artifactory pour permettre un meilleur contrôle sur votre référentiel en constante évolution.

Maven fournit de nombreux archétypes

mvn archetype:generate

imprimera une liste des disponibles.

La principale différence entre les archétypes Java simples et les archétypes J2EE est que les répertoires pour jsp et les images seront générés. Si vous démarrez un nouveau projet J2EE, envisagez d'en utiliser un dès le début.

À mesure que votre projet se développe, vous pouvez ajouter plus de dépendances. Personnellement, je préfère commencer avec une collection minimale de dépendances (par exemple l'archétype de base J2EE), puis ajouter progressivement ce dont j'ai besoin.

Je l'ai fait en partant d'un archétype de base et en ajoutant tous les bits, et je suis assez sûr que ce n'est pas un très bon moyen. Mais je trouve que c'est gênant dans l'autre sens aussi; sélectionner ce qui est un bon archétype est difficile à moins que vous ne soyez déjà «profondément versé dans les secrets». C'est un peu trop de la tradition sorcière (par opposition à des informations techniques découvrables sensibles) à mon goût…

Maven fournit un moyen de créer des projets à partir de modèles appelés archétypes . Vous utilisez la commande mvn archetype:generatepour en choisir une de manière interactive . Vous pouvez également en spécifier un directement.

mvn archetype:generate \
    -DarchetypeGroupId=org.apache.maven.archetypes \
    -DarchetypeArtifactId=maven-archetype-j2ee-simple \
    -DarchetypeVersion=1.0

Le tout sur une seule ligne.

J'utilise Maven et Hudson depuis trois mois. Cela m'aide à vérifier régulièrement la santé de la base de code en exécutant tous les tests unitaires, en générant un rapport de test. Vous pouvez essayer ça.
Vous pouvez également essayer Spring Roo. Il s'agit d'un outil RAD pour créer un projet J2EE basé sur Spring.