Maven入门学习

最新推荐文章于 2021-02-10 13:45:43 发布

穿越技术印记的河流

最新推荐文章于 2021-02-10 13:45:43 发布

阅读量292

点赞数

分类专栏： Maven 文章标签： maven

Maven 专栏收录该内容

2 篇文章 0 订阅

订阅专栏

文档版本	开发工具	测试平台	工程名字	日期	作者	备注
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

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

![](http://i1.piimg.com/567571/710e0de3830d663f.png)

依赖管理-可选依赖

<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>

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

穿越技术印记的河流

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
Maven入门学习

文档版本开发工具测试平台工程名字日期作者备注 V1.0 2016.07.08 lutianfei noneMAVEN 说明翻译为：“专家”，“内行”Maven是跨平台的项目管理工具。主要服务于基于Java平台的项目构建，依赖管理和项目信息管理。理想的项目构建？高度自动化，跨平台，可重用的组件什么是依赖？为什么要进行依赖管理
复制链接

扫一扫

专栏目录