![](https://img-blog.csdnimg.cn/img_convert/f39d4ee2902ceb1de77fb61f21ba8248.png)
Maven est un outil de gestion de projet multiplateforme. Site officiel : https://maven.apache.org/
Les principaux services de Maven sont basés sur le projet Java, la construction de projets Web, la gestion des informations sur les projets et la gestion des dépendances.
Basé sur le concept de modèle objet de projet (abréviation : POM), Maven utilise une information centrale pour gérer les étapes de construction, de reporting et de documentation d'un projet.
La fonction principale :
Fournit une structure de projet standardisée.
Le problème d'incohérence et d'incompatibilité des différentes structures de projet d'environnement de développement intégré (IDE) est résolu en créant des projets maven.
Fournit un ensemble de mécanismes de gestion des dépendances.
En bref, les dépendances des packages jar et les ressources tierces (packages jar, plug-ins...) peuvent être gérées via le fichier pom.xml
Fournit un processus de construction standardisé (compiler, tester, empaqueter, publier...).
Maven fournit un ensemble de commandes simples pour terminer la construction, les tests, le conditionnement, le déploiement de projets, etc., afin de réduire les opérations fastidieuses.
Modèle de gestion des dépendances de Maven
![](https://img-blog.csdnimg.cn/img_convert/9656450387810be928c8475f81c9a149.png)
L'entrepôt ici est divisé en:
Entrepôt local : un répertoire sur la machine locale.
Entrepôt central : le seul entrepôt au monde maintenu par l'équipe Maven, adresse : https://repo1.maven.org/maven2/ .
Entrepôt distant (serveur privé) : Généralement, un entrepôt privé construit par une équipe de l'entreprise.
Lorsque les coordonnées sont utilisées dans le projet pour importer le package jar correspondant,
Tout d'abord, il vérifiera s'il existe un package jar correspondant dans l'entrepôt local :
Si c'est le cas, il est directement référencé dans le projet ;
Si ce n'est pas le cas, rendez-vous dans l'entrepôt central pour télécharger le package jar correspondant dans l'entrepôt local, puis passez la référence.
Si un entrepôt distant est construit, l'ordre de recherche des packages jar à l'avenir deviendra :
Entrepôt local -> entrepôt distant -> entrepôt central
Cycle de vie Maven
Le cycle de vie Maven fait référence au cycle de vie des projets de construction Maven, y compris le nettoyage du projet, l'initialisation, la compilation, les tests, l'empaquetage, les tests d'intégration, la vérification, le déploiement et la génération du site .
Le cycle de vie de Maven est d'abstraire et d'unifier tous les processus de construction.
Maven propose trois cycles de vie indépendants :
clean : traitement du nettoyage du projet
default (ou build) : traitement du déploiement du projet
site : Prise en charge de la création des documents de site du projet
Ces trois ensembles de cycles de vie sont indépendants les uns des autres et n'ont aucune dépendance. Chaque ensemble de cycles de vie comporte plusieurs étapes, et les étapes multiples de chaque ensemble sont séquentielles, et les dernières étapes dépendent des étapes précédentes.
Les utilisateurs peuvent utiliser directement la commande mvn pour appeler ces étapes afin d'effectuer des opérations spécifiques dans le cycle de vie du projet.
Le format de la commande est : mvn life cycle phase.
cycle de vie propre
Le but du cycle de vie propre est de nettoyer le projet,
Il se compose de trois étapes :
1 |
pré-nettoyage |
Effectuer certains travaux qui doivent être effectués avant de nettoyer |
2 |
faire le ménage |
Supprimer tous les fichiers générés par la version précédente |
3 |
post-nettoyage |
Effectuez des travaux qui doivent être effectués immédiatement après le nettoyage |
Entrez la commande mvn pre-clean dans le terminal pour appeler les opérations qui doivent être effectuées dans la phase de pré-nettoyage du cycle de vie de nettoyage.
Appeler mvn post-clean exécutera toutes les opérations dans les trois étapes ci-dessus. La dernière étape de chaque cycle de vie dépendra de l'étape précédente. Lorsqu'une certaine étape est exécutée, l'étape précédente sera exécutée en premier.
cycle de vie par défaut (ou build)
Le cycle de vie par défaut ( ou build ) est le cycle de vie principal de maven, principalement utilisé pour construire des applications,
Il se compose de 23 étapes :
1 |
valider |
Vérifier : vérifiez que le projet est correct et que toutes les informations nécessaires sont disponibles pour terminer le processus de construction du projet. |
2 |
initialiser |
Initialisation : initialisez l'état de la génération, par exemple en définissant les valeurs des propriétés. |
3 |
générer des sources |
Générer le code source : génère tout code source inclus dans la phase de compilation. |
4 |
processus-sources |
Traiter le code source : traiter le code source, par exemple, filtrer des valeurs arbitraires. |
5 |
générer des ressources |
Générer des fichiers de ressources : générez des fichiers de ressources qui seront inclus dans le package de projet. |
6 |
processus-ressources |
编译:复制和处理资源到目标目录,为打包阶段最好准备。 |
7 |
compile |
处理类文件:编译项目的源代码。 |
8 |
process-classes |
处理类文件:处理编译生成的文件,比如说对Java class文件做字节码改善优化 |
9 |
generate-test-sources |
生成测试源代码:生成包含在编译阶段中的任何测试源代码。 |
10 |
process-test-sources |
处理测试源代码:处理测试源代码,比如说,过滤任意值。 |
11 |
generate-test-resources |
生成测试源文件:为测试创建资源文件。 |
12 |
process-test-resources |
处理测试源文件:复制和处理测试资源到目标目录。 |
13 |
test-compile |
编译测试源码:编译测试源代码到测试目标目录 |
14 |
process-test-classes |
处理测试类文件:处理测试源码编译生成的文件 |
15 |
test |
使用合适的单元测试框架运行测试(Juint是其中之一)。 |
16 |
prepare-package |
准备打包:在实际打包之前,执行任何的必要的操作为打包做准备。 |
17 |
package |
打包:将编译后的代码打包成可分发格式的文件,比如JAR、WAR或者EAR文件。 |
18 |
pre-integration-test |
集成测试前:在执行集成测试前进行必要的动作。比如说,搭建需要的环境。 |
19 |
integration-test |
集成测试:处理和部署项目到可以运行集成测试环境中。 |
20 |
post-integration-test |
集成测试后:在执行集成测试完成后进行必要的动作。比如说,清理集成测试环境。 |
21 |
verify |
验证:运行任意的检查来验证项目包有效且达到质量标准 |
22 |
install |
安装:安装项目包到本地仓库,这样项目包可以用作其他本地项目的依赖。 |
23 |
deploy |
部署:将最终的项目包复制到远程仓库中与其他开发者和项目共享。 |
site生命周期
site生命周期的目的是建立和发布项目站点。
Maven能够基于pom.xml所包含的信息,自动生成一个友好的站点,方便团队交流和发布项目信息。
主要包含以下4个阶段:
1 |
pre-site |
执行一些需要在生成站点文档之前完成的工作 |
2 |
site |
生成项目的站点文档 |
3 |
post-site |
执行一些需要在生成站点文档之后完成的工作,并且为部署做准备 |
4 |
site-deploy |
将生成的站点文档部署到特定的服务器上。 |
小结:
从令行执行maven任务的最主要方式就是调用maven生命周期的阶段。
每套生命周期是相互独立的,但是每套生命周期中阶段是有前后依赖关系的,即执行某个的时候,会按序先执行其前面所有的阶段。
mvn执行阶段的命令格式是:mvn 阶段1 [阶段2] [阶段n] 。如:
mvn clean
#调用clean生命周期的clean阶段,实际执行的阶段为clean生命周期中的pre-clean和clean阶段。
mvn test
#调用default生命周期的test阶段,
#实际上会从default生命周期的第一个阶段( validate )开始执行一直到 test 阶段结束。
mvn clean install
#执行了两个阶段: clean 和 install ,
#clean 位于 clean 生命周期中, install 位于 default 生命周期中,
#所以这个命令会先从 clean 生命周期中的 pre-clean 阶段开始执行一直到 clean 生命周期的 clean 阶段;
#然后会继续从default 生命周期的 validate 阶段开始执行一直到default生命周期的 install 阶段。
mvn clean deploy
#先按顺序执行 clean 生命周期的 [pre-clean,clean] 这个闭区间内所有的阶段,
#然后按序执行 default 生命周期的 [validate,deploy] 这个闭区间内的所有阶段
#(也就是default 生命周期中的所有阶段)。
#这个命令内部包含了清理上次构建的结果、编译代码、运行单元测试、打包、将打好的包安装到本地仓库、将打好的包发布到私服仓库。
每个生命周期中含着的一系列阶段(phase)。
这些 phase 就相当于 Maven 提供的统一的接口,然后这些 phase 的实现由 Maven 的插件来完成。
Maven的插件
maven插件主要是服务于maven中生命周期中的阶段。
输入 mvn 命令的时候,比如 mvn clean,clean 对应的就是 Clean 生命周期中的 clean 阶段。但是 clean 的具体操作是由 maven-clean-plugin 来实现的。所以说 Maven 生命周期的每一个阶段的具体实现都是由 Maven 插件实现的。
Maven 实际上是一个依赖插件执行的框架,每个任务实际上是由插件完成。Maven 插件通常被用来:
创建 jar 文件
创建 war 文件
编译代码文件
代码单元测试
创建工程文档
创建工程报告
插件通常提供了一个目标的集合,并且可以使用下面的语法执行:
<code>mvn [plugin-name]:[goal-name]</code>
例如,一个 Java 工程可以使用 maven-compiler-plugin 的 compile-goal 编译,使用以下命令:
<code>mvn compiler:compile</code>
Maven 提供了下面两种类型的插件:
类型 |
描述 |
Build plugins |
在构建时执行,并在 pom.xml 的 元素中配置。 |
Reporting plugins |
在网站生成过程中执行,并在 pom.xml 的 元素中配置。 |
下面是一些常用插件的列表:
插件 |
描述 |
clean |
构建之后清理目标文件。删除目标目录。 |
compiler |
编译 Java 源文件。 |
surefile |
运行 JUnit 单元测试。创建测试报告。 |
jar |
从当前工程中构建 JAR 文件。 |
war |
从当前工程中构建 WAR 文件。 |
javadoc |
为工程生成 Javadoc。 |
antrun |
从构建过程的任意一个阶段中运行一个 ant 任务的集合。 |
实例:在 C:\MVN\project 目录下创建一个 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>
<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>
接下来,打开命令终端跳转到 pom.xml 所在的目录,并执行下面的 mvn 命令。
mvn clean
Maven 将开始处理并显示 clean 生命周期的 clean 阶段。
[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] ------------------------------------------------------------------
上面的例子展示了以下关键概念:
插件是在 pom.xml 中使用 plugins 元素定义的。
每个插件可以有多个目标。
你可以定义阶段,插件会使用它的 phase 元素开始处理。我们已经使用了 clean 阶段。
你可以通过绑定到插件的目标的方式来配置要执行的任务。我们已经绑定了 echo 任务到 maven-antrun-plugin 的 run 目标。
就是这样,Maven 将处理剩下的事情。它将下载本地仓库中获取不到的插件,并开始处理。