注册 登录  
 加关注
   显示下一条  |  关闭
温馨提示!由于新浪微博认证机制调整,您的新浪微博帐号绑定已过期,请重新绑定!立即重新绑定新浪微博》  |  关闭

itoedr的it学苑

记录从IT文盲学到专家的历程

 
 
 

日志

 
 

理解Maven:项目构建管理工具  

2014-11-08 21:03:57|  分类: 开源云系统 |  标签: |举报 |字号 订阅

  下载LOFTER 我的照片书  |

Maven是基于项目对象模型(POM),可以通过一小段描述信息来管理项目的构建,报告和文档的软件项目管理工具。
Maven 除了以程序构建能力为特色之外,还提供高级项目管理工具。 由于 Maven 的缺省构建规则有较高的可重用性,所以常常用两三行 Maven 构建脚本就可以构建简单的项目。由于 Maven 的面向项目的方法,许多 Apache Jakarta 项目发文时使用 Maven,而且公司项目采用 Maven 的比例在持续增长。
            Maven这个单词来自于意第绪语,意为知识的积累,最早在Jakata Turbine项目中它开始被用来试图简化构建过程。当时有很多项目,它们的Ant build文件仅有细微的差别,而JAR文件都由CVS来维护。于是Maven创始者开始了Maven这个项目,该项目的清晰定义包括,一种很方便的发布 项目信息的方式,以及一种在多个项目中共享JAR的方式。
        那 么,Maven 和 Ant 有什么不同呢?在回答这个问题以前,首先要强调一点:Maven 和 Ant 针对构建问题的两个不同方面。Ant 为 Java 技术开发项目提供跨平台构建任务。Maven 本身描述项目的高级方面,它从 Ant 借用了绝大多数构建任务。因此,由于 Maven 和 Ant 代表两个差异很大的工具,所以接下来只说明这两个工具的等同组件之间的区别,如表 1 所示。
  Maven Ant
标准构建文件project.xml 和 maven.xml  build.xml
特性处理顺序
  1. ${maven.home}/bin/driver.properties
  2. ${project.home}/project.properties
  3. ${project.home}/build.properties
  4. ${user.home}/build.properties
  5. 通过 -D 命令行选项定义的系统特性
最后一个定义起决定作用。
  1. 通过 -D 命令行选项定义的系统特性
  2. 由 任务装入的特性
第一个定义最先被处理。
构建规则构建规则更为动态(类似于编程语言);它们是基于 Jelly 的可执行 XML。构建规则或多或少是静态的,除非使用<script>任务
扩展语言  插件是用 Jelly(XML)编写的。插件是用 Java 语言编写的。
构建规则可扩展性通过定义 <preGoal> 和 <postGoal> 使构建 goal 可扩展。构建规则不易扩展;可通过使用 <script> 任务模拟 <preGoal> 和 <postGoal> 所起的作用。
Maven它包含了一个项目对象模型 (Project Object Model),一组标准集合,一个项目生命周期(Project Lifecycle),一个依赖管理系统(Dependency Management System),和用来运行定义在生命周期阶段(phase)中插件(plugin)目标(goal)的逻辑。当你使用Maven的时候,你用一个明确定义的项目对象模型来描述你的项目,然后Maven可以应用横切的逻辑,这些逻辑来自一组共享的(或者自定义的)插件
Maven 有一个生命周期,当你运行 mvn install 的时候被调用。这条命令告诉 Maven 执行一系列的有序的步骤,直到到达你指定的生命周期。遍历生命周期旅途中的一个影响就是,Maven 运行了许多默认的插件目标,这些目标完成了像编译和创建一个 JAR 文件这样的工作。
此外,Maven能够很方便的帮你管理项目报告,生成站点,管理JAR文件,等等。

常用命令

mvn archetype:create 创建Maven项目
mvn compile 编译源代码
mvn deploy 发布项目
mvn test-compile 编译测试源代码
mvn test 运行应用程序中的单元测试
mvn site 生成项目相关信息的网站
mvn clean 清除项目目录中的生成结果
mvn package 根据项目生成的jar
mvn install 在本地Repository中安装jar
mvn eclipse:eclipse 生成eclipse项目文件
mvnjetty:run 启动jetty服务
mvntomcat:run 启动tomcat服务
mvn clean package -Dmaven.test.skip=true:清除以前的包后重新打包,跳过测试类

在cmd中的命令:
a. mvn eclipse:clean 清除Project中以前的编译的东西,重新再来
b. mvn eclipse:eclipse 开始编译Maven的Project
在Myeclipse中的操作:
a. 选中Maven Project 右击 在Run As中选择Maven clean
b. 在Myeclipse中,Project—Clean 开始编译
c. 选中Maven Project 右击 在Run As中选择Maven install
执行完这几步,如果没发生异常,会在project里生成一个target文件夹,这个文件夹里的东西,就是Maven打包发布的东西。
Maven的生命周期是为了对所有的构建过程进行了抽象了,便于统一。
clean(清理)
此生命周期旨在给工程做清理工作,它主要包含以下阶段:
pre-clean - 执行项目清理前所需要的工作。
clean - 清理上一次build项目生成的文件。
post-clean - 执行完成项目清理所需的工作.
default(默认)
validate - 验证项目是否正确且所有必要的信息都可用。
initialize - 初始化构建工作,如:设置参数,创建目录等。
generate-sources - 为包含在编译范围内的代码生成源代码.
process-sources - 处理源代码, 如过滤值.
generate-resources -
process-resources - 复制并处理资源文件,至目标目录,准备打包。
compile - 编译项目中的源代码.
process-classes - 为编译生成的文件做后期工作, 例如做Java类的字节码增强.
generate-test-sources - 为编译内容生成测试源代码.
process-test-sources - 处理测试源代码。
generate-test-resources -
process-test-resources - 复制并处理资源文件,至目标测试目录。
test-compile - 将需测试源代码编译到路径。一般来说,是编译/src/test/java目录下的java文件至目标输出的测试classpath目录中。
process-test-classes -
test - 使用合适的单元测试框架运行测试。这些测试代码不会被打包或部署。
prepare-package -
package - 接受编译好的代码,打包成可发布的格式,如 JAR 。
pre-integration-test -
integration-test - 按需求将发布包部署到运行环境。
post-integration-test -
verify -
install -将包安装到本地仓库,给其他本地引用提供依赖。
deploy -完成集成和发布工作,将最终包复制到远程仓库以便分享给其他开发人员。
site(站点)
pre-site - 执行一些生成项目站点前的准备工作。
site - 生成项目站点的文档。
post-site - 执行需完成站点生成的工作,如站点部署的准备工作。
site-deploy - 向制定的web服务器部署站点生成文件。[2]
*****************************************
Maven使用教程
*****************************************
一、Maven的作用
      我们在开发项目的过程中,会使用一些开源框架、第三方的工具等等,这些都是以jar包的方式被项目所引用,并且有些jar包还会依赖其他的 jar包,我们同样需要添加到项目中,所有这些相关的jar包都会作为项目的依赖。通常,一个Java EE项目所依赖的jar包会有很多。然而,这还并非是主要问题,在管理这些jar包过程中,jar包的版本往往是最令人头疼的问题。选择一个jar包的版 本,需要考虑它所依赖的jar包是否支持这个版本,并且还需要确认依赖它的jar包能不能对这个版本兼容。所以,在过去的构建项目过程中,整理出这么一堆 能让项目正常运行的jar包之后,这个lib目录就会变为禁区。jar包版本更新了,我们也很少会自找麻烦去触碰它。至于是不是存在冗余的jar包?能正 常运行就好了嘛......
        Maven的出现,解决了开发过程中的这一难题。它可以对项目依赖的jar包进行管理,可以让你的项目保持基本的依赖,排除冗余jar包,并且 可以让你非常轻松的对依赖的jar包进行版本升级。而这些仅仅是Maven最基本的功能,它可以在这基础上对项目进行清理、编译、测试、打包、发布等等构 建项目的工作。
 
       可以说,Maven是现在Java社区中最强大的项目管理和项目构建工具,而更加值得庆幸的是,这样一个强大的工具,它的使用也是非常简单的。
 
          现在,JavaEE项目使用的开源软件都可以通过Maven来获取,并且,越来越多的公司也开始使用Maven来管理构建项目了。
 
二、Maven安装

1、配置java运行环境
Maven依赖Java运行环境,因此使用Maven之前需要配置Java的运行环境。下载并安装JDK,配置JDK的环境变量:
    JAVA_HOME=D:\Dev\Tool\Java\jdk1.6.0_38
    在path中加入%JAVA_HOME%\bin;
2、安装Maven
 
       下        载Maven最新版本的二进制zip压缩包就可以,如:apache-maven-3.0.5-bin.zip
        下载完成后,解压,例如我们把解压后的文件夹放在D:\Dev\Tool\目录下。
          然后,将Maven的bin目录添加到path环境变量中,我们这里就是这个目录:D:\Dev\Tool\apache-maven-3.0.4\bin
 
在Windows命令提示符下,输入mvn -v测试一下,如图:
理解Maven:项目构建管理工具 - itoedr - itoedr的it学苑
 
 
         这样,maven就安装完成了,就是这么简单。接下来我们先来了解一下Maven是如何来管理项目的。
 
三、Maven依赖管理

       前面讲了,Maven最核心的就是对依赖jar包的管理,那么它是通过什么方式来进行管理的呢?
       Maven要求每一个jar包都必须明确定义自己的坐标,Maven就是通过这个坐标来查找管理这些jar包的。
        在Maven中,一个jar包的坐标是由它的groupId、artifactId、version这些元素来定义的。
例如:
    <groupId>org.apache.struts</groupId>
    <artifactId>struts2-core</artifactId>
    <version>2.3.8</version>
    <packaging>jar</packaging>

groupId:表明其所属组织或公司及其所属项目,命名规则为组织或公司域名反转加项目名称。
artifactId:项目的模块名,通常与实际项目名称一致。模块的命名通常为项目名前缀加模块名。
version:当前项目的版本号。
packaging:定义项目的打包方式,可选值有jar、war、pom。默认为jar
        注::一个组织或公司都会有很多的项目,而每个项目下都会划分多个模块,在开发中我们可以灵活选择依赖某个模块。而Maven管理的jar包基 本都是模块性质的项目构建出的jar包。所以,artifactId通常都是模块名,而不是项目名称。项目名称是和组织名称组合作为groupId来使用 的。
 
          上面的配置定义了一个Maven项目的坐标,而如果在项目中依赖这个项目时,同样是利用它的坐标来指定依赖。例如:
<project>
    ...
    <dependencies>
        <dependency>
            <groupId>org.apache.struts</groupId>
            <artifactId>struts2-core</artifactId>
            <version>2.3.8</version>
        </dependency>
    </dependencies>
    ...
</project>
 
Maven的配置文件中dependencies元素包含了所有依赖的jar包,每一个jar包依赖使用dependency元素定义。
在声明一个jar包依赖时,除了指定groupId、artifactId、version这三项基本坐标外,还可以使用使用以下元素进行配置:
scope元素:指定依赖的范围
exclusions元素:排除传递性依赖
 
Maven有以下几种依赖范围:
compile:编译依赖范围(默认值),依赖在编译、测试、运行期间都有效。
test:测试依赖范围,只对测试的classpath有效,在编译或运行时无法使用指定为test的依赖包。
provided:已提供的依赖范围,只对编译和测试的classpath有效,运行期间不会使用这个依赖。例如servlet-api,在运行时容器已经提供,不需要再重复引入。
runtime:运行时依赖范围,编译时无效,只在测试和运行时使用这个依赖。
system:系统依赖范围,和provided范围一致,但是provided是使用容器提供依赖,system是使用系统提供依赖,需要指定依赖文件路径。
 
传递性依赖,是指依赖包对其他包的依赖,比如,我们依赖struts2-core,而strtus2-core需要依赖xwork-core、 ognl等,Maven会将这些传递性依赖同时引入项目之中。这也是Maven的一大优点,简化了我们对jar包依赖的管理。而有时我们希望替换某个传递 性依赖时,就需要使用exclusions排除掉这个传递性依赖,然后再添加我们自己要替换的依赖包。
 
例如,如下一个Maven的配置文件,pom.xml:

<?xml version="1.0" encoding="UTF-8"?>  
<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.boya.spring</groupId>  
    <artifactId>spring_ioc</artifactId>  
    <packaging>jar</packaging>  
    <version>1.0.0</version>  
  
    <name>${project.artifactId}</name>  
    <description>Spring Ioc Sample</description>  
  
    <dependencies>  
        <!-- spring start -->  
        <dependency>  
            <groupId>org.springframework</groupId>  
            <artifactId>spring-core</artifactId>  
            <version>3.2.0.RELEASE</version>  
            <exclusions>  
                <exclusion>  
                    <groupId>commons-logging</groupId>  
                    <artifactId>commons-logging</artifactId>  
                </exclusion>  
            </exclusions>  
        </dependency>  
        <dependency>  
            <groupId>org.springframework</groupId>  
            <artifactId>spring-beans</artifactId>  
            <version>3.2.0.RELEASE</version>  
        </dependency>  
        <dependency>  
            <groupId>org.springframework</groupId>  
            <artifactId>spring-context</artifactId>  
            <version>3.2.0.RELEASE</version>  
        </dependency>  
  
        <!-- logging start -->  
        <dependency>  
            <groupId>org.slf4j</groupId>  
            <artifactId>slf4j-api</artifactId>  
            <version>1.6.4</version>  
        </dependency>  
        <dependency>  
            <groupId>org.slf4j</groupId>  
            <artifactId>slf4j-log4j12</artifactId>  
            <version>1.6.4</version>  
        </dependency>  
        <dependency>  
            <groupId>org.slf4j</groupId>  
            <artifactId>jcl-over-slf4j</artifactId>  
            <version>1.6.4</version>  
        </dependency>  
        <dependency>  
            <groupId>log4j</groupId>  
            <artifactId>log4j</artifactId>  
            <version>1.2.16</version>  
        </dependency>  
        <dependency>  
            <groupId>log4jdbc</groupId>  
            <artifactId>log4jdbc4</artifactId>  
            <version>1.2</version>  
        </dependency>  
  
        <!--Test start-->  
        <dependency>  
            <groupId>junit</groupId>  
            <artifactId>junit</artifactId>  
            <version>4.10</version>  
            <scope>test</scope>  
        </dependency>  
    </dependencies>  
</project>  
 
四、Maven仓库

       Maven通过项目定义的坐标来管理这些依赖,而这些依赖的物理文件是通过Maven的仓库来统一管理的。
对于一个依赖坐标,它会按照如下方式反映到Maven的仓库中。

1、将groupId转化为路径:将groupId中的包名分隔符(.)转换成路径分隔符(/)。对于上面的例子就是 org.apache.struts -> org/apache/struts/
2、将artifactId转化为路径:在groupId转化的路径基础上连接artifactId。生成路径为: org/apache/struts/struts2-core/
3、将verion转化为路径:在artifactId转化的路径基础上连接version。生成路径为: org/apache/struts/struts2-core/2.3.8/
4、根据artifactId和version生成依赖包文件名:上例就是 struts2-core-2.3.8
5、根据依赖的打包方式确定文件的扩展名。对于上例它的扩展名就是.jar
 
这样根据路径和文件名就找到了这个物理文件在仓库中的位置:org/apache/struts/struts2-core/2.3.8/struts2-core-2.3.8.jar
 
Maven的仓库分为本地仓库和远程仓库。
本地仓库:是Maven在我们本机设置的仓库目录,默认目录为当前用户目录下的.m2/repository.
远程仓库包括中央仓库、私服、其他公共仓库。
中央仓库是Maven提供的远程仓库,地址是:http://repo.maven.apache.org/maven2
私服是我们为了节省带宽和时间,提升效率,在局域网架设的私有Maven仓库。
 
 
Maven在根据依赖坐标查找依赖时,首先会从本地仓库查找该依赖包,当本地仓库中没有这个依赖包时,Maven会从中央仓库查找依赖,并下载到本地仓库。最后,在我们项目的classpath中引用本地仓库的依赖包路径。
例如,当项目只依赖strtus2-core这个依赖包时,会生成这样的classpath文件:

<?xml version="1.0" encoding="UTF-8"?>  
<classpath>  
  <classpathentry kind="src" path="src/main/java" output="/src/main/webapp/WEB-INF/classes" including="**/*.java"/>  
  <classpathentry kind="src" path="src/main/resources" output="/src/main/webapp/WEB-INF/classes" excluding="**/*.java"/>  
  <classpathentry kind="output" path="src/main/webapp/WEB-INF/classes"/>  
  <classpathentry kind="con" path="org.eclipse.jdt.launching.JRE_CONTAINER"/>  
  <classpathentry kind="con" path="com.genuitec.eclipse.j2eedt.core.J2EE14_CONTAINER"/>  
  <classpathentry kind="var" path="M2_REPO/org/apache/struts/struts2-core/2.3.8/struts2-core-2.3.8.jar" />  
  <classpathentry kind="var" path="M2_REPO/org/apache/struts/xwork/xwork-core/2.3.8/xwork-core-2.3.8.jar" />  
  <classpathentry kind="var" path="M2_REPO/org/apache/commons/commons-lang3/3.1/commons-lang3-3.1.jar" />  
  <classpathentry kind="var" path="M2_REPO/ognl/ognl/3.0.6/ognl-3.0.6.jar" />  
  <classpathentry kind="var" path="M2_REPO/javassist/javassist/3.11.0.GA/javassist-3.11.0.GA.jar" />  
  <classpathentry kind="var" path="M2_REPO/asm/asm/3.3/asm-3.3.jar"/>  
  <classpathentry kind="var" path="M2_REPO/asm/asm-commons/3.3/asm-commons-3.3.jar"/>  
  <classpathentry kind="var" path="M2_REPO/asm/asm-tree/3.3/asm-tree-3.3.jar"/>  
  <classpathentry kind="var" path="M2_REPO/org/freemarker/freemarker/2.3.19/freemarker-2.3.19.jar" />  
  <classpathentry kind="var" path="M2_REPO/commons-fileupload/commons-fileupload/1.2.2/commons-fileupload-1.2.2.jar" />  
  <classpathentry kind="var" path="M2_REPO/commons-io/commons-io/2.3/commons-io-2.3.jar" />  
</classpath>  
其中,本地仓库目录会使用M2_REPO变量表示,因此IDE环境未配置该变量时,需在IDE中添加这个变量的classpath。
 
五、聚合与继承
一个项目通常存在多个模块,每个模块都是作为一个独立的工程存在。通过Maven配置文件可以把多个模块聚合在一起进行编译发布,并且它的聚合 非常简单只需要使用<modules>元素添加模块就可以完成聚合。我们参考struts2的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>  
    <parent>  
        <groupId>org.apache.struts</groupId>  
        <artifactId>struts2-parent</artifactId>  
        <version>2.3.8</version>  
    </parent>  
    <groupId>org.apache.struts</groupId>  
    <artifactId>struts2-apps</artifactId>  
    <packaging>pom</packaging>  
    <name>Webapps</name>  
    <modules>  
        <module>blank</module>  
        <module>mailreader</module>  
        <module>portlet</module>  
        <module>showcase</module>  
        <module>rest-showcase</module>  
    </modules>  
....  
</project>  
另外,在这个项目的个各模块间通常是存在引用关系,并且每个模块会引用一些相同的依赖,Maven也提供了继承的机制来管理这些共同的依赖。你 可以编写一个pom.xml文件作为父级pom配置,各个模块在自己的pom.xml中继承父级pom文件,就像上面的示例那样,使 用<parent>元素标识继承的父级pom文件。
 
父级pom文件的编写:
1、父级pom文件的packaging必须是pom,它需要作为pom文件发布以便子pom继承
2、在父级pom可以使用<dependencyManagement>配置依赖管理。 在<dependencyManagement>下的依赖声明不会引入实际依赖,但是可以让子模块继承依赖配置。例如,在子模块中我们只标识 依赖的groupId和artifactId,它就可以根据父类的依赖管理获取这个依赖的version及exclussions等配置。
3、在父级pom中可以使用<pluginManagement>配置插件管理。作用和<dependencyManagement>类似,只不过一个管理依赖一个管理插件。
 
子模块pom文件的编写:
1、需要使用<parent>元素标识继承的父pom
2、可以使用<relativePath>标识父级pom的物理路径,子模块会直接从指定的路径加载父级pom文件,未指定该元素时,子模块将根据父级pom的坐标从Maven仓库查找
3、子模块pom可以继承父级pom中除artifactId之外的大部分配置,因此子模块的groupId、version以及依赖的version都可以省略。
 
六、Maven脚本使用
现在大部分IDE都有插件支持Maven,使用插件可以方便的构建Maven项目,如果IDE不支持Maven插件或未安装Maven插件也可以使用一个简单的批处理脚本来完成Maven项目的构建。
例如,保存下面内容,存储为bat格式的批处理文件
cd %~dp0
call mvn eclipse:clean eclipse:eclipse
 
pause
......
  评论这张
 
阅读(58)| 评论(0)
推荐 转载

历史上的今天

在LOFTER的更多文章

评论

<#--最新日志,群博日志--> <#--推荐日志--> <#--引用记录--> <#--博主推荐--> <#--随机阅读--> <#--首页推荐--> <#--历史上的今天--> <#--被推荐日志--> <#--上一篇,下一篇--> <#-- 热度 --> <#-- 网易新闻广告 --> <#--右边模块结构--> <#--评论模块结构--> <#--引用模块结构--> <#--博主发起的投票-->
 
 
 
 
 
 
 
 
 
 
 
 
 
 

页脚

网易公司版权所有 ©1997-2017