Projet Java de base avec Maven

Pour plus d’information lire : http://maven.apache.org/guides/getting-started/

Création

Maven propose des archetypes de projet, nous allons utiliser celui pour Java. Il peut être utilisé de façon interactive. 

mvn archetype:generate \
   -DarchetypeGroupId=org.apache.maven.archetypes \
   -DarchetypeArtifactId=maven-archetype-quickstart \
   -DarchetypeVersion=1.4

On donne ensuite les groupId, le nom de projet (artifactId), le nom du package (par défaut le groupId) et la version. Adapter login et le nom de l’application (MyApp) à votre cas. 

Define value for property 'groupId': : fr.univtln.login
Define value for property 'artifactId': : MyApp
Define value for property 'version':  1.0-SNAPSHOT: : 
Define value for property 'package':  fr.univtln.login: :

Il est possible de donner directement ces informations directement (3 dernières lignes): 

mvn archetype:generate \
 -DarchetypeGroupId=org.apache.maven.archetypes \
 -DarchetypeArtifactId=maven-archetype-quickstart \
 -DarchetypeVersion=1.4 \
 -DgroupId=fr.univtln.login \
 -DartifactId=MyApp \
 -Dversion=1.0-SNAPSHOT

Il est aussi possible de choisir parmis la liste de tous les archetypes (c’est celui de Java par défaut): 

mvn archetype:generate \
    -DarchetypeGroupId=org.apache.maven.archetypes

Compilation et Exécution de base

On peut ensuite compiler le projet : 

mvn compile

ou en faire un package directement : 

mvn package

On peut ensuite exécuter l’application classiquement en ajoutant le package au classpath et en donnant le nom de la classe : 

java -cp target/MyApp-1.0-SNAPSHOT.jar fr.univtln.login.App

on peut aussi l’exécuter avec Maven (ce qui facilitera l’utilisation des dépendances) : 

mvn exec:java  -Dexec.mainClass="fr.univtln.login.App"

Le fichier pom.xml permet définir des options pour ces plugins de Maven :

Paramétrage de base

Fixer la version de java

Ici on choisi Java 8 : 

<build>
        <plugins>
        ...
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-compiler-plugin</artifactId>
                <version>2.5.1</version>
                <configuration>
                    <source>1.8</source>
                    <target>1.8</target>
                </configuration>
            </plugin>
            ...
        </plugins>        
    </build>

Fabriquer des jar exécutables incluant les dépendances

Avec cet exemple deux jar seront systématique produit lors de mvn package : un avec seulement les classes du projet et l’autre incluant les dépendances. Les deux contiennent un manifest indiquant la classe “exécutable” par défaut (ici la classe fr.univtln.bruno.d14.simpleihm.App, à changer en fonction de votre programme). 

 <build>
        <plugins>
            ...
            <plugin>
                <artifactId>maven-assembly-plugin</artifactId>
                <version>2.4.1</version>
                <executions>
                    <execution>
                        <id>create-executable-jar</id>
                        <phase>package</phase>
                        <goals>
                            <goal>single</goal>
                        </goals>
                        <configuration>
                            <descriptorRefs>
                                <descriptorRef>
                                    jar-with-dependencies
                                </descriptorRef>
                            </descriptorRefs>
                            <archive>
                                <manifest>
                                    <mainClass>fr.univtln.bruno.d14.simpleihm.App</mainClass>
                                </manifest>
                            </archive>
                        </configuration>
                    </execution>
                </executions>
            </plugin>
            ...
        </plugins>
    </build>

Pom Parent

Avec Maven, un fichier pom peut rapidement devenir volumineux. De plus, une base commun doit souvent être partagée entre plusieurs projets et/ou plusieurs membres d’une équipe. Comme il s’agit d’une modèle orienté objet, il est possible (et fortement conseillé) de factoriser les paramétrages commun dans un ou plusieurs pom parent. Par exemple, chaque pom d’un projet hérite de celui d’une équipe qui hérite de celui de l’entreprise.

Pour créer un pom parent, il suffit de créer un projet contenant un fichier pom.xml dont le packaging est pom puis de le déposer dans un repository commun (mvn install sur chaque ou de façon plus réaliste utilisation d’un entrepôt maven).

Ensuite un projet peut hériter d’une autre projet en ajoutant dans l’élément project : 

 <parent>
  <groupId>...</groupId>
  <artifactId>...</artifactId>
  <version>...</version>
 </parent>

La commande suivante permet de visualiser le pom après intégration des ancêtres (dont celui par défaut). 

mvn help:effective-pom

Un pom parent est proposé ici https://github.com/emmanuelbruno/commonpom (l’artefact est disponible ici https://bintray.com/dptinfoutln/public/commonpom).

Autre commande de base

Il est possible de supprimer les éléments fabriqués (mvn clean), de générer un site web pour l’application avec mvn site (ouvrir target/site/index.html dans un navigateur web).

Un archetype plus complet

Un archetype plus complet utilisant le pom parent précédent est proposé ici https://github.com/emmanuelbruno/javasimplearchetype pour l’utiliser :

- ajouter l’entrepôt maven bin à votre ~/.m2/settings.xml 

<profiles>
       <profile>
           <repositories>
               <repository>
                   <snapshots>
                       <enabled>false</enabled>
                   </snapshots>
                   <id>bintray-dptinfoutln-public</id>
                   <name>bintray</name>
                   <url>https://dl.bintray.com/dptinfoutln/public</url>
               </repository>
           </repositories>
           <pluginRepositories>
               <pluginRepository>
                   <snapshots>
                       <enabled>false</enabled>
                   </snapshots>
                   <id>bintray-dptinfoutln-public</id>
                   <name>bintray-plugins</name>
                   <url>https://dl.bintray.com/dptinfoutln/public</url>
               </pluginRepository>
           </pluginRepositories>
           <id>bintray</id>
       </profile>
   </profiles>
   <activeProfiles>
       <activeProfile>bintray</activeProfile>
   </activeProfiles>

- Puis lancer la génération 

mvn archetype:generate \
   -DarchetypeGroupId=fr.univtln.bruno.archetype \
   -DarchetypeArtifactId=javaSimpleArchetype \
   -DarchetypeVersion=0.1.0-develop-6 \
   -DgroupId=fr.univtln.bruno.test \
   -DartifactId=HelloWorld2 \
   -Dversion=1.0-SNAPSHOT \
   -DprojectShortName=helloworld \
   -DgithubAccount=emmanuelbruno \
   -DUtlnEmail=emmanuel.bruno@univ-tln.fr

suite à une changement des règles de sécurité liée aux certificats il faut mettre à jour une dépendance d’un plugin dans le pom.xml: 

<plugin>
  <groupId>external.atlassian.jgitflow</groupId>
  <artifactId>jgitflow-maven-plugin</artifactId>
  <version>1.0-m5.1</version>
  <dependencies>
    <dependency>
      <groupId>com.jcraft</groupId>
      <artifactId>jsch</artifactId>
      <version>0.1.54</version>
    </dependency>
  </dependencies>
</plugin>

—- dataentry page —- type : Quickstart enseignement_tags : D14, D35 technologie_tags : Java, Maven theme_tags : POO