Maven笔记一——关键概念

Apache Maven概述

maven是什么？

​ Maven 是一个项目管理和整合工具。Maven 为开发者提供了一套完整的构建生命周期框架。开发团队几乎不用花多少时间就能够自动完成工程的基础构建配置，因为 Maven 使用了一个标准的目录结构和一个默认的构建生命周期。

​ 在有多个开发团队环境的情况下，Maven 能够在很短的时间内使得每项工作都按照标准进行。因为大部分的工程配置操作都非常简单并且可复用，在创建报告、检查、构建和测试自动配置时，Maven 可以让开发者的工作变得更简单。

Maven 能够帮助开发者完成以下工作：

• 构建
• 文档生成
• 报告
• 依赖
• SCMs
• 发布
• 分发
• 邮件列表

​ 总的来说，Maven 简化了工程的构建过程，并对其标准化。它无缝衔接了编译、发布、文档生成、团队合作和其他任务。Maven 提高了重用性，负责了大部分构建相关的任务。

Maven 的目标

Maven 的主要目的是为开发者提供

• 一个可复用、可维护、更易理解的工程综合模型
• 与这个模型交互的插件或者工具

​ Maven 工程结构和内容被定义在一个 xml 文件中 － pom.xml，是 Project Object Model (POM) 的简称，此文件是整个 Maven 系统的基础组件。详细内容请参考 Maven POM 部分。

Apache Maven 环境配置

Maven - 环境配置

Maven 是一个基于 Java 的工具，所以要做的第一件事情就是安装 JDK。

工具的版本

maven 3.3要求JDK1.7及以上

步骤1：检查Java安装

windows下打开cmd命令h行，执行java命令：

java -version

以上为正确安装了jdk。

步骤2：配置java环境变量

打开环境变量，在系统变量中新建，然后按下图输入：

然后在Path中添加%JDK_HOME%\bin，确定退出。

步骤3：下载maven文件

步骤4：解压maven文件

步骤5：设置maven环境变量

类似JDK环境变量配置。

1）

2）Path添加%M2_HOME%\bin

步骤6：验证maven安装

cmd中输入mvn -version

出现类似上图内容即安装并配置成功。

Apache Maven POM

Maven - POM

​ POM 代表工程对象模型。它是使用 Maven 工作时的基本组建，是一个 xml 文件。它被放在工程根目录下，文件命名为 pom.xml。

​ POM 包含了关于工程和各种配置细节的信息，Maven 使用这些信息构建工程。

POM 也包含了目标和插件。当执行一个任务或者目标时，Maven 会查找当前目录下的 POM，从其中读取所需要的配置信息，然后执行目标。能够在 POM 中设置的一些配置如下：

• project dependencies
• plugins
• goals
• build profiles
• project version
• developers
• mailing list

在创建 POM 之前，我们首先确定工程组（groupId），及其名称（artifactId）和版本，在仓库中这些属性是工程的唯一标识。

POM举例

<project xmlns="http://maven.apache.org/POM/4.0.0"
   xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
   xsi:schemaLocation="http://maven.apache.org/POM/4.0.0
   http://maven.apache.org/xsd/maven-4.0.0.xsd">
   <modelVersion>4.0.0modelVersion>

   <groupId>com.companyname.project-groupgroupId>
   <artifactId>projectartifactId>
   <version>1.0version>

project>

PS：每个工程只有一个文件。

• 所有的 POM 文件需要 project 元素和三个必须的字段：groupId, artifactId,version。
• 在仓库中的工程标识为 groupId:artifactId:version
• POM.xml 的根元素是 project，它有三个主要的子节点：

节点	描述
groupId	这是工程组的标识。它在一个组织或者项目中通常是唯一的。例如，一个银行组织 com.company.bank 拥有所有的和银行相关的项目。
artifactId	这是工程的标识。它通常是工程的名称。例如，消费者银行。groupId 和 artifactId 一起定义了 artifact 在仓库中的位置。
version	这是工程的版本号。在 artifact 的仓库中，它用来区分不同的版本。例如： com.company.bank:consumer-banking:1.0 com.company.bank:consumer-banking:1.1.

Super POM

所有的 POM 都继承自一个父 POM（无论是否显式定义了这个父 POM）。父 POM 也被称作 Super POM，它包含了一些可以被继承的默认设置。

Maven 使用 effective pom（Super pom 加上工程自己的配置）来执行相关的目标，它帮助开发者在 pom.xml 中做尽可能少的配置，当然这些配置可以被方便的重写。

查看 Super POM 默认配置的一个简单方法是执行以下命令：mvn help:effective-pom

建立一个pom.xml文件，填写上面的pom示例的内容。

结果如下：

Effective POM 的结果就像在控制台中显示的一样，经过继承、插值之后，使配置生效。

<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-insta
nce" xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.x
sd">
  <modelVersion>4.0.0modelVersion>
  <groupId>com.companyname.project-groupgroupId>
  <artifactId>projectartifactId>
  <version>1.0version>
  <properties>
    <maven.compiler.compilerVersion>1.8maven.compiler.compilerVersion>
    <maven.compiler.source>1.8maven.compiler.source>
    <maven.compiler.target>1.8maven.compiler.target>
  properties>
  <repositories>
    <repository>
      <snapshots>
        <enabled>falseenabled>
      snapshots>
      <id>centralid>
      <name>Central Repositoryname>
      <url>https://repo.maven.apache.org/maven2url>
    repository>
  repositories>
  <pluginRepositories>
    <pluginRepository>
      <releases>
        <updatePolicy>neverupdatePolicy>
      releases>
      <snapshots>
        <enabled>falseenabled>
      snapshots>
      <id>centralid>
      <name>Central Repositoryname>
      <url>https://repo.maven.apache.org/maven2url>
    pluginRepository>
  pluginRepositories>
  <build>
    <sourceDirectory>C:\Users\fzhiy\Desktop\maven+junit\maven\src\main\javasourceDirectory>
    <scriptSourceDirectory>C:\Users\fzhiy\Desktop\maven+junit\maven\src\main\scriptsscriptSourceDi
rectory>
    <testSourceDirectory>C:\Users\fzhiy\Desktop\maven+junit\maven\src\test\javatestSourceDirectory
>
    <outputDirectory>C:\Users\fzhiy\Desktop\maven+junit\maven\target\classesoutputDirectory>
    <testOutputDirectory>C:\Users\fzhiy\Desktop\maven+junit\maven\target\test-classestestOutputDir
ectory>
    <resources>
      <resource>
        <directory>C:\Users\fzhiy\Desktop\maven+junit\maven\src\main\resourcesdirectory>
      resource>
    resources>
    <testResources>
      <testResource>
        <directory>C:\Users\fzhiy\Desktop\maven+junit\maven\src\test\resourcesdirectory>
      testResource>
    testResources>
    <directory>C:\Users\fzhiy\Desktop\maven+junit\maven\targetdirectory>
    <finalName>project-1.0finalName>
    <pluginManagement>
      <plugins>
        <plugin>
          <artifactId>maven-antrun-pluginartifactId>
          <version>1.3version>
        plugin>
        <plugin>
          <artifactId>maven-assembly-pluginartifactId>
          <version>2.2-beta-5version>
        plugin>
        <plugin>
          <artifactId>maven-dependency-pluginartifactId>
          <version>2.8version>
        plugin>
        <plugin>
          <artifactId>maven-release-pluginartifactId>
          <version>2.5.3version>
        plugin>
      plugins>
    pluginManagement>
    <plugins>
      <plugin>
        <artifactId>maven-clean-pluginartifactId>
        <version>2.5version>
        <executions>
          <execution>
            <id>default-cleanid>
            <phase>cleanphase>
            <goals>
              <goal>cleangoal>
            goals>
          execution>
        executions>
      plugin>
      <plugin>
        <artifactId>maven-resources-pluginartifactId>
        <version>2.6version>
        <executions>
          <execution>
            <id>default-testResourcesid>
            <phase>process-test-resourcesphase>
            <goals>
              <goal>testResourcesgoal>
            goals>
          execution>
          <execution>
            <id>default-resourcesid>
            <phase>process-resourcesphase>
            <goals>
              <goal>resourcesgoal>
            goals>
          execution>
        executions>
      plugin>
      <plugin>
        <artifactId>maven-jar-pluginartifactId>
        <version>2.4version>
        <executions>
          <execution>
            <id>default-jarid>
            <phase>packagephase>
            <goals>
              <goal>jargoal>
            goals>
          execution>
        executions>
      plugin>
      <plugin>
        <artifactId>maven-compiler-pluginartifactId>
        <version>3.1version>
        <executions>
          <execution>
            <id>default-compileid>
            <phase>compilephase>
            <goals>
              <goal>compilegoal>
            goals>
          execution>
          <execution>
            <id>default-testCompileid>
            <phase>test-compilephase>
            <goals>
              <goal>testCompilegoal>
            goals>
          execution>
        executions>
      plugin>
      <plugin>
        <artifactId>maven-surefire-pluginartifactId>
        <version>2.12.4version>
        <executions>
          <execution>
            <id>default-testid>
            <phase>testphase>
            <goals>
              <goal>testgoal>
            goals>
          execution>
        executions>
      plugin>
      <plugin>
        <artifactId>maven-install-pluginartifactId>
        <version>2.4version>
        <executions>
          <execution>
            <id>default-installid>
            <phase>installphase>
            <goals>
              <goal>installgoal>
            goals>
          execution>
        executions>
      plugin>
      <plugin>
        <artifactId>maven-deploy-pluginartifactId>
        <version>2.7version>
        <executions>
          <execution>
            <id>default-deployid>
            <phase>deployphase>
            <goals>
              <goal>deploygoal>
            goals>
          execution>
        executions>
      plugin>
      <plugin>
        <artifactId>maven-site-pluginartifactId>
        <version>3.3version>
        <executions>
          <execution>
            <id>default-siteid>
            <phase>sitephase>
            <goals>
              <goal>sitegoal>
            goals>
            <configuration>
              <outputDirectory>C:\Users\fzhiy\Desktop\maven+junit\maven\target\siteoutputDirectory
>
              <reportPlugins>
                <reportPlugin>
                  <groupId>org.apache.maven.pluginsgroupId>
                  <artifactId>maven-project-info-reports-pluginartifactId>
                reportPlugin>
              reportPlugins>
            configuration>
          execution>
          <execution>
            <id>default-deployid>
            <phase>site-deployphase>
            <goals>
              <goal>deploygoal>
            goals>
            <configuration>
              <outputDirectory>C:\Users\fzhiy\Desktop\maven+junit\maven\target\siteoutputDirectory
>
              <reportPlugins>
                <reportPlugin>
                  <groupId>org.apache.maven.pluginsgroupId>
                  <artifactId>maven-project-info-reports-pluginartifactId>
                reportPlugin>
              reportPlugins>
            configuration>
          execution>
        executions>
        <configuration>
          <outputDirectory>C:\Users\fzhiy\Desktop\maven+junit\maven\target\siteoutputDirectory>
          <reportPlugins>
            <reportPlugin>
              <groupId>org.apache.maven.pluginsgroupId>
              <artifactId>maven-project-info-reports-pluginartifactId>
            reportPlugin>
          reportPlugins>
        configuration>
      plugin>
    plugins>
  build>
  <reporting>
    <outputDirectory>C:\Users\fzhiy\Desktop\maven+junit\maven\target\siteoutputDirectory>
  reporting>
project>

在上面的 pom.xml 中，你可以看到 Maven 在执行目标时需要用到的默认工程源码目录结构、输出目录、需要的插件、仓库和报表目录。

Maven 的 pom.xml 文件也不需要手工编写。

Maven 提供了大量的原型插件来创建工程，包括工程结构和 pom.xml。

Apache Maven 仓库

Maven - 仓库

什么是 Maven 仓库？

在 Maven 的术语中，仓库是一个位置（place），例如目录，可以存储所有的工程 jar 文件、library jar 文件、插件或任何其他的工程指定的文件。

Maven 仓库有三种类型：

• 本地（local）
• 中央（central）
• 远程（remote）

本地仓库

Maven 本地仓库是机器上的一个文件夹。它在你第一次运行任何 maven 命令的时候创建。

Maven 本地仓库保存你的工程的所有依赖（library jar、plugin jar 等）。当你运行一次 Maven 构建，Maven 会自动下载所有依赖的 jar 文件到本地仓库中。它避免了每次构建时都引用存放在远程机器上的依赖文件。

Maven 本地仓库默认被创建在 %USER_HOME% 目录下。要修改默认位置，在 %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>F:\Repository\MavenRepositorylocalRepository>
    settings>

当你运行 Maven 命令，Maven 将下载依赖的文件到你指定的路径（F:\Repository\MavenRepository）中。

中央仓库

Maven 中央仓库是由 Maven 社区提供的仓库，其中包含了大量常用的库。

中央仓库的关键概念：

• 这个仓库由 Maven 社区管理。
• 不需要配置。
• 需要通过网络才能访问。

要浏览中央仓库的内容，maven 社区提供了一个 URL：http://search.maven.org/#browse。使用这个仓库，开发人员可以搜索所有可以获取的代码库。

远程仓库

如果 Maven 在中央仓库中也找不到依赖的库文件，它会停止构建过程并输出错误信息到控制台。为避免这种情况，Maven 提供了远程仓库的概念，它是开发人员自己定制仓库，包含了所需要的代码库或者其他工程中用到的 jar 文件。

举例，使用下面的 POM.xml，Maven 将从远程仓库中下载该 pom.xml 中声明的所依赖的（在中央仓库中获取不到的）文件。

Maven 依赖搜索顺序

当我们执行 Maven 构建命令时，Maven 开始按照以下顺序查找依赖的库：

• 步骤 1 － 在本地仓库中搜索，如果找不到，执行步骤 2，如果找到了则执行其他操作。
• 步骤 2 － 在中央仓库中搜索，如果找不到，并且有一个或多个远程仓库已经设置，则执行步骤 4，如果找到了则下载到本地仓库中已被将来引用。
• 步骤 3 － 如果远程仓库没有被设置，Maven 将简单的停滞处理并抛出错误（无法找到依赖的文件）。
• 步骤 4 － 在一个或多个远程仓库中搜索依赖的文件，如果找到则下载到本地仓库已被将来引用，否则 Maven 将停止处理并抛出错误（无法找到依赖的文件）。

Apache Maven 插件

Maven - 插件

什么是 Maven 插件？

Maven 实际上是一个依赖插件执行的框架，每个任务实际上是由插件完成。Maven 插件通常被用来：

• 创建 jar 文件
• 创建 war 文件
• 编译代码文件
• 代码单元测试
• 创建工程文档
• 创建工程报告

插件通常提供了一个目标的集合，并且可以使用下面的语法执行：

mvn [plugin-name]:[goal-name]

例如，一个 Java 工程可以使用 maven-compiler-plugin 的 compile-goal 编译，使用以下命令：

mvn compiler:compile

插件类型

Maven 提供了下面两种类型的插件：

类型	描述
Build plugins	在构建时执行，并在 pom.xml 的 元素中配置。
Reporting plugins	在网站生成过程中执行，并在 pom.xml 的 元素中配置。

下面是一些常用插件的列表：

插件	描述
clean	构建之后清理目标文件。删除目标目录。
compiler	编译 Java 源文件。
surefile	运行 JUnit 单元测试。创建测试报告。
jar	从当前工程中构建 JAR 文件。
war	从当前工程中构建 WAR 文件。
javadoc	为工程生成 Javadoc。
antrun	从构建过程的任意一个阶段中运行一个 ant 任务的集合。

---

创建pom.xml文件，位于【C:\Users\fzhiy\Desktop\maven+junit\maven】，内容位于下方

Maven 将开始处理并显示 clean 生命周期的 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]
[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: 17.600 s
[INFO] Finished at: 2019-02-27T14:28:29+08:00
[INFO] ------------------------------------------------------------------------

上面的例子展示了以下关键概念：

• 插件是在 pom.xml 中使用 plugins 元素定义的。
• 每个插件可以有多个目标。
• 你可以定义阶段，插件会使用它的 phase 元素开始处理。我们已经使用了 clean 阶段。
• 你可以通过绑定到插件的目标的方式来配置要执行的任务。我们已经绑定了 echo 任务到 maven-antrun-plugin 的 run 目标。
• 就是这样，Maven 将处理剩下的事情。它将下载本地仓库中获取不到的插件，并开始处理。

Apache Maven创建工程

Maven - 创建工程

Maven 使用**原型（archetype）**插件创建工程。要创建一个简单的 Java 应用，我们将使用 maven-archetype-quickstart 插件。

执行mvn命令：

C:\Users\fzhiy\Desktop\maven+junit\maven\maven创建工程>mvn archetype:generate -DgroupId=com.companyname.bank -DartifactId=consumerBanking

-DarchetypeArtifactId=maven-archetype-quickstart -DinteractiveMode=false

Maven 将开始处理，并将创建完成的 java 应用工程结构。

[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.0.1:generate (default-cli) > generate-sources @ standalone-pom >
>>
[INFO]
[INFO] <<< maven-archetype-plugin:3.0.1:generate (default-cli) < generate-sources @ standalone-pom <
<<
[INFO]
[INFO]
[INFO] --- maven-archetype-plugin:3.0.1:generate (default-cli) @ standalone-pom ---
[INFO] Generating project in Batch mode
[WARNING] No archetype found in remote catalog. Defaulting to internal catalog
[INFO] ----------------------------------------------------------------------------
[INFO] Using following parameters for creating project from Old (1.x) Archetype: maven-archetype-qui
ckstart:1.0
[INFO] ----------------------------------------------------------------------------
[INFO] Parameter: basedir, Value: C:\Users\fzhiy\Desktop\maven+junit\maven\maven创建工程
[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:\Users\fzhiy\Desktop\maven+junit\maven\mav
en创建工程\consumerBanking
[INFO] ------------------------------------------------------------------------
[INFO] BUILD SUCCESS
[INFO] ------------------------------------------------------------------------
[INFO] Total time: 6.591 s
[INFO] Finished at: 2019-02-27T14:44:43+08:00
[INFO] ------------------------------------------------------------------------

在该目录下将看到一个名为 consumerBanking 的 java 应用工程（就像在 artifactId 中设定的一样）。Maven 使用一套标准的目录结构，就像这样：

使用上面的例子，我们可以知道下面几个关键概念：

文件夹结构	描述
consumerBanking	包含 src 文件夹和 pom.xml
src/main/java contains	java 代码文件在包结构下（com/companyName/bank）。
src/main/test contains	测试代码文件在包结构下（com/companyName/bank）。
src/main/resources	包含了 图片 / 属性 文件（在上面的例子中，我们需要手动创建这个结构）。

Maven 也创建了一个简单的 Java 源文件和 Java 测试文件。

Apache Maven 构建 & 测试工程

Maven - 构建 & 测试工程

在创建工程章节中学到的是如何使用 Maven 创建 Java 应用。

执行以下mvn命令：

出现BUILD SUCCESS表示构建了工程并创建了最终的jar文件。

关键概念：

• 我们给了 maven 两个目标，首先清理目标目录（clean），然后打包工程构建的输出为 jar（package）文件。
• 打包好的 jar 文件可以在 consumerBanking\target 中获得，名称为 consumerBanking-1.0-SNAPSHOT.jar。
• 测试报告存放在 consumerBanking\target\surefire-reports 文件夹中。
• Maven 编译源码文件，以及测试源码文件。
• 接着 Maven 运行测试用例。
• 最后 Maven 创建工程包。

target目录下的classes文件夹中编译生成了App.class文件，如下：

运行该文件，结果如下：

Apache Maven 外部依赖

Maven - 外部依赖

Maven的依赖管理使用的是 Maven - 仓库 的概念。但是如果在远程仓库和中央仓库中，依赖不能被满足，如何解决呢? Maven 使用外部依赖的概念来解决这个问题。

例如，让我们对在 Maven - 创建工程 部分创建的项目做以下修改：

• 在 src 文件夹下添加 lib 文件夹
• 复制任何 jar 文件到 lib 文件夹下。我们使用的是 ldapjdk.jar ，它是为 LDAP 操作的一个帮助库

外部依赖的概念：

• 外部依赖（library jar location）能够像其他依赖一样在 pom.xml 中配置。
• 指定 groupId 为 library 的名称。
• 指定 artifactId 为 library 的名称。
• 指定作用域（scope）为系统。
• 指定相对于工程位置的系统路径。

Apache Maven 管理依赖

Maven - 依赖管理

Maven 核心特点之一是依赖管理。一旦我们开始处理多模块工程（包含数百个子模块或者子工程）的时候，模块间的依赖关系就变得非常复杂，管理也变得很困难。针对此种情形，Maven 提供了一种高度控制的方法。

传递依赖发现

这种情形经常可见，当一个库 A 依赖于其他库 B. 另一工程 C 想要使用库 A, 那么该工程同样也需要使用到库 B。

Maven 可以避免去搜索所有需要的库资源的这种需求。通过读取工程文件（pom.xml）中的依赖项，Maven 可以找出工程之间的依赖关系。

我们只需要在每个工程的 pom 文件里去定义直接的依赖关系。Maven 则会自动的来接管后续的工作。

maven有依赖调节、依赖管理、依赖范围、依赖排除、依赖可选几种功能。

就实际使用来说，这里只讨论依赖管理。

通常情况下，在一个共通的工程下，有一系列的工程。在这种情况下，我们可以创建一个公共依赖的 pom 文件，该 pom 包含所有的公共的依赖关系，我们称其为其他子工程 pom 的 pom 父。

接下来的一个例子可以帮助你更好的理解这个概念。

下面是上述依赖图表的细节：

• App-UI-WAR 依赖于 App-Core-lib 和 App-Data-lib.
• Root 是 App-Core-lib 和 App-Data-lib 的父类。
• Root 在其依赖模块里定义了 Lib1,lib2, Lib3 3个依赖关系。

App-UI-WAR 的 POM 文件如下：

<project xmlns="http://maven.apache.org/POM/4.0.0"
   xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
   xsi:schemaLocation="http://maven.apache.org/POM/4.0.0
   http://maven.apache.org/xsd/maven-4.0.0.xsd">
      <modelVersion>4.0.0modelVersion>
      <groupId>com.companyname.groupnamegroupId>
      <artifactId>App-UI-WARartifactId>
      <version>1.0version>
      <packaging>warpackaging>
      <dependencies>
         <dependency>
            <groupId>com.companyname.groupnamegroupId>
            <artifactId>App-Core-libartifactId>
            <version>1.0version>
         dependency>
      dependencies>  
      <dependencies>
         <dependency>
            <groupId>com.companyname.groupnamegroupId>
            <artifactId>App-Data-libartifactId>
            <version>1.0version>
         dependency>
      dependencies>  
project>

App-Core-lib 的 POM 文件如下：

<project xmlns="http://maven.apache.org/POM/4.0.0"
   xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
   xsi:schemaLocation="http://maven.apache.org/POM/4.0.0
   http://maven.apache.org/xsd/maven-4.0.0.xsd">
      <parent>
         <artifactId>RootartifactId>
         <groupId>com.companyname.groupnamegroupId>
         <version>1.0version>
      parent>
      <modelVersion>4.0.0modelVersion>
      <groupId>com.companyname.groupnamegroupId>
      <artifactId>App-Core-libartifactId>
      <version>1.0version> 
      <packaging>jarpackaging>
project>

App-Data-lib 的 POM 文件如下：

<project xmlns="http://maven.apache.org/POM/4.0.0"
   xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
   xsi:schemaLocation="http://maven.apache.org/POM/4.0.0
   http://maven.apache.org/xsd/maven-4.0.0.xsd">
      <parent>
         <artifactId>RootartifactId>
         <groupId>com.companyname.groupnamegroupId>
         <version>1.0version>
      parent>
      <modelVersion>4.0.0modelVersion>
      <groupId>com.companyname.groupnamegroupId>
      <artifactId>App-Data-libartifactId>
      <version>1.0version>   
      <packaging>jarpackaging>
project>

Root 的 POM 文件如下：

<project xmlns="http://maven.apache.org/POM/4.0.0"
   xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
   xsi:schemaLocation="http://maven.apache.org/POM/4.0.0
   http://maven.apache.org/xsd/maven-4.0.0.xsd">
      <modelVersion>4.0.0modelVersion>
      <groupId>com.companyname.groupnamegroupId>
      <artifactId>RootartifactId>
      <version>1.0version>
      <packaging>pompackaging>
      <dependencies>
         <dependency>
            <groupId>com.companyname.groupname1groupId>
            <artifactId>Lib1artifactId>
            <version>1.0version>
         dependency>
      dependencies>  
      <dependencies>
         <dependency>
            <groupId>com.companyname.groupname2groupId>
            <artifactId>Lib2artifactId>
            <version>2.1version>
         dependency>
      dependencies>  
      <dependencies>
         <dependency>
            <groupId>com.companyname.groupname3groupId>
            <artifactId>Lib3artifactId>
            <version>1.1version>
         dependency>
      dependencies>  
project>

当我们构建 App-UI-WAR 工程时， Maven 将会通过遍历依赖图找到所有的依赖关系，并且构建该应用程序。

通过上面的例子，我们可以学习到以下关键概念：

• 公共的依赖可以使用 pom 父的概念被统一放在一起。App-Data-lib 和 App-Core-lib 工程的依赖在Root 工程里列举了出来（参考 Root的包类型，它是一个 POM）.
• 没有必要在 App-UI-W 里声明 Lib1, lib2, Lib3 是它的依赖。 Maven 通过使用可传递的依赖机制来实现该细节。

Apache Maven Web 应用

Maven - Web 应用

创建 Web 应用

https://blog.csdn.net/feng_zhiyu/article/details/84933258