Maven入门学习

文档版本 开发工具 测试平台 工程名字 日期 作者 备注 V1.0 2016.07.08 lutianfei none

---

MAVEN 说明

• 翻译为：“专家”，“内行”

• Maven是跨平台的项目管理工具。主要服务于基于Java平台的项目构建，依赖管理和项目信息管理。

• 理想的项目构建？

  • 高度自动化，跨平台，可重用的组件

• 什么是依赖？为什么要进行依赖管理？

  • 自动下载，统一依赖管理

• 管理哪些项目信息？

  • 项目名称描述等，开发人员信息，开发者信息等

MAVEN 模型

为什么使用Maven

• Eclipse
  
  • 手工操作较多，编译、测试、部署等工作都是独立的，很难一步完成
  • 每个人的IDE配置都不同，很容易出现本地代码换个地方编译就出错
• Ant
  
  • 没有一个约定的目录结构
  • 必须明确让ant做什么，什么时候做，然后编译，打包
  • 没有生命周期，必须定义目标及其实现的任务序列
  • 没有集成依赖管理
• Maven
  
  • 拥有约定，知道你的代码在哪里，放到哪里去
  • 拥有一个生命周期，例如执行 mvn install 就可以自动执行编译，测试，打包等构建过程
  • 只需要定义一个pom.xml,然后把源码放到默认的目录，Maven帮你处理其他事情
  • 拥有依赖管理，仓库管理

MAVEN 安装与初始化说明

MAVEN 安装

• 直接解压bin压缩包即可。

• 目录说明

  • bin：含有mvn运行的脚本
  • boot：含有plexus-classworlds类加载器框架
  • conf：含有settings.xml配置文件
  • lib：含有Maven运行时所需要的java类库
  • LICENSE.txt, NOTICE.txt, README.txt针对Maven版本，第三方软件等简要介绍

• 设置MAVEN_HOME环境变量

  • 升级时只需要下载最新版本，解压缩后重新设置MAVEN_HOME环境变量即可
• 设置MAVEN_OPTS环境变量
  
  • -Xms128m -Xmx512m
• 配置用户范围的settings.xml
  
  • MAVEN_HOME/conf/settings.xml 全局的
    
    • ~/.m2/settings.xml
    • 默认仓库：当前用户路径C:\Users\[UserName]\.m2
• 设置自定义jar包仓库
  
  • 在上述路径中将<localRepository>/path/to/local/repo</localRepository>中的路径改为自己所需的路径D:\maven\repository。
  • 将settings.xml文件复制到与repository同目录下。且两边要求一样。
  • localRepository：用户仓库，用于检索依赖包路径
  • 注意：用户级别的仓库在全局配置中一旦设置，全局配置将不再生效，转用用户所设置的仓库，否则使用默认路径仓库
    

Maven约定

• src/main/java —— 存放项目的.java文件
• src/main/resources —— 存放项目资源文件，如spring, hibernate配置文件
• src/test/java —— 存放所有测试.java文件，如JUnit测试类
• src/test/resources —— 测试资源文件
• target —— 项目输出位置
• pom.xml——maven项目核心配置文件

MyEclipse中的MAVEN插件使用

• 加入maven插件
  

• 设置maven仓库
  

新建maven工程

测试工程1

• One.java

public class One {    public String say(String name){        return "hello " +name+" one";    }}
1
2
3
4
5

• OntTest.java

package ledouya.one;import junit.framework.Assert;import org.junit.Test;public class OneTest {    @Test    public void testSay(){        One one = new One();        String ret = one.say("lutianfei");        Assert.assertEquals("hello lutianfei one",ret);    }}
1
2
3
4
5
6
7
8
9
10
11
12
13
14

• pom.xml文件说明
  
  • maven 的模型指的是pom文件的规范
  • 群组ID：单位域名反写
  • 项目ID：一个单位只有一个域名，但是一个单位可以做多个项目
  • 版本号：用于描述开发过程的阶段性标识

<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>    <!-- 群组ID：单位域名反写 -->    <!-- <groupId>cn.itcast</groupId> -->    <!-- 项目ID：一个单位只有一个域名，但是一个单位可以做多个项目 -->    <artifactId>One</artifactId>    <!-- 版本号：用于描述开发过程的阶段性标识 -->    <version>1.0.15-RELEASE</version>    <properties>        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>    </properties>    <!-- 依賴管理 -->    <dependencies>        <!-- 具体的依赖 -->        <dependency>            <groupId>junit</groupId>            <artifactId>juint</artifactId>            <version>4.9</version>            <scope>test</scope>        </dependency>    </dependencies></project>
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25

测试工程2

• 第一步 ： 新建maven工程与工程1一致。

• 第二步 ： 代码编写

• Two.java

package ledouya.two;import ledouya.one.One;public class Two {    public String say(String name){        One one = new One();        String ret = one.say("lutianfei");        return ret + " two";    }}
1
2
3
4
5
6
7
8
9
10
11
12

• TwoTest.java

package ledouya.two;import org.junit.Test;import junit.framework.Assert;public class TwoTest {    @Test    public void testSay(){        Two two = new Two();        String ret = two.say("miaolu");        Assert.assertEquals("hello miaolu one two", ret);    }}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

• 第三步 ： 添加依赖(工程1中的pom文件已经包含了依赖说明)

    <dependency>      <groupId>ledouya</groupId>       <artifactId>one</artifactId>        <version>0.0.1-SNAPSHOT</version>    </dependency>
1
2
3
4
5

• 第四步：将所依赖的工程1打包加载到仓库中。
  
  

完成以上步骤几个运行工程2。

Maven 坐标

• Maven坐标主要组成

  • groupId：定义当前Maven项目隶属项目
  • artifactId：定义实际项目中的一个模块
  • version：定义当前项目的当前版本
  • packaging：定义该项目的打包方式

• Maven为什么使用坐标？

  • Maven世界拥有大量构建，我们需要找一个用来唯一标识一个构建的统一规范拥有了统一规范，就可以把查找工作交给机器。

依赖管理

• 其中依赖范围scope 用来控制依赖和编译，测试，运行的classpath的关系. 主要的是三种依赖关系如下：
  
  • 1.compile： 默认编译依赖范围。对于编译，测试，运行三种classpath都有效
  • 2.test：测试依赖范围。只对于测试classpath有效
  • 3.provided：已提供依赖范围。对于编译，测试的classpath都有效，但对于运行无效。因为由容器已经提供，例如servlet-api
  • 4.runtime:运行时提供。例如:jdbc驱动

依赖配置 ： 传递性依赖和可选依赖,排除依赖

依赖管理-传递依赖

• 例子：
  

  Two中使用One
  Three中使用Two
  称Two是Three的直接依赖
  称One是Three的间接依赖
  C->B B->A
  C直接依赖B
  C间接依赖A

依赖范围对传递依赖的影响


依赖管理-可选依赖

• <optional> true/false 控制当前对象是否向下传递

• 当一个项目A依赖另一个项目B时，项目A可能很少一部分功能用到了项目B，此时就可以在A中配置对B的可选依赖。

  • 举例来说，一个类似hibernate的项目，它支持对mysql、oracle等各种数据库的支持，但是在引用这个项目时，我们可能只用到其对mysql的支持，此时就可以在这个项目中配置可选依赖。

• 配置可选依赖的原因：

  • 1、节约磁盘、内存等空间；
  • 2、避免license许可问题；
  • 3、避免类路径问题，等等。

• 示例：

<project>  ...  <dependencies>    <!-- declare the dependency to be set as optional -->    <dependency>      <groupId>sample.ProjectB</groupId>      <artifactId>Project-B</artifactId>      <version>1.0</version>      <scope>compile</scope>      <optional>true</optional> <!-- value will be true or false only -->    </dependency>  </dependencies></project>
1
2
3
4
5
6
7
8
9
10
11
12
13

• 假设以上配置是项目A的配置，即：Project-A --> Project-B。在编译项目A时，是可以正常通过的。

• 如果有一个新的项目X依赖A，即：Project-X -> Project-A。此时项目X就不会依赖项目B了。

• 如果项目X用到了涉及项目B的功能，那么就需要在pom.xml中重新配置对项目B的依赖。

依赖管理-排除依赖

• 设置当前依赖中是否使用间接依赖

<exclusions>    <exclusion>
1
2

• 当一个项目A依赖项目B，而项目B同时依赖项目C，如果项目A中因为各种原因不想引用项目C，在配置项目B的依赖时，可以排除对C的依赖。

• 示例（假设配置的是A的pom.xml，依赖关系为：A --> B; B --> C）：

<project>  ...  <dependencies>    <dependency>      <groupId>sample.ProjectB</groupId>      <artifactId>Project-B</artifactId>      <version>1.0</version>      <scope>compile</scope>      <exclusions>        <exclusion>  <!-- declare the exclusion here -->          <groupId>sample.ProjectC</groupId>          <artifactId>Project-C</artifactId>        </exclusion>      </exclusions>     </dependency>  </dependencies></project>
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

• 当然，对于多重依赖，配置也很简单，参考如下示例：

  • Project-A-> Project-B-> Project-D -> Project-E

• A对于E相当于有多重依赖，我们在排除对E的依赖时，只需要在配置B的依赖中进行即可：

<project>  <modelVersion>4.0.0</modelVersion>  <groupId>sample.ProjectA</groupId>  <artifactId>Project-A</artifactId>  <version>1.0-SNAPSHOT</version>  <packaging>jar</packaging>  ...  <dependencies>    <dependency>      <groupId>sample.ProjectB</groupId>      <artifactId>Project-B</artifactId>      <version>1.0-SNAPSHOT</version>      <exclusions>        <exclusion>          <groupId>sample.ProjectE</groupId> <!-- Exclude Project-E from Project-B -->          <artifactId>Project-E</artifactId>        </exclusion>      </exclusions>    </dependency>  </dependencies></project>
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

依赖管理-依赖冲突

• 如果直接与间接依赖中包含有同一个坐标不同版本的资源依赖，以直接依赖的版本为准（就近原则）
• 如果直接依赖中包含有同一个坐标不同版本的资源依赖，以配置顺序下方的版本为准（就近原则）

生命周期

• Maven生命周期就是为了对所有的构建过程进行抽象和统一

• 包括项目清理，初始化，编译，打包，测试，部署等几乎所有构建步骤

• Maven三大生命周期

  • clean：清理项目的
  • default：构建项目的
  • site：生成项目站点的

• 生命周期Maven有三套相互独立的生命周期，请注意这里说的是“三套”，而且“相互独立”，这三套生命周期分别是：

  • Clean Lifecycle 在进行真正的构建之前进行一些清理工作。
  • Default Lifecycle 构建的核心部分，编译，测试，打包，部署等等。
  • Site Lifecycle 生成项目报告，站点，发布站点。

• 再次强调一下它们是相互独立的，你可以仅仅调用clean来清理工作目录，仅仅调用site来生成站点。当然你也可以直接运行 mvn clean install site 运行所有这三套生命周期。

生命周期clean

• clean生命周期每套生命周期都由一组阶段(Phase)组成，我们平时在命令行输入的命令总会对应于一个特定的阶段。比如，运行mvn clean ，这个的clean是Clean生命周期的一个阶段。有Clean生命周期，也有clean阶段。Clean生命周期一共包含了三个阶段：
  
  • pre-clean 执行一些需要在clean之前完成的工作
  • clean 移除所有上一次构建生成的文件
  • post-clean 执行一些需要在clean之后立刻完成的工作
• mvn clean 中的clean就是上面的clean，在一个生命周期中，运行某个阶段的时候，它之前的所有阶段都会被运行，也就是说，mvn clean 等同于 mvn pre-clean clean ，如果我们运行 mvn post-clean ，那么 pre-clean，clean 都会被运行。这是Maven很重要的一个规则，可以大大简化命令行的输入。

生命周期default

• Default生命周期Default生命周期是Maven生命周期中最重要的一个，绝大部分工作都发生在这个生命周期中。这里，只解释一些比较重要和常用的阶段：
  
  • validate
  • generate-sources
  • process-sources
  • generate-resources
  • process-resources 复制并处理资源文件，至目标目录，准备打包。
  • compile 编译项目的源代码。
  • process-classes
  • generate-test-sources
  • process-test-sources
  • generate-test-resources
  • process-test-resources 复制并处理资源文件，至目标测试目录。
  • test-compile 编译测试源代码。
  • process-test-classes
  • test 使用合适的单元测试框架运行测试。这些测试代码不会被打包或部署。
  • prepare-package
  • package 接受编译好的代码，打包成可发布的格式，如 JAR 。
  • pre-integration-test
  • integration-test
  • post-integration-test
  • verify
  • install 将包安装至本地仓库，以让其它项目依赖。
  • deploy 将最终的包复制到远程的仓库，以让其它开发人员与项目共享。
• 运行任何一个阶段的时候，它前面的所有阶段都会被运行，这也就是为什么我们运行mvn install 的时候，代码会被编译，测试，打包。此外，Maven的插件机制是完全依赖Maven的生命周期的，因此理解生命周期至关重要。

生命周期site：

• Site生命周期pre-site 执行一些需要在生成站点文档之前完成的工作
• site 生成项目的站点文档
• post-site 执行一些需要在生成站点文档之后完成的工作，并且为部署做准备
• site-deploy 将生成的站点文档部署到特定的服务器上
• 这里经常用到的是site阶段和site-deploy阶段，用以生成和发布Maven站点，这可是Maven相当强大的功能，Manager比较喜欢，文档及统计数据自动生成，很好看。

插件

• Maven的核心仅仅定义了抽象的生命周期，具体的任务都是交由插件完成的
• 每个插件都能实现多个功能，每个功能就是一个插件目标
• Maven的生命周期与插件目标相互绑定，以完成某个具体的构建任务
• 例如compile就是插件maven-compiler-plugin的一个插件目标

<build>    <plugins>        <plugin>                  <groupId>org.apache.maven.plugins</groupId>            <artifactId>maven-source-plugin</artifactId>              <version>2.2.1</version>              <executions>                        <execution>                    <goals>                        <goal>jar-no-fork</goal>                            </goals>                            <phase>verify</phase>                </execution>                </executions>          </plugin>    </plugins></build>

继承

• 为了消除重复，我们把很多相同的配置提取出来
  
  • 例如：grouptId，version等
  • 父工程设置为被继承
  • <packaging>pom</packaging>
  • 子工程继承父工程,省略父工程中定义的坐标除访问名称中的所有设定，添加继承父工程

<parent>    <groupId>…</groupId>    <artifactId>… </artifactId>    <version>… </version>    <relativePath>../父工程项目名</relativePath></parent>

• 父工程统一管理子工程依赖版本

<dependencyManagement>        <dependencies>        //添加公共依赖包    </dependencies></dependencyManagement>

• 子工程仅仅添加依赖包，无需添加版本，版本由父工程继承而来,为了进一步便于管理，将所有的版本管理设置在一起，设置为系统属性值

<properties>    <junit.version>4.9</junit.version>    ……</properties>
1
2
3
4

• 引用使用${junit.version}格式进行，只能在依赖范围设置

• 父工程统一管理子工程依赖关系
  
  • 如果所有子工程都需要依赖某些包，父工程可以通过设置依赖，将依赖关系传递到子工程中

<dependencies>    //添加公共依赖包</dependencies>

聚合

• 如果我们想一次构建多个项目模块，那我们就需要对多个项目模块进行聚合

<modules>    <module>../子项目名称1</module>    <module>../子项目名称2</module>     <module>../子项目名称3</module></modules>

• 聚合与继承的关系
• 聚合主要为了快速构建项目
• 继承主要为了消除重复