1 <?xml version="1.0" encoding="UTF-8"?>
 2 <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">
 3     <modelVersion>4.0.0</modelVersion>
 4 
 5     <groupId>maven.zyr</groupId>
 6     <artifactId>maven01</artifactId>
 7     <version>0.0.1-SNAPSHOT</version>
 8 
 9     <dependencies>
10         <dependency>
11             <groupId>junit</groupId>
12             <artifactId>junit</artifactId>
13             <version>4.12</version>
14         </dependency>
15         
16     </dependencies>
17 </project>

1 package zyr.maven;
2 
3 public class Hello{
4     public String sayHello(){
5         return "Hello Maven";
6     }
7 }

 1 package zyr.maven;
 2 
 3 import org.junit.*;
 4 
 5 public class TestClass{
 6     @Test
 7     public void testHello(){
 8         System.out.println(new Hello().sayHello());
 9     }
10 }

mvn compile

mvn test

1 mvn install

 mvn archetype:generate

  maven使用groupId、artifactId、version唯一确定坐标，每个坐标都唯一的指向一个maven项目：
   包名应与groupId+artifactId相吻合
　　groupId:项目组织唯一的标识符，一般为反写的公司网址+项目名，跟 Java 包名类似，通常与域名反向一一对应。
　　artifactId:项目的唯一的标识符，一般为项目名+模块名，定义当前 Maven 项目的一个模块，默认情况下，Maven 生成的构件，其文件名会以 artifactId 开头，如 hibernate-core-3.6.5.Final.jar。
　　version:版本号 x.x.x+版本类型
　　           第一个x表示大版本号
　　　　　      第二个x表示分支版本号
　　　　　      第三个x表示小版本号（可省略）
　　　　　   常见版本类型：
　　　　　　　     snapshot快照
　　　　　　　　　　alpha内部测试
　　　　　　　　　　beta公测
　　　　　　　　　　release稳定
　　　　　　　　　　GA正式发布

packaging：定义项目打包方式，如 jar，war，pom，zip ……，默认为 jar。

classifier：定义项目的附属构件，如 hibernate-core-3.6.6.Final-sources.jar，hibernate-core-3.6.6.Final-javadoc.jar，其中 sources 和 javadoc 就是这两个附属构件的 classifier。classifier 不能直接定义，通常由附加的插件帮助生成。

　　　　mvn
　　　　　　 -v 查看maven版本及其他相关信息
　　　　　　 compile 编译maven项目，并生成target文件夹
　　　　　　 test 运行test目录下的测试文件，即测试
　　　　　　 package 将项目打包，默认打包为jar格式，也可以打包成war格式用于服务器运行
　　　　　　 install 将打包的jar文件安装到maven本地仓库（仓库后面会详细介绍）
　　　　　　 clean 删除targert，相当于清除缓存

　　多个生命周期之间相互独立。每个生命周期含有多个阶段，阶段按顺序执行，运行后阶段时，前阶段会自动执行。
　　完整的项目构建构成包括：
　　　　清理、编译、测试、打包、集成测试、验证、部署
　　　　clean 清理项目，包括以下阶段：
　　　　　　pre-clean 执行清理前
　　　　　　clean 清理上一次构建生成的所有文件
　　　　　　post-clean 执行清理后的文件

　　　　default 构建项目(核心：常用)，包括以下阶段

1. 1. validate
   2. initialize
   3. generate-sources
   4. process-sources
   5. generate-resources
   6. process-resources    ：复制和处理资源文件到target目录，准备打包；
   7. compile    ：编译项目的源代码；
   8. process-classes
   9. generate-test-sources
   10. process-test-sources
   11. generate-test-resources
   12. process-test-resources
   13. test-compile    ：编译测试源代码；
   14. process-test-classes
   15. test    ：运行测试代码；
   16. prepare-package
   17. package    ：打包成jar或者war或者其他格式的分发包；
   18. pre-integration-test
   19. integration-test
   20. post-integration-test
   21. verify
   22. install    ：将打好的包安装到本地仓库，供其他项目使用；
   23. deploy    ：将打好的包安装到远程仓库，供其他项目使用；

　　　　　其中主要包括这几个步骤：
             compile 编译
　　　　　　   test 测试
　　　　　　   packeage 打包
　　　　　　   install 安装


　　　　site 生成项目站点,根据pom中信息生成项目站点，包括以下阶段
　　　　　　pre-site 在生成项目站点前要完成的工作
　　　　　　site生成项目的站点文档
　　　　　　post-site在生成项目站点后要完成的工作
　　　　　　site-deploy发布生成的站点到服务器上

 1 <build>
 2     <plugins>
 3         <plugin>
 4             <groupId>org.apache.maven.plugins</groupId>
 5             <artifactId>maven-source-plugin</artifactId>
 6             <version>2.2.1</version>
 7             <executions>
 8                 <execution>
 9                     <id>attach-source</id>
10                     <phase>package</phase><!-- 要绑定到的生命周期的阶段 -->
11                     <goals>
12                         <goal>jar-no-fork</goal><!-- 要绑定的插件的目标 -->
13                     </goals>
14                 </execution>
15             </executions>
16         </plugin>
17     </plugins>
18 </build>

1 <plugin>
2     <groupId>org.apache.maven.plugins</groupId>
3     <artifactId>maven-compiler-plugin</artifactId>
4     <configuration>
5         <source>1.7</source>
6         <target>1.7</target>
7     </configuration>
8 </plugin>

 1 <project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
 2     xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
 3     <!-- 当前pom的版本-->
 4     <modelVersion>4.0.0</modelVersion>
 5 
 6     <!--坐标-->
 7     <groupId>cn.edu</groupId>
 8     <artifactId>maven04</artifactId>
 9     <version>0.0.1-SNAPSHOT</version>
10     <!-- 默认是jar，其他war zip pom等 -->
11     <packaging>jar</packaging>
12 
13     <!--项目描述名 -->
14     <name>maven04</name>
15     <!-- 项目地址 -->
16     <url>http://maven.apache.org</url>
17 
18     <!-- 配置参数 -->
19     <properties>
20         <!-- 这里配置项目编译编码为UTF-8-->
21         <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
22     </properties>
23     
24     <!-- 开发人员信息 -->
25     <developers></developers>
26     <!-- 项目描述 -->
27     <description></description>
28     <!-- 许可信息 -->
29     <licenses></licenses>
30     <!-- 组织信息 -->
31     <organization></organization>
32     <!-- 依赖集，用于配置依赖 -->
33     <dependencies>
34         <dependency>
35             <groupId>junit</groupId>
36             <artifactId>junit</artifactId>
37             <version>3.8.1</version>
38             
39             <!-- 依赖范围：这个jar包只在范围内生效，范围外引用会报错，这里让junit只在test时被依赖。
40                             其他一些情况，如：servlet-api.jar，在编译阶段需要引用，而在服务器运行阶段则不需要引用，就可以使用scope-->
41             <scope>test</scope>
42 
43             <!-- 默认为false，子项目将会继承，true时子项目需要显式引用 -->
44             <optional>false</optional>
45 
46             <!-- 排除依赖列表：用于去除传递依赖等-->
47             <exclusions>
48                 <exclusion></exclusion>
49             </exclusions>
50             
51 
52         </dependency>
53     </dependencies>
54     
55     <!-- 依赖管理
56             为依赖进行统一管理，如果在父项目中声明此标签时，在子项目中不需声明，确保父子项目依赖版本一致；
57             如子项目需要不同版本的依赖，只需在子项目中进行声明即可，将会覆盖父项目中的声明。
58      -->
59     <!--     
60         <dependencyManagement>
61             <dependencies>
62                 <dependency></dependency>
63             </dependencies>
64         </dependencyManagement> 
65     -->
66     
67     <!--配置构建时的属性-->
68     <build>
69         <plugins></plugins>
70     </build>
71     
72     <!-- 指定父模块 -->
73         <!-- <parent></parent> -->
74 
75     <!-- 用于聚合编译多个maven模块 -->
76     <modules></modules>
77 </project>

　   范围：maven中提供了三种classpath:编译、测试、运行
　　　　scope标签
　　　　　　-compile 默认，编译测试运行均有效，会传递
　　　　　　-provided 在编译和测试时有效，如servletAPI可以加入，不传递
　　　　　　-runtime 在测试和运行时有效，如JDBCAPI可以加入
　　　　　　-test 在测试时有效，如junit可以加入
　　　　　　-system 在编译和测试时有效，与本机系统相关联，移植性差，在系统中以外部jar包的形式引入，不会在仓库中查找
　　　　　　-import 导入，只能用在dependecyManagement中，表示从其他pom中导入dependecy的配置
　　 传递：
　　　　 如果C依赖B，B依赖A，那么C→B→A，那么此时C也会依赖A且会包含A中的依赖,这就是传递依赖。消除传递依赖：需要使用<exclusions>
    冲突：
        当多个传递性依赖中有对同一构件不同版本的依赖时，如何解决呢？
        短路径优先：假如有以下依赖：A -> B -> C ->X(版本 1.0) 和 A -> D -> X(版本 2.0)，则优先解析较短路径的 X(版本 2.0)；
        先声明优先：若路径长度相同，则谁先声明，谁被解析。
   依赖排除：
       针对依赖冲突中的“短路径优先”，如果我们想使用长路径的依赖怎么办呢？
       这时可以使用依赖排除 <exclusions> 元素，显示排除短路径依赖。在非冲突的情况下，这种方法同样有效。

   依赖归类：
       通常在项目中，我们会同时依赖同一个构件的不同模块，如 spring-orm-3.2.0，spring-context-3.2.0，且多个模块版本相同，
       为了维护和升级方便，我们可以对其同一管理，这时可以使用到 Maven 属性，类似于变量的概念。
<properties>
    <springframework.version>3.2.0.RELEASE</springframework.version>
</properties>

<dependencies>
    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-orm</artifactId>
        <version>${springframework.version}</version>
    </dependency>
    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-context</artifactId>
        <version>${springframework.version}</version>
    </dependency>
</dependencies>

1   <modules>
2     <!--这里的路径是基于D项目的pom.xml路径，module标签内为指向其他项目的pom文件的路径
3        A、B、C、D项目在同一个文件夹内，那么从D内的pom中，通过../项目名，来找到其他项目的pom.xml-->
4       <module>../A</module>
5       <module>../B</module>
6       <module>../C</module>
7   </modules>

 1 <project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
 2     xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
 3     <modelVersion>4.0.0</modelVersion>
 4 
 5     <groupId>cn.edu</groupId>
 6     <artifactId>parent</artifactId>
 7     <version>0.0.1-SNAPSHOT</version>
 8     <packaging>pom</packaging>
 9 
10     <name>parent</name>
11     <url>http://maven.apache.org</url>
12 
13     <properties>
14         <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
15     </properties>
16 
17     <dependencies>
18         <dependency>
19             <groupId>junit</groupId>
20             <artifactId>junit</artifactId>
21             <version>4.12</version>
22             <scope>test</scope>
23         </dependency>
24     </dependencies>
25 
26     <dependencyManagement>
27         <!-- 在这里声明的依赖可以被子项目继承引用 -->
28         <dependencies>
29             <dependency>
30                 <groupId>commons-io</groupId>
31                 <artifactId>commons-io</artifactId>
32                 <version>2.4</version>
33             </dependency>
34         </dependencies>
35     </dependencyManagement>
36 </project>

 1 <project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
 2     xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
 3     <modelVersion>4.0.0</modelVersion>
 4 
 5 
 6     <groupId>cn.edu</groupId>
 7     <artifactId>B</artifactId>
 8     <version>0.0.1-SNAPSHOT</version>
 9     <packaging>jar</packaging>
10 
11     <name>B</name>
12     <url>http://maven.apache.org</url>
13 
14     <properties>
15         <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
16     </properties>
17 
18     <!-- 在parent标签中使用父项目的坐标进行配置 -->
19      <parent>
20           <groupId>cn.edu</groupId> 
21           <artifactId>parent</artifactId> 
22         <version>0.0.1-SNAPSHOT</version> 
23     </parent>
24     
25     <dependencies>
26         <!-- 此处使用依赖时，就不需声明版本 -->
27         <dependency> 
28             <groupId>commons-io</groupId> 
29             <artifactId>commons-io</artifactId> 
30         </dependency>
31         
32         <dependency>
33             <groupId>junit</groupId>
34             <artifactId>junit</artifactId>
35             <version>4.12</version>
36             <scope>test</scope>
37         </dependency>
38     </dependencies>
39 </project>