Maven - Guide rapide
Qu'est-ce que Maven?
Maven est un outil de gestion et de compréhension de projet qui fournit aux développeurs un cadre complet de cycle de vie de construction. L'équipe de développement peut automatiser l'infrastructure de construction du projet en un rien de temps car Maven utilise une disposition de répertoire standard et un cycle de vie de construction par défaut.
En cas d'environnement d'équipes de développement multiples, Maven peut mettre en place la manière de travailler selon les normes dans un délai très court. Comme la plupart des configurations de projet sont simples et réutilisables, Maven facilite la vie du développeur tout en créant des rapports, des vérifications, des configurations d'automatisation de construction et de test.
Maven fournit aux développeurs des moyens de gérer les éléments suivants -
- Builds
- Documentation
- Reporting
- Dependencies
- SCMs
- Releases
- Distribution
- Liste de diffusion
Pour résumer, Maven simplifie et standardise le processus de construction du projet. Il gère la compilation, la distribution, la documentation, la collaboration d'équipe et d'autres tâches de manière transparente. Maven augmente la réutilisabilité et prend en charge la plupart des tâches liées à la construction.
Évolution Maven
Maven a été conçu à l'origine pour simplifier les processus de construction dans le projet Jakarta Turbine. Il y avait plusieurs projets et chaque projet contenait des fichiers de construction ANT légèrement différents. Les fichiers JAR ont été enregistrés dans CVS.
Le groupe Apache s'est ensuite développé Maven qui peut construire plusieurs projets ensemble, publier des informations sur les projets, déployer des projets, partager des JAR à travers plusieurs projets et aider à la collaboration d'équipes.
Objectif
L'objectif principal de Maven est de fournir aux développeurs les éléments suivants:
Un modèle complet pour les projets, qui est réutilisable, maintenable et plus facile à comprendre.
Plugins ou outils qui interagissent avec ce modèle déclaratif.
La structure et le contenu du projet Maven sont déclarés dans un fichier xml, pom.xml, appelé Project Object Model (POM), qui est l'unité fondamentale de l'ensemble du système Maven. Dans les chapitres suivants, nous expliquerons POM en détail.
Convention sur la configuration
Maven utilise Convention plus de Configuration, ce qui signifie que les développeurs ne sont pas obligés de créer eux-mêmes le processus de construction.
Les développeurs n'ont pas à mentionner chaque détail de configuration. Maven fournit un comportement par défaut judicieux pour les projets. Lorsqu'un projet Maven est créé, Maven crée une structure de projet par défaut. Le développeur est uniquement tenu de placer les fichiers en conséquence et il / elle n'a pas besoin de définir de configuration dans pom.xml.
À titre d'exemple, le tableau suivant montre les valeurs par défaut des fichiers de code source du projet, des fichiers de ressources et d'autres configurations. En supposant,${basedir} désigne l'emplacement du projet -
| Article | Défaut |
|---|---|
| code source | $ {basedir} / src / main / java |
| Ressources | $ {basedir} / src / main / resources |
| Des tests | $ {basedir} / src / test |
| Code d'octet respecté | $ {basedir} / cible |
| JAR distribuable | $ {basedir} / target / classes |
Afin de construire le projet, Maven fournit aux développeurs des options pour mentionner les objectifs du cycle de vie et les dépendances du projet (qui reposent sur les capacités du plugin Maven et sur ses conventions par défaut). Une grande partie de la gestion de projet et des tâches liées à la construction sont gérées par les plugins Maven.
Les développeurs peuvent créer n'importe quel projet Maven sans avoir besoin de comprendre le fonctionnement des plugins individuels. Nous discuterons en détail des plugins Maven dans les chapitres suivants.
Caractéristiques de Maven
Configuration de projet simple qui suit les meilleures pratiques.
Utilisation cohérente dans tous les projets.
Gestion des dépendances avec mise à jour automatique.
Un référentiel important et croissant de bibliothèques.
Extensible, avec la possibilité d'écrire facilement des plugins en Java ou en langage de script.
Accès instantané à de nouvelles fonctionnalités avec peu ou pas de configuration supplémentaire.
Model-based builds - Maven est capable de créer n'importe quel nombre de projets dans des types de sortie prédéfinis tels que jar, war, métadonnées.
Coherent site of project information - En utilisant les mêmes métadonnées que lors du processus de construction, maven est capable de générer un site Web et un PDF avec une documentation complète.
Release management and distribution publication - Sans configuration supplémentaire, maven s'intégrera à votre système de contrôle de source tel que CVS et gère la sortie d'un projet.
Backward Compatibility- Vous pouvez facilement porter les multiples modules d'un projet dans Maven 3 à partir d'anciennes versions de Maven. Il peut également prendre en charge les anciennes versions.
Automatic parent versioning - Pas besoin de spécifier le parent dans le sous-module pour la maintenance.
Parallel builds- Il analyse le graphe de dépendance du projet et vous permet de créer des modules de planification en parallèle. Grâce à cela, vous pouvez obtenir des améliorations de performances de 20 à 50%.
Better Error and Integrity Reporting - Maven a amélioré le rapport d'erreurs, et il vous fournit un lien vers la page wiki Maven où vous obtiendrez une description complète de l'erreur.
Maven est un outil basé sur Java, donc la toute première exigence est d'avoir JDK installé sur votre machine.
Exigence du système
| JDK | 1.7 ou supérieur. |
|---|---|
| Mémoire | Aucune exigence minimale. |
| Espace disque | Aucune exigence minimale. |
| Système opérateur | Aucune exigence minimale. |
Étape 1 - Vérifiez l'installation de Java sur votre machine
Ouvrez la console et exécutez ce qui suit java commander.
| OS | Tâche | Commander |
|---|---|---|
| les fenêtres | Ouvrez la console de commande | c: \> java -version |
| Linux | Ouvrir le terminal de commande | $ java -version |
| Mac | Terminal ouvert | machine: ~ joseph $ java -version |
Vérifions la sortie pour tous les systèmes d'exploitation -
| OS | Production |
|---|---|
| les fenêtres | version java "1.7.0_60" Environnement d'exécution Java (TM) SE (build 1.7.0_60-b19) VM serveur 64 bits Java HotSpot (TM) (build 24.60-b09, mode mixte) |
| Linux | version java "1.7.0_60" Environnement d'exécution Java (TM) SE (build 1.7.0_60-b19) VM serveur 64 bits Java HotSpot (TM) (build 24.60-b09, mode mixte) |
| Mac | version java "1.7.0_60" Environnement d'exécution Java (TM) SE (build 1.7.0_60-b19) VM serveur 64 bits Java HotSpot (TM) (build 24.60-b09, mode mixte) |
Si Java n'est pas installé, installez le kit de développement logiciel Java (SDK) à partir de https://www.oracle.com/technetwork/java/javase/downloads/index.html. Nous supposons Java 1.7.0.60 comme version installée pour ce didacticiel.
Étape 2 - Définir l'environnement JAVA
Met le JAVA_HOMEvariable d'environnement pour pointer vers l'emplacement du répertoire de base où Java est installé sur votre machine. Par exemple -
| OS | Production |
|---|---|
| les fenêtres | Définissez la variable d'environnement JAVA_HOME sur C: \ Program Files \ Java \ jdk1.7.0_60 |
| Linux | export JAVA_HOME = / usr / local / java-current |
| Mac | export JAVA_HOME = / Bibliothèque / Java / Accueil |
Ajoutez l'emplacement du compilateur Java au chemin système.
| OS | Production |
|---|---|
| les fenêtres | Ajoutez la chaîne «; C: \ Program Files \ Java \ jdk1.7.0.60 \ bin» à la fin de la variable système, Path. |
| Linux | export PATH =$PATH:$JAVA_HOME / bin / |
| Mac | non requis |
Vérifiez l'installation de Java à l'aide de java -version comme expliqué ci-dessus.
Étape 3 - Téléchargez l'archive Maven
Téléchargez Maven 2.2.1 depuis https://maven.apache.org/download.cgi.
| OS | Nom de l'archive |
|---|---|
| les fenêtres | apache-maven-3.3.1-bin.zip |
| Linux | apache-maven-3.3.1-bin.tar.gz |
| Mac | apache-maven-3.3.1-bin.tar.gz |
Étape 4 - Extraire l'archive Maven
Extrayez l'archive dans le répertoire dans lequel vous souhaitez installer Maven 3.3.1. Le sous-répertoire apache-maven-3.3.1 sera créé à partir de l'archive.
| OS | Emplacement (peut être différent en fonction de votre installation) |
|---|---|
| les fenêtres | C: \ Program Files \ Apache Software Foundation \ apache-maven-3.3.1 |
| Linux | / usr / local / apache-maven |
| Mac | / usr / local / apache-maven |
Étape 5 - Définir les variables d'environnement Maven
Ajoutez M2_HOME, M2, MAVEN_OPTS aux variables d'environnement.
| OS | Production |
|---|---|
| les fenêtres | Définissez les variables d'environnement à l'aide des propriétés système. M2_HOME = C: \ Program Files \ Apache Software Foundation \ apache-maven-3.3.1 M2 =% M2_HOME% \ bin MAVEN_OPTS = -Xms256m -Xmx512m |
| Linux | Ouvrez le terminal de commande et définissez les variables d'environnement. export M2_HOME = / usr / local / apache-maven / apache-maven-3.3.1 export M2 = $ M2_HOME / bin export MAVEN_OPTS = -Xms256m -Xmx512m |
| Mac | Ouvrez le terminal de commande et définissez les variables d'environnement. export M2_HOME = / usr / local / apache-maven / apache-maven-3.3.1 export M2 = $ M2_HOME / bin export MAVEN_OPTS = -Xms256m -Xmx512m |
Étape 6 - Ajouter l'emplacement du répertoire Maven bin au chemin système
Maintenant, ajoutez la variable M2 au chemin système.
| OS | Production |
|---|---|
| les fenêtres | Ajoutez la chaîne;% M2% à la fin de la variable système, Path. |
| Linux | export PATH =$M2:$CHEMIN |
| Mac | export PATH =$M2:$CHEMIN |
Étape 7 - Vérifiez l'installation de Maven
Ouvrez maintenant la console et exécutez ce qui suit mvn commander.
| OS | Tâche | Commander |
|---|---|---|
| les fenêtres | Ouvrez la console de commande | c: \> mvn --version |
| Linux | Ouvrir le terminal de commande | $ mvn --version |
| Mac | Terminal ouvert | machine: ~ joseph $ mvn --version |
Enfin, vérifiez la sortie des commandes ci-dessus, qui devraient être comme suit -
| OS | Production |
|---|---|
| les fenêtres | Apache Maven 3.3.1 (r801777; 2009-08-07 00: 46: 01 + 0530) Version Java: 1.7.0_60 Accueil Java: C: \ Program Files \ Java \ jdk1.7.0_60 \ jre |
| Linux | Apache Maven 3.3.1 (r801777; 2009-08-07 00: 46: 01 + 0530) Version Java: 1.7.0_60 Accueil Java: C: \ Program Files \ Java \ jdk1.7.0_60 \ jre |
| Mac | Apache Maven 3.3.1 (r801777; 2009-08-07 00: 46: 01 + 0530) Version Java: 1.7.0_60 Accueil Java: C: \ Program Files \ Java \ jdk1.7.0_60 \ jre |
POM signifie Project Object Model. C'est une unité de travail fondamentale à Maven. Il s'agit d'un fichier XML qui réside dans le répertoire de base du projet sous le nom pom.xml.
Le POM contient des informations sur le projet et divers détails de configuration utilisés par Maven pour construire le (s) projet (s).
POM contient également les objectifs et les plugins. Lors de l'exécution d'une tâche ou d'un objectif, Maven recherche le POM dans le répertoire courant. Il lit le POM, obtient les informations de configuration nécessaires, puis exécute l'objectif. Certaines des configurations qui peuvent être spécifiées dans le POM sont les suivantes:
- dépendances du projet
- plugins
- goals
- créer des profils
- version du projet
- developers
- liste de diffusion
Avant de créer un POM, nous devons d'abord décider du projet group (groupId), son name (artifactId) et sa version car ces attributs aident à identifier de manière unique le projet dans le référentiel.
Exemple de POM
<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/xsd/maven-4.0.0.xsd">
<modelVersion>4.0.0</modelVersion>
<groupId>com.companyname.project-group</groupId>
<artifactId>project</artifactId>
<version>1.0</version>
</project>Il convient de noter qu'il doit y avoir un seul fichier POM pour chaque projet.
Tous les fichiers POM nécessitent le project élément et trois champs obligatoires: groupId, artifactId, version.
La notation des projets dans le référentiel est groupId:artifactId:version.
Exigences minimales pour un POM -
| Sr.No. | Nœud et description |
|---|---|
| 1 | Project root Il s'agit de la balise racine du projet. Vous devez spécifier les paramètres de schéma de base tels que le schéma Apache et la spécification w3.org. |
| 2 | Model version La version du modèle doit être 4.0.0. |
| 3 | groupId Ceci est un identifiant du groupe du projet. Ceci est généralement unique au sein d'une organisation ou d'un projet. Par exemple, un groupe bancaire com.company.bank a tous les projets liés à la banque. |
| 4 | artifactId Ceci est un identifiant du projet. C'est généralement le nom du projet. Par exemple, les services bancaires aux consommateurs. Avec le groupId, l'artefactId définit l'emplacement de l'artefact dans le référentiel. |
| 5 | version Ceci est la version du projet. Avec le groupId, il est utilisé dans le référentiel d'un artefact pour séparer les versions les unes des autres. Par exemple - com.company.bank:consumer-banking:1.0 com.company.bank:consumer-banking:1.1. |
Super POM
Le Super POM est le POM par défaut de Maven. Tous les POM héritent d'un parent ou par défaut (malgré la définition explicite ou non). Ce POM de base est connu sous le nom deSuper POMet contient des valeurs héritées par défaut.
Maven utilise le POM efficace (configuration à partir de la configuration du projet super pom plus) pour exécuter l'objectif pertinent. Il aide les développeurs à spécifier les détails de configuration minimum dans son pom.xml. Bien que les configurations puissent être remplacées facilement.
Un moyen simple de consulter les configurations par défaut du super POM consiste à exécuter la commande suivante: mvn help:effective-pom
Créez un pom.xml dans n'importe quel répertoire de votre ordinateur.Utilisez le contenu de l'exemple pom mentionné ci-dessus.
Dans l'exemple ci-dessous, nous avons créé un pom.xml dans le dossier C: \ MVN \ project.
Maintenant, ouvrez la console de commande, allez dans le dossier contenant pom.xml et exécutez ce qui suit mvn commander.
C:\MVN\project>mvn help:effective-pomMaven commencera le traitement et affichera le pom efficace.
[INFO] Scanning for projects...
[INFO] Searching repository for plugin with prefix: 'help'.
[INFO] ------------------------------------------------------------------------
[INFO] Building Unnamed - com.companyname.project-group:project-name:jar:1.0
[INFO] task-segment: [help:effective-pom] (aggregator-style)
[INFO] ------------------------------------------------------------------------
[INFO] [help:effective-pom {execution: default-cli}]
[INFO]
.....
[INFO] ------------------------------------------------------------------------
[INFO] BUILD SUCCESSFUL
[INFO] ------------------------------------------------------------------------
[INFO] Total time: < 1 second
[INFO] Finished at: Thu Jul 05 11:41:51 IST 2012
[INFO] Final Memory: 6M/15M
[INFO] ------------------------------------------------------------------------POM effectif affiché comme résultat dans la console, après application de l'héritage, de l'interpolation et des profils.
<?xml version="1.0" encoding="UTF-8"?>
<!-- ============================================== -->
<!-- -->
<!-- Generated by Maven Help Plugin on 2015-04-09T11:41:51 -->
<!-- See: http://maven.apache.org/plugins/maven-help-plugin/ -->
<!-- -->
<!-- ==============================================-->
<!-- ==============================================-->
<!-- -->
<!-- Effective POM for project -->
<!-- 'com.companyname.project-group:project-name:jar:1.0' -->
<!-- -->
<!-- ============================================== -->
<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/xsd/maven-4.0.0.xsd">
<modelVersion>4.0.0</modelVersion>
<groupId>com.companyname.project-group</groupId>
<artifactId>project</artifactId>
<version>1.0</version>
<build>
<sourceDirectory>C:\MVN\project\src\main\java</sourceDirectory>
<scriptSourceDirectory>src/main/scripts</scriptSourceDirectory>
<testSourceDirectory>C:\MVN\project\src\test\java</testSourceDirectory>
<outputDirectory>C:\MVN\project\target\classes</outputDirectory>
<testOutputDirectory>C:\MVN\project\target\test-classes</testOutputDirectory>
<resources>
<resource>
<mergeId>resource-0</mergeId>
<directory>C:\MVN\project\src\main\resources</directory>
</resource>
</resources>
<testResources>
<testResource>
<mergeId>resource-1</mergeId>
<directory>C:\MVN\project\src\test\resources</directory>
</testResource>
</testResources>
<directory>C:\MVN\project\target</directory>
<finalName>project-1.0</finalName>
<pluginManagement>
<plugins>
<plugin>
<artifactId>maven-antrun-plugin</artifactId>
<version>1.3</version>
</plugin>
<plugin>
<artifactId>maven-assembly-plugin< /artifactId>
<version>2.2-beta-2</version>
</plugin>
<plugin>
<artifactId>maven-clean-plugin< /artifactId>
<version>2.2</version>
</plugin>
<plugin>
<artifactId>maven-compiler-plugin</artifactId>
<version>2.0.2</version>
</plugin>
<plugin>
<artifactId>maven-dependency-plugin</artifactId>
<version>2.0</version>
</plugin>
<plugin>
<artifactId>maven-deploy-plugin</artifactId>
<version>2.4</version>
</plugin>
<plugin>
<artifactId>maven-ear-plugin</artifactId>
<version>2.3.1</version>
</plugin>
<plugin>
<artifactId>maven-ejb-plugin</artifactId>
<version>2.1</version>
</plugin>
<plugin>
<artifactId>maven-install-plugin</artifactId>
<version>2.2</version>
</plugin>
<plugin>
<artifactId>maven-jar-plugin</artifactId>
<version>2.2</version>
</plugin>
<plugin>
<artifactId>maven-javadoc-plugin</artifactId>
<version>2.5</version>
</plugin>
<plugin>
<artifactId>maven-plugin-plugin</artifactId>
<version>2.4.3</version>
</plugin>
<plugin>
<artifactId>maven-rar-plugin</artifactId>
<version>2.2</version>
</plugin>
<plugin>
<artifactId>maven-release-plugin</artifactId>
<version>2.0-beta-8</version>
</plugin>
<plugin>
<artifactId>maven-resources-plugin</artifactId>
<version>2.3</version>
</plugin>
<plugin>
<artifactId>maven-site-plugin</artifactId>
<version>2.0-beta-7</version>
</plugin>
<plugin>
<artifactId>maven-source-plugin</artifactId>
<version>2.0.4</version>
</plugin>
<plugin>
<artifactId>maven-surefire-plugin</artifactId>
<version>2.4.3</version>
</plugin>
<plugin>
<artifactId>maven-war-plugin</artifactId>
<version>2.1-alpha-2</version>
</plugin>
</plugins>
</pluginManagement>
<plugins>
<plugin>
<artifactId>maven-help-plugin</artifactId>
<version>2.1.1</version>
</plugin>
</plugins>
</build>
<repositories>
<repository>
<snapshots>
<enabled>false</enabled>
</snapshots>
<id>central</id>
<name>Maven Repository Switchboard</name>
<url>http://repo1.maven.org/maven2</url>
</repository>
</repositories>
<pluginRepositories>
<pluginRepository>
<releases>
<updatePolicy>never</updatePolicy>
</releases>
<snapshots>
<enabled>false</enabled>
</snapshots>
<id>central</id>
<name>Maven Plugin Repository</name>
<url>http://repo1.maven.org/maven2</url>
</pluginRepository>
</pluginRepositories>
<reporting>
<outputDirectory>C:\MVN\project\target/site</outputDirectory>
</reporting>
</project>Dans pom.xml ci-dessus, vous pouvez voir la structure par défaut des dossiers sources du projet, le répertoire de sortie, les plug-ins requis, les référentiels, le répertoire de rapports que Maven utilisera lors de l'exécution des objectifs souhaités.
Maven pom.xml ne doit pas non plus être écrit manuellement. Maven fournit de nombreux plugins d'archétype pour créer des projets, qui dans l'ordre, créent la structure du projet et pom.xml
Qu'est-ce que Build Lifecycle?
Un cycle de vie de construction est une séquence bien définie de phases, qui définissent l'ordre dans lequel les objectifs doivent être exécutés. Ici, la phase représente une étape du cycle de vie. À titre d'exemple, unMaven Build Lifecycle se compose de la séquence de phases suivante.
| Phase | Poignées | La description |
|---|---|---|
| préparer-ressources | copie de ressources | La copie des ressources peut être personnalisée dans cette phase. |
| valider | Valider les informations | Valide si le projet est correct et si toutes les informations nécessaires sont disponibles. |
| compiler | compilation | La compilation du code source est effectuée dans cette phase. |
| Tester | Essai | Teste le code source compilé adapté au framework de test. |
| paquet | emballage | Cette phase crée le package JAR / WAR comme mentionné dans le package dans POM.xml. |
| installer | installation | Cette phase installe le package dans le référentiel maven local / distant. |
| Déployer | Déploiement | Copie le package final dans le référentiel distant. |
Il y a toujours pre et post phases pour s'inscrire goals, qui doit s'exécuter avant ou après une phase particulière.
Lorsque Maven commence à construire un projet, il parcourt une séquence définie de phases et exécute des objectifs, qui sont enregistrés avec chaque phase.
Maven a les trois cycles de vie standard suivants -
- clean
- default (ou build)
- site
UNE goalreprésente une tâche spécifique qui contribue à la construction et à la gestion d'un projet. Il peut être lié à zéro ou plusieurs phases de construction. Un objectif qui n'est lié à aucune phase de construction peut être exécuté en dehors du cycle de vie de construction par appel direct.
L'ordre d'exécution dépend de l'ordre dans lequel le (s) but (s) et la ou les phases de construction sont appelés. Par exemple, considérez la commande ci-dessous. leclean et package les arguments sont des phases de construction tandis que les dependency:copy-dependencies est un objectif.
mvn clean dependency:copy-dependencies packageIci, la phase de nettoyage sera exécutée en premier, suivie dedependency:copy-dependencies goal, et enfin la phase du package sera exécutée.
Cycle de vie propre
Lorsque nous exécutons la commande mvn post-clean , Maven appelle le cycle de vie propre composé des phases suivantes.
- pre-clean
- clean
- post-clean
But Maven propre (propre: propre) est lié à la propre phase du cycle de vie propre. Sesclean:cleangoalsupprime la sortie d'une construction en supprimant le répertoire de construction. Ainsi, lorsque la commande mvn clean s'exécute, Maven supprime le répertoire de construction.
Nous pouvons personnaliser ce comportement en mentionnant des objectifs dans l'une des phases ci-dessus du cycle de vie propre.
Dans l'exemple suivant, nous allons attacher maven-antrun-plugin: run goal aux phases de pré-nettoyage, de nettoyage et de post-nettoyage. Cela nous permettra de faire écho aux messages texte affichant les phases du cycle de vie propre.
Nous avons créé un pom.xml dans le dossier C: \ MVN \ project.
<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/xsd/maven-4.0.0.xsd">
<modelVersion>4.0.0</modelVersion>
<groupId>com.companyname.projectgroup</groupId>
<artifactId>project</artifactId>
<version>1.0</version>
<build>
<plugins>
<plugin>
<groupId>org.apache.maven.plugins</groupId>
<artifactId>maven-antrun-plugin</artifactId>
<version>1.1</version>
<executions>
<execution>
<id>id.pre-clean</id>
<phase>pre-clean</phase>
<goals>
<goal>run</goal>
</goals>
<configuration>
<tasks>
<echo>pre-clean phase</echo>
</tasks>
</configuration>
</execution>
<execution>
<id>id.clean</id>
<phase>clean</phase>
<goals>
<goal>run</goal>
</goals>
<configuration>
<tasks>
<echo>clean phase</echo>
</tasks>
</configuration>
</execution>
<execution>
<id>id.post-clean</id>
<phase>post-clean</phase>
<goals>
<goal>run</goal>
</goals>
<configuration>
<tasks>
<echo>post-clean phase</echo>
</tasks>
</configuration>
</execution>
</executions>
</plugin>
</plugins>
</build>
</project>Maintenant, ouvrez la console de commande, allez dans le dossier contenant pom.xml et exécutez ce qui suit mvn commander.
C:\MVN\project>mvn post-cleanMaven commencera le traitement et affichera toutes les phases du cycle de vie propre.
[INFO] Scanning for projects...
[INFO] -----------------------------------------------------------------
-
[INFO] Building Unnamed - com.companyname.projectgroup:project:jar:1.0
[INFO] task-segment: [post-clean]
[INFO] ------------------------------------------------------------------
[INFO] [antrun:run {execution: id.pre-clean}]
[INFO] Executing tasks
[echo] pre-clean phase
[INFO] Executed tasks
[INFO] [clean:clean {execution: default-clean}]
[INFO] [antrun:run {execution: id.clean}]
[INFO] Executing tasks
[echo] clean phase
[INFO] Executed tasks
[INFO] [antrun:run {execution: id.post-clean}]
[INFO] Executing tasks
[echo] post-clean phase
[INFO] Executed tasks
[INFO] ------------------------------------------------------------------
[INFO] BUILD SUCCESSFUL
[INFO] ------------------------------------------------------------------
[INFO] Total time: > 1 second
[INFO] Finished at: Sat Jul 07 13:38:59 IST 2012
[INFO] Final Memory: 4M/44M
[INFO] ------------------------------------------------------------------Vous pouvez essayer de régler mvn clean commande, qui affichera pre-cleanet propre. Rien ne sera exécuté pourpost-clean phase.
Cycle de vie par défaut (ou build)
Il s'agit du cycle de vie principal de Maven et est utilisé pour créer l'application. Il comporte les 21 phases suivantes.
| Sr.No. | Phase et description du cycle de vie |
|---|---|
| 1 | validate Valide si le projet est correct et si toutes les informations nécessaires sont disponibles pour terminer le processus de génération. |
| 2 | initialize Initialise l'état de construction, par exemple définir les propriétés. |
| 3 | generate-sources Générez tout code source à inclure dans la phase de compilation. |
| 4 | process-sources Traitez le code source, par exemple, filtrez n'importe quelle valeur. |
| 5 | generate-resources Générez des ressources à inclure dans le package. |
| 6 | process-resources Copiez et traitez les ressources dans le répertoire de destination, prêt pour la phase d'empaquetage. |
| sept | compile Compilez le code source du projet. |
| 8 | process-classes Post-traiter les fichiers générés à partir de la compilation, par exemple pour améliorer / optimiser le bytecode sur les classes Java. |
| 9 | generate-test-sources Générez tout code source de test à inclure dans la phase de compilation. |
| dix | process-test-sources Traitez le code source du test, par exemple, filtrez toutes les valeurs. |
| 11 | test-compile Compilez le code source du test dans le répertoire de destination du test. |
| 12 | process-test-classes Traitez les fichiers générés à partir de la compilation du fichier de code de test. |
| 13 | test Exécutez des tests en utilisant un cadre de test unitaire approprié (Junit en est un). |
| 14 | prepare-package Effectuer toutes les opérations nécessaires pour préparer un colis avant l'emballage proprement dit. |
| 15 | package Prenez le code compilé et conditionnez-le dans son format distribuable, tel qu'un fichier JAR, WAR ou EAR. |
| 16 | pre-integration-test Effectuez les actions requises avant l'exécution des tests d'intégration. Par exemple, configurer l'environnement requis. |
| 17 | integration-test Traitez et déployez le package si nécessaire dans un environnement où des tests d'intégration peuvent être exécutés. |
| 18 | post-integration-test Effectuez les actions requises après l'exécution des tests d'intégration. Par exemple, nettoyer l'environnement. |
| 19 | verify Exécutez tous les contrôles pour vérifier que le colis est valide et répond aux critères de qualité. |
| 20 | install Installez le package dans le référentiel local, qui peut être utilisé comme dépendance dans d'autres projets localement. |
| 21 | deploy Copie le package final dans le référentiel distant pour le partager avec d'autres développeurs et projets. |
Il y a peu de concepts importants liés aux cycles de vie Maven, qui valent la peine d'être mentionnés -
Lorsqu'une phase est appelée via la commande Maven, par exemple mvn compile, seules les phases jusqu'à et y compris cette phase seront exécutées.
Différents objectifs de maven seront liés à différentes phases du cycle de vie de Maven en fonction du type d'emballage (JAR / WAR / EAR).
Dans l'exemple suivant, nous allons attacher maven-antrun-plugin: run goal à quelques-unes des phases du cycle de vie de Build. Cela nous permettra de faire écho aux messages texte affichant les phases du cycle de vie.
Nous avons mis à jour pom.xml dans le dossier C: \ MVN \ project.
<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/xsd/maven-4.0.0.xsd">
<modelVersion>4.0.0</modelVersion>
<groupId>com.companyname.projectgroup</groupId>
<artifactId>project</artifactId>
<version>1.0</version>
<build>
<plugins>
<plugin>
<groupId>org.apache.maven.plugins</groupId>
<artifactId>maven-antrun-plugin</artifactId>
<version>1.1</version>
<executions>
<execution>
<id>id.validate</id>
<phase>validate</phase>
<goals>
<goal>run</goal>
</goals>
<configuration>
<tasks>
<echo>validate phase</echo>
</tasks>
</configuration>
</execution>
<execution>
<id>id.compile</id>
<phase>compile</phase>
<goals>
<goal>run</goal>
</goals>
<configuration>
<tasks>
<echo>compile phase</echo>
</tasks>
</configuration>
</execution>
<execution>
<id>id.test</id>
<phase>test</phase>
<goals>
<goal>run</goal>
</goals>
<configuration>
<tasks>
<echo>test phase</echo>
</tasks>
</configuration>
</execution>
<execution>
<id>id.package</id>
<phase>package</phase>
<goals>
<goal>run</goal>
</goals>
<configuration>
<tasks>
<echo>package phase</echo>
</tasks>
</configuration>
</execution>
<execution>
<id>id.deploy</id>
<phase>deploy</phase>
<goals>
<goal>run</goal>
</goals>
<configuration>
<tasks>
<echo>deploy phase</echo>
</tasks>
</configuration>
</execution>
</executions>
</plugin>
</plugins>
</build>
</project>Maintenant, ouvrez la console de commande, allez dans le dossier contenant pom.xml et exécutez ce qui suit mvn commander.
C:\MVN\project>mvn compileMaven commencera le traitement et affichera les phases du cycle de vie de construction jusqu'à la phase de compilation.
[INFO] Scanning for projects...
[INFO] -----------------------------------------------------------------
-
[INFO] Building Unnamed - com.companyname.projectgroup:project:jar:1.0
[INFO] task-segment: [compile]
[INFO] -----------------------------------------------------------------
-
[INFO] [antrun:run {execution: id.validate}]
[INFO] Executing tasks
[echo] validate phase
[INFO] Executed tasks
[INFO] [resources:resources {execution: default-resources}]
[WARNING] Using platform encoding (Cp1252 actually) to copy filtered
resources,
i.e. build is platform dependent!
[INFO] skip non existing resourceDirectory
C:\MVN\project\src\main\resources
[INFO] [compiler:compile {execution: default-compile}]
[INFO] Nothing to compile - all classes are up to date
[INFO] [antrun:run {execution: id.compile}]
[INFO] Executing tasks
[echo] compile phase
[INFO] Executed tasks
[INFO] -----------------------------------------------------------------
-
[INFO] BUILD SUCCESSFUL
[INFO] -----------------------------------------------------------------
-
[INFO] Total time: 2 seconds
[INFO] Finished at: Sat Jul 07 20:18:25 IST 2012
[INFO] Final Memory: 7M/64M
[INFO] -----------------------------------------------------------------
-Cycle de vie du site
Le plugin Maven Site est généralement utilisé pour créer de la documentation fraîche pour créer des rapports, déployer le site, etc. Il comporte les phases suivantes -
- pre-site
- site
- post-site
- site-deploy
Dans l'exemple suivant, nous attacherons maven-antrun-plugin:runobjectif à toutes les phases du cycle de vie du site. Cela nous permettra de faire écho aux messages texte affichant les phases du cycle de vie.
Nous avons mis à jour pom.xml dans le dossier C: \ MVN \ project.
<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/xsd/maven-4.0.0.xsd">
<modelVersion>4.0.0</modelVersion>
<groupId>com.companyname.projectgroup</groupId>
<artifactId>project</artifactId>
<version>1.0</version>
<build>
<plugins>
<plugin>
<groupId>org.apache.maven.plugins</groupId>
<artifactId>maven-antrun-plugin</artifactId>
<version>1.1</version>
<executions>
<execution>
<id>id.pre-site</id>
<phase>pre-site</phase>
<goals>
<goal>run</goal>
</goals>
<configuration>
<tasks>
<echo>pre-site phase</echo>
</tasks>
</configuration>
</execution>
<execution>
<id>id.site</id>
<phase>site</phase>
<goals>
<goal>run</goal>
</goals>
<configuration>
<tasks>
<echo>site phase</echo>
</tasks>
</configuration>
</execution>
<execution>
<id>id.post-site</id>
<phase>post-site</phase>
<goals>
<goal>run</goal>
</goals>
<configuration>
<tasks>
<echo>post-site phase</echo>
</tasks>
</configuration>
</execution>
<execution>
<id>id.site-deploy</id>
<phase>site-deploy</phase>
<goals>
<goal>run</goal>
</goals>
<configuration>
<tasks>
<echo>site-deploy phase</echo>
</tasks>
</configuration>
</execution>
</executions>
</plugin>
</plugins>
</build>
</project>Ouvrez maintenant la console de commande, accédez au dossier contenant pom.xml et exécutez ce qui suit mvn commander.
C:\MVN\project>mvn siteMaven commencera à traiter et à afficher les phases du cycle de vie du site jusqu'à la phase du site.
[INFO] Scanning for projects...
[INFO] ------------------------------------------------------------------
[INFO] Building Unnamed - com.companyname.projectgroup:project:jar:1.0
[INFO] task-segment: [site]
[INFO] ------------------------------------------------------------------
[INFO] [antrun:run {execution: id.pre-site}]
[INFO] Executing tasks
[echo] pre-site phase
[INFO] Executed tasks
[INFO] [site:site {execution: default-site}]
[INFO] Generating "About" report.
[INFO] Generating "Issue Tracking" report.
[INFO] Generating "Project Team" report.
[INFO] Generating "Dependencies" report.
[INFO] Generating "Project Plugins" report.
[INFO] Generating "Continuous Integration" report.
[INFO] Generating "Source Repository" report.
[INFO] Generating "Project License" report.
[INFO] Generating "Mailing Lists" report.
[INFO] Generating "Plugin Management" report.
[INFO] Generating "Project Summary" report.
[INFO] [antrun:run {execution: id.site}]
[INFO] Executing tasks
[echo] site phase
[INFO] Executed tasks
[INFO] ------------------------------------------------------------------
[INFO] BUILD SUCCESSFUL
[INFO] ------------------------------------------------------------------
[INFO] Total time: 3 seconds
[INFO] Finished at: Sat Jul 07 15:25:10 IST 2012
[INFO] Final Memory: 24M/149M
[INFO] ------------------------------------------------------------------Qu'est-ce que Build Profile?
Un profil de construction est un ensemble de valeurs de configuration, qui peuvent être utilisées pour définir ou remplacer les valeurs par défaut de la construction Maven. À l'aide d'un profil de build, vous pouvez personnaliser la build pour différents environnements tels que les environnements Production v / s Development.
Les profils sont spécifiés dans le fichier pom.xml à l'aide de ses éléments activeProfiles / profiles et sont déclenchés de diverses manières. Les profils modifient le POM au moment de la construction et sont utilisés pour donner des paramètres à différents environnements cibles (par exemple, le chemin du serveur de base de données dans les environnements de développement, de test et de production).
Types de profil de construction
Les profils de construction sont principalement de trois types.
| Type | Où il est défini |
|---|---|
| Par projet | Défini dans le fichier POM du projet, pom.xml |
| Par utilisateur | Défini dans le fichier xml des paramètres Maven (% USER_HOME% /. M2 / settings.xml) |
| Global | Défini dans le fichier xml des paramètres globaux Maven (% M2_HOME% / conf / settings.xml) |
Activation du profil
Un profil de build Maven peut être activé de différentes manières.
- Utilisation explicite de l'entrée de la console de commande.
- Grâce aux paramètres maven.
- Basé sur des variables d'environnement (variables utilisateur / système).
- Paramètres du système d'exploitation (par exemple, famille Windows).
- Fichiers présents / manquants.
Exemples d'activation de profil
Supposons la structure de répertoires suivante de votre projet -
Maintenant, sous src/main/resources, il existe trois fichiers spécifiques à l'environnement -
| Sr.No. | Nom et description du fichier |
|---|---|
| 1 | env.properties configuration par défaut utilisée si aucun profil n'est mentionné. |
| 2 | env.test.properties configuration de test lorsque le profil de test est utilisé. |
| 3 | env.prod.properties configuration de production lorsque le profil de production est utilisé. |
Activation de profil explicite
Dans l'exemple suivant, nous allons attacher maven-antrun-plugin: run goal pour tester la phase. Cela nous permettra de faire écho aux messages texte pour différents profils. Nous utiliserons pom.xml pour définir différents profils et activerons le profil sur la console de commande à l'aide de la commande maven.
Supposons que nous ayons créé le pom.xml suivant dans le dossier C: \ MVN \ project.
<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/xsd/maven-4.0.0.xsd">
<modelVersion>4.0.0</modelVersion>
<groupId>com.companyname.projectgroup</groupId>
<artifactId>project</artifactId>
<version>1.0</version>
<profiles>
<profile>
<id>test</id>
<build>
<plugins>
<plugin>
<groupId>org.apache.maven.plugins</groupId>
<artifactId>maven-antrun-plugin</artifactId>
<version>1.1</version>
<executions>
<execution>
<phase>test</phase>
<goals>
<goal>run</goal>
</goals>
<configuration>
<tasks>
<echo>Using env.test.properties</echo>
<copy file="src/main/resources/env.test.properties"
tofile="${project.build.outputDirectory}
/env.properties"/>
</tasks>
</configuration>
</execution>
</executions>
</plugin>
</plugins>
</build>
</profile>
</profiles>
</project>Ouvrez maintenant la console de commande, accédez au dossier contenant pom.xml et exécutez ce qui suit mvncommander. Passez le nom du profil comme argument à l'aide de l'option -P.
C:\MVN\project>mvn test -PtestMaven commencera le traitement et affichera le résultat du profil de build de test.
[INFO] Scanning for projects...
[INFO] ------------------------------------------------------------------
[INFO] Building Unnamed - com.companyname.projectgroup:project:jar:1.0
[INFO] task-segment: [test]
[INFO] ------------------------------------------------------------------
[INFO] [resources:resources {execution: default-resources}]
[WARNING] Using platform encoding (Cp1252 actually) to copy filtered resources,
i.e. build is platform dependent!
[INFO] Copying 3 resources
[INFO] [compiler:compile {execution: default-compile}]
[INFO] Nothing to compile - all classes are up to date
[INFO] [resources:testResources {execution: default-testResources}]
[WARNING] Using platform encoding (Cp1252 actually) to copy filtered resources,
i.e. build is platform dependent!
[INFO] skip non existing resourceDirectory C:\MVN\project\src\test\resources
[INFO] [compiler:testCompile {execution: default-testCompile}]
[INFO] Nothing to compile - all classes are up to date
[INFO] [surefire:test {execution: default-test}]
[INFO] Surefire report directory: C:\MVN\project\target\surefire-reports
-------------------------------------------------------
T E S T S
-------------------------------------------------------
There are no tests to run.
Results :
Tests run: 0, Failures: 0, Errors: 0, Skipped: 0
[INFO] [antrun:run {execution: default}]
[INFO] Executing tasks
[echo] Using env.test.properties
[INFO] Executed tasks
[INFO] ------------------------------------------------------------------
[INFO] BUILD SUCCESSFUL
[INFO] ------------------------------------------------------------------
[INFO] Total time: 1 second
[INFO] Finished at: Sun Jul 08 14:55:41 IST 2012
[INFO] Final Memory: 8M/64M
[INFO] ------------------------------------------------------------------Maintenant, à titre d'exercice, vous pouvez effectuer les étapes suivantes -
Ajoutez un autre élément de profil à l'élément de profil de pom.xml (copiez l'élément de profil existant et collez-le là où les éléments de profil se terminent).
Mettez à jour l'ID de cet élément de profil de test à normal.
Mettez à jour la section des tâches pour faire écho à env.properties et copiez env.properties dans le répertoire cible.
Répétez à nouveau les trois étapes ci-dessus, mettez à jour l'id vers la section prod et la tâche pour env.prod.properties.
C'est tout. Vous avez maintenant trois profils de construction prêts (normal / test / prod).
Ouvrez maintenant la console de commande, accédez au dossier contenant pom.xml et exécutez ce qui suit mvncommandes. Passez les noms de profil en argument à l'aide de l'option -P.
C:\MVN\project>mvn test -Pnormal
C:\MVN\project>mvn test -PprodVérifiez la sortie de la construction pour voir la différence.
Activation du profil via les paramètres Maven
Ouvrez Maven settings.xml fichier disponible dans le répertoire% USER_HOME% /. m2 où %USER_HOME%représente le répertoire de base de l'utilisateur. Si le fichier settings.xml n'est pas là, créez-en un nouveau.
Ajoutez un profil de test en tant que profil actif à l'aide du nœud Profils actif, comme illustré ci-dessous dans l'exemple.
<settings 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/xsd/settings-1.0.0.xsd">
<mirrors>
<mirror>
<id>maven.dev.snaponglobal.com</id>
<name>Internal Artifactory Maven repository</name>
<url>http://repo1.maven.org/maven2/</url>
<mirrorOf>*</mirrorOf>
</mirror>
</mirrors>
<activeProfiles>
<activeProfile>test</activeProfile>
</activeProfiles>
</settings>Maintenant, ouvrez la console de commande, allez dans le dossier contenant pom.xml et exécutez ce qui suit mvncommander. Ne transmettez pas le nom du profil à l'aide de l'option -P. Maven affichera le résultat du profil de test étant un profil actif.
C:\MVN\project>mvn testActivation de profil via des variables d'environnement
Supprimez maintenant le profil actif de maven settings.xml et mettez à jour le profil de test mentionné dans pom.xml. Ajoutez un élément d'activation à l'élément de profil comme indiqué ci-dessous.
Le profil de test se déclenchera lorsque la propriété système "env" est spécifiée avec la valeur "test". Créez une variable d'environnement "env" et définissez sa valeur sur "test".
<profile>
<id>test</id>
<activation>
<property>
<name>env</name>
<value>test</value>
</property>
</activation>
</profile>Ouvrons la console de commande, allons dans le dossier contenant pom.xml et exécutons ce qui suit mvn commander.
C:\MVN\project>mvn testActivation du profil via le système d'exploitation
Élément d'activation pour inclure les détails du système d'exploitation comme indiqué ci-dessous. Ce profil de test se déclenchera lorsque le système est Windows XP.
<profile>
<id>test</id>
<activation>
<os>
<name>Windows XP</name>
<family>Windows</family>
<arch>x86</arch>
<version>5.1.2600</version>
</os>
</activation>
</profile>Maintenant, ouvrez la console de commande, allez dans le dossier contenant pom.xml et exécutez ce qui suit mvncommandes. Ne transmettez pas le nom du profil à l'aide de l'option -P. Maven affichera le résultat du profil de test étant un profil actif.
C:\MVN\project>mvn testActivation du profil via un fichier présent / manquant
Maintenant, élément d'activation pour inclure les détails du système d'exploitation comme indiqué ci-dessous. Le profil de test se déclenchera lorsquetarget/generated-sources/axistools/wsdl2java/com/companyname/group est manquant.
<profile>
<id>test</id>
<activation>
<file>
<missing>target/generated-sources/axistools/wsdl2java/
com/companyname/group</missing>
</file>
</activation>
</profile>Ouvrez maintenant la console de commande, accédez au dossier contenant pom.xml et exécutez ce qui suit mvncommandes. Ne transmettez pas le nom du profil à l'aide de l'option -P. Maven affichera le résultat du profil de test étant un profil actif.
C:\MVN\project>mvn testQu'est-ce qu'un référentiel Maven?
Dans la terminologie Maven, un référentiel est un répertoire dans lequel tous les fichiers jar du projet, jar de bibliothèque, plugins ou tout autre artefact spécifique au projet sont stockés et peuvent être utilisés facilement par Maven.
Les référentiels Maven sont de trois types. L'illustration suivante vous donnera une idée de ces trois types.
- local
- central
- remote
Dépôt local
Le référentiel local Maven est un emplacement de dossier sur votre machine. Il est créé lorsque vous exécutez une commande maven pour la première fois.
Le référentiel local Maven conserve toutes les dépendances de votre projet (jars de bibliothèque, jars de plugin, etc.). Lorsque vous exécutez une compilation Maven, Maven télécharge automatiquement tous les fichiers JAR de dépendances dans le référentiel local. Cela permet d'éviter les références aux dépendances stockées sur une machine distante à chaque fois qu'un projet est généré.
Le référentiel local Maven est créé par défaut par Maven dans le répertoire% USER_HOME%. Pour remplacer l'emplacement par défaut, mentionnez un autre chemin dans le fichier Maven settings.xml disponible dans le répertoire% M2_HOME% \ conf.
<settings xmlns = "http://maven.apache.org/SETTINGS/1.0.0"
xmlns:xsi = "http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation = "http://maven.apache.org/SETTINGS/1.0.0
http://maven.apache.org/xsd/settings-1.0.0.xsd">
<localRepository>C:/MyLocalRepository</localRepository>
</settings>Lorsque vous exécutez la commande Maven, Maven téléchargera les dépendances sur votre chemin personnalisé.
Dépôt central
Le référentiel central Maven est un référentiel fourni par la communauté Maven. Il contient un grand nombre de bibliothèques couramment utilisées.
Lorsque Maven ne trouve aucune dépendance dans le référentiel local, il commence la recherche dans le référentiel central en utilisant l'URL suivante - https://repo1.maven.org/maven2/
Les concepts clés du référentiel central sont les suivants:
- Ce référentiel est géré par la communauté Maven.
- Il n'est pas nécessaire de le configurer.
- Il nécessite un accès Internet pour être recherché.
Pour parcourir le contenu du référentiel maven central, la communauté maven a fourni une URL - https://search.maven.org/#browse. En utilisant cette bibliothèque, un développeur peut rechercher toutes les bibliothèques disponibles dans le référentiel central.
Référentiel distant
Parfois, Maven ne trouve pas non plus une dépendance mentionnée dans le référentiel central. Il arrête ensuite le processus de construction et envoie un message d'erreur à la console. Pour éviter une telle situation, Maven propose le concept deRemote Repository, qui est le propre référentiel personnalisé du développeur contenant les bibliothèques requises ou d'autres fichiers JAR de projet.
Par exemple, en utilisant le POM.xml mentionné ci-dessous, Maven téléchargera la dépendance (non disponible dans le référentiel central) à partir des référentiels distants mentionnés dans le même pom.xml.
<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/xsd/maven-4.0.0.xsd">
<modelVersion>4.0.0</modelVersion>
<groupId>com.companyname.projectgroup</groupId>
<artifactId>project</artifactId>
<version>1.0</version>
<dependencies>
<dependency>
<groupId>com.companyname.common-lib</groupId>
<artifactId>common-lib</artifactId>
<version>1.0.0</version>
</dependency>
<dependencies>
<repositories>
<repository>
<id>companyname.lib1</id>
<url>http://download.companyname.org/maven2/lib1</url>
</repository>
<repository>
<id>companyname.lib2</id>
<url>http://download.companyname.org/maven2/lib2</url>
</repository>
</repositories>
</project>Séquence de recherche de dépendances Maven
Lorsque nous exécutons les commandes de construction Maven, Maven commence à rechercher des bibliothèques de dépendances dans la séquence suivante -
Step 1 - Rechercher une dépendance dans le référentiel local, si elle n'est pas trouvée, passez à l'étape 2 sinon effectuez le traitement ultérieur.
Step 2 - Rechercher la dépendance dans le référentiel central, si non trouvé et le référentiel / référentiel distant est / sont mentionnés, passez à l'étape 4. Sinon, il est téléchargé dans le référentiel local pour référence future.
Step 3 - Si un référentiel distant n'a pas été mentionné, Maven arrête simplement le traitement et renvoie une erreur (Impossible de trouver la dépendance).
Step 4- Rechercher la dépendance dans le référentiel ou les référentiels distants, si elle est trouvée, elle est téléchargée dans le référentiel local pour référence future. Sinon, Maven arrête le traitement et renvoie une erreur (impossible de trouver la dépendance).
Que sont les plugins Maven?
Maven est en fait un framework d'exécution de plugins où chaque tâche est en fait effectuée par des plugins. Les plugins Maven sont généralement utilisés pour -
- créer un fichier jar
- créer un fichier de guerre
- compiler des fichiers de code
- test unitaire de code
- créer la documentation du projet
- créer des rapports de projet
Un plugin fournit généralement un ensemble d'objectifs, qui peuvent être exécutés en utilisant la syntaxe suivante -
mvn [plugin-name]:[goal-name]Par exemple, un projet Java peut être compilé avec l'objectif de compilation de maven-compiler-plugin en exécutant la commande suivante.
mvn compiler:compileTypes de plugins
Maven a fourni les deux types de plugins suivants -
| Sr.No. | Type et description |
|---|---|
| 1 | Build plugins Ils s'exécutent pendant le processus de construction et doivent être configurés dans l'élément <build /> de pom.xml. |
| 2 | Reporting plugins Ils s'exécutent pendant le processus de génération du site et doivent être configurés dans l'élément <reporting /> du pom.xml. |
Voici la liste de quelques plugins courants -
| Sr.No. | Plugin et description |
|---|---|
| 1 | clean Nettoie la cible après la construction. Supprime le répertoire cible. |
| 2 | compiler Compile les fichiers source Java. |
| 3 | surefire Exécute les tests unitaires JUnit. Crée des rapports de test. |
| 4 | jar Construit un fichier JAR à partir du projet actuel. |
| 5 | war Construit un fichier WAR à partir du projet actuel. |
| 6 | javadoc Génère Javadoc pour le projet. |
| sept | antrun Exécute un ensemble de tâches ant à partir de n'importe quelle phase mentionnée de la construction. |
Example
Nous avons utilisé maven-antrun-pluginlargement dans nos exemples pour imprimer des données sur la console. Reportez-vous au chapitre Build Profiles. Comprenons-le mieux et créons un pom.xml dans le dossier C: \ MVN \ project.
<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/xsd/maven-4.0.0.xsd">
<modelVersion>4.0.0</modelVersion>
<groupId>com.companyname.projectgroup</groupId>
<artifactId>project</artifactId>
<version>1.0</version>
<build>
<plugins>
<plugin>
<groupId>org.apache.maven.plugins</groupId>
<artifactId>maven-antrun-plugin</artifactId>
<version>1.1</version>
<executions>
<execution>
<id>id.clean</id>
<phase>clean</phase>
<goals>
<goal>run</goal>
</goals>
<configuration>
<tasks>
<echo>clean phase</echo>
</tasks>
</configuration>
</execution>
</executions>
</plugin>
</plugins>
</build>
</project>Ensuite, ouvrez la console de commande et accédez au dossier contenant pom.xml et exécutez ce qui suit mvn commander.
C:\MVN\project>mvn cleanMaven commencera le traitement et affichera la phase de nettoyage du cycle de vie propre.
[INFO] Scanning for projects...
[INFO] ------------------------------------------------------------------
[INFO] Building Unnamed - com.companyname.projectgroup:project:jar:1.0
[INFO] task-segment: [post-clean]
[INFO] ------------------------------------------------------------------
[INFO] [clean:clean {execution: default-clean}]
[INFO] [antrun:run {execution: id.clean}]
[INFO] Executing tasks
[echo] clean phase
[INFO] Executed tasks
[INFO] ------------------------------------------------------------------
[INFO] BUILD SUCCESSFUL
[INFO] ------------------------------------------------------------------
[INFO] Total time: < 1 second
[INFO] Finished at: Sat Jul 07 13:38:59 IST 2012
[INFO] Final Memory: 4M/44M
[INFO] ------------------------------------------------------------------L'exemple ci-dessus illustre les concepts clés suivants -
Les plugins sont spécifiés dans pom.xml à l'aide de l'élément plugins.
Chaque plugin peut avoir plusieurs objectifs.
Vous pouvez définir la phase à partir de laquelle le plugin doit commencer son traitement en utilisant son élément phase. Nous avons utiliséclean phase.
Vous pouvez configurer les tâches à exécuter en les liant aux objectifs du plugin. Nous avons liéecho tâche avec runobjectif de maven-antrun-plugin .
Maven téléchargera alors le plugin s'il n'est pas disponible dans le référentiel local et démarrera son traitement.
Maven utilise archetypeplugins pour créer des projets. Pour créer une application Java simple, nous utiliserons le plugin maven-archetype-quickstart. Dans l'exemple ci-dessous, nous allons créer un projet d'application Java basé sur maven dans le dossier C: \ MVN.
Ouvrons la console de commande, allons dans le répertoire C: \ MVN et exécutons ce qui suit mvn commander.
C:\MVN>mvn archetype:generate
-DgroupId = com.companyname.bank
-DartifactId = consumerBanking
-DarchetypeArtifactId = maven-archetype-quickstart
-DinteractiveMode = falseMaven commencera le traitement et créera la structure complète du projet d'application Java.
[INFO] Scanning for projects...
[INFO] Searching repository for plugin with prefix: 'archetype'.
[INFO] -------------------------------------------------------------------
[INFO] Building Maven Default Project
[INFO] task-segment: [archetype:generate] (aggregator-style)
[INFO] -------------------------------------------------------------------
[INFO] Preparing archetype:generate
[INFO] No goals needed for project - skipping
[INFO] [archetype:generate {execution: default-cli}]
[INFO] Generating project in Batch mode
[INFO] -------------------------------------------------------------------
[INFO] Using following parameters for creating project
from Old (1.x) Archetype: maven-archetype-quickstart:1.0
[INFO] -------------------------------------------------------------------
[INFO] Parameter: groupId, Value: com.companyname.bank
[INFO] Parameter: packageName, Value: com.companyname.bank
[INFO] Parameter: package, Value: com.companyname.bank
[INFO] Parameter: artifactId, Value: consumerBanking
[INFO] Parameter: basedir, Value: C:\MVN
[INFO] Parameter: version, Value: 1.0-SNAPSHOT
[INFO] project created from Old (1.x) Archetype in dir: C:\MVN\consumerBanking
[INFO] ------------------------------------------------------------------
[INFO] BUILD SUCCESSFUL
[INFO] ------------------------------------------------------------------
[INFO] Total time: 14 seconds
[INFO] Finished at: Tue Jul 10 15:38:58 IST 2012
[INFO] Final Memory: 21M/124M
[INFO] ------------------------------------------------------------------Accédez maintenant au répertoire C: / MVN. Vous verrez un projet d'application Java créé, nommé Consumer Banking (comme spécifié dans artifactId). Maven utilise une disposition de répertoire standard comme indiqué ci-dessous -
En utilisant l'exemple ci-dessus, nous pouvons comprendre les concepts clés suivants -
| Sr.No. | Structure et description des dossiers |
|---|---|
| 1 | consumerBanking contient le dossier src et pom.xml |
| 2 | src/main/java contient des fichiers de code java sous la structure du package (com / companyName / bank). |
| 3 | src/main/test contient des fichiers de code java de test sous la structure du package (com / companyName / bank). |
| 4 | src/main/resources il contient des fichiers images / propriétés (dans l'exemple ci-dessus, nous devons créer cette structure manuellement). |
Si vous observez, vous constaterez que Maven a également créé un exemple de fichier source Java et de fichier de test Java. Ouvrez le dossier C: \ MVN \ consumerBanking \ src \ main \ java \ com \ companyname \ bank, vous verrez App.java.
package com.companyname.bank;
/**
* Hello world!
*
*/
public class App {
public static void main( String[] args ){
System.out.println( "Hello World!" );
}
}Ouvrez le dossier C: \ MVN \ consumerBanking \ src \ test \ java \ com \ companyname \ bank pour voir AppTest.java.
package com.companyname.bank;
import junit.framework.Test;
import junit.framework.TestCase;
import junit.framework.TestSuite;
/**
* Unit test for simple App.
*/
public class AppTest extends TestCase {
/**
* Create the test case
*
* @param testName name of the test case
*/
public AppTest( String testName ) {
super( testName );
}
/**
* @return the suite of tests being tested
*/
public static Test suite() {
return new TestSuite( AppTest.class );
}
/**
* Rigourous Test :-)
*/
public void testApp() {
assertTrue( true );
}
}Les développeurs doivent placer leurs fichiers comme indiqué dans le tableau ci-dessus et Maven gère toutes les complexités liées à la construction.
Dans le chapitre suivant, nous verrons comment créer et tester le projet à l'aide de maven Build and Test Project.
Ce que nous avons appris dans le chapitre Création de projet est de savoir comment créer une application Java à l'aide de Maven. Nous allons maintenant voir comment créer et tester l'application.
Accédez au répertoire C: / MVN dans lequel vous avez créé votre application java. OuvertconsumerBankingdossier. Vous verrez lePOM.xml fichier avec le contenu suivant.
<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/xsd/maven-4.0.0.xsd">
<modelVersion>4.0.0</modelVersion>
<groupId>com.companyname.projectgroup</groupId>
<artifactId>project</artifactId>
<version>1.0</version>
<dependencies>
<dependency>
<groupId>junit</groupId>
<artifactId>junit</artifactId>
<version>3.8.1</version>
</dependency>
</dependencies>
</project>Ici vous pouvez voir, Maven a déjà ajouté Junit comme cadre de test. Par défaut, Maven ajoute un fichier sourceApp.java et un fichier de test AppTest.java dans sa structure de répertoire par défaut, comme expliqué dans le chapitre précédent.
Ouvrons la console de commande, allons dans le répertoire C: \ MVN \ consumerBanking et exécutons ce qui suit mvn commander.
C:\MVN\consumerBanking>mvn clean packageMaven commencera à construire le projet.
[INFO] Scanning for projects...
[INFO] -------------------------------------------------------------------
[INFO] Building consumerBanking
[INFO] task-segment: [clean, package]
[INFO] -------------------------------------------------------------------
[INFO] [clean:clean {execution: default-clean}]
[INFO] Deleting directory C:\MVN\consumerBanking\target
[INFO] [resources:resources {execution: default-resources}]
[WARNING] Using platform encoding (Cp1252 actually) to copy filtered resources,
i.e. build is platform dependent!
[INFO] skip non existing resourceDirectory C:\MVN\consumerBanking\src\main\resources
[INFO] [compiler:compile {execution: default-compile}]
[INFO] Compiling 1 source file to C:\MVN\consumerBanking\target\classes
[INFO] [resources:testResources {execution: default-testResources}]
[WARNING] Using platform encoding (Cp1252 actually) to copy filtered resources,
i.e. build is platform dependent!
[INFO] skip non existing resourceDirectory C:\MVN\consumerBanking\src\test\resources
[INFO] [compiler:testCompile {execution: default-testCompile}]
[INFO] Compiling 1 source file to C:\MVN\consumerBanking\target\test-classes
[INFO] [surefire:test {execution: default-test}]
[INFO] Surefire report directory: C:\MVN\consumerBanking\target\surefire-reports
-----------------------------------------------------
T E S T S
-----------------------------------------------------
Running com.companyname.bank.AppTest
Tests run: 1, Failures: 0, Errors: 0, Skipped: 0, Time elapsed: 0.027 sec
Results :
Tests run: 1, Failures: 0, Errors: 0, Skipped: 0
[INFO] [jar:jar {execution: default-jar}]
[INFO] Building jar: C:\MVN\consumerBanking\target\
consumerBanking-1.0-SNAPSHOT.jar
[INFO]-----------------------------------------------
[INFO] BUILD SUCCESSFUL
[INFO]-----------------------------------------------
[INFO] Total time: 2 seconds
[INFO] Finished at: Tue Jul 10 16:52:18 IST 2012
[INFO] Final Memory: 16M/89M
[INFO]-----------------------------------------------Vous avez construit votre projet et créé le fichier jar final, voici les principaux concepts d'apprentissage -
Nous donnons à maven deux objectifs, d'abord nettoyer le répertoire cible (nettoyer), puis empaqueter le résultat de la construction du projet en jar (package).
Le pot emballé est disponible dans le dossier consumerBanking \ target en tant que consumerBanking-1.0-SNAPSHOT.jar.
Les rapports de test sont disponibles dans le dossier consumerBanking \ target \ surefire-reports.
Maven compile le (s) fichier (s) de code source, puis teste le ou les fichiers de code source.
Ensuite, Maven exécute les cas de test.
Enfin, Maven crée le package.
Ouvrez maintenant la console de commande, accédez au répertoire C: \ MVN \ consumerBanking \ target \ classes et exécutez la commande java suivante.
>java com.companyname.bank.AppVous verrez le résultat comme suit -
Hello World!Ajout de fichiers source Java
Voyons comment nous pouvons ajouter des fichiers Java supplémentaires dans notre projet. Ouvrez le dossier C: \ MVN \ consumerBanking \ src \ main \ java \ com \ companyname \ bank, créez-y la classe Util en tant que Util.java.
package com.companyname.bank;
public class Util {
public static void printMessage(String message){
System.out.println(message);
}
}Mettez à jour la classe App pour utiliser la classe Util.
package com.companyname.bank;
/**
* Hello world!
*
*/
public class App {
public static void main( String[] args ){
Util.printMessage("Hello World!");
}
}Maintenant, ouvrez la console de commande, allez C:\MVN\consumerBanking répertoire et exécutez ce qui suit mvn commander.
>mvn clean compileUne fois la construction de Maven réussie, accédez au répertoire C: \ MVN \ consumerBanking \ target \ classes et exécutez la commande java suivante.
>java -cp com.companyname.bank.AppVous verrez le résultat comme suit -
Hello World!Comme vous le savez, Maven fait la gestion des dépendances en utilisant le concept de référentiels. Mais que se passe-t-il si la dépendance n'est disponible dans aucun des référentiels distants et du référentiel central? Maven fournit une réponse pour un tel scénario en utilisant le concept deExternal Dependency.
Par exemple, apportons les modifications suivantes au projet créé dans le chapitre «Création d'un projet Java».
Ajouter lib dossier dans le dossier src.
Copiez n'importe quel fichier jar dans le dossier lib. Nous avons utiliséldapjdk.jar, qui est une bibliothèque d'aide pour les opérations LDAP.
Maintenant, notre structure de projet devrait ressembler à ce qui suit -
Ici, vous avez votre propre bibliothèque, spécifique au projet, ce qui est un cas habituel et elle contient des fichiers JAR, qui peuvent ne pas être disponibles dans aucun référentiel pour que maven puisse être téléchargé. Si votre code utilise cette bibliothèque avec Maven, la compilation de Maven échouera car elle ne peut pas télécharger ou faire référence à cette bibliothèque pendant la phase de compilation.
Pour gérer la situation, ajoutons cette dépendance externe à maven pom.xml en utilisant la manière suivante.
<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.companyname.bank</groupId>
<artifactId>consumerBanking</artifactId>
<packaging>jar</packaging>
<version>1.0-SNAPSHOT</version>
<name>consumerBanking</name>
<url>http://maven.apache.org</url>
<dependencies>
<dependency>
<groupId>junit</groupId>
<artifactId>junit</artifactId>
<version>3.8.1</version>
<scope>test</scope>
</dependency>
<dependency>
<groupId>ldapjdk</groupId>
<artifactId>ldapjdk</artifactId>
<scope>system</scope>
<version>1.0</version>
<systemPath>${basedir}\src\lib\ldapjdk.jar</systemPath>
</dependency>
</dependencies>
</project>Regardez le deuxième élément de dépendance sous les dépendances dans l'exemple ci-dessus, qui efface les concepts clés suivants sur External Dependency.
Les dépendances externes (emplacement du fichier jar de la bibliothèque) peuvent être configurées dans pom.xml de la même manière que les autres dépendances.
Spécifiez groupId identique au nom de la bibliothèque.
Spécifiez artifactId comme le nom de la bibliothèque.
Spécifiez la portée comme système.
Spécifiez le chemin du système par rapport à l'emplacement du projet.
J'espère que vous êtes maintenant clair sur les dépendances externes et que vous pourrez spécifier des dépendances externes dans votre projet Maven.
Ce tutoriel vous apprendra comment créer la documentation de l'application en une seule fois. Alors commençons, allez dans le répertoire C: / MVN où vous aviez créé votre javaconsumerBankingapplication en utilisant les exemples donnés dans les chapitres précédents. OuvertconsumerBanking dossier et exécutez ce qui suit mvn commander.
C:\MVN>mvn siteMaven commencera à construire le projet.
[INFO] Scanning for projects...
[INFO]-----------------------------------------------
[INFO] Building consumerBanking
[INFO] task-segment: [site]
[INFO]-----------------------------------------------
[INFO] [site:site {execution: default-site}]
[INFO] artifact org.apache.maven.skins:maven-default-skin:
checking for updates from central
[INFO] Generating "About" report.
[INFO] Generating "Issue Tracking" report.
[INFO] Generating "Project Team" report.
[INFO] Generating "Dependencies" report.
[INFO] Generating "Continuous Integration" report.
[INFO] Generating "Source Repository" report.
[INFO] Generating "Project License" report.
[INFO] Generating "Mailing Lists" report.
[INFO] Generating "Plugin Management" report.
[INFO] Generating "Project Summary" report.
[INFO]-----------------------------------------------
[INFO] BUILD SUCCESSFUL
[INFO]-----------------------------------------------
[INFO] Total time: 16 seconds
[INFO] Finished at: Wed Jul 11 18:11:18 IST 2012
[INFO] Final Memory: 23M/148M
[INFO]-----------------------------------------------La documentation de votre projet est maintenant prête. Maven a créé un site dans le répertoire cible.
Ouvrez le dossier C: \ MVN \ consumerBanking \ target \ site. Cliquez sur index.html pour voir la documentation.
Maven crée la documentation à l'aide d'un moteur de traitement de la documentation appelé Doxia qui lit plusieurs formats source dans un modèle de document commun. Pour rédiger la documentation de votre projet, vous pouvez rédiger votre contenu dans les quelques formats couramment utilisés qui sont analysés par Doxia.
| Nom du format | La description | Référence |
|---|---|---|
| XDoc | Un format de documentation Maven 1.x | https://jakarta.apache.org/site |
| FML | Utilisé pour les documents FAQ | https://maven.apache.org |
Maven fournit aux utilisateurs une très grande liste de différents types de modèles de projet (614 en nombre) utilisant le concept de Archetype. Maven aide les utilisateurs à démarrer rapidement un nouveau projet java à l'aide de la commande suivante.
mvn archetype:generateQu'est-ce que l'archétype?
Archetype est un plugin Maven dont la tâche est de créer une structure de projet selon son modèle. Nous allons utiliser le plugin d'archétype de démarrage rapide pour créer une application Java simple ici.
Utilisation du modèle de projet
Ouvrons la console de commande, allons à la C:\ > MVN répertoire et exécutez ce qui suit mvn commander.
C:\MVN>mvn archetype:generateMaven commencera le traitement et demandera de choisir l'archétype requis.
[INFO] Scanning for projects...
[INFO] Searching repository for plugin with prefix: 'archetype'.
[INFO] -------------------------------------------------------------------
[INFO] Building Maven Default Project
[INFO] task-segment: [archetype:generate] (aggregator-style)
[INFO] -------------------------------------------------------------------
[INFO] Preparing archetype:generate
...
600: remote −> org.trailsframework:trails-archetype (-)
601: remote −> org.trailsframework:trails-secure-archetype (-)
602: remote −> org.tynamo:tynamo-archetype (-)
603: remote −> org.wicketstuff.scala:wicket-scala-archetype (-)
604: remote −> org.wicketstuff.scala:wicketstuff-scala-archetype
Basic setup for a project that combines Scala and Wicket,
depending on the Wicket-Scala project.
Includes an example Specs test.)
605: remote −> org.wikbook:wikbook.archetype (-)
606: remote −> org.xaloon.archetype:xaloon-archetype-wicket-jpa-glassfish (-)
607: remote −> org.xaloon.archetype:xaloon-archetype-wicket-jpa-spring (-)
608: remote −> org.xwiki.commons:xwiki-commons-component-archetype
(Make it easy to create a maven project for creating XWiki Components.)
609: remote −> org.xwiki.rendering:xwiki-rendering-archetype-macro
(Make it easy to create a maven project for creating XWiki Rendering Macros.)
610: remote −> org.zkoss:zk-archetype-component (The ZK Component archetype)
611: remote −> org.zkoss:zk-archetype-webapp (The ZK wepapp archetype)
612: remote −> ru.circumflex:circumflex-archetype (-)
613: remote −> se.vgregion.javg.maven.archetypes:javg-minimal-archetype (-)
614: remote −> sk.seges.sesam:sesam-annotation-archetype (-)
Choose a number or apply filter
(format: [groupId:]artifactId, case sensitive contains): 203:Appuyez sur Entrée pour choisir l'option par défaut (203: maven-archetype-quickstart)
Maven demandera une version particulière de l'archétype.
Choose org.apache.maven.archetypes:maven-archetype-quickstart version:
1: 1.0-alpha-1
2: 1.0-alpha-2
3: 1.0-alpha-3
4: 1.0-alpha-4
5: 1.0
6: 1.1
Choose a number: 6:Appuyez sur Entrée pour choisir l'option par défaut (6: maven-archetype-quickstart: 1.1)
Maven demandera les détails du projet. Entrez les détails du projet comme demandé. Appuyez sur Entrée si la valeur par défaut est fournie. Vous pouvez les remplacer en entrant votre propre valeur.
Define value for property 'groupId': : com.companyname.insurance
Define value for property 'artifactId': : health
Define value for property 'version': 1.0-SNAPSHOT:
Define value for property 'package': com.companyname.insurance:Maven demandera la confirmation des détails du projet. Appuyez sur entrée ou appuyez sur Y.
Confirm properties configuration:
groupId: com.companyname.insurance
artifactId: health
version: 1.0-SNAPSHOT
package: com.companyname.insurance
Y:Maintenant, Maven commencera à créer la structure du projet et affichera ce qui suit -
[INFO]-----------------------------------------------
[INFO] Using following parameters for creating project
from Old (1.x) Archetype: maven-archetype-quickstart:1.1
[INFO]-----------------------------------------------
[INFO] Parameter: groupId, Value: com.companyname.insurance
[INFO] Parameter: packageName, Value: com.companyname.insurance
[INFO] Parameter: package, Value: com.companyname.insurance
[INFO] Parameter: artifactId, Value: health
[INFO] Parameter: basedir, Value: C:\MVN
[INFO] Parameter: version, Value: 1.0-SNAPSHOT
[INFO] project created from Old (1.x) Archetype in dir: C:\MVN\health
[INFO]-----------------------------------------------
[INFO] BUILD SUCCESSFUL
[INFO]-----------------------------------------------
[INFO] Total time: 4 minutes 12 seconds
[INFO] Finished at: Fri Jul 13 11:10:12 IST 2012
[INFO] Final Memory: 20M/90M
[INFO]-----------------------------------------------Projet créé
Allez maintenant à C:\ > MVNannuaire. Vous verrez un projet d'application Java créé, nomméhealth, qui a été donné comme artifactIdau moment de la création du projet. Maven créera une disposition de répertoire standard pour le projet comme indiqué ci-dessous -
Créé POM.xml
Maven génère un fichier POM.xml pour le projet comme indiqué ci-dessous -
<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/xsd/maven-4.0.0.xsd">
<modelVersion>4.0.0</modelVersion>
<groupId>com.companyname.insurance</groupId>
<artifactId>health</artifactId>
<version>1.0-SNAPSHOT</version>
<packaging>jar</packaging>
<name>health</name>
<url>http://maven.apache.org</url>
<properties>
<project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
</properties>
<dependencies>
<dependency>
<groupId>junit</groupId>
<artifactId>junit</artifactId>
<version>3.8.1</version>
<scope>test</scope>
</dependency>
</dependencies>
</project>Créé App.java
Maven génère un exemple de fichier source java, App.java pour le projet comme indiqué ci-dessous -
Emplacement: C:\ > MVN > health > src > main > java > com > companyname > insurance > App.java.
package com.companyname.insurance;
/**
* Hello world!
*
*/
public class App {
public static void main( String[] args ) {
System.out.println( "Hello World!" );
}
}Créé AppTest.java
Maven génère un exemple de fichier de test source java, AppTest.java pour le projet comme indiqué ci-dessous -
Emplacement: C:\ > MVN > health > src > test > java > com > companyname > insurance > AppTest.java.
package com.companyname.insurance;
import junit.framework.Test;
import junit.framework.TestCase;
import junit.framework.TestSuite;
/**
* Unit test for simple App.
*/
public class AppTest extends TestCase {
/**
* Create the test case
*
* @param testName name of the test case
*/
public AppTest( String testName ) {
super( testName );
}
/**
* @return the suite of tests being tested
*/
public static Test suite() {
return new TestSuite( AppTest.class );
}
/**
* Rigourous Test :-)
*/
public void testApp() {
assertTrue( true );
}
}Vous pouvez maintenant voir la puissance de Maven. Vous pouvez créer n'importe quel type de projet à l'aide d'une seule commande dans maven et démarrer votre développement.
Différents archétypes
| Sr.No. | Archétype ArtefactIds & Description |
|---|---|
| 1 | maven-archetype-archetype Un archétype, qui contient un exemple d'archétype. |
| 2 | maven-archetype-j2ee-simple Un archétype, qui contient un exemple d'application J2EE simplifié. |
| 3 | maven-archetype-mojo Un archétype, qui contient un exemple d'un exemple de plugin Maven. |
| 4 | maven-archetype-plugin Un archétype, qui contient un exemple de plugin Maven. |
| 5 | maven-archetype-plugin-site Un archétype, qui contient un exemple de site de plugin Maven. |
| 6 | maven-archetype-portlet Un archétype, qui contient un exemple de portlet JSR-268. |
| sept | maven-archetype-quickstart Un archétype, qui contient un exemple de projet Maven. |
| 8 | maven-archetype-simple An archetype, which contains a simple Maven project. |
| 9 | maven-archetype-site An archetype, which contains a sample Maven site to demonstrates some of the supported document types like APT, XDoc, and FML and demonstrates how to i18n your site. |
| 10 | maven-archetype-site-simple An archetype, which contains a sample Maven site. |
| 11 | maven-archetype-webapp An archetype, which contains a sample Maven Webapp project. |
Une grande application logicielle se compose généralement de plusieurs modules et c'est un scénario courant où plusieurs équipes travaillent sur différents modules de la même application. Par exemple, supposons qu'une équipe travaille sur le front-end de l'application en tant que projet app-ui (app-ui.jar: 1.0) et qu'elle utilise un projet de service de données (data-service.jar: 1.0).
Maintenant, il peut arriver que l'équipe travaillant sur le service de données subisse des corrections de bogues ou des améliorations à un rythme rapide et qu'elle publie la bibliothèque dans un référentiel distant presque tous les deux jours.
Désormais, si l'équipe du service de données télécharge une nouvelle version tous les deux jours, les problèmes suivants se poseront -
L'équipe du service de données doit informer l'équipe app-ui chaque fois qu'elle a publié un code mis à jour.
L'équipe app-ui doit mettre à jour régulièrement son pom.xml pour obtenir la version mise à jour.
Pour gérer ce genre de situation, SNAPSHOT le concept entre en jeu.
Qu'est-ce que SNAPSHOT?
SNAPSHOT est une version spéciale qui indique une copie de développement en cours. Contrairement aux versions régulières, Maven recherche une nouvelle version SNAPSHOT dans un référentiel distant pour chaque build.
Maintenant l'équipe de service de données publiera l'INSTANTANÉ de son code mis à jour chaque fois au référentiel, disons le service de données: 1.0-SNAPSHOT, remplaçant un pot plus ancien d'INSTANTANÉ.
Instantané vs version
Dans le cas de Version, si Maven a téléchargé une fois la version mentionnée, disons data-service: 1.0, il n'essaiera jamais de télécharger une version 1.0 plus récente disponible dans le référentiel. Pour télécharger le code mis à jour, la version du service de données est mise à niveau vers la version 1.1.
En cas d'INSTANTANÉ, Maven récupérera automatiquement le dernier INSTANTANÉ (data-service: 1.0-SNAPSHOT) chaque fois que l'équipe app-ui construira leur projet.
app-ui pom.xml
app-ui le projet utilise 1.0-SNAPSHOT du service de données.
<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/xsd/maven-4.0.0.xsd">
<modelVersion>4.0.0</modelVersion>
<groupId>app-ui</groupId>
<artifactId>app-ui</artifactId>
<version>1.0</version>
<packaging>jar</packaging>
<name>health</name>
<url>http://maven.apache.org</url>
<properties>
<project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
</properties>
<dependencies>
<dependency>
<groupId>data-service</groupId>
<artifactId>data-service</artifactId>
<version>1.0-SNAPSHOT</version>
<scope>test</scope>
</dependency>
</dependencies>
</project>service de données pom.xml
data-service le projet libère 1.0-SNAPSHOT pour chaque changement mineur.
<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/xsd/maven-4.0.0.xsd">
<modelVersion>4.0.0</modelVersion>
<groupId>data-service</groupId>
<artifactId>data-service</artifactId>
<version>1.0-SNAPSHOT</version>
<packaging>jar</packaging>
<name>health</name>
<url>http://maven.apache.org</url>
<properties>
<project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
</properties>
</project>Bien que, dans le cas de SNAPSHOT, Maven récupère automatiquement le dernier SNAPSHOT quotidiennement, vous pouvez forcer maven à télécharger la dernière version de snapshot en utilisant le commutateur -U vers n'importe quelle commande maven.
mvn clean package -UOuvrons la console de commande, allons à la C:\ > MVN > app-ui répertoire et exécutez ce qui suit mvn commander.
C:\MVN\app-ui>mvn clean package -UMaven commencera à construire le projet après avoir téléchargé le dernier SNAPSHOT du service de données.
[INFO] Scanning for projects...
[INFO]--------------------------------------------
[INFO] Building consumerBanking
[INFO] task-segment: [clean, package]
[INFO]--------------------------------------------
[INFO] Downloading data-service:1.0-SNAPSHOT
[INFO] 290K downloaded.
[INFO] [clean:clean {execution: default-clean}]
[INFO] Deleting directory C:\MVN\app-ui\target
[INFO] [resources:resources {execution: default-resources}]
[WARNING] Using platform encoding (Cp1252 actually) to copy filtered resources,
i.e. build is platform dependent!
[INFO] skip non existing resourceDirectory C:\MVN\app-ui\src\main\resources
[INFO] [compiler:compile {execution:default-compile}]
[INFO] Compiling 1 source file to C:\MVN\app-ui\target\classes
[INFO] [resources:testResources {execution: default-testResources}]
[WARNING] Using platform encoding (Cp1252 actually) to copy filtered resources,
i.e. build is platform dependent!
[INFO] skip non existing resourceDirectory C:\MVN\app-ui\src\test\resources
[INFO] [compiler:testCompile {execution: default-testCompile}]
[INFO] Compiling 1 source file to C:\MVN\app-ui\target\test-classes
[INFO] [surefire:test {execution: default-test}]
[INFO] Surefire report directory: C:\MVN\app-ui\target\
surefire-reports
--------------------------------------------------
T E S T S
--------------------------------------------------
Running com.companyname.bank.AppTest
Tests run: 1, Failures: 0, Errors: 0, Skipped: 0, Time elapsed: 0.027 sec
Results :
Tests run: 1, Failures: 0, Errors: 0, Skipped: 0
[INFO] [jar:jar {execution: default-jar}]
[INFO] Building jar: C:\MVN\app-ui\target\
app-ui-1.0-SNAPSHOT.jar
[INFO]--------------------------------------------------------
[INFO] BUILD SUCCESSFUL
[INFO]--------------------------------------------------------
[INFO] Total time: 2 seconds
[INFO] Finished at: 2015-09-27T12:30:02+05:30
[INFO] Final Memory: 16M/89M
[INFO]------------------------------------------------------------------------Build Automation définit le scénario dans lequel le processus de construction du ou des projets dépendants démarre une fois que la construction du projet est terminée avec succès, afin de garantir la stabilité du ou des projets dépendants.
Example
Considérez qu'une équipe développe un projet bus-core-api sur lequel deux autres projets app-web-ui et app-desktop-ui sont dépendants.
app-web-ui le projet utilise 1.0-SNAPSHOT de bus-core-api projet.
<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/xsd/maven-4.0.0.xsd">
<modelVersion>4.0.0</modelVersion>
<groupId>app-web-ui</groupId>
<artifactId>app-web-ui</artifactId>
<version>1.0</version>
<packaging>jar</packaging>
<dependencies>
<dependency>
<groupId>bus-core-api</groupId>
<artifactId>bus-core-api</artifactId>
<version>1.0-SNAPSHOT</version>
</dependency>
</dependencies>
</project>app-desktop-ui le projet utilise 1.0-SNAPSHOT de bus-core-api projet.
<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/xsd/maven-4.0.0.xsd">
<modelVersion>4.0.0</modelVersion>
<groupId>app_desktop_ui</groupId>
<artifactId>app_desktop_ui</artifactId>
<version>1.0</version>
<packaging>jar</packaging>
<name>app_desktop_ui</name>
<url>http://maven.apache.org</url>
<properties>
<project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
</properties>
<dependencies>
<dependency>
<groupId>junit</groupId>
<artifactId>junit</artifactId>
<version>3.8.1</version>
<scope>test</scope>
</dependency>
<dependency>
<groupId>bus_core_api</groupId>
<artifactId>bus_core_api</artifactId>
<version>1.0-SNAPSHOT</version>
<scope>system</scope>
<systemPath>C:\MVN\bus_core_api\target\bus_core_api-1.0-SNAPSHOT.jar</systemPath>
</dependency>
</dependencies>
</project>bus-core-api projet -
<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/xsd/maven-4.0.0.xsd">
<modelVersion>4.0.0</modelVersion>
<groupId>bus_core_api</groupId>
<artifactId>bus_core_api</artifactId>
<version>1.0-SNAPSHOT</version>
<packaging>jar</packaging>
</project>Désormais, des équipes de app-web-ui et app-desktop-ui les projets exigent que leur processus de construction démarre chaque fois bus-core-api changements de projet.
L'utilisation de snapshot garantit que la dernière bus-core-api project doit être utilisé, mais pour répondre à l'exigence ci-dessus, nous devons faire quelque chose de plus.
Nous pouvons procéder des deux manières suivantes -
Ajouter un objectif post-build dans bus-core-api pom au coup d'envoi app-web-ui et app-desktop-ui construit.
Utilisez un serveur d'intégration continue (CI) comme Hudson pour gérer automatiquement l'automatisation de la construction.
Utiliser Maven
Mettre à jour bus-core-api projet pom.xml.
<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/xsd/maven-4.0.0.xsd">
<modelVersion>4.0.0</modelVersion>
<groupId>bus-core-api</groupId>
<artifactId>bus-core-api</artifactId>
<version>1.0-SNAPSHOT</version>
<packaging>jar</packaging>
<build>
<plugins>
<plugin>
<artifactId>maven-invoker-plugin</artifactId>
<version>1.6</version>
<configuration>
<debug>true</debug>
<pomIncludes>
<pomInclude>app-web-ui/pom.xml</pomInclude>
<pomInclude>app-desktop-ui/pom.xml</pomInclude>
</pomIncludes>
</configuration>
<executions>
<execution>
<id>build</id>
<goals>
<goal>run</goal>
</goals>
</execution>
</executions>
</plugin>
</plugins>
<build>
</project>Ouvrons la console de commande, allons à la C:\ > MVN > bus-core-api répertoire et exécutez ce qui suit mvn commander.
>mvn clean package -UMaven commencera à construire le projet bus-core-api.
[INFO] Scanning for projects...
[INFO] ------------------------------------------------------------------
[INFO] Building bus-core-api
[INFO] task-segment: [clean, package]
[INFO] ------------------------------------------------------------------
...
[INFO] [jar:jar {execution: default-jar}]
[INFO] Building jar: C:\MVN\bus-core-ui\target\
bus-core-ui-1.0-SNAPSHOT.jar
[INFO] ------------------------------------------------------------------
[INFO] BUILD SUCCESSFUL
[INFO] ------------------------------------------------------------------Une fois que bus-core-api build réussit, Maven commencera à construire le app-web-ui projet.
[INFO] ------------------------------------------------------------------
[INFO] Building app-web-ui
[INFO] task-segment: [package]
[INFO] ------------------------------------------------------------------
...
[INFO] [jar:jar {execution: default-jar}]
[INFO] Building jar: C:\MVN\app-web-ui\target\
app-web-ui-1.0-SNAPSHOT.jar
[INFO] ------------------------------------------------------------------
[INFO] BUILD SUCCESSFUL
[INFO] ------------------------------------------------------------------Une fois que app-web-ui build réussit, Maven commencera à construire le app-desktop-ui projet.
[INFO] ------------------------------------------------------------------
[INFO] Building app-desktop-ui
[INFO] task-segment: [package]
[INFO] ------------------------------------------------------------------
...
[INFO] [jar:jar {execution: default-jar}]
[INFO] Building jar: C:\MVN\app-desktop-ui\target\
app-desktop-ui-1.0-SNAPSHOT.jar
[INFO] -------------------------------------------------------------------
[INFO] BUILD SUCCESSFUL
[INFO] -------------------------------------------------------------------Utilisation du service d'intégration continue avec Maven
L'utilisation d'un serveur CI est plus préférable aux développeurs. Il n'est pas nécessaire de mettre à jour lebus-core-api projet, chaque fois qu'un nouveau projet (par exemple, app-mobile-ui) est ajouté, en tant que projet dépendant de bus-core-apiprojet. Hudsion est un outil d'intégration continue écrit en java, qui se trouve dans un conteneur de servlet, tel que Apache tomcat et le serveur d'applications glassfish. Hudson gère automatiquement l'automatisation des builds à l'aide de la gestion des dépendances Maven. L'instantané suivant définira le rôle de l'outil Hudson.
Hudson considère chaque construction de projet comme un travail. Une fois qu'un code de projet est archivé dans SVN (ou tout outil de gestion de source mappé à Hudson), Hudson démarre sa tâche de construction et une fois cette tâche terminée, il démarre automatiquement d'autres tâches dépendantes (autres projets dépendants).
Dans l'exemple ci-dessus, quand bus-core-uile code source est mis à jour dans SVN, Hudson commence sa construction. Une fois la construction réussie, Hudson recherche automatiquement les projets dépendants et commence la constructionapp-web-ui et app-desktop-ui projets.
L'une des principales fonctionnalités de Maven est la gestion des dépendances. La gestion des dépendances est une tâche difficile une fois que nous avons affaire à des projets multi-modules (composés de centaines de modules / sous-projets). Maven offre un degré élevé de contrôle pour gérer de tels scénarios.
Découverte des dépendances transitives
C'est assez souvent un cas, lorsqu'une bibliothèque, disons A, dépend d'une autre bibliothèque, disons B. Dans le cas où un autre projet C veut utiliser A, alors ce projet doit également utiliser la bibliothèque B.
Maven permet d'éviter de telles exigences pour découvrir toutes les bibliothèques requises. Maven le fait en lisant les fichiers de projet (pom.xml) des dépendances, en identifiant leurs dépendances et ainsi de suite.
Il suffit de définir la dépendance directe dans chaque projet pom. Maven gère le reste automatiquement.
Avec les dépendances transitives, le graphique des bibliothèques incluses peut rapidement se développer dans une large mesure. Des cas peuvent survenir lorsqu'il existe des bibliothèques en double. Maven fournit peu de fonctionnalités pour contrôler l'étendue des dépendances transitives.
| Sr.No. | Description des fonctions |
|---|---|
| 1 | Dependency mediation Détermine la version d'une dépendance à utiliser lorsque plusieurs versions d'un artefact sont rencontrées. Si deux versions de dépendances sont à la même profondeur dans l'arborescence de dépendances, la première dépendance déclarée sera utilisée. |
| 2 | Dependency management Spécifiez directement les versions des artefacts à utiliser lorsqu'ils sont rencontrés dans des dépendances transitives. Pour un exemple de projet, C peut inclure B en tant que dépendance dans sa section de gestion des dépendances et contrôler directement la version de B à utiliser lorsqu'elle est référencée. |
| 3 | Dependency scope Inclut les dépendances selon l'étape actuelle de la construction. |
| 4 | Excluded dependencies Toute dépendance transitive peut être exclue à l'aide de l'élément "exclusion". Par exemple, A dépend de B et B dépend de C, alors A peut marquer C comme exclu. |
| 5 | Optional dependencies Toute dépendance transitive peut être marquée comme facultative à l'aide de l'élément "facultatif". Par exemple, A dépend de B et B dépend de C. Maintenant B marqué C comme facultatif. Alors A n'utilisera pas C. |
Portée de la dépendance
La découverte des dépendances transitives peut être restreinte à l'aide de diverses étendues de dépendance, comme indiqué ci-dessous.
| Sr.No. | Portée et description |
|---|---|
| 1 | compile Cette portée indique que la dépendance est disponible dans le chemin de classe du projet. C'est la portée par défaut. |
| 2 | provided Cette portée indique que la dépendance doit être fournie par JDK ou Web-Server / Container lors de l'exécution. |
| 3 | runtime Cette portée indique que la dépendance n'est pas requise pour la compilation, mais est requise lors de l'exécution. |
| 4 | test Cette portée indique que la dépendance n'est disponible que pour les phases de compilation et d'exécution du test. |
| 5 | system Cette étendue indique que vous devez fournir le chemin du système. |
| 6 | import Cette portée n'est utilisée que lorsque la dépendance est de type pom. Cette portée indique que le POM spécifié doit être remplacé par les dépendances dans la section <dependencyManagement> de ce POM. |
Gestion des dépendances
Habituellement, nous avons un ensemble de projets dans le cadre d'un projet commun. Dans ce cas, nous pouvons créer un pom commun ayant toutes les dépendances communes puis faire de ce pom le parent des poms du sous-projet. L'exemple suivant vous aidera à comprendre ce concept.
Voici le détail du graphique de dépendances ci-dessus -
- App-UI-WAR dépend de App-Core-lib et App-Data-lib.
- Root est le parent d'App-Core-lib et d'App-Data-lib.
- Root définit Lib1, lib2, Lib3 comme des dépendances dans sa section de dépendances.
App-UI-WAR
<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/xsd/maven-4.0.0.xsd">
<modelVersion>4.0.0</modelVersion>
<groupId>com.companyname.groupname</groupId>
<artifactId>App-UI-WAR</artifactId>
<version>1.0</version>
<packaging>war</packaging>
<dependencies>
<dependency>
<groupId>com.companyname.groupname</groupId>
<artifactId>App-Core-lib</artifactId>
<version>1.0</version>
</dependency>
</dependencies>
<dependencies>
<dependency>
<groupId>com.companyname.groupname</groupId>
<artifactId>App-Data-lib</artifactId>
<version>1.0</version>
</dependency>
</dependencies>
</project>App-Core-lib
<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/xsd/maven-4.0.0.xsd">
<parent>
<artifactId>Root</artifactId>
<groupId>com.companyname.groupname</groupId>
<version>1.0</version>
</parent>
<modelVersion>4.0.0</modelVersion>
<groupId>com.companyname.groupname</groupId>
<artifactId>App-Core-lib</artifactId>
<version>1.0</version>
<packaging>jar</packaging>
</project>App-Data-lib
<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/xsd/maven-4.0.0.xsd">
<parent>
<artifactId>Root</artifactId>
<groupId>com.companyname.groupname</groupId>
<version>1.0</version>
</parent>
<modelVersion>4.0.0</modelVersion>
<groupId>com.companyname.groupname</groupId>
<artifactId>App-Data-lib</artifactId>
<version>1.0</version>
<packaging>jar</packaging>
</project>Root
<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/xsd/maven-4.0.0.xsd">
<modelVersion>4.0.0</modelVersion>
<groupId>com.companyname.groupname</groupId>
<artifactId>Root</artifactId>
<version>1.0</version>
<packaging>pom</packaging>
<dependencies>
<dependency>
<groupId>com.companyname.groupname1</groupId>
<artifactId>Lib1</artifactId>
<version>1.0</version>
</dependency>
</dependencies>
<dependencies>
<dependency>
<groupId>com.companyname.groupname2</groupId>
<artifactId>Lib2</artifactId>
<version>2.1</version>
</dependency>
</dependencies>
<dependencies>
<dependency>
<groupId>com.companyname.groupname3</groupId>
<artifactId>Lib3</artifactId>
<version>1.1</version>
</dependency>
</dependencies>
</project>Désormais, lorsque nous construirons le projet App-UI-WAR, Maven découvrira toutes les dépendances en parcourant le graphique de dépendances et en construisant l'application.
À partir de l'exemple ci-dessus, nous pouvons apprendre les concepts clés suivants -
Les dépendances communes peuvent être placées à un seul endroit en utilisant le concept de pom parent. Dépendances deApp-Data-lib et App-Core-libLes projets sont répertoriés dans Projet racine (voir le type d'empaquetage de Root. C'est POM).
Il n'est pas nécessaire de spécifier Lib1, lib2, Lib3 comme dépendance dans App-UI-WAR. Maven utilise leTransitive Dependency Mechanism pour gérer ces détails.
Dans le développement d'un projet, normalement un processus de déploiement comprend les étapes suivantes:
Archivez le code de tous les projets en cours dans le SVN (système de contrôle de version) ou dans le référentiel de code source et étiquetez-le.
Téléchargez le code source complet de SVN.
Créez l'application.
Stockez le fichier de sortie de construction WAR ou EAR dans un emplacement réseau commun.
Récupérez le fichier du réseau et déployez le fichier sur le site de production.
Mise à jour de la documentation avec la date et le numéro de version mis à jour de l'application.
Énoncé du problème
Il y a normalement plusieurs personnes impliquées dans le processus de déploiement mentionné ci-dessus. Une équipe peut gérer l'archivage du code, une autre peut gérer la compilation et ainsi de suite. Il est très probable que n'importe quelle étape puisse être manquée en raison des efforts manuels impliqués et en raison de l'environnement multi-équipes. Par exemple, l'ancienne version ne peut pas être remplacée sur la machine réseau et l'équipe de déploiement a déployé à nouveau l'ancienne version.
Solution
Automatisez le processus de déploiement en combinant les éléments suivants:
- Maven, pour construire et publier des projets.
- SubVersion, référentiel de code source, pour gérer le code source.
- Remote Repository Manager (Jfrog / Nexus) pour gérer les binaires du projet.
Mettre à jour le projet POM.xml
Nous utiliserons le plug-in Maven Release pour créer un processus de publication automatisé.
Par exemple: projet bus-core-api POM.xml.
<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/xsd/maven-4.0.0.xsd">
<modelVersion>4.0.0</modelVersion>
<groupId>bus-core-api</groupId>
<artifactId>bus-core-api</artifactId>
<version>1.0-SNAPSHOT</version>
<packaging>jar</packaging>
<scm>
<url>http://www.svn.com</url>
<connection>scm:svn:http://localhost:8080/svn/jrepo/trunk/
Framework</connection>
<developerConnection>scm:svn:${username}/${password}@localhost:8080:
common_core_api:1101:code</developerConnection>
</scm>
<distributionManagement>
<repository>
<id>Core-API-Java-Release</id>
<name>Release repository</name>
<url>http://localhost:8081/nexus/content/repositories/
Core-Api-Release</url>
</repository>
</distributionManagement>
<build>
<plugins>
<plugin>
<groupId>org.apache.maven.plugins</groupId>
<artifactId>maven-release-plugin</artifactId>
<version>2.0-beta-9</version>
<configuration>
<useReleaseProfile>false</useReleaseProfile>
<goals>deploy</goals>
<scmCommentPrefix>[bus-core-api-release-checkin]-<
/scmCommentPrefix>
</configuration>
</plugin>
</plugins>
</build>
</project>Dans Pom.xml, voici les éléments importants que nous avons utilisés -
| Sr.No. | Élément et description |
|---|---|
| 1 | SCM Configure l'emplacement SVN à partir duquel Maven extraira le code source. |
| 2 | Repositories L'emplacement où le WAR / EAR / JAR construit ou tout autre artefact sera stocké une fois la construction du code réussie. |
| 3 | Plugin maven-release-plugin est configuré pour automatiser le processus de déploiement. |
Plug-in de version Maven
Le Maven effectue les tâches utiles suivantes en utilisant maven-release-plugin.
mvn release:cleanIl nettoie l'espace de travail au cas où le dernier processus de publication échouerait.
mvn release:rollbackAnnulez les modifications apportées au code et à la configuration de l'espace de travail au cas où le dernier processus de publication échouerait.
mvn release:prepareEffectue plusieurs opérations, telles que -
Vérifie s'il y a des modifications locales non validées ou non.
Garantit qu'il n'y a pas de dépendances SNAPSHOT.
Modifie la version de l'application et supprime SNAPSHOT de la version pour rendre la publication.
Mettez à jour les fichiers pom vers SVN.
Exécutez des cas de test.
Validez les fichiers POM modifiés.
Taguer le code en subversion
Incrémentez le numéro de version et ajoutez SNAPSHOT pour la prochaine version.
Validez les fichiers POM modifiés dans SVN.
mvn release:performExtrait le code à l'aide de la balise précédemment définie et exécutez l'objectif de déploiement Maven, pour déployer la guerre ou l'artefact construit dans le référentiel.
Ouvrons la console de commande, allons à la C:\ > MVN >bus-core-api répertoire et exécutez ce qui suit mvn commander.
>mvn release:prepareMaven commencera à construire le projet. Une fois la construction réussie, exécutez ce qui suitmvn commander.
>mvn release:performUne fois la construction réussie, vous pouvez vérifier le fichier JAR téléchargé dans votre référentiel.
Ce chapitre vous apprend à gérer un projet Web en utilisant Maven. Ici, vous apprendrez comment créer / construire / déployer et exécuter une application Web.
Créer une application Web
Pour créer une simple application web java, nous utiliserons maven-archetype-webappbrancher. Alors, ouvrons la console de commande, allons à laC:\MVN répertoire et exécutez ce qui suit mvn commander.
C:\MVN>mvn archetype:generate
-DgroupId = com.companyname.automobile
-DartifactId = trucks
-DarchetypeArtifactId = maven-archetype-webapp
-DinteractiveMode = falseMaven commencera le traitement et créera la structure complète du projet d'application Java basée sur le Web comme suit -
[INFO] Scanning for projects...
[INFO] Searching repository for plugin with prefix: 'archetype'.
[INFO] -------------------------------------------------------------------
[INFO] Building Maven Default Project
[INFO] task-segment: [archetype:generate] (aggregator-style)
[INFO] -------------------------------------------------------------------
[INFO] Preparing archetype:generate
[INFO] No goals needed for project - skipping
[INFO] [archetype:generate {execution: default-cli}]
[INFO] Generating project in Batch mode
[INFO] --------------------------------------------------------------------
[INFO] Using following parameters for creating project
from Old (1.x) Archetype: maven-archetype-webapp:1.0
[INFO] --------------------------------------------------------------------
[INFO] Parameter: groupId, Value: com.companyname.automobile
[INFO] Parameter: packageName, Value: com.companyname.automobile
[INFO] Parameter: package, Value: com.companyname.automobile
[INFO] Parameter: artifactId, Value: trucks
[INFO] Parameter: basedir, Value: C:\MVN
[INFO] Parameter: version, Value: 1.0-SNAPSHOT
[INFO] project created from Old (1.x) Archetype in dir: C:\MVN\trucks
[INFO] -------------------------------------------------------------------
[INFO] BUILD SUCCESSFUL
[INFO] -------------------------------------------------------------------
[INFO] Total time: 16 seconds
[INFO] Finished at: Tue Jul 17 11:00:00 IST 2012
[INFO] Final Memory: 20M/89M
[INFO] -------------------------------------------------------------------Accédez maintenant au répertoire C: / MVN. Vous verrez un projet d'application Java créé, nommé trucks (comme spécifié dans artifactId) comme spécifié dans l'instantané suivant. La structure de répertoires suivante est généralement utilisée pour les applications Web -
Maven utilise une disposition de répertoire standard. En utilisant l'exemple ci-dessus, nous pouvons comprendre les concepts clés suivants -
| Sr.No. | Structure et description des dossiers |
|---|---|
| 1 | trucks contient le dossier src et pom.xml. |
| 2 | src/main/webapp contient le dossier index.jsp et WEB-INF. |
| 3 | src/main/webapp/WEB-INF contient web.xml |
| 4 | src/main/resources il contient des fichiers images / propriétés. |
POM.xml
<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.companyname.automobile</groupId>
<artifactId>trucks</artifactId>
<packaging>war</packaging>
<version>1.0-SNAPSHOT</version>
<name>trucks Maven Webapp</name>
<url>http://maven.apache.org</url>
<dependencies>
<dependency>
<groupId>junit</groupId>
<artifactId>junit</artifactId>
<version>3.8.1</version>
<scope>test</scope>
</dependency>
</dependencies>
<build>
<finalName>trucks</finalName>
</build>
</project>Si vous observez, vous constaterez que Maven a également créé un exemple de fichier source JSP.
Ouvert C:\ > MVN > trucks > src > main > webapp > dossier pour voir index.jsp avec le code suivant -
<html>
<body>
<h2>Hello World!</h2>
</body>
</html>Créer une application Web
Ouvrons la console de commande, allons dans le répertoire C: \ MVN \ trucks et exécutons ce qui suit mvn commander.
C:\MVN\trucks>mvn clean packageMaven commencera à construire le projet.
[INFO] Scanning for projects...
[INFO] -------------------------------------------------------------------
[INFO] Building trucks Maven Webapp
[INFO] task-segment: [clean, package]
[INFO] -------------------------------------------------------------------
[INFO] [clean:clean {execution: default-clean}]
[INFO] [resources:resources {execution: default-resources}]
[WARNING] Using platform encoding (Cp1252 actually) to
copy filtered resources,i.e. build is platform dependent!
[INFO] Copying 0 resource
[INFO] [compiler:compile {execution: default-compile}]
[INFO] No sources to compile
[INFO] [resources:testResources {execution: default-testResources}]
[WARNING] Using platform encoding (Cp1252 actually) to
copy filtered resources,i.e. build is platform dependent!
[INFO] skip non existing resourceDirectory
C:\MVN\trucks\src\test\resources
[INFO] [compiler:testCompile {execution: default-testCompile}]
[INFO] No sources to compile
[INFO] [surefire:test {execution: default-test}]
[INFO] No tests to run.
[INFO] [war:war {execution: default-war}]
[INFO] Packaging webapp
[INFO] Assembling webapp[trucks] in [C:\MVN\trucks\target\trucks]
[INFO] Processing war project
[INFO] Copying webapp resources[C:\MVN\trucks\src\main\webapp]
[INFO] Webapp assembled in[77 msecs]
[INFO] Building war: C:\MVN\trucks\target\trucks.war
[INFO] -------------------------------------------------------------------
[INFO] BUILD SUCCESSFUL
[INFO] -------------------------------------------------------------------
[INFO] Total time: 3 seconds
[INFO] Finished at: Tue Jul 17 11:22:45 IST 2012
[INFO] Final Memory: 11M/85M
[INFO] -------------------------------------------------------------------Déployer une application Web
Maintenant, copiez le trucks.war créé en C:\ > MVN > trucks > target > dossier dans le répertoire webapp de votre serveur Web et redémarrez le serveur Web.
Test de l'application Web
Exécutez l'application Web en utilisant l'URL: http://<server-name>:<port-number>/trucks/index.jsp.
Vérifiez la sortie.
Eclipse fournit un excellent plugin m2eclipse qui intègre de manière transparente Maven et Eclipse ensemble.
Certaines des fonctionnalités de m2eclipse sont répertoriées ci-dessous -
Vous pouvez exécuter des objectifs Maven à partir d'Eclipse.
Vous pouvez afficher la sortie des commandes Maven à l'intérieur de l'Eclipse, en utilisant sa propre console.
Vous pouvez mettre à jour les dépendances maven avec IDE.
Vous pouvez lancer des builds Maven à partir d'Eclipse.
Il fait la gestion des dépendances pour le chemin de construction Eclipse basé sur le pom.xml de Maven.
Il résout les dépendances Maven à partir de l'espace de travail Eclipse sans installation dans le référentiel Maven local (nécessite que le projet de dépendance se trouve dans le même espace de travail).
Il télécharge automatiquement les dépendances et sources requises à partir des référentiels Maven distants.
Il fournit des assistants pour créer de nouveaux projets Maven, pom.xml et pour activer le support Maven sur les projets existants
Il fournit une recherche rapide des dépendances dans les référentiels Maven distants.
Installer le plugin m2eclipse
Utilisez l'un des liens suivants pour installer m2eclipse -
| Éclipse | URL |
|---|---|
| Eclipse 3.5 (Gallileo) | Installation de m2eclipse dans Eclipse 3.5 (Gallileo) |
| Eclipse 3.6 (Helios) | Installation de m2eclipse dans Eclipse 3.6 (Helios) |
L'exemple suivant vous aidera à tirer parti des avantages de l'intégration d'Eclipse et de maven.
Importer un projet maven dans Eclipse
Ouvrez Eclipse.
Sélectionner File > Import > option.
Sélectionnez l'option Projets Maven. Cliquez sur le bouton Suivant.
Sélectionnez Emplacement du projet, où un projet a été créé à l'aide de Maven. Nous avons créé un projet Java Consumer Banking dans les chapitres précédents. Allez au chapitre «Création d'un projet Java» pour voir comment créer un projet à l'aide de Maven.
Cliquez sur le bouton Terminer.
Maintenant, vous pouvez voir le projet maven dans eclipse.
Maintenant, jetez un œil à consumer Bankingpropriétés du projet. Vous pouvez voir qu'Eclipse a ajouté des dépendances Maven au chemin de construction java.
Maintenant, il est temps de construire ce projet en utilisant la capacité maven d'Eclipse.
- Cliquez avec le bouton droit sur le projet consumerBanking pour ouvrir le menu contextuel.
- Sélectionnez l'option Exécuter en tant que.
- Puis l'option de package maven.
Maven commencera à construire le projet. Vous pouvez voir la sortie dans Eclipse Console comme suit -
[INFO] Scanning for projects...
[INFO] -------------------------------------------------------------------
[INFO] Building consumerBanking
[INFO]
[INFO] Id: com.companyname.bank:consumerBanking:jar:1.0-SNAPSHOT
[INFO] task-segment: [package]
[INFO] -------------------------------------------------------------------
[INFO] [resources:resources]
[INFO] Using default encoding to copy filtered resources.
[INFO] [compiler:compile]
[INFO] Nothing to compile - all classes are up to date
[INFO] [resources:testResources]
[INFO] Using default encoding to copy filtered resources.
[INFO] [compiler:testCompile]
[INFO] Nothing to compile - all classes are up to date
[INFO] [surefire:test]
[INFO] Surefire report directory:
C:\MVN\consumerBanking\target\surefire-reports
-------------------------------------------------------
T E S T S
-------------------------------------------------------
Running com.companyname.bank.AppTest
Tests run: 1, Failures: 0, Errors: 0, Skipped: 0, Time elapsed: 0.047 sec
Results :
Tests run: 1, Failures: 0, Errors: 0, Skipped: 0
[INFO] [jar:jar]
[INFO] -------------------------------------------------------------------
[INFO] BUILD SUCCESSFUL
[INFO] -------------------------------------------------------------------
[INFO] Total time: 1 second
[INFO] Finished at: Thu Jul 12 18:18:24 IST 2012
[INFO] Final Memory: 2M/15M
[INFO] -------------------------------------------------------------------Maintenant, faites un clic droit sur App.java. SélectionnerRun Asoption. Puis sélectionnezJava Application.
Vous verrez le résultat comme suit -
Hello World!NetBeans 6.7 et plus récent a un support intégré pour Maven. Dans le cas de la version précédente, le plugin Maven est disponible dans plugin Manager. Nous utilisons NetBeans 6.9 dans cet exemple.
Certaines des fonctionnalités de NetBeans sont répertoriées ci-dessous -
Vous pouvez exécuter des objectifs Maven à partir de NetBeans.
Vous pouvez afficher la sortie des commandes Maven dans NetBeans en utilisant sa propre console.
Vous pouvez mettre à jour les dépendances maven avec IDE.
Vous pouvez lancer des builds Maven depuis NetBeans.
NetBeans fait la gestion des dépendances automatiquement en fonction du pom.xml de Maven.
NetBeans résout les dépendances Maven à partir de son espace de travail sans installation dans le référentiel Maven local (nécessite que le projet de dépendance se trouve dans le même espace de travail).
NetBeans télécharge automatiquement les dépendances et les sources requises à partir des référentiels Maven distants.
NetBeans fournit des assistants pour créer de nouveaux projets Maven, pom.xml.
NetBeans fournit un navigateur de référentiel Maven qui vous permet d'afficher votre référentiel local et les référentiels Maven externes enregistrés.
L'exemple suivant vous aidera à tirer parti des avantages de l'intégration de NetBeans et Maven.
Ouvrez un projet maven dans NetBeans
Ouvrez NetBeans.
Sélectionner File Menu > Open Project option.
Sélectionnez Emplacement du projet, où un projet a été créé à l'aide de Maven. Nous avons créé un ConsumerBanking Java Project. Allez au chapitre «Création d'un projet Java» pour voir comment créer un projet à l'aide de Maven.
Maintenant, vous pouvez voir le projet maven dans NetBeans. Jetez un œil aux bibliothèques et aux bibliothèques de test du projet consumerBanking. Vous pouvez voir que NetBeans a ajouté des dépendances Maven à son chemin de construction.
Construire un projet maven dans NetBeans
Maintenant, il est temps de construire ce projet en utilisant la capacité maven de NetBeans.
- Cliquez avec le bouton droit sur le projet consumerBanking pour ouvrir le menu contextuel.
- Sélectionnez Nettoyer et construire comme option.
Maven commencera à construire le projet. Vous pouvez voir la sortie dans la console NetBeans comme suit -
NetBeans: Executing 'mvn.bat -Dnetbeans.execution = true clean install'
NetBeans: JAVA_HOME = C:\Program Files\Java\jdk1.6.0_21
Scanning for projects...
------------------------------------------------------------------------
Building consumerBanking
task-segment: [clean, install]
------------------------------------------------------------------------
[clean:clean]
[resources:resources]
[WARNING] Using platform encoding (Cp1252 actually)
to copy filtered resources, i.e. build is platform dependent!
skip non existing resourceDirectory C:\MVN\consumerBanking\src\main\resources
[compiler:compile]
Compiling 2 source files to C:\MVN\consumerBanking\target\classes
[resources:testResources]
[WARNING] Using platform encoding (Cp1252 actually)
to copy filtered resources, i.e. build is platform dependent!
skip non existing resourceDirectory C:\MVN\consumerBanking\src\test\resources
[compiler:testCompile]
Compiling 1 source file to C:\MVN\consumerBanking\target\test-classes
[surefire:test]
Surefire report directory: C:\MVN\consumerBanking\target\surefire-reports
-------------------------------------------------------
T E S T S
-------------------------------------------------------
Running com.companyname.bank.AppTest
Tests run: 1, Failures: 0, Errors: 0, Skipped: 0, Time elapsed: 0.023 sec
Results :
Tests run: 1, Failures: 0, Errors: 0, Skipped: 0
[jar:jar]
Building jar: C:\MVN\consumerBanking\target\consumerBanking-1.0-SNAPSHOT.jar
[install:install]
Installing C:\MVN\consumerBanking\target\consumerBanking-1.0-SNAPSHOT.jar
to C:\Users\GB3824\.m2\repository\com\companyname\bank\consumerBanking\
1.0-SNAPSHOT\consumerBanking-1.0-SNAPSHOT.jar
------------------------------------------------------------------------
BUILD SUCCESSFUL
------------------------------------------------------------------------
Total time: 9 seconds
Finished at: Thu Jul 19 12:57:28 IST 2012
Final Memory: 16M/85M
------------------------------------------------------------------------Exécuter l'application dans NetBeans
Maintenant, faites un clic droit sur App.java. SélectionnerRun Fileen option. Vous verrez le résultat dans la console NetBeans.
NetBeans: Executing 'mvn.bat -Dexec.classpathScope = runtime
-Dexec.args = -classpath %classpath com.companyname.bank.App
-Dexec.executable = C:\Program Files\Java\jdk1.6.0_21\bin\java.exe
-Dnetbeans.execution = true process-classes
org.codehaus.mojo:exec-maven-plugin:1.1.1:exec'
NetBeans: JAVA_HOME = C:\Program Files\Java\jdk1.6.0_21
Scanning for projects...
------------------------------------------------------------------------
Building consumerBanking
task-segment: [process-classes,
org.codehaus.mojo:exec-maven-plugin:1.1.1:exec]
------------------------------------------------------------------------
[resources:resources]
[WARNING] Using platform encoding (Cp1252 actually)
to copy filtered resources, i.e. build is platform dependent!
skip non existing resourceDirectory C:\MVN\consumerBanking\src\main\resources
[compiler:compile]
Nothing to compile - all classes are up to date
[exec:exec]
Hello World!
------------------------------------------------------------------------
BUILD SUCCESSFUL
------------------------------------------------------------------------
Total time: 1 second
Finished at: Thu Jul 19 14:18:13 IST 2012
Final Memory: 7M/64M
------------------------------------------------------------------------IntelliJ IDEA a une prise en charge intégrée de Maven. Nous utilisons IntelliJ IDEA Community Edition 11.1 dans cet exemple.
Certaines des fonctionnalités d'IntelliJ IDEA sont répertoriées ci-dessous -
Vous pouvez exécuter des objectifs Maven à partir d'IntelliJ IDEA.
Vous pouvez afficher la sortie des commandes Maven dans IntelliJ IDEA en utilisant sa propre console.
Vous pouvez mettre à jour les dépendances maven dans l'EDI.
Vous pouvez lancer des builds Maven depuis IntelliJ IDEA.
IntelliJ IDEA effectue automatiquement la gestion des dépendances sur la base du pom.xml de Maven.
IntelliJ IDEA résout les dépendances Maven à partir de son espace de travail sans installation dans le référentiel Maven local (nécessite que le projet de dépendance se trouve dans le même espace de travail).
IntelliJ IDEA télécharge automatiquement les dépendances et sources requises à partir des référentiels Maven distants.
IntelliJ IDEA fournit des assistants pour créer de nouveaux projets Maven, pom.xml.
L'exemple suivant vous aidera à tirer parti des avantages de l'intégration d'IntelliJ IDEA et de Maven.
Créer un nouveau projet dans IntelliJ IDEA
Nous importerons le projet Maven à l'aide de l'assistant de nouveau projet.
Ouvrez IntelliJ IDEA.
Sélectionner File Menu > New Project Option.
Sélectionnez le projet d'importation à partir du modèle existant.
- Sélectionnez l'option Maven
Sélectionnez Emplacement du projet, où un projet a été créé à l'aide de Maven. Nous avons créé un projet Java consumerBanking. Allez au chapitre «Création d'un projet Java» pour voir comment créer un projet à l'aide de Maven.
- Sélectionnez le projet Maven à importer.
- Entrez le nom du projet et cliquez sur Terminer.
Maintenant, vous pouvez voir le projet maven dans IntelliJ IDEA. Jetez un œil aux bibliothèques externes du projet consumerBanking. Vous pouvez voir qu'IntelliJ IDEA a ajouté des dépendances Maven à son chemin de construction dans la section Maven.
Créez un projet maven dans IntelliJ IDEA
Il est maintenant temps de construire ce projet en utilisant les capacités d'IntelliJ IDEA.
Sélectionnez le projet ConsumerBanking.
Sélectionner Buid menu > Rebuild Project Option
Vous pouvez voir la sortie dans IntelliJ IDEA Console
4:01:56 PM Compilation completed successfullyExécuter l'application dans IntelliJ IDEA
Sélectionnez le projet ConsumerBanking.
Cliquez avec le bouton droit sur App.java pour ouvrir le menu contextuel.
sélectionner Run App.main()
Vous verrez le résultat dans IntelliJ IDEA Console.
"C:\Program Files\Java\jdk1.6.0_21\bin\java"
-Didea.launcher.port=7533
"-Didea.launcher.bin.path=
C:\Program Files\JetBrains\IntelliJ IDEA Community Edition 11.1.2\bin"
-Dfile.encoding=UTF-8
-classpath "C:\Program Files\Java\jdk1.6.0_21\jre\lib\charsets.jar;
C:\Program Files\Java\jdk1.6.0_21\jre\lib\deploy.jar;
C:\Program Files\Java\jdk1.6.0_21\jre\lib\javaws.jar;
C:\Program Files\Java\jdk1.6.0_21\jre\lib\jce.jar;
C:\Program Files\Java\jdk1.6.0_21\jre\lib\jsse.jar;
C:\Program Files\Java\jdk1.6.0_21\jre\lib\management-agent.jar;
C:\Program Files\Java\jdk1.6.0_21\jre\lib\plugin.jar;
C:\Program Files\Java\jdk1.6.0_21\jre\lib\resources.jar;
C:\Program Files\Java\jdk1.6.0_21\jre\lib\rt.jar;
C:\Program Files\Java\jdk1.6.0_21\jre\lib\ext\dnsns.jar;
C:\Program Files\Java\jdk1.6.0_21\jre\lib\ext\localedata.jar;
C:\Program Files\Java\jdk1.6.0_21\jre\lib\ext\sunjce_provider.jar;
C:\Program Files\Java\jdk1.6.0_21\jre\lib\ext\sunmscapi.jar;
C:\Program Files\Java\jdk1.6.0_21\jre\lib\ext\sunpkcs11.jar
C:\MVN\consumerBanking\target\classes;
C:\Program Files\JetBrains\
IntelliJ IDEA Community Edition 11.1.2\lib\idea_rt.jar"
com.intellij.rt.execution.application.AppMain com.companyname.bank.App
Hello World!
Process finished with exit code 0