Création d'un projet de Web Application - Le blog de Sébastien Glon

1. Introduction

Le projet va consité à créer un site internet en java et basé sur les dernières technologies du moment.

Dans le cadre de ce projet d'application web, nous allons tenté de respecter au maximum les standards et les frameworks existant à ce jour.

1.1 Outils utilisés

l'environnement de développement choisi est NetBeans pour sa grande stabilité, la disponnibilité abondante de plugin et une très bonne intégration des frameworks et outils annexe que nous allos mettre en oeuvre.

En ce qui concerne le développement, voici une liste d'outil qui vont nous ammenée une certaine souplesse et fiabilité dans le code généré:

MAVEN :gestionnaire de processus de build avec gestionnaire de dépendance et générateur de document
CHECKSTYLE :outils de vérification syntaxique et de respect des normes Java
CONTINUUM : plateforme d'intégration continu; permet de compilé l'application en automatique et par la même occasion réaliser des tests de dépendance entre modules; cette plateforme fait parti de la suite Apache.
ARCHIVA : Gestionnaire de package et de versionning s'utilise avec maven;
TOMCAT : serveur d'application web dynamique; permet de déployer une application sur le we.

Attention dans ce tutorial, je ne présenterai pas l'installation des ces différens outils mais uniquement leurs configurations au sein du projet.

1.2 Organisation du projet

Nom du projet global : tutoWeb

Le projet va se décomposer en 4 sous projets (modules) et 1 projet maitre. Ce découpage à pour objectif de respecter les différentes couches d'abstraction (type MVC).

le découpage va donc être le suivant:

tutoWeb-Maitre
tutoWeb-Beans
tutWeb-Dao
tutoWeb-Métier
tutoWeb-Présentation

2. Initialisation des projets

2.1 Strucutre d'un projet Maven

Un porjet Maven est composé d'un répertoire principal du nom du projet.
A l'intérieur de celui-ci, nous y retrouvons le fichier de configuration Maven "pom.xml" également appelé fichier POM et le répertoire "src" (sauf pour le projet Maître).
Ce répertoire source "src" ce décompose à son tour en 3 sous répertoires "main, test" qui contiennent respectivement des sources principales du projet, les sources de test.
Dasn chacun de ces 2 répertoires ("main" et "test") nous y retrouverons une arborescence commune que nous pouvons voir ci-dessous.

Les sous projets (modules) sont à créer à la racine du projet maître.

Voici la base de tous les fichiers POM nécessaire pour la compilation via Maven.
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/maven-v4_0_0.xsd">
    <modelVersion>4.0.0</modelVersion>
    <groupId>com.tutoWeb</groupId>
    <artifactId>tutoWeb-Maitre</artifactId>
    <packaging>pom</packaging>
    <version>1.0-SNAPSHOT</version>
    <name>tutiWeb projet Maître</name>
<url>http://sglon.overblog.fr</url>
</project>

définition des différentes balises:

modelVersion - définit la version de POM Maven utilisée; A ne surtout pas Modifier
grouId - définit l'identifiant unique du groupe de projet (ex dans notre cas com.tutoWeb)
artifactId - définit l'identfiant unique du projet au sein de son groupe
packaging - définit le type de projet qui va être généré; valeurs possibles: pom, jar, war
version - définit la version actuelle du projet; l'extension -SNAPSHOT nous indique qu'elle en cours de dev.
name - définit un nom plus explicite a notre projet
url - permet d'identifier le site de référence du projet

C"est à l'intérieur de la balise "project" que nous allons pouvoir définir les différentes librairies, plugins et paramètres de compilations propre à notre projet.

2.2 Configuration du POM maître

L'utilité d'avoir un projet maître est que nous allons pouvoir y définir un certain nombre de données communes à l'ensemble des modules sou-jacent.

1ère étape, nous allons commencer par lui indiquer les modules qui vont le composer.
Pour cela nous allons y ajouter le groupe de balise "modules" ainsi qu'une balise "module" pour chacun d'entre eux. (dépendence décendante)
    <modules>
        <module>tutoWeb-Beans</module>
        <module>tutoWeb-Dao</module>
        <module>tutoWeb-Metier</module>
        <module>tutoWeb-Presentation</module>
    </modules>

Ces balise vont tout simplement permettre à maven d'identifier quels sont les projet sous jacent qu'il va devoir compiler.

2ème étape, nous allons définir les paramètres de compilation nécessaire à l'ensemble des projets.
Pur cela voici la structure générale des balise à inséré:
    <build>
        <plugins>
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-clean-plugin</artifactId>
                <version>2.1.1</version>
            </plugin>
        </plugins>
    </build>

Voici également une liste des différents plugin (du groupId "org.apache.maven.plugins") utilisable lors de la compilation:

maven-clean-plugin - définir les règles de nettoyage des fichiers généré lors de la compilation.
maven-help-plugin - obtenir des informations relative au projet ou au system
maven-resources-plugin - gérer les resources principales et d'essais
maven-surefire-plugin - executer les tests unitaires et générer des rapports
maven-compiler-plugin - définit le compilateur à utiliser et les versions source et target à prendre
maven-jar-plugin - construire et signer les librairie JAR
maven-source-plugin - générer un JAR des sources
maven-war-plugin - construire et signer un package WAR
maven-assembly-plugin - générer des distribution binaire avec script
maven-install-plugin - définir le repository local à utiliser
maven-deploy-plugin -permet le déployement sur un repository
maven-release-plugin - prépare et livre le projet sur le repository
maven-idea-plugin - générer les fichiers de propriété intellectuelle, IML, et IWS
maven-site-plugin - générer le site du projet

Pour connaitre plus en détail les possibilitées et les configuration, vous rapprocher du site officiel

http://maven.apache.org/plugins/

Certain de ces plugins seront abordé plus en détail lors de la mise en place d'autres outils de gestion de projet.

2.3 Configuration du POM module

Comme nous l'avons fait plus haut avec les dépendances décendantes, nous allons maintenant mettre en place la dépendance montante.

Pour cela nous repartons de la structure générale du fichier POM auquel nous ajoutons les balises suivantes:

<parent>
<groupId>com.evasion</groupId>
<artifactId>Evasion-parent</artifactId>
<version>1.003-SNAPSHOT</version>
</parent>

3. Intégration des outils projet

Afin que la configuration soit prise en compte par l'ensemble des sous-projets, nous allons placer ces mise à jour dans le POM parent (tutoWeb-Maitre).

3.1 Configuration du gestionnaire de versionning

La configuration ci dessous a été réailsé pour un serveur de versionning Subversion.

scm>
<connection>scm:svn:http://mon_serveur/</connection>
<developerConnection>scm:svn:http://mon_serveur/</developerConnection>
<url>http://mon_serveur/</url>
</scm>

Comme vous le constaté, nous pouvons dévinir une connection particulière pour les développeur

ATTENTION ne pas oublier le "/" à la fin de l'url

4. Astuce MAVEN

Voici de quoi compléter les connaissances sur MAVEN.

4.1 Creation d'un Archetype

La création d'un Archetype personnalisé va vous permettre de modifier la structure et le contenu de base de vos projet à venir.

Pour commencer nous allons créer une architecture type de projet Archetype par la commande:

mvn archetype:create
-DgroupId=[your project's group id]
-DartifactId=[your project's artifact id]
-DarchetypeArtifactId=maven-archetype-archetype

Une fois la structure du projet d'Archetype réaliser, nous allons nous attaquer à sa personalisation.

Commençons par le fichier propotype pom.xml. Pour cela voici la structure de base que vous pourez personaliser à vos souhait.

<project>
<modelVersion>4.0.0</modelVersion>
<groupId>${groupId}</groupId>
<artifactId>${artifactId}</artifactId>
<packaging>jar</packaging>
<version>${version}</version>
<name>A custom project</name>
<url>http://www.myorganization.org</url>
<dependencies>
<dependency>
<groupId>junit</groupId>
<artifactId>junit</artifactId>
<version>3.8.1</version>
<scope>test</scope>
</dependency>
</dependencies>
</project>

Enfin nous allons ajouter dans le répertoire src/main/resources/archetype-resources/ l'ensemble des fichiers de personalisation.

Pour les classes Java, mettre "${package}" pour définir le nom du package de destination de la classe.

Nous alons configurer l'ensemble de ces fichiers dans le fichier de configuration de notre Archetype
src/main/resources/META-INF/maven/archetype.xml

<archetype>
<id>quickstart</id>
<sources>
<source>src/main/java/App.java</source>
</sources>
<testSources>
<source>src/test/java/AppTest.java</source>
</testSources>
<resources>
<resource>mon_répertoire/monfichier.txt</resource>
</resources>
</archetype>

Chaque fichier inséré à l'étape précédente doit être déclaré

Une fois votre projet terminé, il ne vous reste plus qu'à le deployer sur votre repository local par la commande mvn install

Pour utiliser cette archetype, rien de plus simple, nous faisons comme nous avons l'habitude:

mvn archetype:create
-DgroupId=[your project's group id]
-DartifactId=[your project's artifact id]
-DarchetypeArtifactId=maven-archetype-archetype