Maven 简明教程
Maven - Overview
What is Maven?
Maven 是一种项目管理和理解工具，为开发人员提供了完整的构建生命周期框架。开发团队几乎可以在很短的时间内自动执行项目的构建基础设施，因为 Maven 使用了标准目录布局和默认构建生命周期。
在涉及多个开发团队的环境中，Maven 可以迅速建立按照标准工作的方式。由于大部分项目设置简单可重复利用，Maven 在创建报告、检查、构建和测试自动化设置时，简化了开发人员的工作。
Maven 为开发人员提供了管理以下内容的方式：
-
Builds
-
Documentation
-
Reporting
-
Dependencies
-
SCMs
-
Releases
-
Distribution
-
Mailing list
总结来说，Maven 简化并标准化了项目构建过程。它无缝处理编译、分发、文档编制、团队协作及其他任务。Maven 提高了可重复利用性，并负责大部分与构建相关的任务。
Maven Evolution
Maven 最初设计目的是简化 Jakarta Turbine 项目中的构建流程。它包含多个项目，每个项目都包含稍有不同的 ANT 构建文件。JAR 已签入 CVS。
Apache 小组随后开发了 Maven ，它可以同时构建多个项目，发布项目信息，部署项目，在多个项目中共享 JAR，并协助团队协作。
Objective
Maven 的主要目标是为开发人员提供以下内容：
-
一个全面、可重复利用、可维护且易于理解的项目模型。
-
与此声明模型相交互的插件或工具。
Maven 项目结构和内容在 XML 文件 pom.xml 中声明，该文件称为项目对象模型 (POM)，它是整个 Maven 系统的基本单元。在后续章节中，我们将详细解释 POM。
Convention over Configuration
Maven 在 Convention 上使用 Configuration ，这意味着开发人员无需自己创建构建流程。
开发人员不必提及每个配置详情。Maven 为项目提供了可行的默认行为。当创建 Maven 项目时，Maven 将创建默认项目结构。开发人员只需要相应放置文件，而无需在 pom.xml 中定义任何配置。
例如，下一表格显示了项目源代码文件、资源文件和其他配置的默认值。假设 ${basedir} 表示项目位置 -
Item |
Default |
source code |
${basedir}/src/main/java |
Resources |
${basedir}/src/main/resources |
Tests |
${basedir}/src/test |
Complied byte code |
${basedir}/target |
distributable JAR |
${basedir}/target/classes |
为了构建项目，Maven 为开发人员提供了提及生命周期目标和项目依赖项的选项（依赖于 Maven 插件功能及其默认约定）。大部分项目管理和构建相关任务均由 Maven 插件维护。
开发人员可以构建任何 Maven 项目，而无需理解各个插件的工作方式。我们在后续章节中将详细讨论 Maven 插件。
Features of Maven
-
遵循最佳实践的简单项目设置。
-
在所有项目中一致使用。
-
依赖项管理，包括自动更新。
-
大型且愈发丰富的库存储库。
-
可扩展，能够在 Java 或脚本语言中轻松编写插件。
-
几乎不需额外配置即可即时访问新功能。
-
Model-based builds − Maven 能够将任意数量的项目构建成 jar、war、metadata 等预定义的输出类型。
-
Coherent site of project information − Maven 能够根据构建过程中的元数据生成网站和 PDF，包括完整的文档。
-
Release management and distribution publication − 无需额外配置，Maven 便会整合 CVS 等源代码管理系统，并管理项目的发布。
-
Backward Compatibility − 您能轻松地将某个项目的多个模块从旧版 Maven 移植到 Maven 3。它也可支持旧版本。
-
Automatic parent versioning − 无需在维护的子模块中指定父级。
-
Parallel builds − 它分析项目依赖图并使您能够并行构建调度模块。利用此功能，您可提高 20-50% 的性能。
-
Better Error and Integrity Reporting − Maven 改进了错误报告，并为您提供指向 Maven Wiki 页面的链接，以便您获取错误的完整描述。
Maven - Environment Setup
Step 1: Verify Java Installation in Your Machine
首先，打开控制台并根据您正在使用的操作系统执行 java 命令。
OS |
Task |
Command |
Windows |
Open Command Console |
c:> java -version |
Linux |
Open Command Terminal |
$ java -version |
Mac |
Open Terminal |
machine:< joseph$ java -version |
让我们验证所有操作系统的输出 −
OS |
Output |
Windows |
java 11.0.11 2021-04-20 LTSJava™ SE Runtime Environment 18.9 (build 11.0.11+9-LTS-194)Java HotSpot™ 64-Bit Server VM 18.9 (build 11.0.11+9-LTS-194, mixed mode) |
Linux |
java 11.0.11 2021-04-20 LTSJava™ SE Runtime Environment 18.9 (build 11.0.11+9-LTS-194)Java HotSpot™ 64-Bit Server VM 18.9 (build 11.0.11+9-LTS-194, mixed mode) |
Mac |
java 11.0.11 2021-04-20 LTSJava™ SE Runtime Environment 18.9 (build 11.0.11+9-LTS-194)Java HotSpot™ 64-Bit Server VM 18.9 (build 11.0.11+9-LTS-194, mixed mode) |
如果你尚未在你的系统中安装 Java，那么从以下链接下载 Java 软件开发套件 (SDK) http://www.oracle.com 。对于本教程，我们假设已安装 Java 11.0.11 作为版本。
Step 2: Set JAVA Environment
将 JAVA_HOME 环境变量设置为您计算机中安装 Java 的基本目录位置。例如。
OS |
Output |
Windows |
将环境变量 JAVA_HOME 设置为 C:\Program Files\Java\jdk11.0.11 |
Linux |
export JAVA_HOME = /usr/local/java-current |
Mac |
export JAVA_HOME = /Library/Java/Home |
在系统路径中追加 Java 编译器位置。
OS |
Output |
Windows |
在系统变量 Path 的末尾追加字符串 C:\Program Files\Java\jdk11.0.11\bin 。 |
Linux |
export PATH = $PATH:$JAVA_HOME/bin/ |
Mac |
not required |
如上所述，使用命令 java -version 验证 Java 安装。
Step 3 - Download Maven Archive
从 https://maven.apache.org/download.cgi 下载 Maven 3.8.4。
OS |
Archive name |
Windows |
apache-maven-3.8.4-bin.zip |
Linux |
apache-maven-3.8.4-bin.tar.gz |
Mac |
apache-maven-3.8.4-bin.tar.gz |
Step 4 - Extract the Maven Archive
将存档解压到要安装 Maven 3.8.4 的目录。存档将创建一个子目录 apache-maven-3.8.4。
OS |
位置（根据你的安装而异） |
Windows |
C:\Program Files\Apache Software Foundation\apache-maven-3.8.4 |
Linux |
/usr/local/apache-maven |
Mac |
/usr/local/apache-maven |
Step 5 - Set Maven Environment Variables
将 M2_HOME、M2、MAVEN_OPTS 添加到环境变量。
OS |
Output |
Windows |
使用系统属性设置环境变量。M2_HOME=C:\Program Files\Apache Software Foundation\apache-maven-3.8.4 M2=%M2_HOME%\bin MAVEN_OPTS=-Xms256m -Xmx512m |
Linux |
打开命令终端并设置环境变量。 export M2_HOME=/usr/local/apache-maven/apache-maven-3.8.4 export M2=$M2_HOME/bin export MAVEN_OPTS=-Xms256m -Xmx512m |
Mac |
打开命令终端并设置环境变量。export M2_HOME=/usr/local/apache-maven/apache-maven-3.8.4export M2=$M2_HOME/bin export MAVEN_OPTS=-Xms256m -Xmx512m |
Step 6 - Add Maven bin Directory Location to System Path
现在将 M2 变量附加到系统路径。
OS |
Output |
Windows |
将字符串 ;%M2% 附加到系统变量 Path 的末尾。 |
Linux |
export PATH=$M2:$PATH |
Mac |
export PATH=$M2:$PATH |
Step 7 - Verify Maven Installation
现在打开控制台并执行以下 mvn 命令。
OS |
Task |
Command |
Windows |
Open Command Console |
c:> mvn --version |
Linux |
Open Command Terminal |
$ mvn --version |
Mac |
Open Terminal |
machine:~ joseph$ mvn --version |
最后，验证上述命令的输出，其应如下所示 −
OS |
Output |
Windows |
Apache Maven 3.8.4 (9b656c72d54e5bacbed989b64718c159fe39b537)Maven 主目录：C:\Program Files\Apache Software Foundation\apache-maven-3.8.4Java 版本：11.0.11，供应商：Oracle Corporation，运行时：C:\Program Files\Java\jdk11.0.11\默认语言环境：en_IN，平台编码：Cp1252操作系统名称：“windows 10”，版本：“10.0”，体系结构：“amd64”，系列：“windows” |
Linux |
Apache Maven 3.8.4 (9b656c72d54e5bacbed989b64718c159fe39b537)Java 版本：11.0.11Java 主目录：/usr/local/java-current/jre |
Mac |
Apache Maven 3.8.4 (9b656c72d54e5bacbed989b64718c159fe39b537)Java 版本：11.0.11Java 主目录：/Library/Java/Home/jre |
Maven - POM
POM 是 Project Object Model 的缩写。它是 Maven 中基本的工作单元。它是一个 XML 文件，作为 pom.xml 位于项目的根目录中。
POM 包含有关项目的信息，以及用于 Maven 构建项目的各种配置细节。
POM 还包含目标和插件。在执行任务或目标时，Maven 会在当前目录中寻找 POM。它读取 POM，获取所需的配置信息，然后执行目标。可以在 POM 中指定的一些配置如下 −
-
project dependencies
-
plugins
-
goals
-
build profiles
-
project version
-
developers
-
mailing list
在创建 POM 之前，我们应该首先确定项目的 group (groupId)、其 name (artifactId) 及其版本，因为这些属性有助于在存储库中唯一地识别项目。
POM Example
<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>请注意，每个项目应该有一个 POM 文件。
-
所有 POM 文件都需要 project 元素和三个强制性字段： groupId, artifactId, version 。
-
存储库中的项目表示法为 groupId:artifactId:version 。
-
POM 的最低要求 −
Sr.No. |
Node & Description |
1 |
Project root 这是项目根标记。您需要指定基本架构设置，例如 apache 架构和 w3.org 规范。 |
2 |
Model version 模型版本应为 4.0.0。 |
3 |
groupId 这是项目组的 ID。对于某个组织或项目而言，此 ID 通常是唯一的。例如，银行集团 com.company.bank 拥有所有与银行相关的项目。 |
4 |
artifactId 这是项目的 Id。这通常是项目的名称。例如，consumer-banking。与 groupId 一起，artifactId 定义了仓库中该构件的位置。 |
5 |
version 这是项目的版本。与 groupId 一起，它用于仓库中一个构件中将不同的版本彼此分开。例如 − com.company.bank:consumer-banking:1.0 com.company.bank:consumer-banking:1.1. |
Super POM
超级 POM 是 Maven 的默认 POM。所有 POM 都继承自一个父 POM 或默认 POM（明确定义或未明确定义）。这个基本 POM 被称为 Super POM ，并包含默认继承的值。
Maven 使用生效 POM（超级 POM 的配置加上项目配置）来执行相关的目标。这有助于开发者在其 pom.xml 中指定最少的配置详情。尽管可以轻松地覆盖配置。
通过运行以下命令，可以轻松查看超级 POM 的默认配置： mvn help:effective-pom
在计算机的任何目录中创建一个 pom.xml。使用上面提到的示例 pom 的内容。
在以下示例中，我们在 C:\MVN\project 文件夹中创建了一个 pom.xml。
现在打开命令控制台，转到包含 pom.xml 的文件夹并执行以下 mvn 命令。
C:\MVN\project>mvn help:effective-pomMaven 将开始处理并显示 effective-pom。
C:\MVN>mvn help:effective-pom
[INFO] Scanning for projects...
[INFO]
[INFO] ---------------< com.companyname.project-group:project >----------------
[INFO] Building project 1.0
[INFO] --------------------------------[ jar ]---------------------------------
[INFO]
[INFO] --- maven-help-plugin:3.2.0:effective-pom (default-cli) @ project ---
[INFO]
Effective POMs, after inheritance, interpolation, and profiles are applied:
[INFO] ------------------------------------------------------------------------
[INFO] BUILD SUCCESS
[INFO] ------------------------------------------------------------------------
[INFO] Total time: 2.261 s
[INFO] Finished at: 2021-12-10T19:54:53+05:30
[INFO] ------------------------------------------------------------------------
C:\MVN>在应用继承、插入和配置文件后，Effective POM 显示为控制台的结果。
<?xml version="1.0" encoding="Cp1252"?>
<!-- ====================================================================== -->
<!-- -->
<!-- Generated by Maven Help Plugin on 2021-12-10T19:54:52+05:30 -->
<!-- See: http://maven.apache.org/plugins/maven-help-plugin/ -->
<!-- -->
<!-- ====================================================================== -->
<!-- ====================================================================== -->
<!-- -->
<!-- Effective POM for project -->
<!-- 'com.companyname.project-group:project: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 https://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>
<repositories>
<repository>
<snapshots>
<enabled>false</enabled>
</snapshots>
<id>central</id>
<name>Central Repository</name>
<url>https://repo.maven.apache.org/maven2</url>
</repository>
</repositories>
<pluginRepositories>
<pluginRepository>
<releases>
<updatePolicy>never</updatePolicy>
</releases>
<snapshots>
<enabled>false</enabled>
</snapshots>
<id>central</id>
<name>Central Repository</name>
<url>https://repo.maven.apache.org/maven2</url>
</pluginRepository>
</pluginRepositories>
<build>
<sourceDirectory>C:\MVN\src\main\java</sourceDirectory>
<scriptSourceDirectory>C:\MVN\src\main\scripts</scriptSourceDirectory>
<testSourceDirectory>C:\MVN\src\test\java</testSourceDirectory>
<outputDirectory>C:\MVN\target\classes</outputDirectory>
<testOutputDirectory>C:\MVN\target\test-classes</testOutputDirectory>
<resources>
<resource>
<directory>C:\MVN\src\main\resources</directory>
</resource>
</resources>
<testResources>
<testResource>
<directory>C:\MVN\src\test\resources</directory>
</testResource>
</testResources>
<directory>C:\MVN\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-5</version>
</plugin>
<plugin>
<artifactId>maven-dependency-plugin</artifactId>
<version>2.8</version>
</plugin>
<plugin>
<artifactId>maven-release-plugin</artifactId>
<version>2.5.3</version>
</plugin>
</plugins>
</pluginManagement>
<plugins>
<plugin>
<artifactId>maven-clean-plugin</artifactId>
<version>2.5</version>
<executions>
<execution>
<id>default-clean</id>
<phase>clean</phase>
<goals>
<goal>clean</goal>
</goals>
</execution>
</executions>
</plugin>
<plugin>
<artifactId>maven-resources-plugin</artifactId>
<version>2.6</version>
<executions>
<execution>
<id>default-testResources</id>
<phase>process-test-resources</phase>
<goals>
<goal>testResources</goal>
</goals>
</execution>
<execution>
<id>default-resources</id>
<phase>process-resources</phase>
<goals>
<goal>resources</goal>
</goals>
</execution>
</executions>
</plugin>
<plugin>
<artifactId>maven-jar-plugin</artifactId>
<version>2.4</version>
<executions>
<execution>
<id>default-jar</id>
<phase>package</phase>
<goals>
<goal>jar</goal>
</goals>
</execution>
</executions>
</plugin>
<plugin>
<artifactId>maven-compiler-plugin</artifactId>
<version>3.1</version>
<executions>
<execution>
<id>default-compile</id>
<phase>compile</phase>
<goals>
<goal>compile</goal>
</goals>
</execution>
<execution>
<id>default-testCompile</id>
<phase>test-compile</phase>
<goals>
<goal>testCompile</goal>
</goals>
</execution>
</executions>
</plugin>
<plugin>
<artifactId>maven-surefire-plugin</artifactId>
<version>2.12.4</version>
<executions>
<execution>
<id>default-test</id>
<phase>test</phase>
<goals>
<goal>test</goal>
</goals>
</execution>
</executions>
</plugin>
<plugin>
<artifactId>maven-install-plugin</artifactId>
<version>2.4</version>
<executions>
<execution>
<id>default-install</id>
<phase>install</phase>
<goals>
<goal>install</goal>
</goals>
</execution>
</executions>
</plugin>
<plugin>
<artifactId>maven-deploy-plugin</artifactId>
<version>2.7</version>
<executions>
<execution>
<id>default-deploy</id>
<phase>deploy</phase>
<goals>
<goal>deploy</goal>
</goals>
</execution>
</executions>
</plugin>
<plugin>
<artifactId>maven-site-plugin</artifactId>
<version>3.3</version>
<executions>
<execution>
<id>default-site</id>
<phase>site</phase>
<goals>
<goal>site</goal>
</goals>
<configuration>
<outputDirectory>C:\MVN\target\site</outputDirectory>
<reportPlugins>
<reportPlugin>
<groupId>org.apache.maven.plugins</groupId>
<artifactId>maven-project-info-reports-plugin</artifactId>
</reportPlugin>
</reportPlugins>
</configuration>
</execution>
<execution>
<id>default-deploy</id>
<phase>site-deploy</phase>
<goals>
<goal>deploy</goal>
</goals>
<configuration>
<outputDirectory>C:\MVN\target\site</outputDirectory>
<reportPlugins>
<reportPlugin>
<groupId>org.apache.maven.plugins</groupId>
<artifactId>maven-project-info-reports-plugin</artifactId>
</reportPlugin>
</reportPlugins>
</configuration>
</execution>
</executions>
<configuration>
<outputDirectory>C:\MVN\target\site</outputDirectory>
<reportPlugins>
<reportPlugin>
<groupId>org.apache.maven.plugins</groupId>
<artifactId>maven-project-info-reports-plugin</artifactId>
</reportPlugin>
</reportPlugins>
</configuration>
</plugin>
</plugins>
</build>
<reporting>
<outputDirectory>C:\MVN\target\site</outputDirectory>
</reporting>
</project>在上面的 pom.xml 中，您可以看到 Maven 在执行所需目标时将使用的默认项目源文件夹结构、输出目录、所需的插件、存储库、报告目录。
也不必手动编写 Maven pom.xml。Maven 提供了许多原型插件用于创建项目，依次创建项目结构和 pom.xml。
Maven - Build Life Cycle
What is Build Lifecycle?
构建生命周期是一个定义明确的阶段序列，该序列定义了执行目标的顺序。在此，阶段表示生命周期中的一个阶段。例如，一个典型的 Maven Build Lifecycle 包含以下阶段序列。
Phase |
Handles |
Description |
prepare-resources |
resource copying |
可以在此阶段自定义资源复制。 |
validate |
Validating the information |
验证项目是否正确，以及是否提供了所有必要信息。 |
compile |
compilation |
在此阶段完成源代码编译。 |
Test |
Testing |
为适合测试框架的已编译源代码进行测试。 |
package |
packaging |
此阶段根据 POM.xml 中的打包创建 JAR/WAR 包。 |
install |
installation |
此阶段在本地/远程 maven 仓库中安装包。 |
Deploy |
Deploying |
将最终的软件包复制到远程仓库。 |
始终都有 pre 和 post 阶段来注册 goals ，这些阶段必须在特定阶段之前或之后运行。
当 Maven 开始构建项目时，它会逐步执行一系列已定义的阶段并执行目标，这些目标已注册到各个阶段。
Maven 具有以下三个标准生命周期−
-
clean
-
default(or build)
-
site
goal 表示一项有助于构建和管理项目，并可能绑定到一个或多个构建阶段的特定任务。未绑定到任何构建阶段的目标可以通过直接调用在构建生命周期之外执行。
执行顺序取决于目标和构建阶段的调用顺序。例如，考虑以下命令。 clean 和 package 参数是构建阶段，而 dependency:copy-dependencies 是目标。
mvn clean dependency:copy-dependencies package此处将首先执行 clean 阶段，然后执行 dependency:copy-dependencies goal ，最后执行 package 阶段。
Clean Lifecycle
当我们执行 mvn post-clean 命令时，Maven 将调用包含以下阶段的 clean 生命周期。
-
pre-clean
-
clean
-
post-clean
Maven clean 目标 (clean:clean) 绑定到 clean 生命周期中的 clean 阶段。它的 clean:cleangoal 通过删除构建目录来删除构建结果。因此，当执行 mvn clean 命令时，Maven 将删除构建目录。
我们可以通过在 clean 生命周期中的任何上述阶段中指定目标来自定义此行为。
在以下示例中，我们将 maven-antrun-plugin:run 目标附加到 pre-clean、clean 和 post-clean 阶段。这将允许我们回显显示 clean 生命周期各个阶段的文本消息。
我们在 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.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>现在，打开命令控制台，转到包含 pom.xml 的文件夹，并执行以下 mvn 命令。
C:\MVN\project>mvn post-cleanMaven 将开始处理并显示 clean 生命周期中的所有阶段。
C:\MVN>mvn post-clean
[INFO] Scanning for projects...
[INFO]
[INFO] ----------------< com.companyname.projectgroup:project >----------------
[INFO] Building project 1.0
[INFO] --------------------------------[ jar ]---------------------------------
[INFO]
[INFO] --- maven-antrun-plugin:1.1:run (id.pre-clean) @ project ---
[INFO] Executing tasks
[echo] pre-clean phase
[INFO] Executed tasks
[INFO]
[INFO] --- maven-clean-plugin:2.5:clean (default-clean) @ project ---
[INFO]
[INFO] --- maven-antrun-plugin:1.1:run (id.clean) @ project ---
[INFO] Executing tasks
[echo] clean phase
[INFO] Executed tasks
[INFO]
[INFO] --- maven-antrun-plugin:1.1:run (id.post-clean) @ project ---
[INFO] Executing tasks
[echo] post-clean phase
[INFO] Executed tasks
[INFO] ------------------------------------------------------------------------
[INFO] BUILD SUCCESS
[INFO] ------------------------------------------------------------------------
[INFO] Total time: 0.740 s
[INFO] Finished at: 2021-12-10T20:03:53+05:30
[INFO] ------------------------------------------------------------------------
C:\MVN>您可以尝试调整 mvn clean 命令，该命令将显示 pre-clean 和 clean。没有 post-clean 阶段将被执行。
Default (or Build) Lifecycle
这是 Maven 的主要生命周期，用于构建应用程序。它具有以下 21 个阶段。
Sr.No. |
Lifecycle Phase & Description |
1 |
validate 验证项目是否正确，以及是否可以使用完成构建过程所需的所有必要信息。 |
2 |
initialize 初始化构建状态，例如设置属性。 |
3 |
generate-sources 生成要包括在编译阶段中的所有源代码。 |
4 |
process-sources 处理源代码，例如筛选任何值。 |
5 |
generate-resources 生成要包含在程序包中的资源。 |
6 |
process-resources 将资源复制并处理到目标目录，为打包阶段做好准备。 |
7 |
compile 编译项目的源代码。 |
8 |
process-classes 后处理从编译中生成的源代码，例如，优化 Java 类中的字节码增强/优化。 |
9 |
generate-test-sources 生成要在编译阶段包含的任何测试源代码。 |
10 |
process-test-sources 处理测试源代码，例如筛选任何值。 |
11 |
test-compile 将测试源代码编译到测试目标目录。 |
12 |
process-test-classes 处理从测试代码文件编译中生成的文件。 |
13 |
test 使用合适的单元测试框架（Junit 是其中之一）运行测试。 |
14 |
prepare-package 在实际打包之前执行为准备 程序包所必需的任何操作。 |
15 |
package 获取已编译代码，并将其打包为可分发的格式，如 JAR、WAR 或 EAR 文件。 |
16 |
pre-integration-test 在执行集成测试之前执行所需的操作。例如，设置所需的测试环境。 |
17 |
integration-test 处理和部署程序包（如果需要）到可运行集成测试的环境中。 |
18 |
post-integration-test 在执行集成测试后执行所需的操作。例如，清理环境。 |
19 |
verify 运行任何检查以验证程序包有效且满足质量标准。 |
20 |
install 将程序包安装到本地存储库，该存储库可用作其他项目的本地依赖项。 |
21 |
deploy 将最终版本包复制到远程存储库中，以便与其他开发者和项目共享。 |
以下是几个与 Maven 生命周期相关的概念，值得提及：
-
当通过 Maven 命令调用某个阶段时，例如 mvn compile ，只会执行该阶段及其之前的阶段。
-
根据打包类型（JAR/WAR/EAR），不同的 Maven 目标将绑定到 Maven 生命周期不同的阶段。
在以下示例中，我们将 maven-antrun-plugin:run 目标附加到构建生命周期的几个阶段。这将允许我们通过回显文本消息来显示生命周期的阶段。
我们在 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.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>现在打开命令控制台，转到包含 pom.xml 的文件夹并执行以下 mvn 命令。
C:\MVN\project>mvn compileMaven 将开始处理并显示构建生命周期中直至编译阶段的阶段。
C:\MVN>mvn compile
[INFO] Scanning for projects...
[INFO]
[INFO] ----------------< com.companyname.projectgroup:project >----------------
[INFO] Building project 1.0
[INFO] --------------------------------[ jar ]---------------------------------
[INFO]
[INFO] --- maven-antrun-plugin:1.1:run (id.validate) @ project ---
[INFO] Executing tasks
[echo] validate phase
[INFO] Executed tasks
[INFO]
[INFO] --- maven-resources-plugin:2.6:resources (default-resources) @ project ---
[WARNING] Using platform encoding (Cp1252 actually) to copy filtered resources, i.e. build is platform dependent!
[INFO] skip non existing resourceDirectory C:\MVN\src\main\resources
[INFO]
[INFO] --- maven-compiler-plugin:3.1:compile (default-compile) @ project ---
[INFO] No sources to compile
[INFO]
[INFO] --- maven-antrun-plugin:1.1:run (id.compile) @ project ---
[INFO] Executing tasks
[echo] compile phase
[INFO] Executed tasks
[INFO] ------------------------------------------------------------------------
[INFO] BUILD SUCCESS
[INFO] ------------------------------------------------------------------------
[INFO] Total time: 3.033 s
[INFO] Finished at: 2021-12-10T20:05:46+05:30
[INFO] ------------------------------------------------------------------------
C:\MVN>Site Lifecycle
Maven Site 插件通常用于创建新文档来创建报告、部署站点等。它具有以下阶段 -
-
pre-site
-
site
-
post-site
-
site-deploy
在以下示例中，我们将 maven-antrun-plugin:run 目标附加到 Site 生命周期所有阶段。这将允许我们通过回显文本消息来显示生命周期的阶段。
我们在 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-site-plugin</artifactId>
<version>3.7</version>
</plugin>
<plugin>
<groupId>org.apache.maven.plugins</groupId>
<artifactId>maven-project-info-reports-plugin</artifactId>
<version>2.9</version>
</plugin>
<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>现在打开命令控制台，转到包含 pom.xml 的文件夹并执行以下 mvn 命令。
C:\MVN\project>mvn siteMaven 将开始处理并显示站点生命周期中直至站点阶段的阶段。
C:\MVN>mvn site
[INFO] Scanning for projects...
[INFO]
[INFO] ----------------< com.companyname.projectgroup:project >----------------
[INFO] Building project 1.0
[INFO] --------------------------------[ jar ]---------------------------------
[INFO]
[INFO] --- maven-antrun-plugin:3.0.0:run (id.pre-site) @ project ---
[INFO] Executing tasks
[WARNING] [echo] pre-site phase
[INFO] Executed tasks
[INFO]
[INFO] --- maven-site-plugin:3.7:site (default-site) @ project ---
[WARNING] Input file encoding has not been set, using platform encoding Cp1252, i.e. build is platform dependent!
[WARNING] No project URL defined - decoration links will not be relativized!
[INFO] Rendering site with org.apache.maven.skins:maven-default-skin:jar:1.2 skin.
[INFO]
[INFO] --- maven-antrun-plugin:3.0.0:run (id.site) @ project ---
[INFO] Executing tasks
[WARNING] [echo] site phase
[INFO] Executed tasks
[INFO] ------------------------------------------------------------------------
[INFO] BUILD SUCCESS
[INFO] ------------------------------------------------------------------------
[INFO] Total time: 4.323 s
[INFO] Finished at: 2021-12-10T20:22:31+05:30
[INFO] ------------------------------------------------------------------------
C:\MVN>Maven - Build Profiles
What is Build Profile?
构建配置文件是一组配置值，可用于设置或覆盖 Maven 构建的默认值。使用构建配置文件，可以针对不同环境（如生产环境与开发环境）自定义构建。
配置文件在 pom.xml 文件中使用其 activeProfiles/profiles 元素指定，并且以多种方式触发。配置文件在构建时修改 POM，并且用于向不同的目标环境提供参数（例如，开发、测试和生产环境中的数据库服务器的路径）。
Types of Build Profile
构建配置文件主要分为三种类型。
Type |
Where it is defined |
Per Project |
在项目 POM 文件中定义，即 pom.xml |
Per User |
在 Maven 设置 xml 文件 (%USER_HOME%/.m2/settings.xml) 中定义 |
Global |
在 Maven 全局设置 xml 文件 (%M2_HOME%/conf/settings.xml) 中定义 |
Profile Activation
Maven 构建配置文件可以通过多种方式激活。
-
显式地使用命令控制台输入。
-
Through maven settings.
-
基于环境变量（用户/系统变量）。
-
操作系统设置（例如，Windows 系列）。
-
Present/missing files.
Profile Activation Examples
让我们假设项目的目录结构如下 −
现在，在 src/main/resources 下，有三个特定于环境的文件 −
Sr.No. |
File Name & Description |
1 |
env.properties 未提及配置文件时使用默认配置。 |
2 |
env.test.properties 使用 test 配置文件时测试配置。 |
3 |
env.prod.properties 使用 prod 配置文件时生成配置。 |
Explicit Profile Activation
在以下示例中，我们将附加 maven-antrun-plugin:run 目标以测试阶段。这将允许我们为不同的配置文件回显文本消息。我们将使用 pom.xml 定义不同的配置文件，并将使用 maven 命令在命令台中激活配置文件。
假设我们已在 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>
<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>现在打开命令台，转到包含 pom.xml 的文件夹，并执行以下 mvn 命令。使用 -P 选项将配置文件名传递为参数。
C:\MVN\project>mvn test -PtestMaven 将开始处理并显示测试构建配置文件的结果。
C:\MVN>mvn test -Ptest
[INFO] Scanning for projects...
[INFO]
[INFO] ----------------< com.companyname.projectgroup:project >----------------
[INFO] Building project 1.0
[INFO] --------------------------------[ jar ]---------------------------------
[INFO]
[INFO] --- maven-resources-plugin:2.6:resources (default-resources) @ project ---
[WARNING] Using platform encoding (Cp1252 actually) to copy filtered resources, i.e. build is platform dependent!
[INFO] Copying 3 resources
[INFO]
[INFO] --- maven-compiler-plugin:3.1:compile (default-compile) @ project ---
[INFO] No sources to compile
[INFO]
[INFO] --- maven-resources-plugin:2.6:testResources (default-testResources) @ project ---
[WARNING] Using platform encoding (Cp1252 actually) to copy filtered resources, i.e. build is platform dependent!
[INFO] skip non existing resourceDirectory C:\MVN\src\test\resources
[INFO]
[INFO] --- maven-compiler-plugin:3.1:testCompile (default-testCompile) @ project ---
[INFO] No sources to compile
[INFO]
[INFO] --- maven-surefire-plugin:2.12.4:test (default-test) @ project ---
[INFO] No tests to run.
[INFO]
[INFO] --- maven-antrun-plugin:1.1:run (default) @ project ---
[INFO] Executing tasks
[echo] Using env.test.properties
[INFO] Executed tasks
[INFO] ------------------------------------------------------------------------
[INFO] BUILD SUCCESS
[INFO] ------------------------------------------------------------------------
[INFO] Total time: 2.011 s
[INFO] Finished at: 2021-12-10T20:29:39+05:30
[INFO] ------------------------------------------------------------------------
C:\MVN>现在作为一项练习，您可以执行以下步骤：
-
将另一个配置文件元素添加到 pom.xml 的配置文件元素（复制现有的配置文件元素并将其粘贴到配置文件元素结束的位置）。
-
将此配置文件元素的 ID 从 test 更新为 normal。
-
更新任务部分以回显 env.properties 并将 env.properties 复制到目标目录。
-
再次重复以上三个步骤，将 ID 更新为 prod 和 env.prod.properties 的任务部分。
-
就这样。现在您已准备好三个构建配置文件（normal/test/prod）。
现在打开命令台，转到包含 pom.xml 的文件夹，并执行以下 mvn 命令。使用 -P 选项将配置文件名称作为参数传递。
C:\MVN\project>mvn test -Pnormal
C:\MVN\project>mvn test -Pprod检查构建的输出以查看差异。
Profile Activation via Maven Settings
打开位于 %USER_HOME%/.m2 目录中的 Maven settings.xml 文件，其中 %USER_HOME% 表示用户主目录。如果 settings.xml 文件不存在，则创建一个新文件。
添加测试配置文件，并使用活动配置文件节点将其作为活动配置文件，如下例所示。
<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>现在打开命令台，转到包含 pom.xml 的文件夹，并执行以下 mvn 命令。不要使用 -P 选项传递配置文件名称。Maven 将显示测试配置文件成为活动配置文件的结果。
C:\MVN\project>mvn testProfile Activation via Environment Variables
现在从 maven settings.xml 中删除活动配置文件，并更新 pom.xml 中提到的测试配置文件。将 activation 元素添加到配置文件元素，如下所示。
当使用值“测试”指定系统属性"env"时，测试配置文件将触发。创建环境变量“env”，并将它的值设置为“测试”。
<profile>
<id>test</id>
<activation>
<property>
<name>env</name>
<value>test</value>
</property>
</activation>
</profile>让我们打开命令控制台，转到包含 pom.xml 的文件夹，然后执行以下 mvn 命令。
C:\MVN\project>mvn testProfile Activation via Operating System
激活元素将操作系统详细信息包含在内，如下所示。当系统是 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>现在打开命令控制台，转到包含 pom.xml 的文件夹，然后执行以下 mvn 命令。不使用 -P 选项传递配置文件名。Maven 将显示测试配置文件是处于活动状态的结果。
C:\MVN\project>mvn testProfile Activation via Present/Missing File
现在激活元素将操作系统详细信息包含在内，如下所示。当 target/generated-sources/axistools/wsdl2java/com/companyname/group 缺失时，测试配置文件将触发。
<profile>
<id>test</id>
<activation>
<file>
<missing>target/generated-sources/axistools/wsdl2java/
com/companyname/group</missing>
</file>
</activation>
</profile>现在打开命令控制台，转到包含 pom.xml 的文件夹，然后执行以下 mvn 命令。不使用 -P 选项传递配置文件名。Maven 将显示测试配置文件是处于活动状态的结果。
C:\MVN\project>mvn testMaven - Repositories
What is a Maven Repository?
在 Maven 术语中，存储库是一个存储所有项目 jar、库 jar、插件或任何其他项目特定构件的目录，Maven 可以在其中轻松使用它们。
Maven 存储库有三种类型。以下说明将介绍这三种类型的相关概念。
-
local
-
central
-
remote
Local Repository
Maven 本地存储库是计算机上的一个文件夹位置。首次运行任何 maven 命令时将创建它。
Maven 本地存储库保存项目的所有依赖项（库 jar、插件 jar 等）。运行 Maven 构建时，Maven 会自动将所有依赖项 jar 下载到本地存储库中。这有助于避免每次构建项目时引用存储在远程计算机上的依赖项。
默认情况下，Maven会在 %USER_HOME% 目录中创建 Maven 本地存储库。要覆盖默认位置，请在 %M2_HOME%\conf 目录中提供的 Maven settings.xml 文件中指定另一路径。
<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>运行 Maven 命令时，Maven 会将依赖项下载到自定义路径。
Central Repository
Maven 中央存储库是由 Maven 社区提供的存储库。它包含大量常用库。
当 Maven 在本地存储库中找不到任何依赖项时，它会使用以下 URL 在中央存储库中开始搜索： https://repo1.maven.org/maven2/
中央存储库的关键概念如下：
-
此存储库由 Maven 社区管理。
-
无需进行配置。
-
需要互联网访问才能进行搜索。
为了浏览中央 Maven 存储库的内容，Maven 社区提供了 URL − https://search.maven.org/#browse 。使用此库，开发人员可以搜索中央存储库中所有可用的库。
Remote Repository
有时，Maven 也找不到中央存储库中提到的依赖项。然后它会停止构建过程，并向控制台输出错误消息。为了防止这种情况，Maven 提供了 Remote Repository 的概念，它是开发人员自己的自定义存储库，其中包含所需的库或其他项目 jar。
例如，使用下面提到的 POM.xml，Maven 将从在同一 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>Maven Dependency Search Sequence
当我们执行 Maven 构建命令时，Maven 将按以下顺序开始查找依赖库 −
-
Step 1 − 如果未找到，则在本地存储库中搜索依赖项，然后转到步骤 2，否则执行进一步的处理。
-
Step 2 − 在中央存储库中搜索依赖项，如果未找到，且提到了远程存储库，则转到步骤 4。否则将其下载到本地存储库以供将来参考。
-
Step 3 − 如果没有提过远程存储库，Maven 会直接停止处理并抛出错误（无法找到依赖项）。
-
Step 4 − 在远程存储库中搜索依赖项，如果找到，则将其下载到本地存储库以供将来参考。否则，Maven 会停止处理并抛出错误（无法找到依赖项）。
Maven - Plugins
What are Maven Plugins?
Maven 实际上是一个插件执行框架，其中的每一项任务都是由插件执行。Maven 插件通常用于：-
-
create jar file
-
create war file
-
compile code files
-
unit testing of code
-
create project documentation
-
create project reports
一个插件通常提供一组目标，这些目标可以使用以下语法执行：-
mvn [plugin-name]:[goal-name]例如，可以通过运行以下命令，使用 maven-compiler-plugin 的 compile-goal 编译一个 Java 项目。
mvn compiler:compilePlugin Types
Maven 提供了以下两种类型的插件：-
Sr.No. |
Type & Description |
1 |
Build plugins 它们在构建过程中执行，应该在 pom.xml 的 <build/> 元素中配置。 |
2 |
Reporting plugins 它们在网站生成过程中执行，应该在 pom.xml 的 <reporting/> 元素中配置。 |
以下是几个常见插件的列表：-
Sr.No. |
Plugin & Description |
1 |
clean 在构建后清理目标。删除目标目录。 |
2 |
compiler Compiles Java source files. |
3 |
surefire 运行 JUnit 单元测试。创建测试报告。 |
4 |
jar 从当前项目构建一个 JAR 文件。 |
5 |
war 从当前项目构建一个 WAR 文件。 |
6 |
javadoc 为项目生成 Javadoc。 |
7 |
antrun 从构建的任何指定的 phase 中运行一组 ant 任务。 |
Example
我们在示例中大量使用 maven-antrun-plugin 在控制台上打印数据。参考构建配置文件章节。让我们进一步了解一下它，并在 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 命令。
C:\MVN\project>mvn cleanMaven 将开始处理并显示 clean 生命周期中的 clean phase。
C:\MVN>mvn clean
[INFO] Scanning for projects...
[INFO]
[INFO] ----------------< com.companyname.projectgroup:project >----------------
[INFO] Building project 1.0
[INFO] --------------------------------[ jar ]---------------------------------
[INFO]
[INFO] --- maven-clean-plugin:2.5:clean (default-clean) @ project ---
[INFO] Deleting C:\MVN\target
[INFO]
[INFO] --- maven-antrun-plugin:1.1:run (id.clean) @ project ---
[INFO] Executing tasks
[echo] clean phase
[INFO] Executed tasks
[INFO] ------------------------------------------------------------------------
[INFO] BUILD SUCCESS
[INFO] ------------------------------------------------------------------------
[INFO] Total time: 1.266 s
[INFO] Finished at: 2021-12-13T13:58:10+05:30
[INFO] ------------------------------------------------------------------------
C:\MVN>上述示例说明了以下几个关键概念：-
-
插件使用插件元素在 pom.xml 中指定。
-
每个插件都可以有多个目标。
-
您可以使用 phase 元素定义插件从哪里开始其处理的阶段。我们使用了 clean 阶段。
-
您可以通过将任务绑定到插件的目标来配置要执行的任务。我们已经将 echo 任务与 maven-antrun-plugin 的 run 目标进行绑定。
-
如果没有本地存储库中的插件，Maven 就会下载该插件并开始其处理。
Maven - Creating Project
Maven 使用 archetype 插件创建项目。为了创建简单的 Java 应用程序，我们将使用 maven-archetype-quickstart 插件。在下面的示例中，我们将使用 C:\MVN 文件夹创建一个基于 maven 的 java 应用程序项目。
让我们打开命令控制台，进入 C:\MVN 目录并执行以下 mvn 命令。确保在运行命令之前 C:\MVN 目录处于空状态。
C:\MVN>mvn archetype:generate
-DgroupId = com.companyname.bank
-DartifactId = consumerBanking
-DarchetypeArtifactId = maven-archetype-quickstart
-DinteractiveMode = falseMaven 将开始处理并创建完整的 Java 应用程序项目结构。
C:\MVN>mvn archetype:generate -DgroupId=com.companyname.bank -DartifactId=consumerBanking -DarchetypeArtifactId=maven-archetype-quickstart -DinteractiveMode=false
[INFO] Scanning for projects...
[INFO]
[INFO] ------------------< org.apache.maven:standalone-pom >-------------------
[INFO] Building Maven Stub Project (No POM) 1
[INFO] --------------------------------[ pom ]---------------------------------
[INFO]
[INFO] >>> maven-archetype-plugin:3.2.0:generate (default-cli) > generate-sources @ standalone-pom >>>
[INFO]
[INFO] <<< maven-archetype-plugin:3.2.0:generate (default-cli) < generate-sources @ standalone-pom <<<
[INFO]
[INFO]
[INFO] --- maven-archetype-plugin:3.2.0:generate (default-cli) @ standalone-pom ---
[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: basedir, Value: C:\MVN
[INFO] Parameter: package, Value: com.companyname.bank
[INFO] Parameter: groupId, Value: com.companyname.bank
[INFO] Parameter: artifactId, Value: consumerBanking
[INFO] Parameter: packageName, Value: com.companyname.bank
[INFO] Parameter: version, Value: 1.0-SNAPSHOT
[INFO] project created from Old (1.x) Archetype in dir: C:\MVN\consumerBanking
[INFO] ------------------------------------------------------------------------
[INFO] BUILD SUCCESS
[INFO] ------------------------------------------------------------------------
[INFO] Total time: 9.396 s
[INFO] Finished at: 2021-12-13T15:13:00+05:30
[INFO] ------------------------------------------------------------------------
C:\MVN>现在，进入 C:/MVN 目录。你将看到一个名为“消费者银行”（在 artifactId 中指定）的 Java 应用程序项目已创建。Maven 使用下面所示的标准目录布局 −
使用上述示例，我们可以了解到以下关键概念 −
Sr.No. |
Folder Structure & Description |
1 |
consumerBanking 包含 src 文件夹和 pom.xml |
2 |
src/main/java 在包结构（com/companyName/bank）下包含 Java 代码文件。 |
3 |
src/main/test 在包结构（com/companyName/bank）下包含测试 Java 代码文件。 |
4 |
src/main/resources 包含图像/属性文件（在上述示例中，我们需要手动创建此结构）。 |
如果你仔细观察，你会发现 Maven 还会创建一个示例 Java 源文件和 Java 测试文件。打开 C:\MVN\consumerBanking\src\main\java\com\companyname\bank 文件夹，你将看到 App.java。
package com.companyname.bank;
/**
* Hello world!
*
*/
public class App {
public static void main( String[] args ){
System.out.println( "Hello World!" );
}
}打开 C:\MVN\consumerBanking\src\test\java\com\companyname\bank 文件夹，查看 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 );
}
}开发人员需要按照上表中所述放置自己的文件，Maven 会处理所有与构建相关的复杂性。
在下一章中，我们将讨论如何使用 maven 构建和测试项目，即构建和测试项目。
Maven - Build & Test Project
我们在项目创建章节中学到的内容是如何使用 Maven 创建 Java 应用程序。现在，我们将了解如何构建和测试应用程序。
转到 C:/MVN 目录（你在其中创建 Java 应用程序）。打开 consumerBanking 文件夹。你将看到 POM.xml 文件，其中包含下列内容。更新它以反映当前的 Java 版本。
<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>
<properties>
<maven.compiler.source>11</maven.compiler.source>
<maven.compiler.target>11</maven.compiler.target>
</properties>
<dependencies>
<dependency>
<groupId>junit</groupId>
<artifactId>junit</artifactId>
<version>3.8.1</version>
</dependency>
</dependencies>
</project>这里你可以看到，Maven 已将 Junit 作为测试框架添加进来。在先前章节中所讨论的那样，默认情况下，Maven 会在其默认目录结构中添加源文件 App.java 和测试文件 AppTest.java 。
让我们打开命令控制台，转到 C:\MVN\consumerBanking 目录，然后执行以下 mvn 命令。
C:\MVN\consumerBanking>mvn clean packageMaven 将开始构建该项目。
C:\MVN\consumerBanking>mvn clean package
[INFO] Scanning for projects...
[INFO]
[INFO] ----------------< com.companyname.bank:consumerBanking >----------------
[INFO] Building consumerBanking 1.0-SNAPSHOT
[INFO] --------------------------------[ jar ]---------------------------------
[INFO]
[INFO] --- maven-clean-plugin:2.5:clean (default-clean) @ consumerBanking ---
[INFO] Deleting C:\MVN\consumerBanking\target
[INFO]
[INFO] --- maven-resources-plugin:2.6:resources (default-resources) @ consumerBanking ---
[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]
[INFO] --- maven-compiler-plugin:3.1:compile (default-compile) @ consumerBanking ---
[INFO] Changes detected - recompiling the module!
[WARNING] File encoding has not been set, using platform encoding Cp1252, i.e. build is platform dependent!
[INFO] Compiling 1 source file to C:\MVN\consumerBanking\target\classes
[INFO]
[INFO] --- maven-resources-plugin:2.6:testResources (default-testResources) @ consumerBanking ---
[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]
[INFO] --- maven-compiler-plugin:3.1:testCompile (default-testCompile) @ consumerBanking ---
[INFO] Changes detected - recompiling the module!
[WARNING] File encoding has not been set, using platform encoding Cp1252, i.e. build is platform dependent!
[INFO] Compiling 1 source file to C:\MVN\consumerBanking\target\test-classes
[INFO]
[INFO] --- maven-surefire-plugin:2.12.4:test (default-test) @ consumerBanking ---
[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.028 sec
Results :
Tests run: 1, Failures: 0, Errors: 0, Skipped: 0
[INFO]
[INFO] --- maven-jar-plugin:2.4:jar (default-jar) @ consumerBanking ---
[INFO] Building jar: C:\MVN\consumerBanking\target\consumerBanking-1.0-SNAPSHOT.jar
[INFO] ------------------------------------------------------------------------
[INFO] BUILD SUCCESS
[INFO] ------------------------------------------------------------------------
[INFO] Total time: 4.663 s
[INFO] Finished at: 2021-12-13T17:34:27+05:30
[INFO] ------------------------------------------------------------------------
C:\MVN\consumerBanking>你已构建自己的项目并创建了最终 jar 文件，以下是关键学习概念 −
-
我们给 maven 指定了两个目标，首先清除 target 目录 (clean)，然后将项目构建输出打包为 jar (package)。
-
打包后的 jar 可在 consumerBanking\target 文件夹中作为 consumerBanking-1.0-SNAPSHOT.jar 获得。
-
测试报告可在 consumerBanking\target\surefire-reports 文件夹中获得。
-
Maven 编译源代码文件，然后测试源代码文件。
-
然后，Maven 运行测试用例。
-
最后，Maven 创建软件包。
现在打开命令行控制台，转到 C:\MVN\consumerBanking\target\classes 目录，并执行以下 java 命令。
>java com.companyname.bank.App您将看到如下结果 −
Hello World!Adding Java Source Files
让我们看看如何在项目中添加其他 Java 文件。打开 C:\MVN\consumerBanking\src\main\java\com\companyname\bank 文件夹，其中创建名为 Util.java 的 Util 类。
package com.companyname.bank;
public class Util {
public static void printMessage(String message){
System.out.println(message);
}
}更新 App 类，使用 Util 类。
package com.companyname.bank;
/**
* Hello world!
*
*/
public class App {
public static void main( String[] args ){
Util.printMessage("Hello World!");
}
}现在打开命令行控制台，转到 C:\MVN\consumerBanking 目录，并执行以下 mvn 命令。
>mvn clean compileMaven 构建成功后，转到 C:\MVN\consumerBanking\target\classes 目录并执行以下 java 命令。
>java -cp com.companyname.bank.App您将看到如下结果 −
Hello World!Maven - External Dependencies
如你所知，Maven 使用存储库概念完成依赖管理。但如果依赖项在任何远程存储库和中央存储库中都不可用，会发生什么情况呢？Maven 使用 External Dependency 的概念为这种情况提供了答案。
例如，让我们对在“创建 Java 项目”章节中创建的项目进行以下更改。
-
将 lib 文件夹添加到 src 文件夹中。
-
将任何 jar 复制到 lib 文件夹中。我们使用了 ldapjdk.jar ，这是一个 LDAP 操作的辅助库。
现在我们的项目结构应如下所示 −
这里，您拥有自己的特定于项目的库，这是一个常见的情况，它包含 jar 文件，Maven 可能无法从任何存储库中下载这些 jar 文件。如果您的代码使用 Maven 使用此库，则 Maven 构建将失败，因为它在编译阶段无法下载或引用此库。
为了处理这种情况，让我们使用以下方法将此外部依赖项添加到 maven 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.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>查看上面的示例中 dependencies 依赖项下面的第二个依赖项元素，它明确了以下有关 External Dependency 的关键概念。
-
外部依赖项（library jar 位置）可以像其他依赖项一样在 pom.xml 中进行配置。
-
指定与库名称相同的 groupId。
-
指定与库名称相同的 artifactId。
-
Specify scope as system.
-
指定相对于项目位置的系统路径。
希望你现在已经对外部依赖项有了清晰的了解，你将能够在你的 Maven 项目中指定外部依赖项。
Maven - Project Documents
本教程将教您如何一次性创建应用程序文档。因此，让我们开始，转到 C:/MVN 目录，您已使用前面的章节中给出的示例创建了您的 Java consumerBanking 应用程序。打开 consumerBanking 文件夹并执行以下 mvn 命令。
如下所示，更新 C:\MVN\consumerBanking 文件夹中的 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.bank</groupId>
<artifactId>consumerBanking</artifactId>
<packaging>jar</packaging>
<version>1.0-SNAPSHOT</version>
<name>consumerBanking</name>
<url>http://maven.apache.org</url>
<properties>
<maven.compiler.source>11</maven.compiler.source>
<maven.compiler.target>11</maven.compiler.target>
</properties>
<build>
<plugins>
<plugin>
<groupId>org.apache.maven.plugins</groupId>
<artifactId>maven-site-plugin</artifactId>
<version>3.7</version>
</plugin>
<plugin>
<groupId>org.apache.maven.plugins</groupId>
<artifactId>maven-project-info-reports-plugin</artifactId>
<version>2.9</version>
</plugin>
</plugins>
</build>
<dependencies>
<dependency>
<groupId>junit</groupId>
<artifactId>junit</artifactId>
<version>3.8.1</version>
<scope>test</scope>
</dependency>
</dependencies>
</project>C:\MVN\consumerBanking>mvn siteMaven 将开始构建该项目。
[INFO] Scanning for projects...
[INFO]
[INFO] ----------------< com.companyname.bank:consumerBanking >----------------
[INFO] Building consumerBanking 1.0-SNAPSHOT
[INFO] --------------------------------[ jar ]---------------------------------
[INFO]
[INFO] --- maven-site-plugin:3.7:site (default-site) @ consumerBanking ---
[WARNING] Input file encoding has not been set, using platform encoding Cp1252, i.e. build is platform dependent!
[INFO] Relativizing decoration links with respect to localized project URL: http://maven.apache.org
[INFO] Rendering site with org.apache.maven.skins:maven-default-skin:jar:1.2 skin.
[INFO] ------------------------------------------------------------------------
[INFO] BUILD SUCCESS
[INFO] ------------------------------------------------------------------------
[INFO] Total time: 5.850 s
[INFO] Finished at: 2021-12-13T17:49:56+05:30
[INFO] ------------------------------------------------------------------------您的项目文档现已就绪。Maven 已在目标目录中创建了一个网站。
打开 C:\MVN\consumerBanking\target\site 文件夹。点击 index.html 可查看文档。
Maven 使用一个名为 Doxia 的文档处理引擎创建文档，该引擎可将多个源格式导入到公共文档模型中。要为您的项目编写文档，您可以在 Doxia 解析的以下几种常用格式中撰写您的内容。
Format Name |
Description |
Reference |
XDoc |
Maven 1.x 文档格式 |
|
FML |
Used for FAQ documents |
Maven - Project Templates
Maven 使用 Archetype 的概念为用户提供了非常多的不同类型的项目模板列表（614 个）。Maven 帮助用户使用以下命令快速启动新的 Java 项目。
mvn archetype:generateWhat is Archetype?
Archetype 是一个 Maven 插件，其任务是根据其模板创建项目结构。我们将在本文中使用 quickstart archetype 插件来创建简单的 Java 应用程序。
Using Project Template
让我们打开命令控制台，转到 C:\ > MVN 目录，然后执行以下 mvn 命令。
C:\MVN>mvn archetype:generateMaven 将开始处理，并将要求选择所需的模版。
C:\MVN>mvn archetype:generate
[INFO] Scanning for projects...
[INFO]
[INFO] ------------------< org.apache.maven:standalone-pom >-------------------
[INFO] Building Maven Stub Project (No POM) 1
[INFO] --------------------------------[ pom ]---------------------------------
[INFO]
[INFO] >>> maven-archetype-plugin:3.2.0:generate (default-cli) > generate-sources @ standalone-pom >>>
[INFO]
[INFO] <<< maven-archetype-plugin:3.2.0:generate (default-cli) < generate-sources @ standalone-pom <<<
[INFO]
[INFO]
[INFO] --- maven-archetype-plugin:3.2.0:generate (default-cli) @ standalone-pom ---
[INFO] Generating project in Interactive mode
[INFO] No archetype defined. Using maven-archetype-quickstart (org.apache.maven.archetypes:maven-archetype-quickstart:1.0)
Choose archetype:
1: remote -> am.ik.archetype:elm-spring-boot-blank-archetype (Blank multi project for Spring Boot + Elm)
2: remote -> am.ik.archetype:graalvm-blank-archetype (Blank project for GraalVM)
...
3021: remote -> za.co.absa.hyperdrive:component-archetype_2.12 (-)
Choose a number or apply filter (format: [groupId:]artifactId, case sensitive contains): 1843:按 Enter 键选择默认选项 (1843: maven-archetype-quickstart)
Maven 将询问模版特定版本。
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
7: 1.3
8: 1.4
Choose a number: 8:按 Enter 键选择默认选项 (8: maven-archetype-quickstart:1.4)
Maven 将询问项目详细信息。按照要求输入项目详细信息。如果提供了默认值，请按 Enter 键。你可以通过输入自己的值来覆盖它们。
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 将询问项目详细信息确认。按 Enter 键或按 Y 键。
Confirm properties configuration:
groupId: com.companyname.insurance
artifactId: health
version: 1.0-SNAPSHOT
package: com.companyname.insurance
Y:现在，Maven 将开始创建项目结构，并将显示以下内容：
[INFO] ----------------------------------------------------------------------------
[INFO] Using following parameters for creating project from Archetype: maven-archetype-quickstart:1.4
[INFO] ----------------------------------------------------------------------------
[INFO] Parameter: groupId, Value: com.companyname.insurance
[INFO] Parameter: artifactId, Value: health
[INFO] Parameter: version, Value: 1.0-SNAPSHOT
[INFO] Parameter: package, Value: com.companyname.insurance
[INFO] Parameter: packageInPathFormat, Value: com/companyname/insurance
[INFO] Parameter: package, Value: com.companyname.insurance
[INFO] Parameter: groupId, Value: com.companyname.insurance
[INFO] Parameter: artifactId, Value: health
[INFO] Parameter: version, Value: 1.0-SNAPSHOT
[INFO] Project created from Archetype in dir: C:\MVN\health
[INFO] ------------------------------------------------------------------------
[INFO] BUILD SUCCESS
[INFO] ------------------------------------------------------------------------
[INFO] Total time: 04:44 min
[INFO] Finished at: 2021-12-13T18:52:59+05:30
[INFO] ------------------------------------------------------------------------Created Project
现在，转到 C:\ > MVN 目录。你将看到一个名为 health 的 Java 应用程序项目，即在创建项目时提供的 artifactId 。Maven 将为该项目创建如下所示的标准目录布局 −
Created POM.xml
Maven 为该项目生成了一个 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.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>Created App.java
Maven 为该项目生成了一个示例 Java 源文件 App.java，如下所示 −
位置： 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!" );
}
}Created AppTest.java
Maven 为该项目生成了一个示例 Java 源代码测试文件 AppTest.java，如下所示 −
位置： 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 );
}
}你现在可以看到 Maven 的强大功能。你可以在 maven 中使用单个命令创建任何类型的项目，并且立即启动你的开发。
Different Archetypes
Sr.No. |
Archetype ArtifactIds & Description |
1 |
maven-archetype-archetype archetype，其中包含示例 archetype。 |
2 |
maven-archetype-j2ee-simple archetype，其中包含一个简化示例 J2EE 应用程序。 |
3 |
maven-archetype-mojo archetype，其中包含一个示例 Maven 插件。 |
4 |
maven-archetype-plugin archetype，其中包含一个示例 Maven 插件。 |
5 |
maven-archetype-plugin-site archetype，其中包含一个示例 Maven 插件网站。 |
6 |
maven-archetype-portlet archetype，其中包含一个示例 JSR-268 小部件。 |
7 |
maven-archetype-quickstart archetype，其中包含一个示例 Maven 项目。 |
8 |
maven-archetype-simple archetype，其中包含一个简单的 Maven 项目。 |
9 |
maven-archetype-site archetype，其中包含一个示例 Maven 网站，用于展示一些受支持的文档类型（如 APT、XDoc 和 FML）并展示如何将你的网站国际化。 |
10 |
maven-archetype-site-simple archetype，其中包含一个示例 Maven 网站。 |
11 |
maven-archetype-webapp archetype，其中包含一个示例 Maven Webapp 项目。 |
Maven - Snapshots
大型软件应用程序通常包含多个模块，在多个团队处理同一应用程序的不同模块时，这种情况很常见。例如，假设有一个团队正在处理应用程序的前端，作为 app-ui 项目（app-ui.jar:1.0），并且他们正在使用 data-service 项目（data-service.jar:1.0）。
现在可能发生的情况是，负责 data-service 的团队正在快速修复 bug 或进行增强，他们几乎每隔一天就会向远程存储库发布库。
现在，如果 data-service 团队每隔一天上传一个新版本，那么将会出现以下问题 −
-
data-service 团队应在每次发布更新代码后告知 app-ui 团队。
-
app-ui 团队需要定期更新其 pom.xml 以获取更新的版本。
为了处理此类情况， SNAPSHOT 的概念便应运而生。
What is SNAPSHOT?
SNAPSHOT 是一个特殊版本，它表示当前开发副本。与常规版本不同，Maven 会在远程存储库中为每次构建检查新的 SNAPSHOT 版本。
现在，data-service 团队将每次向存储库发布更新的代码的 SNAPSHOT，比如 data-service:1.0-SNAPSHOT，替换旧的 SNAPSHOT jar。
Snapshot vs Version
对于版本，如果 Maven 曾经下载过提到的版本，比如 data-service:1.0，它将永远不会尝试下载存储库中可用的较新的 1.0。要下载更新的代码，data-service 版本应升级到 1.1。
对于 SNAPSHOT，Maven 将每次 app-ui 团队构建其项目时自动获取最新的 SNAPSHOT（data-service:1.0-SNAPSHOT）。
app-ui pom.xml
app-ui 项目使用 data-service 1.0-SNAPSHOT。
<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>data-service pom.xml
data-service 项目对每一次轻微的变更发布1.0-SNAPSHOT。
<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>尽管对于 SNAPSHOT，Maven 会在每天自动提取最新的 SNAPSHOT，但你可以通过任何 Maven 命令使用 -U 转换强制 Maven 下载最新的快照构建。
mvn clean package -U让我们打开命令控制台，进入 C:\ > MVN > app-ui 目录并执行以下 mvn 命令。
C:\MVN\app-ui>mvn clean package -UMaven 会在下载 data-service 的最新 SNAPSHOT 后开始构建项目。
[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]------------------------------------------------------------------------Maven - Build Automation
构建自动化定义了依赖项目构建过程在项目构建成功完成后启动的方案，以确保依赖项目稳定。
Example
考虑一个团队正在开发一个项目 bus-core-api ，另两个项目 app-web-ui 和 app-desktop-ui 依赖于该项目。
app-web-ui 项目正在使用 bus-core-api 项目的 1.0-SNAPSHOT。
<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 项目正在使用 bus-core-api 项目的 1.0-SNAPSHOT。
<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 项目 -
<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>现在， app-web-ui 和 app-desktop-ui 项目的团队要求只要 bus-core-api 项目发生更改，就应启动他们的构建过程。
使用快照可确保使用最新的 bus-core-api 项目，但为了满足上述要求，我们需要做一些额外的事情。
我们可以采用以下两种方式进行：
-
在 bus-core-api pom 中添加一个构建后目标，以启动 app-web-ui 和 app-desktop-ui 构建。
-
使用诸如 Hudson 的连续集成 (CI) 服务器来自动管理构建自动化。
Using Maven
更新 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>
<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>让我们打开命令控制台，转到 C:\ > MVN > bus-core-api 目录并执行以下 mvn 命令。
>mvn clean package -UMaven 将开始构建 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] ------------------------------------------------------------------bus-core-api 构建成功后，Maven 将开始构建 app-web-ui 项目。
[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] ------------------------------------------------------------------app-web-ui 构建成功后，Maven 将开始构建 app-desktop-ui 项目。
[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] -------------------------------------------------------------------Using Continuous Integration Service with Maven
开发人员更倾向于使用 CI 服务器。每当添加一个新项目（例如 app-mobile-ui）时，都不需要更新 bus-core-api 项目，因为该项目是 bus-core-api 项目的依赖项目。Hudson 是一种用 Java 编写的持续集成工具，它包含在一个 servlet 容器中，例如 Apache tomcat 和 glassfish 应用服务器。Hudson 使用 Maven 依赖管理自动管理构建自动化。以下快照将定义 Hudson 工具的角色。
Hudson 将每个项目构建视为作业。一旦将项目代码检入到 SVN（或映射到 Hudson 的任何源管理工具）中，Hudson 就会开始其构建作业，一旦此作业完成，它会自动开始其他依赖作业（其他依赖项目）。
在上面的示例中，当 bus-core-ui 源代码在 SVN 中更新时，Hudson 就会开始其构建。构建成功后，Hudson 会自动查找依赖项目，并开始构建 app-web-ui 和 app-desktop-ui 项目。
Maven - Manage Dependencies
Maven 的核心功能之一是依赖项管理。一旦我们开始处理多模块项目（包含数百个模块/子项目），那么管理依赖项就会成为一项困难的任务。Maven 提供了高度的控制来管理此类场景。
Transitive Dependencies Discovery
通常一种情况是，一个库（例如 A）依赖于另一个库（例如 B）。如果另一个项目 C 要使用 A，那么该项目需要使用库 B。
Maven 帮助避免此类要求以发现所有必需的库。Maven 通过读取依赖项的项目文件 (pom.xml)、找出它们的依赖项等来做到这一点。
我们只需要在每个项目 pom 中定义直接依赖。Maven 会自动处理其余部分。
使用传递依赖项，包含的库的图形可能会迅速增长到很大程度。当出现重复库时，可能会出现这种情况。Maven 提供了一些功能来控制传递依赖项的范围。
Sr.No. |
Feature & Description |
1 |
Dependency mediation 确定当遇到某个构件的多个版本时要使用哪个版本的依赖项。如果两个依赖项版本在依赖项树中的深度相同，则将使用第一个声明的依赖项。 |
2 |
Dependency management 当依赖项以传递依赖项的形式出现时，直接指定要使用的构件的版本。对于一个示例项目，C 可以将其依赖项管理部分中的 B 包含为依赖项，并直接控制在引用它时要使用 B 的哪个版本。 |
3 |
Dependency scope 根据构建的当前阶段包含依赖项。 |
4 |
Excluded dependencies 可以使用“exclusion”元素排除任何传递依赖项。例如，A 依赖于 B，而 B 依赖于 C，那么 A 可以将 C 标记为已排除。 |
5 |
Optional dependencies 可以使用“optional”元素将任何传递依赖项标记为可选。例如，A 依赖于 B，而 B 依赖于 C。现在 B 将 C 标记为可选的。那么 A 不会使用 C。 |
Dependency Scope
可以使用各种依赖项范围来限制传递依赖项发现，如下所述。
Sr.No. |
Scope & Description |
1 |
compile 此范围表明依赖项可在项目的 classpath 中使用。它是默认范围。 |
2 |
provided 此范围表明依赖项将在运行时由 JDK 或 web 服务器/容器提供。 |
3 |
runtime 此范围表明在编译过程中不需要依赖项，但在执行过程中需要依赖项。 |
4 |
test 此范围表明依赖项仅可用于测试编译和执行阶段。 |
5 |
system 此范围表明您必须提供系统路径。 |
6 |
import 只有依赖项为 pom 类型时，才使用此范围。此范围表明应当使用该 POM 中 <dependencyManagement> 部分中的依赖项替换指定的 POM。 |
Dependency Management
通常，在通用项目下，我们有一组项目。在这种情况下，我们可以创建一个具有所有通用依赖项的通用 pom，然后将此 pom 设为子项目 pom 的父级。下面的示例将帮助你理解此概念。
以下是上述依赖项关系图的详细信息 -
-
App-UI-WAR 依赖于 App-Core-Lib 和 App-Data-Lib。
-
Root 是 App-Core-Lib 和 App-Data-Lib 的父级。
-
Root 在其依赖项部分中将 Lib1、lib2、Lib3 定义为依赖项。
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>现在，当我们构建 App-UI-WAR 项目时，Maven 将通过遍历依赖项关系图来发现所有依赖项，并构建应用程序。
从以上示例中，我们可以了解以下关键概念 -
-
可以使用父级 pom 的概念将通用依赖项置于单个位置。 App-Data-lib 和 App-Core-lib 项目的依赖项在 Root 项目中列出（请参阅 Root 的打包类型。它是 POM）。
-
不必在 App-UI-WAR 中将 Lib1、lib2、Lib3 指定为依赖项。Maven 使用 Transitive Dependency Mechanism 来管理此类详细信息。
Maven - Deployment Automation
在项目开发中，一般情况下，部署流程包含以下步骤：
-
将进行中的所有项目的代码检入到 SVN（版本控制系统）或源代码仓库并对其打标签。
-
从 SVN 下载完整的源代码。
-
Build the application.
-
将构建输出（WAR 或 EAR 文件）存储到一个公共网络位置。
-
从网络获取文件并将其部署到生产站点。
-
使用应用程序的日期和更新版本号更新文档。
Problem Statement
一般情况下，上述部署流程涉及多人。一个团队可能处理代码检入，另一个团队可能处理构建，以此类推。很容易出现任何步骤因需要人工操作而遗漏，也可能是由于多团队环境所致。例如，可能未在网络计算机上替换旧的构建，而部署团队再次部署了旧构建。
Solution
通过结合以下内容来自动部署流程：
-
用于构建和发布项目的 Maven。
-
用于管理源代码的源代码仓库 SubVersion。
-
用于管理项目二进制文件的远程仓库管理器 (Jfrog/Nexus)。
Update Project POM.xml
我们将使用 Maven Release 插件来创建一个自动化发布过程。
例如：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>在 Pom.xml 中，我们使用了以下重要的元素：
Sr.No. |
Element & Description |
1 |
SCM 配置 Maven 将源代码检出的 SVN 位置。 |
2 |
Repositories 代码构建成功后，构建的 WAR/EAR/JAR 或任何其他制品的存储位置。 |
3 |
Plugin maven-release-plugin 配置为自动化部署过程。 |
Maven Release Plug-in
Maven 使用 maven-release-plugin 执行以下有用的任务。
mvn release:clean如果上次发布过程未成功，则清除工作空间。
mvn release:rollback如果上次发布过程未成功，则回滚对工作空间代码和配置所做的更改。
mvn release:prepare执行多个操作，例如：
-
检查是否存在未提交的本地更改。
-
确保没有 SNAPSHOT 依赖项。
-
更改应用程序版本并从版本中移除 SNAPSHOT 以进行发布。
-
将 pom 文件更新到 SVN。
-
Run test cases.
-
提交已修改的 POM 文件。
-
在 Subversion 中标记代码
-
增加版本号，并追加 SNAPSHOT 以便于将来发布。
-
将已修改的 POM 文件提交到 SVN。
mvn release:perform使用先前定义的标记签出代码，并运行 Maven deply 目标，将 war 或构建的制品部署到存储库。
让我们打开命令控制台，转到 C:\ > MVN >bus-core-api 目录并执行以下 mvn 命令。
>mvn release:prepareMaven 将开始构建项目。成功构建后，运行以下 mvn 命令。
>mvn release:perform成功构建后，您可以在存储库中验证上传的 JAR 文件。
Maven - Web Application
本部分介绍如何使用 Maven 管理基于 Web 的项目。您将在此了解如何创建/构建/部署和运行 Web 应用程序。
Create Web Application
要创建简单的 Java Web 应用程序，我们将使用 maven-archetype-webapp 插件。因此，让我们打开命令控制台，转至 C:\MVN 目录并执行以下 mvn 命令。
C:\MVN>mvn archetype:generate
-DgroupId = com.companyname.automobile
-DartifactId = trucks
-DarchetypeArtifactId = maven-archetype-webapp
-DinteractiveMode = falseMaven 将开始处理并将创建完整的基于 Web 的 Java 应用程序项目结构，如下所示 -
C:\MVN>mvn archetype:generate -DgroupId=com.companyname.automobile -DartifactId=trucks -DarchetypeArtifactId=maven-archetype-webapp -DinteractiveMode=false
[INFO] Scanning for projects...
[INFO]
[INFO] ------------------< org.apache.maven:standalone-pom >-------------------
[INFO] Building Maven Stub Project (No POM) 1
[INFO] --------------------------------[ pom ]---------------------------------
...
[INFO] ----------------------------------------------------------------------------
[INFO] Using following parameters for creating project from Old (1.x) Archetype: maven-archetype-webapp:1.0
[INFO] ----------------------------------------------------------------------------
[INFO] Parameter: basedir, Value: C:\MVN
[INFO] Parameter: package, Value: com.companyname.automobile
[INFO] Parameter: groupId, Value: com.companyname.automobile
[INFO] Parameter: artifactId, Value: trucks
[INFO] Parameter: packageName, Value: com.companyname.automobile
[INFO] Parameter: version, Value: 1.0-SNAPSHOT
[INFO] project created from Old (1.x) Archetype in dir: C:\MVN\trucks
[INFO] ------------------------------------------------------------------------
[INFO] BUILD SUCCESS
[INFO] ------------------------------------------------------------------------
[INFO] Total time: 10.381 s
[INFO] Finished at: 2021-12-13T19:00:13+05:30
[INFO] ------------------------------------------------------------------------
C:\MVN>现在转至 C:/MVN 目录。您将看到已创建名为 trucks（在 artifactId 中指定）的 Java 应用程序项目，如以下快照中所示。基于 Web 的应用程序通常使用以下目录结构 -
Maven 使用标准目录布局。使用以上示例，我们可以理解以下关键概念 -
Sr.No. |
Folder Structure & Description |
1 |
trucks 包含 src 文件夹和 pom.xml。 |
2 |
src/main/webapp 包含 index.jsp 和 WEB-INF 文件夹。 |
3 |
src/main/webapp/WEB-INF contains web.xml |
4 |
src/main/resources it contains images/properties files. |
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>如果您仔细观察，您会发现 Maven 还创建了一个示例 JSP 源文件。
打开 C:\ > MVN > trucks > src > main > webapp > 文件夹查看 index.jsp 及其代码：
<html>
<body>
<h2>Hello World!</h2>
</body>
</html>Build Web Application
让我们打开命令控制台，转至 C:\MVN\trucks 目录并执行以下 mvn 命令。
C:\MVN\trucks>mvn clean packageMaven 将开始构建该项目。
C:\MVN\trucks>mvn clean package
[INFO] Scanning for projects...
[INFO]
[INFO] -----------------< com.companyname.automobile:trucks >------------------
[INFO] Building trucks Maven Webapp 1.0-SNAPSHOT
[INFO] --------------------------------[ war ]---------------------------------
[INFO]
[INFO] --- maven-clean-plugin:2.5:clean (default-clean) @ trucks ---
[INFO] Deleting C:\MVN\trucks\target
[INFO]
[INFO] --- maven-resources-plugin:2.6:resources (default-resources) @ trucks ---
[WARNING] Using platform encoding (Cp1252 actually) to copy filtered resources, i.e. build is platform dependent!
[INFO] Copying 0 resource
[INFO]
[INFO] --- maven-compiler-plugin:3.1:compile (default-compile) @ trucks ---
[INFO] No sources to compile
[INFO]
[INFO] --- maven-resources-plugin:2.6:testResources (default-testResources) @ trucks ---
[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]
[INFO] --- maven-compiler-plugin:3.1:testCompile (default-testCompile) @ trucks ---
[INFO] No sources to compile
[INFO]
[INFO] --- maven-surefire-plugin:2.12.4:test (default-test) @ trucks ---
[INFO] No tests to run.
[INFO]
[INFO] --- maven-war-plugin:2.2:war (default-war) @ trucks ---
WARNING: An illegal reflective access operation has occurred
WARNING: Illegal reflective access by com.thoughtworks.xstream.core.util.Fields (file:/C:/Users/intel/.m2/repository/com/thoughtworks/xstream/xstream/1.3.1/xstream-1.3.1.jar) to field java.util.Properties.defaults
WARNING: Please consider reporting this to the maintainers of com.thoughtworks.xstream.core.util.Fields
WARNING: Use --illegal-access=warn to enable warnings of further illegal reflective access operations
WARNING: All illegal access operations will be denied in a future release
[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 [50 msecs]
[INFO] Building war: C:\MVN\trucks\target\trucks.war
[INFO] WEB-INF\web.xml already added, skipping
[INFO] ------------------------------------------------------------------------
[INFO] BUILD SUCCESS
[INFO] ------------------------------------------------------------------------
[INFO] Total time: 2.494 s
[INFO] Finished at: 2021-12-13T19:02:15+05:30
[INFO] ------------------------------------------------------------------------
C:\MVN\trucks>Deploy Web Application
现在将 trucks.war 复制在 C:\ > MVN > trucks > target > 文件夹中创建到您的 web 服务器 webapp 目录中并重启该 web 服务器。
Test Web Application
使用 URL 运行 web 应用程序： http://<server-name>:<port-number>/trucks/index.jsp 。
验证输出。
Maven - Eclipse IDE
Eclipse 提供了一个出色的插件 m2eclipse ，该插件将 Maven 和 Eclipse 无缝集成在一起。
m2eclipse 的一些功能如下所示：
-
您可以从 Eclipse 运行 Maven 目标。
-
您可以使用自己的控制台在 Eclipse 中查看 Maven 命令的输出。
-
您可以使用 IDE 更新 Maven 依赖项。
-
您可以在 Eclipse 中启动 Maven 构建。
-
它根据 Maven 的 pom.xml 为 Eclipse 构建路径执行依赖项管理。
-
它从 Eclipse 工作区解析 Maven 依赖项，而无需安装到本地 Maven 存储库（需要依赖项项目位于同一个工作区）。
-
它会从远程 Maven 存储库自动下载所需的依赖项和源。
-
它提供了用于创建新的 Maven 项目、pom.xml 以及为现有项目启用 Maven 支持的向导。
-
它提供了在远程 Maven 存储库中快速搜索依赖项的功能。
Installing m2eclipse plugin
使用以下链接之一安装 m2eclipse：
Eclipse |
URL |
Eclipse 3.5 (Gallileo) |
|
Eclipse 3.6 (Helios) |
以下示例将帮助您利用集成 Eclipse 和 maven 的好处。
Import a maven project in Eclipse
-
Open Eclipse.
-
选择 File > Import > 选项。
-
选择 Maven Projects 选项。单击 Next 按钮。
-
选择项目位置，其中创建了一个使用 Maven 的项目。我们在前面的章节中创建了一个 Java 项目 consumer Banking。转到“创建 Java 项目”章节，查看如何使用 Maven 创建项目。
-
Click Finish Button.
现在，您可以在 eclipse 中看到 Maven 项目。
现在，查看一下 consumer Banking 项目属性。您可以看到 Eclipse 已将 Maven 依赖项添加到 java 构建路径。
现在，是使用 eclipse 的 maven 能力构建这个项目的时候了。
-
右键单击 consumerBanking 项目以打开上下文菜单。
-
Select Run as option.
-
Then maven package option.
Maven 将开始构建项目。您可以在 Eclipse 控制台中看到以下输出 −
[INFO] Scanning for projects...
[INFO]
[INFO] ----------------< com.companyname.bank:consumerBanking >----------------
[INFO] Building consumerBanking 1.0-SNAPSHOT
[INFO] --------------------------------[ jar ]---------------------------------
[INFO]
[INFO] --- maven-clean-plugin:2.5:clean (default-clean) @ consumerBanking ---
[INFO] Deleting C:\MVN\consumerBanking\target
[INFO]
[INFO] --- maven-resources-plugin:2.6:resources (default-resources) @ consumerBanking ---
[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]
[INFO] --- maven-compiler-plugin:3.1:compile (default-compile) @ consumerBanking ---
[INFO] Changes detected - recompiling the module!
[WARNING] File encoding has not been set, using platform encoding Cp1252, i.e. build is platform dependent!
[INFO] Compiling 1 source file to C:\MVN\consumerBanking\target\classes
[INFO]
[INFO] --- maven-resources-plugin:2.6:testResources (default-testResources) @ consumerBanking ---
[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]
[INFO] --- maven-compiler-plugin:3.1:testCompile (default-testCompile) @ consumerBanking ---
[INFO] Changes detected - recompiling the module!
[WARNING] File encoding has not been set, using platform encoding Cp1252, i.e. build is platform dependent!
[INFO] Compiling 1 source file to C:\MVN\consumerBanking\target\test-classes
[INFO]
[INFO] --- maven-surefire-plugin:2.12.4:test (default-test) @ consumerBanking ---
[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.028 sec
Results :
Tests run: 1, Failures: 0, Errors: 0, Skipped: 0
[INFO]
[INFO] --- maven-jar-plugin:2.4:jar (default-jar) @ consumerBanking ---
[INFO] Building jar: C:\MVN\consumerBanking\target\consumerBanking-1.0-SNAPSHOT.jar
[INFO] ------------------------------------------------------------------------
[INFO] BUILD SUCCESS
[INFO] ------------------------------------------------------------------------
[INFO] Total time: 4.663 s
[INFO] Finished at: 2021-12-13T17:34:27+05:30
[INFO] ------------------------------------------------------------------------现在，右键单击 App.java。选择 Run As 选项。然后选择 Java Application 。
您将看到如下结果 −
Hello World!Maven - NetBeans
NetBeans 6.7 及更高版本内置支持 Maven。在以前版本的案例中，Maven 插件可在插件管理器中找到。我们在本示例中使用的是 NetBeans 6.9。
以下是 NetBeans 的部分功能 −
-
您可以在 NetBeans 中运行 Maven 目标。
-
您可以使用其控制台在 NetBeans 内查看 Maven 命令的输出。
-
您可以使用 IDE 更新 Maven 依赖项。
-
您可以从 NetBeans 内部启动 Maven 构建。
-
NetBeans 根据 Maven 的 pom.xml 自动管理依赖项。
-
NetBeans 从其工作空间解析 Maven 依赖项，而无需安装到本地 Maven 存储库（需要依赖项项目位于同一个工作空间）。
-
NetBeans 自动下载远程 Maven 存储库中所需的依赖项和源。
-
NetBeans 为新建 Maven 项目和 pom.xml 提供向导。
-
NetBeans 提供 Maven 存储库浏览器，让您能够查看本地存储库和注册的外部 Maven 存储库。
以下示例将帮助您利用集成 NetBeans 和 Maven 的优势。
Open a maven project in NetBeans
-
Open NetBeans.
-
选择 File Menu > Open Project 选项。
-
选择项目位置，使用 Maven 创建项目的位置。我们创建了一个 Java 项目 consumerBanking。转到“创建 Java 项目”章节，查看如何使用 Maven 创建项目。
现在，您可以在 NetBeans 中看到以下 Maven 项目。查看 consumerBanking 项目库和测试库。您会看到 NetBeans 已将 Maven 依赖项添加到其构建路径中。
Build a maven project in NetBeans
现在是使用 NetBeans 的 Maven 功能构建此项目的时候了。
-
右键单击 consumerBanking 项目以打开上下文菜单。
-
选择“清理和构建”作为选项。
Maven 将开始构建项目。您可以在 NetBeans 控制台中看到输出，如下所示：
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
------------------------------------------------------------------------Run Application in NetBeans
现在，右键单击 App.java。选择 Run File 作为选项。您将在 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
------------------------------------------------------------------------Maven - IntelliJ IDEA IDE Integration
IntelliJ IDEA 内置了对 Maven 的支持。在本示例中，我们使用 IntelliJ IDEA Community Edition 11.1。
IntelliJ IDEA 的一些功能列在下面：
-
您可以从 IntelliJ IDEA 运行 Maven 目标。
-
您可以使用 IntelliJ IDEA 自己的控制台在 IntelliJ IDEA 中查看 Maven 命令的输出。
-
您可以在 IDE 中更新 maven 依赖项。
-
您可以在 IntelliJ IDEA 内启动 Maven 构建。
-
IntelliJ IDEA 根据 Maven 的 pom.xml 自动执行依赖性管理。
-
IntelliJ IDEA 从其工作区解析 Maven 依赖项，而无需安装到本地 Maven 存储库（要求依赖项目位于同一个工作区中）。
-
IntelliJ IDEA 会自动从远程 Maven 存储库下载所需的依赖项和源。
-
IntelliJ IDEA 提供用于创建新的 Maven 项目和 pom.xml 的向导。
以下示例将帮助您充分利用将 IntelliJ IDEA 和 Maven 集成的优势。
Create a new project in IntelliJ IDEA
我们将使用 New Project Wizard 导入 Maven 项目。
-
Open IntelliJ IDEA.
-
选择 File Menu > New Project 选项。
-
选择从现有模型导入项目。
-
Select Maven option
-
选择创建项目的 Project location，已使用 Maven 创建。我们已创建 Java Project consumerBanking。转到“创建 Java Project”章节，查看如何使用 Maven 创建项目。
-
选择要导入的 Maven 项目。
-
输入项目的名称，然后单击完成。
-
现在，你可以在 IntelliJ IDEA 中看到 maven 项目。看看 consumerBanking 项目外部库。你可以看到 IntelliJ IDEA 已将 Maven 依赖项添加到 Maven 部分下的构建路径中。
Build a maven project in IntelliJ IDEA
现在，是时候使用 IntelliJ IDEA 的功能来构建此项目了。
-
Select consumerBanking project.
-
选择 Buid menu > Rebuild Project 选项
你可以在 IntelliJ IDEA 控制台中看到输出
4:01:56 PM Compilation completed successfullyRun Application in IntelliJ IDEA
-
Select consumerBanking project.
-
右击 App.java 以打开上下文菜单。
-
select Run App.main()
你将在 IntelliJ IDEA 控制台中看到结果。
"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