maven命令/依赖/聚合

一，编写pom.xml

 

首先我们看一下pom.xml

 

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. <groupId>com.ys.hello</groupId>
5. <artifactId>hello-world</artifactId>
6. <version>0.0.1-SNAPSHOT</version>
7. <packaging>jar</packaging>
8. <name>hello-world</name>
9. <url>http://maven.apache.org</url>
10. <properties>
11. <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
12. </properties>
13. <dependencies>
14. <dependency>
15. <groupId>junit</groupId>
16. <artifactId>junit</artifactId>
17. <version>3.8.1</version>
18. <scope>test</scope>
19. </dependency>
20. </dependencies>
21. </project>

 

第一个子元素modelVersion指定了当前POM模型的版本，对于Maven2及Maven 3来说，它只能是4.0.0。

 

groupId，artifactId和version三行。这三个元素定义了一个项目基本的坐标，在Maven的世界，任何的jar、pom或者war都是以基于这些基本的坐标进行区分的。

 

groupId定义了项目属于哪个组，这个组往往和项目所在的组织或公司存在关联,例如com.google.myapp(前面代表公司名，后面myapp代表项目名)

 

artifactId定义了当前Maven项目在组中唯一的ID，建议使用   项目的名称-模块名称例如   myapp-hello

 

version指定了Hello World项目当前的版本——1.0-SNAPSHOT。SNAPSHOT意为快照，说明该项目还处于开发中，是不稳定的版本.

 

 

二，源代码存放位置

 

 

 

 

 

Maven依赖查询：

网上提供了坐标的查询
http://mvnrepository.com
http://www.sonatype.org/nexus/

三，maven常用命令

 

1. 创建Maven的普通java项目： 
mvn archetype:create -DgroupId=packageName -DartifactId=projectName 
2. 创建Maven的Web项目： 
mvn archetype:create -DgroupId=packageName -DartifactId=webappName -DarchetypeArtifactId=maven-archetype-webapp 
3. 编译源代码： mvn compile 
4. 编译测试代码：mvn test-compile 
5. 运行测试：mvn test 
6. 产生site：mvn site 
7. 打包：mvn package 
8. 在本地Repository中安装jar：mvn install 
9. 清除产生的项目：mvn clean 
10. 生成eclipse项目：mvn eclipse:eclipse 
11. 生成idea项目：mvn idea:idea 
12. 组合使用goal命令，如只打包不测试：mvn -Dtest package 
13. 编译测试的内容：mvn test-compile 
14. 只打jar包: mvn jar:jar 
15. 只测试而不编译，也不测试编译：mvn test -skipping compile -skipping test-compile ( -skipping 的灵活运用，当然也可以用于其他组合命令) 
16. 清除eclipse的一些系统设置:mvn eclipse:clean 

17.mvn clean表示运行清理操作（会默认把target文件夹中的数据清理）
18.mvn clean package运行清理和打包
19.mvn clean install运行清理和安装（会将打好的jar包安装到本地仓库中，以便其他的项目可以调用）
20.mvn clean compile表示先运行清理，之后运行编译，会将代码编译到target文件夹中
21.mvn clean test运行清理和测试
22.mvn package deploy 运行清理和发布（发布到私有服务器上面）
23.mvn clean 
24.mvn archetype:generate生成骨架

 

 

 

四，maven依赖

1. <dependencies>
2. <dependency>
3. <groupId>junit</groupId>
4. <artifactId>junit</artifactId>
5. <version>3.8.1</version>
6. <scope>test</scope>
7. </dependency>
8. </dependencies>

type: 依赖的类型，对应于项目坐标定义的packaging。大部分情况下，该元素不必声明，其默认值是jar

 

  scope: 依赖的范围，下面会进行详解

 

  optional: 标记依赖是否可选

 

  exclusions: 用来排除传递性依赖，下面会进行详解

1依赖的范围：

依赖范围就是用来控制依赖与这三种classpath(编译classpath、测试classpath、运行classpath)的关系，Maven有以下几种依赖范围：

 

compile: 编译依赖范围。如果没有指定，就会默认使用该依赖范围。使用此依赖范围的Maven依赖，对于编译、测试、运行三种classpath都有效。

 

test: 测试依赖范围。使用此依赖范围的Maven依赖，只对于测试classpath有效，在编译主代码或者运行项目的使用时将无法使用此类依赖。典型的例子就是JUnit，它只有在编译测试代码及运行测试的时候才需要。

 

provided: 已提供依赖范围。使用此依赖范围的Maven依赖，对于编译和测试classpath有效，但在运行时无效。典型的例子是servlet-api，编译和测试项目的时候需要该依赖，但在运行项目的时候，由于容器已经提供，就不需要Maven重复地引入一遍。

 

runtime: 运行时依赖范围。使用此依赖范围的Maven依赖，对于测试和运行classpath有效，但在编译主代码时无效。典型的例子是JDBC驱动实现，项目主代码的编译只需要JDK提供的JDBC接口，只有在执行测试或者运行项目的时候才需要实现上述接口的具体JDBC驱动。

 

system: 系统依赖范围。该依赖与三种classpath的关系，和provided依赖范围完全一致。但是，使用system范围依赖时必须通过systemPath元素显式地指定依赖文件的路径。由于此类依赖不是通过Maven仓库解析的，而且往往与本机系统绑定，可能造成构建的不可移植，因此应该谨慎使用。systemPath元素可以引用环境变量，如：

1. <dependency>
2. <groupId>javax.sql</groupId>
3. <artifactId>jdbc-stdext</artifactId>
4. <version>2.0</version>
5. <scope></scope>
6. <systemPath>${java.home}/lib/rt.jar</systemPath>
7. </dependency>

 

2，依赖的传递性

我们先看一下pom.xml文件

 

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. <groupId>com.ys.hello</groupId>
5. <artifactId>hello-world</artifactId>
6. <version>0.0.1-SNAPSHOT</version>
7. <packaging>jar</packaging>
8. <name>hello-world</name>
9. <url>http://maven.apache.org</url>
10. <properties>
11. <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
12. </properties>
13. <dependencies>
14. <dependency>
15. <groupId>junit</groupId>
16. <artifactId>junit</artifactId>
17. <version>3.8.1</version>
18. <scope>test</scope>
19. </dependency>
20. <dependency>
21. <groupId>org.springframework</groupId>
22. <artifactId>spring-core</artifactId>
23. <version>3.2.3.RELEASE</version>
24. </dependency>
25. </dependencies>
26. </project>

我们可以看到此项目引入依赖junit和spring-core，

 

但我们的maven引入包的情况为

 

 

3，可选依赖

有时候我们不想让依赖传递，那么可配置该依赖为可选依赖，将元素optional设置为true即可,例如：

1. <dependency>
2. <groupId>commons-logging</groupId>
3. <artifactId>commons-logging</artifactId>
4. <version>1.1.1</version>
5. <optional>true<optional>
6. </dependency>

4，排除依赖

 当我们引入第三方jar包的时候，难免会引入传递性依赖，有些时候这是好事，然而有些时候我们不需要其中的一些传递性依赖

比如上例中的项目，我们不想引入传递性依赖commons-logging，我们可以使用exclusions元素声明排除依赖，exclusions可以包含一个或者多个exclusion子元素，因此可以排除一个或者多个传递性依赖。需要注意的是，声明exclusions的时候只需要groupId和artifactId，而不需要version元素，这是因为只需要groupId和artifactId就能唯一定位依赖图中的某个依赖。换句话说，Maven解析后的依赖中，不可能出现groupId和artifactId相同，但是version不同的两个依赖。

 如下是一个排除依赖的例子：

1. <dependency>
2. <groupId>org.springframework</groupId>
3. <span style="white-space:pre">          </span><artifactId>spring-core</artifactId>
4. <span style="white-space:pre">          </span><version>3.2.3.RELEASE</version>
5. <exclusions>
6. <exclusion>
7. <groupId>commons-logging</groupId>
8. <artifactId>commons-logging</artifactId>
9. </exclusion>
10. </exclusions>
11. </dependency>

5，properties属性

 

五，maven的聚合问题

为了能够使用一条命令就能构建 account-email和 account-persist两个模块，我们需要建立一个额外的名为 account-aggregator的模块，然后通过该模块构建整个项目的所有模块。 account-aggregator本身也是个 Maven项目，它的 POM如下

 

1. <project>
2. <modelVersion>4.0.0</modelVersion>
3. <groupId>com.ys.account</groupId>
4. <artifactId>account-aggregator</artifactId>
5. <version>1.0.0-SNAPSHOT</version>
6. <packaging> pom </packaging>
7. <name>Account Aggregator</name>
8. <modules>
9. <module>../account-email</module>
10. <module>../account-persist</module>
11. </modules>
12. </project>

 注意：packaging的类型为pom ，module的值是一个以当前POM为主目录的相对路径。

 

六，maven的继承问题

 

父模块POM如下：

1. <project>
2. <modelVersion>4.0.0</modelVersion>
3. <groupId>com.ys.account</groupId>
4. <artifactId> account-parent </artifactId>
5. <version>1.0.0-SNAPSHOT</version>
6. <packaging>pom</packaging>
7. <name>Account Parent</name>
8. </project>

子模块声明继承如下：

1. <project>
2. <modelVersion>4.0.0</modelVersion>

1. <span style="white-space:pre">  </span><!--继承-->
2. < parent >
3. <groupId>com.ys.account</groupId>
4. <artifactId> account-parent </artifactId>
5. <version>1.0.0-SNAPSHOT</version>
6. < relativePath >../account-parent/pom.xml</ relativePath>
7. </ parent >
8. <artifactId> account-email </artifactId>
9. <name>Account Email</name>
10. ...
11. </project>

最后，同样还需要把 account-parent加入到聚合模块account-aggregator中。聚合的 POM如下：

 

1. <project>
2. <modelVersion>4.0.0</modelVersion>
3. <groupId>com.ys.account</groupId>
4. <artifactId>account-aggregator</artifactId>
5. <version>1.0.0-SNAPSHOT</version>
6. <packaging> pom </packaging>
7. <name>Account Aggregator</name>
8. <modules>
9. <module>account-email</module>
10. <module>account-persist</module>
11. <module> account-parent</module>
12. </modules>
13. </project>

注意：

1、子模块没有声明groupId和version, 这两个属性继承至父模块。但如果子模块有不同与父模块的 groupId、version ，也可指定；

2、不应该继承artifactId,如果groupId ，version，artifactId 完全继承的话会造成坐标冲突；另外即使使用不同的 groupId或version，同样的 artifactId也容易产生混淆。
3、使用继承后 parent也必须像自模块一样加入到聚合模块中。也就是在在聚合模块的 pom中加入<module>account-parent</module>

 

 

Maven可继承的POM 元素

 

groupId ：项目组 ID ，项目坐标的核心元素；
version ：项目版本，项目坐标的核心元素；
description ：项目的描述信息；
organization ：项目的组织信息；
inceptionYear ：项目的创始年份；
url ：项目的 url 地址
develoers ：项目的开发者信息；
contributors ：项目的贡献者信息；
distributionManagerment ：项目的部署信息；
issueManagement ：缺陷跟踪系统信息；
ciManagement ：项目的持续继承信息；
scm ：项目的版本控制信息；
mailingListserv ：项目的邮件列表信息；
properties ：自定义的 Maven 属性；
dependencies ：项目的依赖配置；
dependencyManagement ：醒目的依赖管理配置；
repositories ：项目的仓库配置；
build ：包括项目的源码目录配置、输出目录配置、插件配置、插件管理配置等；
reporting ：包括项目的报告输出目录配置、报告插件配置等。

 

 

七，聚合与继承的关系

 

区别 ：

1.对于聚合模块来说，它知道有哪些被聚合的模块，但那些被聚合的模块不知道这个聚合模块的存在。

2.对于继承关系的父 POM来说，它不知道有哪些子模块继承与它，但那些子模块都必须知道自己的父 POM是什么。

 

共同点 ：

1.聚合 POM与继承关系中的父POM的 packaging都是pom

2.聚合模块与继承关系中的父模块除了 POM之外都没有实际的内容。

注：在现有的实际项目中一个 POM既是聚合POM，又是父 POM，这么做主要是为了方便