Tout d'abord, permettez-moi de trier rapidement le concept de maven, afin que nous puissions établir rapidement un scénario d'application maven plus précis.
maven n'est pas une fourmi, ni un make Pour les outils de construction auxquels j'ai été exposé auparavant, je dois le faire. écrivez quelques étapes détaillées, telles que : compiler project1/src/*.java et d'autres instructions similaires.
Maven adopte l'approche « convention sur configuration ». Certaines opérations et étapes de développement courantes ont été solidifiées dans Maven, de sorte que les utilisateurs n'ont plus besoin d'écrire ces déclarations.
Maven dispose d'un support intégré pour le processus de développement. Il peut non seulement compiler, mais également empaqueter et publier, et peut également effectuer toutes ces étapes en une seule fois.
Maven n'est pas Ivy, La gestion des dépendances est l'une des fonctions de Maven. Maven ajoute le concept de portée à la relation de dépendance, affinant encore la division des dépendances. relations.
maven se positionne comme un outil de gestion de projet. Il est chargé de gérer presque tout dans le processus de développement du projet.
a. Version : Maven a sa propre définition de version et ses propres règles
b. Maven prend en charge de nombreux types d'applications, et un ensemble de règles de construction et d'ensembles d'outils sont définis pour chaque type d'application pris en charge
c. gérer les produits construits par le projet et les ajouter à la bibliothèque utilisateur. Cette fonction peut être utilisée pour le comportement de livraison entre l'équipe de projet et d'autres départements ; d. Dépendances :
Maven effectue une analyse détaillée et une analyse des caractéristiques de dépendance Diviser pour éviter confusion de dépendances et contamination mutuelle pendant le processus de développement ; e. Documentation et résultats de construction :
La commande site de Maven prend en charge la publication de diverses informations sur le document, y compris diverses sorties de le processus de construction, le javadoc, la documentation du produit, etc.; f. Relation projet :
Un grand projet comporte généralement plusieurs petits projets ou modules. Composition, cela peut être facilement géré avec maven ; h. Gestion de la portabilité :
Maven peut générer différents types de résultats de sortie pour différents scénarios de développement ; 02. Cycle de vie de Maven
Maven divise la construction du projet en différents cycles de vie,
incluent : la vérification, la compilation, les tests, l'empaquetage et le déploiement. Toutes les actions d'exécution (objectifs) dans maven doivent indiquer leur position d'exécution dans le processus. Ensuite, lorsque maven s'exécutera, ces objectifs seront appelés dans l'ordre en fonction du développement du processus. type de traitement.
Il s'agit également d'un mécanisme de planification de base de maven. D'une manière générale, les processus ultérieurs dépendront des processus précédents.
Bien entendu, maven fournit également des fichiers de configuration, qui peuvent sauter certaines étapes en fonction des besoins de l'utilisateur.
03. maven "La convention vaut mieux que la configuration"
maven "Convention sur la configuration" n'est pas totalement inmodifiable, ce ne sont que des valeurs par défaut pour certaines configurations.
Mais les utilisateurs n'ont pas besoin de modifier ces contenus convenus, sauf si cela est nécessaire.
La structure de stockage de fichiers par défaut de maven est la suivante :
/Répertoire du projet
pom.xml Fichier de configuration pour maven /src répertoire de code source
/src/main Répertoire du code source du projet
/src/main/java Répertoire du code source java du projet
/ src/main/resource répertoire des ressources du projet
/src/test répertoire des tests unitaires
/src/test/java
Répertoire de sortie /target, toutes les sorties sont stockées dans ce répertoire
/target/classes fichier de classe compilé
Chaque étape de la tâche sait accomplir correctement son travail.
Par exemple, la tâche de compilation sait compiler tous les fichiers Java de src/main/java et stocker ses fichiers de classe de sortie dans target/classes.
L'adoption de la stratégie de « convention plutôt que de configuration » peut réduire la charge de travail de modification des configurations et réduire les coûts d'apprentissage. Plus important encore, elle introduit des spécifications unifiées dans le projet.
<groupId>org.springframework</groupId> <artifactId>spring-webmvc</artifactId> <version>4.3.7.RELEASE</version>
Maven utilise 4 éléments pour localiser de manière unique une certaine sortie : groupId:artifactId:packaging:version. Tel que org.springframework:spring:2.5.
groupId Groupe, entreprise, groupe, organisation, projet ou autre groupe. La convention pour un ID de groupe est qu'il commence par le nom de domaine inversé de l'organisation qui a créé le projet.
artefactId sous groupId représente l'identifiant unique d'un seul projet. Par exemple, notre matou, commons, etc. N'incluez pas de point (.) dans artificialId.
version Une version spécifique d'un projet. Les projets de version ont un identifiant de version fixe qui pointe vers une version spécifique du projet.
Bien que le format de packaging du projet soit également une partie importante des coordonnées Maven, il ne fait pas partie de l'identifiant unique du projet.
Le groupId:artifactId:version d'un projet en fait un projet unique ; vous ne pouvez pas avoir un projet avec les mêmes identifiants de groupe, d'artefact et de version en même temps.
packaging Le type de projet, la valeur par défaut est jar, qui décrit le résultat du projet après packaging.
maven peut utiliser plusieurs chaînes spéciales SNAPSHOT, LATEST, RELEASE lors de la gestion des versions.
Par exemple, "1.0-SNAPSHOT". La signification et la logique de traitement de chaque partie sont les suivantes :
INSTANTANÉ : est utilisé dans le processus de développement, Maven installera ou publiera ce composant Lorsque vous développez le symbole en une valeur de date et d'heure, convertissez-le en heure UTC.
Par exemple, "1.0-SNAPSHOT" deviendra 1.0-20100505-141000-1 lors de sa sortie à 14h10 le 5 mai 2010.
DERNIÈRE : fait référence à la dernière version d'un composant spécifique. Cette version peut être une version finale ou une version instantanée, selon l'heure de la dernière.
VERSION : fait référence à la dernière version.
Personnellement, je pense à la gestion des dépendances est maven La fonctionnalité la plus intéressante est qu'elle permet aux développeurs de se concentrer uniquement sur les dépendances directes du code.
Par exemple, si nous utilisons spring, ajoutez simplement la description de la dépendance spring. Quant aux éléments externes dont dépend Spring lui-même, maven peut nous aider.
Toute description de dépendance externe contient les éléments suivants : groupId,artefactId, version, scope, type, facultatif. Les trois premiers sont obligatoires et leurs significations respectives sont les suivantes :
La version ici peut être exprimée par des expressions d'intervalle, telles que (2.0,) signifie >2.0, [2.0,3.0 ) Indique 2.0<=ver<3.0 ; plusieurs conditions sont séparées par des virgules, telles que [1,3),[5,7].
Maven estime que les dépendances externes du programme changeront avec l'étape et le scénario d'application du programme, de sorte que les dépendances dans Maven sont limitées par leur portée.
scope contient les valeurs suivantes :
compile (compile scope) ---> compile est la valeur par défaut scope, les dépendances de portée de compilation sont disponibles sur tous les chemins de classe et elles sont également empaquetées.
fourni (portée fournie) ---> la dépendance fournie n'est utilisée que lorsque le JDK ou un conteneur a fourni la dépendance.
Par exemple, si vous développez une application Web, vous avez besoin de l'API Servlet disponible dans le chemin de classe de compilation pour compiler le servlet, mais vous ne souhaitez pas inclure cette API Servlet dans le package. GUERRE.
runtime（运行时范围 --> runtime 依赖在运行和测试系统的时候需要，但在编译的时候不需要。
比如你可能在编译的时候只需要 JDBC API JAR，而只有在运行的时候才需要 JDBC 驱动实现。
test（测试范围）--> test 范围依赖 在一般的 编译和运行时都不需要，它们只有在测试编译和测试运行阶段可用。
system（系统范围） --> system 范围依赖与 provided 类似，但是你必须显式的提供一个对于本地系统中 JAR 文件的路径。
<dependency> <groupId>org.wltea</groupId> <artifactId>analyzer</artifactId> <version>2012_u6</version> <scope>system</scope> <systemPath>${project.basedir}/src/main/webapp/WEB-INF/lib/analyzer-2012_u6.jar</systemPath> </dependency>注意该范围是不推荐使用的（你应该一直尽量去从公共或定制的Maven仓库中引用依赖）。
type 一般在pom引用依赖时候出现，其他时候不用， optional 是否可选依赖。
依赖也可以是可选的，比如我们代码中没有任何cache依赖，但是hibernate可能要配置cache，所以该cache的依赖就是可选的。
maven的多项目管理也是非常强大的。一般来说，maven要求同一个工程的所有子项目都放置到同一个目录下，每一个子目录代表一个项目，比如
总项目/ pom.xml 总项目的 pom 配置文件
子项目1/pom.xml 子项目1的 pom 文件
子项目2/ pom.xml 子项目2的 pom 文件
按照这种格式存放，就是继承方式，所有具体子项目的pom.xml都会继承总项目pom的内容，取值为子项目pom内容优先。
要设置继承方式，首先要在总项目的pom中加入如下配置
<modules> <module>simple-weather</module> <module>simple-webapp</module> </modules>
其次在每个子项目中加入
<parent> <groupId>org.sonatype.mavenbook.ch06</groupId> <artifactId>simple-parent</artifactId> <version>1.0</version> </parent>
当然，继承不是唯一的配置文件共用方式，maven还支持引用方式。引用pom的方式更简单，在依赖中加入一个type为pom的依赖即可。
<dependency> <groupId>org.sonatype.mavenbook</groupId> <artifactId>persistence-deps</artifactId> <version>1.0</version> <type>pom</type> </dependency>
用户可以在maven中定义一些属性，然后在其他地方用${xxx}进行引用。比如：
value1
maven 提供了三个隐式的变量，用来访问系统环境变量、POM信息和 maven 的 settings：
env 暴露操作系统的环境变量，比如 env.PATH
project 暴露 POM 中的内容，用点号(.)的路径来引用POM元素的值，比如 ${project.artifactId}。另外，java的系统属性比如user.dir等，也暴露在这里。
settings 暴露 maven 的 settings 的信息，也可以用点号(.)来引用。
profile 是 maven 的一个重要特性，它可以让 maven 能够自动适应外部的环境变化。
比如同一个项目，在linux下编译linux的版本，在win下编译win的版本等。
一个项目可以设置多个 profile，也可以在同一时间设置多个 profile 被激活（active）的。
自动激活的 profile 的条件可以是各种各样的设定条件，组合放置在 activation 节点中，也可以通过命令行直接指定。
profile 包含的其他配置内容可以覆盖掉 pom 定义的相应值。
如果认为 profile 设置比较复杂，可以将所有的 profiles 内容移动到专门的 profiles.xml 文件中，不过记得和 pom.xml 放在一起。
maven的主执行程序为 mvn.bat，linux下为mvn.sh，这两个程序都很简单，它们的共同用途就是收集一些参数，然后用 java.exe来运行maven的Main函数。
maven 同样需要有配置文件，名字叫做 settings.xml，它放在两个地方，一个是 maven 安装目录的conf目录下，对所有使用该 maven 的用户都起作用。
我们称为主配置文件，另外一个放在 %USERPROFILE%/.m2/settings.xml 下，我们成为用户配置文件，只对当前用户有效，且可以覆盖主配置文件的参数内容。
还有就是项目级别的配置信息了，它存放在每一个 maven 管理的项目目录下，叫 pom.xml，主要用于配置项目相关的一些内容。
当然，如果有必要用户也可以在 pom 中写一些配置，覆盖住配置文件和用户配置文件的设置参数内容。
一般来说，settings文件配置的是比如repository库路径之类的全局信息，具体可以参考官方网站的文章。
在maven中一般都会用到安装库文件的功能，一则是我们常用的hibernate要使用jmx库，但是因为sun的license限制，所以无法将其直接包含在repository中。
所以我们使用mvn命令把jar安装到我们本地的repository中
mvn install:install-file -DgroupId=com.sun.jdmk -DartifactId=jmxtools -Dversion=1.2.1 -Dpackaging=jar -Dfile=/path/to/file
如果我们想把它安装到公司的repository中，需要使用命令
mvn deploy:deploy-file -DgroupId=com.sun.jdmk -DartifactId=jmxtools -Dversion=1.2.1 -Dpackaging=jar -Dfile=/path/to/file -Durl= -DrepositoryId=release-repo
对于我们的工程输出，如果需要放置到公司的repository中的话，可以通过配置 pom 来实现
<distributionManagement> <repository> <id>mycompany-repository</id> <name>MyCompany Repository</name> <url>scp://repository.mycompany.com/repository/maven2</url> </repository> </distributionManagement>
1. 创建Maven的普通java项目： mvn archetype:create -DgroupId=packageName -DartifactId=projectName 2. 创建Maven的Web项目： mvn archetype:create -DgroupId=packageName -DartifactId=webappName -DarchetypeArtifactId=maven-archetype-webapp 3. 编译源代码： mvn compile 4. 编译测试代码：mvn test-compile 5. 运行测试：mvn test 6. 产生site：mvn site 7. 打包：mvn package 8. 在本地Repository中安装jar：mvn install 9. 清除产生的项目：mvn clean 10. 生成eclipse项目：mvn eclipse:eclipse 11. 生成idea项目：mvn idea:idea 12. 组合使用goal命令，如只打包不测试：mvn -Dtest package 13. 编译测试的内容：mvn test-compile 14. 只打jar包: mvn jar:jar 15. 只测试而不编译，也不测试编译：mvn test -skipping compile -skipping test-compile ( -skipping 的灵活运用，当然也可以用于其他组合命令) 16. 清除eclipse的一些系统设置:mvn eclipse:clean
Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!
Oracle ajoute une méthode de déclenchement
qu'est-ce que JavaWeb
Que signifie DHCP ?
Comment ouvrir le format json
Quelles sont les fonctions de fenêtrage ?
Une seule page Word change l'orientation du papier
Comment créer un clone WeChat sur un téléphone mobile Huawei
Méthode de contrôle du moteur pas à pas
![[Web front-end] Démarrage rapide de Node.js](https://img.php.cn/upload/course/000/000/067/662b5d34ba7c0227.png)
