一、什么是POM
Project Object Model，项目对象模型。通过xml格式保存的pom.xml文件。作用类似ant的build.xml文件，功能更强大。该文件用于管理：源代码、配置文件、开发者的信息和角色、问题追踪系统、组织信息、项目授权、项目的url、项目的依赖关系等等。
在Maven依赖管理中，唯一标识一个依赖项是由该依赖项的三个属性构成的，分别是groupId、artifactId以及version。这三个属性可以唯一确定一个组件（Jar包或者War包）。
一个完整的pom.xml文件，放置在项目的根目录下：
1. <project xmlns="http://maven.apache.org/POM/4.0.0"
2. xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
3. xsi:schemaLocation="http://maven.apache.org/POM/4.0.0
4. http://maven.apache.org/maven-v4_0_0.xsd">
5. <modelVersion>4.0.0</modelVersion>
6.
7. <!– The Basics 基本设置–>
8. //GroupID是项目组织唯一的标识符，实际对应JAVA的包的结构，是main目录里java的目录结构
9. <groupId>com.xxx</groupId>
10. <artifactId>ssmm</artifactId> //artifactId : 项目名称，此名称则是本地仓库中的路径
11. <version>1.0-SNAPSHOT</version>
12. //packaging : 打包的格式，可以为：pom , jar , maven-plugin , ejb , war , ear , rar , par
13. <packaging>war</packaging>
14. <dependencies>…</dependencies>
15. <parent>…</parent>
16. <dependencyManagement>…</dependencyManagement>
17. <modules>…</modules>
18. <properties>…</properties>
19.
20. <!– Build Settings构建过程的设置 –>
21. <build>…</build>
22. <reporting>…</reporting>
23.
24. <!– More Project Information项目信息设置 –>
25. <name>…</name> //元素声明了一个对用户更为友好的项目名称
26. <description>…</description>
27. <url>…</url>
28. <inceptionYear>…</inceptionYear>
29. <licenses>…</licenses>
30. <organization>…</organization>
31. <developers>…</developers>
32. <contributors>…</contributors>
33.
34. <!– Environment Settings 环境设置 –>
35. <issueManagement>…</issueManagement>
36. <ciManagement>…</ciManagement>
37. <mailingLists>…</mailingLists>
38. <scm>…</scm>
39. <prerequisites>…</prerequisites>
40. <repositories>…</repositories>
41. <pluginRepositories>…</pluginRepositories>
42. <distributionManagement>…</distributionManagement>
43. <profiles>…</profiles>
44. </project>
二、POM之间的关系
如果当我们有多个项目要进行，这多个项目有些配置内容是相同的，有些是要彼此关联的，那如果按照传统的做法的话我们就需要在多个项目中都定义这些重复的内容。这无疑是非常耗费时间和不易维护的。好在Maven给我们提供了一个pom的继承和聚合的功能。
对于使用java的人而言，继承这个词大家应该都不陌生。要继承pom就需要有一个父pom，在Maven中定义了超级pom.xml，任何没有申明自己父pom.xml的pom.xml都将默认继承自这个超级pom.xml。
位置：
在Maven 2.xxx版本中，比如maven-2.0.9-uber.jar，打开此Jar文件后，在包包org.apache.maven.project下会有pom-4.0.0.xml的文件。
但是到了3.xxx版本之后在：maven安装目录下的：/lib/maven-model-builder-version.jar中 orgapachemavenmode目录中的pom-4.0.0.xml。
对于一个pom.xml来说有几个元素是必须定义的，一个是project根元素，然后就是它里面的modelVersion、groupId、 artifactId和version。由上面的超级pom.xml的内容我们可以看到超级pom.xml中没有groupId、artifactId和version的定义，所以我们在建立自己的pom.xml的时候就需要定义这三个元素。和java里面的继承类似，子pom.xml会完全继承父pom.xml中所有的元素，而且对于相同的元素，一般子pom.xml中的会覆盖父pom.xml中的元素，但是有几个特殊的元素它们会进行合并而不是覆盖。这些特殊的元素是：
dependencies（属国）
developers（开发商）
contributors（贡献者）
plugin（插件）列表，包括plugin下面的reports（报告）
resources（资源）
1.继承(增加代码的重用性)
（1）标签：<parent>
（2）例子：被继承项目与继承项目是父子目录关系：
现在假设我们有一个项目projectA，它的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.tiantian.mavenTest</groupId>
<artifactId>projectA</artifactId>
<packaging>jar</packaging>
<version>1.0-SNAPSHOT</version>
</project>
然后我们有另一个项目projectB，而且projectB是跟projectA的pom.xml文件处于同一个目录下：
------projectA
------pom.xml
------projectB
------pom.xml
这时候如果projectB需要继承自projectA的话我们可以这样定义projectB的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">
<parent>
<groupId>com.tiantian.mavenTest</groupId>
<artifactId>projectA</artifactId>
<version>1.0-SNAPSHOT</version>
</parent>
<modelVersion>4.0.0</modelVersion>
<groupId>com.tiantian.mavenTest</groupId>
<artifactId>projectB</artifactId>
<packaging>jar</packaging>
<version>1.0-SNAPSHOT</version>
</project>
由projectB的pom.xml文件的定义我们可以知道，当需要继承指定的一个Maven项目时，我们需要在自己的pom.xml中定义一个parent元素，在这个元素中指明需要继承项目的groupId、artifactId和version。
（3）例子：被继承项目与继承项目的目录结构不是父子关系：
当被继承项目与继承项目的目录结构不是父子关系的时候，我们再利用上面的配置是不能实现Maven项目的继承关系的，这个时候我们就需要在子项目的pom.xml文件定义中的parent元素下再加上一个relativePath元素的定义，用以描述父项目的pom.xml文件相对于子项目的pom.xml文件的位置。
假设我们现在还是有上面两个项目，projectA和projectB，projectB还是继承自projectA，但是现在projectB不在projectA的子目录中，而是与projectA处于同一目录中。这个时候projectA和projectB的目录结构如下：
------projectA
------pom.xml
------projectB
------pom.xml
这个时候我们可以看出projectA的pom.xml相对于projectB的pom.xml的位置是“../projectA/pom.xml”，所以这个时候projectB的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">
<parent>
<groupId>com.tiantian.mavenTest</groupId>
<artifactId>projectA</artifactId>
<version>1.0-SNAPSHOT</version>
<relativePath>../projectA/pom.xml</relativePath>
</parent>
<modelVersion>4.0.0</modelVersion>
<groupId>com.tiantian.mavenTest</groupId>
<artifactId>projectB</artifactId>
<packaging>jar</packaging>
<version>1.0-SNAPSHOT</version>
</project>
2. 聚合（减轻编译与打包的繁琐操作）
对于聚合这个概念搞java的人应该都不会陌生。先来说说我对聚合和被聚合的理解，比如说如果projectA聚合到projectB，那么我们就可以说projectA是projectB的子模块， projectB是被聚合项目，也可以类似于继承那样称为父项目。对于聚合而言，这个主体应该是被聚合的项目。所以，我们需要在被聚合的项目中定义它的子模块，而不是像继承那样在子项目中定义父项目。具体做法是：
修改被聚合项目的pom.xml中的packaging元素的值为pom;
在被聚合项目的pom.xml中的modules元素下指定它的子模块项目;
对于聚合而言，当我们在被聚合的项目上使用Maven命令时，实际上这些命令都会在它的子模块项目上使用。这就是Maven中聚合的一个非常重要的作用。假设这样一种情况，你同时需要打包或者编译projectA、projectB、projectC和projectD，按照正常的逻辑我们一个一个项目去使用mvn compile或mvn package进行编译和打包，对于使用Maven而言，你还是这样使用的话是非常麻烦的。因为Maven给我们提供了聚合的功能。我们只需要再定义一个超级项目，然后在超级项目的pom.xml中定义这个几个项目都是聚合到这个超级项目的。之后我们只需要对这个超级项目进行mvn compile，它就会把那些子模块项目都进行编译。
（1）标签：<modules>
（2）举例：被聚合项目和子模块项目在目录结构上是父子关系：
还拿上面定义的projectA和projectB来举例子，现在假设我们需要把projectB聚合到projectA中。projectA和projectB的目录结构如下所示：
------projectA
------projectB
-----pom.xml
------pom.xml
这个时候projectA的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.tiantian.mavenTest</groupId>
<artifactId>projectA</artifactId>
<version>1.0-SNAPSHOT</version>
<packaging>pom</packaging>
<modules>
<module>projectB</module>
</modules>
</project>
由上面的定义我们可以看到被聚合的项目的packaging类型应该为pom，而且一个项目可以有多个子模块项目。对于聚合这种情况，我们使用子模块项目的artifactId来作为module的值，表示子模块项目相对于被聚合项目的地址，在上面的示例中就表示子模块projectB是处在被聚合项目的子目录下，即与被聚合项目的pom.xml处于同一目录。这里使用的module值是子模块projectB对应的目录名projectB，而不是子模块对应的artifactId。这个时候当我们对projectA进行mvn package命令时，实际上Maven也会对projectB进行打包。
（3）例子：被聚合项目与子模块项目在目录结构上不是父子关系：
<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.tiantian.mavenTest</groupId>
<artifactId>projectA</artifactId>
<version>1.0-SNAPSHOT</version>
<packaging>pom</packaging>
<modules>
<module>../projectB</module>
</modules>
</project>
注意看module的值是“../projectB”，我们知道“..”是代表当前目录的上层目录，所以它表示子模块projectB是被聚合项目projectA的pom.xml文件所在目录（即projectA）的上层目录下面的子目录，即与projectA处于同一目录层次。注意，这里的projectB对应的是projectB这个项目的目录名称，而不是它的artifactId。
（4）例子：聚合与继承同时进行（继承修改子pom，聚合修改被聚合的pom）：
假设有这样一种情况，有两个项目，projectA和projectB，现在我们需要projectB继承projectA，同时需要把projectB聚合到projectA。然后projectA和projectB的目录结构如下：
------projectA
------pom.xml
------projectB
------pom.xml
那么这个时候按照上面说的那样，projectA的pom.xml中需要定义它的packaging为pom，需要定义它的modules，所以projectA的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.tiantian.mavenTest</groupId>
<artifactId>projectA</artifactId>
<version>1.0-SNAPSHOT</version>
<packaging>pom</packaging>
<modules>
<module>../projectB</module>
</modules>
</project>
而projectB是继承自projectA的，所以我们需要在projectB的pom.xml文件中新增一个parent元素，用以定义它继承的项目信息。所以projectB的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>
<parent>
<groupId>com.tiantian.mavenTest</groupId>
<artifactId>projectA</artifactId>
<version>1.0-SNAPSHOT</version>
<relativePath>../projectA/pom.xml</relativePath>
</parent>
<groupId>com.tiantian.mavenTest</groupId>
<artifactId>projectB</artifactId>
<version>1.0-SNAPSHOT</version>
<packaging>jar</packaging>
</project>
3. 依赖
（1）标签：<plugins>
1. <plugins>
2. <plugin>
3. <artifactId>maven-war-plugin</artifactId>
4. <version>2.1-alpha-2</version>
5. </plugin>
6. </plugins>
（2）举例：
项目之间的依赖是通过pom.xml文件里面的dependencies元素下面的dependency元素进行的。一个dependency元素定义一个依赖关系。在dependency元素中我们主要通过依赖项目的groupId、artifactId和version来定义所依赖的项目。
先来看一个简单的项目依赖的示例吧，假设我现在有一个项目projectA，然后它里面有对junit的依赖，那么它的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.tiantian.mavenTest</groupId>
<artifactId>projectB</artifactId>
<version>1.0-SNAPSHOT</version>
<packaging>jar</packaging>
<dependencies>
<dependency>
<groupId>junit</groupId>
<artifactId>junit</artifactId>
<version>3.8.1</version>
<scope>test</scope>
<optional>true</optional>
</dependency>
</dependencies>
</project>