【转】java项目构建工具Maven

java项目构建工具Maven
---------------------------------------------------------------------------------------------------
title:java project build tool is great maven
author:chinayaosir
blog:http://blog.csdn.net/chinayaosir
qq:44633197
email:[e-mail]
---------------------------------------------------------------------------------------------------
文章目录

1.1java-maven简介
1.2java-maven来源
1.3java-maven安装
1.4java-maven插件
1.5java-maven命令
1.6java-maven入门

1.7java-maven书籍

---------------------------------------------------------------------------------------------------

1.1java-maven简介
c/c++软件自动编译有makefile,
程序源码管理有cvs,subverion,
linux应用程序管理yum,yast(它们自动管理程序版本和依赖)
windows程序管理有360软件管理
java源码编译有ant，
那么java项目工程里在有没有jar包管理和源码管理，程序编译三合一的优秀工具？
它就是伟大的maven！！！!

随着近两年Maven在国内的普及,越来越多的公司与项目开始接受并使用其作为项目构建与依赖管理工具,
Java开发人员用Maven来管理和维护java软件项目就越来越方便！
Apache Maven是一个基于java的apache ant的构建工具的替代者。
Maven这个单词来自于意第绪语，意为知识的积累，
最早在Jakata Turbine项目中它开始被用来试图简化构建过程。
当时有很多项目，它们的Ant build文件仅有细微的差别，而JAR文件都由CVS来维护。
于是Maven创始者开始了Maven这个项目，该项目的清晰定义包括，
一种很方便的发布项目信息的方式，以及一种在多个项目中共享JAR的方式。


作为Apache组织中的一个颇为成功的开源项目，Maven主要服务于基于Java平 台的项目构建、依赖管理和项目信息管理。
无论是小型的开源类库项目，还是大型的企业级应用；无论是传统的瀑布式开发，还是流行的敏捷模式，Maven都能大显身手。

---------------------------------------------------------------------------------------------------
1.2java-maven来源
--------------------------------------------------
java构建
不管你是否意识到，构建（build）是每一位程序员每天都在做的工作。
早上来 到公司，我们做的第一件事情就是从源码库签出最新的源码，然后进行单元测试，
如果发现失败的测试，会找相关的同事一起调试，修复错误代码。
接着回到自己的 工作上来，编写自己的单元测试及产品代码，我们会感激IDE随时报出的编译错误提示。
忙到午饭时间，代码编写得差不多了，测试也通过了，开心地享用午餐然后休息。
下午先在昏昏沉沉中开了个例会，会议结束后喝杯咖啡继续工作。
刚才在会上经理要求看测试报告，于是找了相关工具集成进IDE，
生成了像 模像样的测试覆盖率报告，接着发了一封电子邮件给经理，松了口气。
谁料QA小组又发过来了几个bug，没办法，先本地重现再说，于是熟练地用IDE生成了 一个WAR包，部署到Web容器下，启动容器。
看到熟悉的界面了，遵循bug报告，一步步重现了bug……快下班的时候，bug修好了，提交代码，
通知 QA小组，在愉快中结束了一天的工作。
仔细总结一下，我们会发现，除了编写源代码，
我们每天有相当一部分时间花在了编译、运行单元测试、生成文档、打包和部署等烦琐且不起眼的工作上，这就是构建。
如果我们现在还手工这样做，那成本也太高了，于是有人用软件的方法让这一系列工作完全自动化，
使得软件的构建可以像全自动流水线一样，只需要一条简单的命令，所有烦琐的步骤都能够自动完成，很快就能得到最终结果。
--------------------------------------------------
Ant就是参考c make的makefle
Ant不是指蚂蚁，而是意指“另一个整洁的工具”（Another Neat Tool），
它最早用来构建著名的Tomcat，其作者James Duncan Davidson创作它的动机就是因为受不了Makefile的语法格式。
我们可以将Ant看成是一个Java版本的Make，也正因为使用了Java，Ant是跨平台的。
此外，Ant使用XML定义构建脚本，相对于Makefile来说，这也更加友好。
与Make类似，Ant有一个构建脚本build.xml，如下所示： 
<?xml version="1.0"?>
<project name="Hello" default="compile">
<target name="compile" description="compile the Java source code to class files">
<mkdir dir="classes"/>
<javac srcdir="." destdir="classes"/>
</target>
<target name="jar" depends="compile" description="create a Jar file ">
<jar destfile="hello.jar">
<fileset dir="classes" includes="**/*.class"/>
<manifest>
<attribute name="Main.Class" value="HelloProgram"/>
</manifest>
</jar>
</target>
</project>
build.xml的基本结构也是目标（target）、依赖（depends），以及实现目标的任务。
比如在上面的脚本中，jar目标用来创建应用程序jar文件，该目标依赖于compile目标，
后者执行的任务是创建一个名为classes的文件夹，编译当前目录的java文件至classes目录。
compile目标完成后，jar目标再执行自己的任务。
Ant有大量内置的用Java实现的任务，这保证了其跨平台的特质，同时，Ant也有特殊的任务exec来执行本地命令。
和Make一样，Ant也都是过程式的，开发者显式地指定每一个目标，以及完成该目标所需要执行的任务。
针对每一个项目，开发者都需要重新编写这一过程，这里其实隐含着很大的重复。
Maven是声明式的，项目构建过程和过程各个阶段所需的工作都由插件实现，
并且大部分插件都是现成的，开发者只需要声明项目的基本元素，Maven就执行内置的、完整的构建过程。这在很大程度上消除了重复。
Ant是没有依赖管理的，所以很长一段时间Ant用户都不得不手工管理依赖，这是一个令人头疼的问题。
幸运的是，Ant用户现在可以借助Ivy管理依赖。
而对于Maven用户来说，依赖管理是理所当然的
Maven不仅内置了依赖管理，更有一个可能拥有全世界最多Java开源软件包的中央仓库，
Maven用户无须进行任何配置就可以直接享用。
--------------------------------------------------
maven与ant的比较
第一：ant脚本是可以直接运行在maven中的。 
maven和ant最大的差别就是在于maven的编译以及所有的脚本都有一个基础，就是POM（project object model）。
这个模型定义了项目的方方面面，然后各式各样的脚本在这个模型上工作，而ant完全是自己定义，显然maven更胜一筹。
第二：Maven对所依赖的包有明确的定义，如使用那个包，版本是多少，一目了然。
而ant则通常是简单的inclde 所有的jar。
导致的最终结果就是，你根本无法确定JBoss中的lib下的common－logging 是哪个版本的，
唯一的方法就是打开 META－INF 目录下MANIFEST.MF。估计JBoss迟早会转向Maven的。
第三：Maven是基于中央仓库的编译，即把编译所需要的资源放在一个中央仓库里，如jar，tld，pom，等。
当编译的时候，maven会自动在仓库中找到相应的包，如果本地仓库没有，则从设定好的远程仓库中下载到本地。
这一切都是自动的，而ant需要自己定义了。
这个好处导致的结果就是，用maven编译的项目在发布的时候只需要发布源码，小得很，
而反之，ant的发布则要把所有的包一起发布，显然maven又胜了一筹。 
第四：maven有大量的重用脚本可以利用，如生成网站，生成javadoc，sourcecode reference，等。
而ant都需要自己去写。试试 maven site 的效果。 
第五：maven目前不足的地方就是没有象ant那样成熟的GUI界面，
不过mavengui正在努力中。目前使用maven最好的方法还是命令行，又快又方便。
---------------------------------------------------------------------------------
Maven与极限编程 
极限编程（XP）是近些年在软件行业红得发紫的敏捷开发方法，它强调拥抱变化。
该软件开发方法的创始人Kent Beck提出了XP所追求的价值、实施原则和推荐实践。
下面看一下Maven是如何适应XP的。
首先看一下Maven如何帮助XP团队实现一些核心价值：
1.简单。
Maven暴露了一组一致、简洁的操作接口，能帮助团队成员从原来的高度自定义的、复杂的构建系统中解脱出来，
使用Maven现有的成熟的、稳定的组件也能简化构建系统的复杂度。
2.交流与反馈。
与版本控制系统结合后，所有人都能执行最新的构建并快速得到反馈。
此外，自动生成的项目报告也能帮助成员了解项目的状态，促进团队的交流。
3.接近XP风格：
3.1测试驱动开发（TDD）。TDD强调测试先行，所有产品都应该由测试用例覆盖。
而测试是Maven生命周期的最重要的组成部分之一，并且Maven有现成的成熟插件支持业界流行的测试框架，如JUnit和TestNG。
3.2十分钟构建。十分钟构建强调我们能够随时快速地从源码构建出最终的产品。
用一条简单的命令就能让Maven帮你清理、编译、测试、打包、部署，然后得到最终的产品。
3.3持续集成（CI）。CI强调项目以很短的周期（如15分钟）集成最新的代码。 实际上,CI的前提是源码管理系统和构建系统。
4.富有信息的工作区。 这条实践强调开发者能够快速方便地了解到项目的最新状态。
当然，Maven并不会帮你把测试覆盖率报告贴到墙上，也不会在你的工作台上放个鸭子告诉你构建 失败了。

事实上，除了其他敏捷开发方法如SCRUM之外，几乎任何软件开发方法都能借鉴这些实践。
也就是说，Maven几乎能够很好地支持任何软件开发方法。
例如，在传统的瀑布模型开发中，项目依次要经历需求开发、分析、设计、编码、测试和集成发布阶段。
从设计和编码阶段开始，就可以使用Maven来建立项目的 构建系统。
在设计阶段，也完全可以针对设计开发测试用例，然后再编写代码来满足这些测试用例。
有了自动化构建系统，我们可以节省很多手动的测试时间。
尽早地使用构建系统集成团队的代码，对项目也是百利而无一害。最后，Maven还能帮助我们快速地发布项目。

---------------------------------------------------------------------------------------------------
1.3java-maven安装
下载Maven 
请访问Maven的下载页面：http://maven.apache.org/download.html，
其中包含针对不同平台的各种版本的Maven下载文件。对于首次接触Maven的读者来说，推荐使用Maven 3.0，
因此下载apache-maven-3.0-bin.zip。
如果你对Maven的源代码感兴趣并想自己构建Maven，还可以下载apache-maven-3.0 -src.zip。
该下载页面还提供了md5校验和（checksum）文件和asc数字签名文件，可以用来检验Maven分发包的正确性和安全性。

windows安装和设置Maven
先检查和设置JAVA_HOME环境变量以及Java命令
将安装文件解压到你指定的目录中，如：
D:\bin>jar xvf "C:\Users\Juven Xu\Downloads\apache-maven-3.0--bin.zip"
这里的Maven安装目录是D:\bin\apache-maven-3.0，接着需要设置环境变量，将Maven安装配置到操作系统环境中。
打开系统属性面板（桌面上右键单击“我的电脑”→“属性”），点击高级系统设置，
再点击环境变量，在系统变量中新建一个变量，变量名为M2_HOME，
变量值为Maven的安装目录D:\bin\apache-maven-3.0。
点击确定，接着在系统变量中找到一个名为Path的变量，在变量值的末尾加上%M2_HOME%\bin;，环境变量设置完成

linux/unix安装和设置Maven

需要检查JAVA_HOME环境变量以及Java命令，命令如下：
juven@juven-ubuntu:~$ echo $JAVA_HOME
juven@juven-ubuntu:~$ java –version
下载Maven安装文件，
如apache-maven-3.0-bin.tar.gz，然后解压到本地目录：
juven@juven-ubuntu:bin$ tar -xvzf apache-maven-3.0-bin.tar.gz 
现在已经创建好了一个Maven安装目录apache-maven-3.0，
虽然直接使用该目录配置环境变量之后就能使用Maven了，
但这里我更推荐做法是，在安装目录旁平行地创建一个符号链接，以方便日后的升级： 
juven@juven-ubuntu:bin$ ln -s apache-maven-3.0 apache-maven

需要设置M2_HOME环境变量指向符号链接apache-maven，
并且把Maven安装目录下的bin/文件夹添加到系统环境变量PATH中去： 
juven@juven-ubuntu:bin$ export M2_HOME=/home/juven/bin/apache-maven
juven@juven-ubuntu:bin$ export PATH=$PATH:$M2_HOME/bin
命令检查Maven安装：
juven@juven-ubuntu:bin$ echo $M2_HOME
juven@juven-ubuntu:bin$ mvn –version


---------------------------------------------------------------------------------------------------
1.4java-maven插件安装
安装eclipse安装m2eclipse插件
Eclipse是一款非常优秀的IDE。
最新版的Eclipse还能很好地支持重构，并且集成了JUnit、CVS、Mylyn等各种流行工具。
可惜Eclipse默认没有集成对Maven的支持。
幸运的是，由Maven之父Jason Van Zyl创立的Sonatype公司建立了m2eclipse项目，
这是Eclipse下的一款十分强大的Maven插件，可以访问http://m2eclipse.sonatype.org/ 了解更多该项目的信息。
本小节将先介绍如何安装m2eclipse插件，本书后续的章节会逐步介绍m2eclipse插件的使用。
以Eclipse 3.6为例逐步讲解m2eclipse的安装。
启动Eclipse之后，在菜单栏中选择Help，然后选择Install New Software…，
接着你会看到一个Install对话框，点击Work with:字段边上的Add按钮，
你会得到一个新的Add Repository对话框，在Name字段中输入m2e，
Location字段中输入http://m2eclipse.sonatype.org/sites/m2e，
然后点击OK。Eclipse会下载m2eclipse安装站点上的资源信息。
等待资源载入完成之后，我们再将其全部展开， 
显示了m2eclipse的核心模块Maven Integration for Eclipse (Required)，
选择后点击Next >，Eclipse会自动计算模块间依赖，然后给出一个将被安装的模块列表，
确认无误后，继续点击Next >，
这时我们会看到许可证信息，m2eclipse使用的开源许可证是Eclipse Public License v1.0，
选择I accept the terms of the license agreements，然后点击Finish，接着就耐心等待Eclipse下载安装这些模块，
-----------------------------
安装NetBeans Maven插件 
如何在NetBeans上安装Maven插件，后面的章节中还会介绍NetBeans中具体的Maven操作。
首先，如果你正在使用NetBeans 6.7及以上版本，那么Maven插件已经预装了。
你可以检查Maven插件安装，点击菜单栏中的工具，接着选择插件，在弹出的插件对话框中选择已安装标签，你应该能够看到Maven插件，
如果你在使用NetBeans 6.7之前的版本，或者由于某些原因NetBeans Maven插件被卸载了，
那么你就需要安装NetBeans Maven插件，下面我们以NetBeans 6.1为例，介绍Maven插件的安装。
点击菜单栏中的工具，选择插件，在弹出的插件对话框中选择可用插件标签，
接着在右边的搜索框内输入Maven，这时你会在左边的列表中看到一个名为Maven的插件，选择该插件，然后点击下面的安装按钮
接着在随后的对话框中根据提示操作，阅读相关许可证并接受，NetBeans会自动帮我们下载并安装Maven插件，
结束之后会提示安装完成，之后再点击插件对话框的已安装标签，就能看到已经激活的Maven插件。
最后，为了确认Maven插件确实已经正确安装了，可以看一下NetBeans是否已经拥有创建Maven项目的相关菜单。
在菜单栏中选择文件，然后选择新建项目，这时应该能够看到项目类别中有Maven一项，
选择该类别，右边会相应地显示Maven项目和基于现有POM的Maven项目：
---------------------------------------------------------------------------------------------------
1.5java-maven常用命令
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服务
---------------------------------------------------------------------------------------------------
1.6java-maven入门
我们开始 创建一个最简单的Hello World项目。
如果你是初次接触Maven，建议按照本章的内容一步步地编写代码并执行。 
3.1 编写POM 
3.2 编写主代码 
3.3 编写测试代码 
3.4 打包和运行 
3.5 使用Archetype生成项目骨架 
-----------------------------------------
3.1 编写POM 
就像Make的Makefile，Ant的build.xml一样，Maven项目的核心是pom.xml。
POM（Project Object Model，项目对象模型）定义了项目的基本信息，用于描述项目如何构建，声明项目依赖，等等。
现在我们先为Hello World项目编写一个最简单的pom.xml。
首先创建一个名为hello-world的文件夹（本书中各章的代码都会对应一个以ch开头的项目），
打开该文件夹，新建一个名为pom.xml的文件，输入其内容如代码清单3-1：
代码清单3-1：Hello World的POM
Java代码 
<span style="font-size: small;"><?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.juvenxu.mvnbook</groupId> 
<artifactId>hello-world</artifactId> 
<version>1.0-SNAPSHOT</version> 
<name>Maven Hello World Project</name> 
</project> 
</span> 

代码的第一行是XML头，指定了该xml文档的版本和编码方式。
紧接着是project元素，project是所有pom.xml的根元素，它还声明了一些POM相关的命名空间及xsd元素，
虽然这些属性不是必须的，但使用这些属性能够让第三方工具（如IDE中的XML编辑器）帮助我们快速编辑POM。
根元素下的第一个子元素modelVersion指定了当前POM模型的版本，对于Maven2及Maven 3来说，它只能是4.0.0。
这段代码中最重要的是groupId，artifactId和version三行。
这三个元素定义了一个项目基本的坐标，在Maven的世界，任何的jar、pom或者war都是以基于这些基本的坐标进行区分的。
groupId定义了项目属于哪个组，这个组往往和项目所在的组织或公司存在关联，
譬如你在googlecode上建立了一个名为myapp的项目，那么groupId就应该是com.googlecode.myapp，
如果你的公司是mycom，有一个项目为myapp，那么groupId就应该是com.mycom.myapp。
所有的代码都基于groupId com.juvenxu.mvnbook。
artifactId定义了当前Maven项目在组中唯一的ID，我们为这个Hello World项目定义artifactId为hello-world，
其他章节代码会被分配其他的artifactId。
而在前面的groupId为com.googlecode.myapp的例子中，
你可能会为不同的子项目（模块）分配artifactId，如：myapp-util、myapp-domain、myapp-web等等。
顾名思义，version指定了Hello World项目当前的版本——1.0-SNAPSHOT。SNAPSHOT意为快照，
说明该项目还处于开发中，是不稳定的版本。随着项目的发展，version会不断更新，
如升级为1.0、1.1-SNAPSHOT、1.1、2.0等等。
最后一个name元素声明了一个对于用户更为友好的项目名称，
虽然这不是必须的，但我还是推荐为每个POM声明name，以方便信息交流。
没有任何实际的Java代码，我们就能够定义一个Maven项目的POM，这体现了Maven的一大优点，
它能让项目对象模型最大程度地与实际代码相独立，我们可以称之为解耦，或者正交性，
这在很大程度上避免了Java代码和POM代码的相互影响。
比如当项目需要升级版本时，只需要修改POM，而不需要更改Java代码；
而在POM稳定之后，日常的Java代码开发工作基本不涉及POM的修改。
---------------------------------------
3.2 编写主代码 
项目主代码和测试代码不同，项目的主代码会被打包到最终的构件中（比如jar），
而测试代码只在运行测试时用到，不会被打包。
默认情况下，Maven假设项目主代码位于src/main/java目录，
我们遵循Maven的约定，创建该目录，然后在该目录下创建文件com/juvenxu/mvnbook/helloworld/HelloWorld.java，
其内容如代码清单3-2：
代码清单3-2：Hello World的主代码
Java代码 
<span style="font-size: small;">package com.juvenxu.mvnbook.helloworld; 
public class HelloWorld 
{ 
public String sayHello() 
{ 
return "Hello Maven"; 
} 

public static void main(String[] args) 
{ 
System.out.print( new HelloWorld().sayHello() ); 
} 
} 
</span> 

这是一个简单的Java类，它有一个sayHello()方法，返回一个String。
同时这个类还带有一个main方法，创建一个HelloWorld实例，调用sayHello()方法，并将结果输出到控制台。
关于该Java代码有两点需要注意。
首先，在95%以上的情况下，我们应该把项目主代码放到src/main/java/目录下（遵循Maven的约定），
而无须额外的配置，Maven会自动搜寻该目录找到项目主代码。
其次，该Java类的包名是com.juvenxu.mvnbook.helloworld，这与我们之前在POM中定义的groupId和artifactId相吻合。
一般来说，项目中Java类的包都应该基于项目的groupId和artifactId，这样更加清晰，更加符合逻辑，也方便搜索构件或者Java类。
代码编写完毕后，我们使用Maven进行编译，
在项目根目录下运行命令 mvn clean compile ，我们会得到如下输出：
Java代码 
<span style="font-size: small;">[INFO] Scanning for projects... 
[INFO] ------------------------------------------------------------------------ 
[INFO] Building Maven Hello World Project 
[INFO] task-segment: [clean, compile] 
[INFO] ------------------------------------------------------------------------ 
[INFO] [clean:clean {execution: default-clean}] 
[INFO] Deleting directory D:\code\hello-world\target 
[INFO] [resources:resources {execution: default-resources}] 
[INFO] skip non existing resourceDirectory D: \code\hello-world\src\main\resources 
[INFO] [compiler:compile {execution: default-compile}] 
[INFO] Compiling 1 source file to D: \code\hello-world\target\classes 
[INFO] ------------------------------------------------------------------------ 
[INFO] BUILD SUCCESSFUL 
[INFO] ------------------------------------------------------------------------ 
[INFO] Total time: 1 second 
[INFO] Finished at: Fri Oct 09 02:08:09 CST 2009 
[INFO] Final Memory: 9M/16M 
[INFO] ------------------------------------------------------------------------ 
</span> 
clean告诉Maven清理输出目录target/，compile告诉Maven编译项目主代码，
从输出中我们看到Maven首先执行了clean:clean任务，删除target/目录，
默认情况下Maven构建的所有输出都在target/目录中；
接着执行resources:resources任务（未定义项目资源，暂且略过）；
最后执行compiler:compile任务，
将项目主代码编译至target/classes目录(编译好的类为com/juvenxu/mvnbook/helloworld/HelloWorld.Class）。
提到的clean:clean、resources:resources，以及compiler:compile对应了一些Maven插件及插件目标，
比如clean:clean是clean插件的clean目标，compiler:compile是compiler插件的compile目标，会详细讲述Maven插件及其编写方法。
至此，Maven在没有任何额外的配置的情况下就执行了项目的清理和编译任务，
接下来，我们编写一些单元测试代码并让Maven执行自动化测试。
--------------------------------------- 
3.3 编写测试代码 
为了使项目结构保持清晰，主代码与测试代码应该分别位于独立的目录中。
Maven项目中默认的主代码目录是src/main/java，对应地，Maven项目中默认的测试代码目录是src/test/java。
因此，在编写测试用例之前，我们先创建该目录。
在Java世界中，由Kent Beck和Erich Gamma建立的JUnit是事实上的单元测试标准。
要使用JUnit，我们首先需要为Hello World项目添加一个JUnit依赖，修改项目的POM如代码清单3-3：
代码清单3-3：为Hello World的POM添加依赖
Java代码 
<?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.juvenxu.mvnbook</groupId> 
<artifactId>hello-world</artifactId> 
<version>1.0-SNAPSHOT</version> 
<name>Maven Hello World Project</name> 
<dependencies> 
<dependency> 
<groupId>junit</groupId> 
<artifactId>junit</artifactId> 
<version>4.7</version> 
<scope>test</scope> 
</dependency> 
</dependencies> 
</project> 

代码中添加了dependencies元素，该元素下可以包含多个dependency元素以声明项目的依赖，
这里我们添加了一个依赖——groupId是junit，artifactId是junit，version是4.7。
前面我们提到groupId、artifactId和version是任何一个Maven项目最基本的坐标，
JUnit也不例外，有了这段声明，Maven就能够自动下载junit-4.7.jar。
也许你会问，Maven从哪里下载这个jar呢？在Maven之前，我们可以去JUnit的官网下载分发包。
而现在有了Maven，它会自动访问中央仓库（http://repo1.maven.org/maven2/），下载需要的文件。
读者也可以自己访问该仓库，打开路径junit/junit/4.7/，就能看到junit-4.7.pom和junit-4.7.jar。
上述POM代码中还有一个值为test的元素scope，scope为依赖范围，
若依赖范围为test则表示该依赖只对测试有效，换句话说，测试代码中的import JUnit代码是没有问题的，
但是如果我们在主代码中用import JUnit代码，就会造成编译错误。
如果不声明依赖范围，那么默认值就是compile，表示该依赖对主代码和测试代码都有效。
配置了测试依赖，接着就可以编写测试类，
回顾一下前面的HelloWorld类，现在我们要测试该类的sayHello()方法，
检查其返回值是否为“Hello Maven”。在src/test/java目录下创建文件，
其内容如代码清单3-4：
代码清单3-4：Hello World的测试代码
Java代码 
package com.juvenxu.mvnbook.helloworld; 
import static org.junit.Assert.assertEquals; 
import org.junit.Test; 
public class HelloWorldTest 
{ 
@Test 
public void testSayHello() 
{ 
HelloWorld helloWorld = new HelloWorld(); 

String result = helloWorld.sayHello(); 

assertEquals( "Hello Maven", result ); 
} 
} 

一个典型的单元测试包含三个步骤：
一，准备测试类及数据；
二，执行要测试的行为；
三，检查结果。
上述样例中，我们首先初始化了一个要测试的HelloWorld实例，
接着执行该实例的sayHello()方法并保存结果到result变量中，
最后使用JUnit框架的Assert类检查结果是否为我们期望的”Hello Maven”。
在JUnit 3中，约定所有需要执行测试的方法都以test开头，这里我们使用了JUnit 4，
在JUnit 4中，需要执行的测试方法都应该以@Test进行标注。
测试用例编写完毕之后就可以调用Maven执行测试，运行 mvn clean test ：
Java代码 
[INFO] Scanning for projects... 
[INFO] ------------------------------------------------------------------------ 
[INFO] Building Maven Hello World Project 
[INFO] task-segment: [clean, test] 
[INFO] ------------------------------------------------------------------------ 
[INFO] [clean:clean {execution: default-clean}] 
[INFO] Deleting directory D:\git-juven\mvnbook\code\hello-world\target 
[INFO] [resources:resources {execution: default-resources}] 
Downloading: http://repo1.maven.org/maven2/junit/junit/4.7/junit-4.7.pom 
1K downloaded (junit-4.7.pom) 
[INFO] [compiler:compile {execution: default-compile}] 
[INFO] Compiling 1 source file to D: \code\hello-world\target\classes 
[INFO] [resources:testResources {execution: default-testResources}] 
Downloading: http://repo1.maven.org/maven2/junit/junit/4.7/junit-4.7.jar 
226K downloaded (junit-4.7.jar) 
[INFO] [compiler:testCompile {execution: default-testCompile}] 
[INFO] Compiling 1 source file to D:\ code\hello-world\target\test-classes 
[INFO] ------------------------------------------------------------------------ 
[ERROR] BUILD FAILURE 
[INFO] ------------------------------------------------------------------------ 
[INFO] Compilation failure 
D:\code\hello-world\src\test\java\com\juvenxu\mvnbook\helloworld\HelloWorldTest.java:[8,5] -source 1.3 中不支持注释 
（请使用 -source 5 或更高版本以启用注释） 
@Test 
[INFO] ------------------------------------------------------------------------ 
[INFO] For more information, run Maven with the -e switch 
… 


不幸的是构建失败了，不过我们先耐心分析一下这段输出（为了本书的简洁，一些不重要的信息我用省略号略去了）。
命令行输入的是mvn clean test，而Maven实际执行的可不止这两个任务，
还有clean:clean、resources:resources、compiler:compile、resources:testResources以及compiler:testCompile。
暂时我们需要了解的是，在Maven执行测试（test）之前，
它会先自动执行项目主资源处理，主代码编译，测试资源处理，测试代码编译等工作，
这是Maven生命周期的一个特性，本书后续章节会详细解释Maven的生命周期。
从输出中我们还看到：Maven从中央仓库下载了junit-4.7.pom和junit-4.7.jar
这两个文件到本地仓库（~/.m2/repository）中，供所有Maven项目使用。
构建在执行compiler:testCompile任务的时候失败了，Maven输出提示我们需要使用-source 5或更高版本以启动注释，
也就是前面提到的JUnit 4的@Test注解。这是Maven初学者常常会遇到的一个问题。
由于历史原因，Maven的核心插件之一compiler插件默认只支持编译Java 1.3，
因此我们需要配置该插件使其支持Java 5，见代码清单3-5：
代码清单3-5：配置maven-compiler-plugin支持Java 5
Java代码 
<project> 
… 
<build> 
<plugins> 
<plugin> 
<groupId>org.apache.maven.plugins</groupId> 
<artifactId>maven-compiler-plugin</artifactId> 
<configuration> 
<source>1.5</source> 
<target>1.5</target> 
</configuration> 
</plugin> 
</plugins> 
</build> 
… 
</project> 

该POM省略了除插件配置以外的其他部分，我们暂且不去关心插件配置的细节，只需要知道compiler插件支持Java 5的编译。
现在再执行mvn clean test，输出如下：
Java代码 
… 
[INFO] [compiler:testCompile {execution: default-testCompile}] 
[INFO] Compiling 1 source file to D: \code\hello-world\target\test-classes 
[INFO] [surefire:test {execution: default-test}] 
[INFO] Surefire report directory: D:\code\hello-world\target\surefire-reports 
------------------------------------------------------- 
T E S T S 
------------------------------------------------------- 
Running com.juvenxu.mvnbook.helloworld.HelloWorldTest 
Tests run: 1, Failures: 0, Errors: 0, Skipped: 0, Time elapsed: 0.055 sec 
Results : 
Tests run: 1, Failures: 0, Errors: 0, Skipped: 0 
[INFO] ------------------------------------------------------------------------ 
[INFO] BUILD SUCCESSFUL 
[INFO] ------------------------------------------------------------------------ 
… 

我们看到compiler:testCompile任务执行成功了，测试代码通过编译之后在target/test-classes下生成了二进制文件，
紧接着surefire:test任务运行测试，surefire是Maven世界中负责执行测试的插件，
这里它运行测试用例HelloWorldTest，并且输出测试报告。显然，我们的测试通过了——BUILD SUCCESSFUL。
---------------------------------------
3.4 打包和运行 

将项目进行编译、测试之后，下一个重要步骤就是打包（package）。
Hello World的POM中没有指定打包类型，使用默认打包类型jar，
我们可以简单地执行命令 mvn clean package 进行打包，
可以看到如下输出：
Java代码 
Tests run: 1, Failures: 0, Errors: 0, Skipped: 0 
[INFO] [jar:jar {execution: default-jar}] 
[INFO] Building jar: D:\code\hello-world\target\hello-world-1.0-SNAPSHOT.jar 
[INFO] 
-------------------------------------------------------------------- 
[INFO] BUILD SUCCESSFUL 
… 
类似地，Maven会在打包之前执行编译、测试等操作。
这里我们看到jar:jar任务负责打包，实际上就是jar插件的jar目标将项目主代码打包成一个名为hello-world-1.0-SNAPSHOT.jar的文件，
该文件也位于target/输出目录中，它是根据artifact-version.jar规则进行命名的，
如有需要，我们还可以使用finalName来自定义该文件的名称，这里暂且不展开，本书后面会详细解释。
至此，我们得到了项目的输出，如果有需要的话，就可以复制这个jar文件到其他项目的Classpath中从而使用HelloWorld类。
但是，如何才能让其他的Maven项目直接引用这个jar呢？
我们还需要一个安装的步骤，执行 mvn clean install：
Java代码 
… 
[INFO] [jar:jar {execution: default-jar}] 
[INFO] Building jar: D: \code\hello-world\target\hello-world-1.0-SNAPSHOT.jar 
[INFO] [install:install {execution: default-install}] 
[INFO] Installing D:\code\hello-world\target\hello-world-1.0-SNAPSHOT.jar to 
C:\Users\juven\.m2\repository\com\juvenxu\mvnbook\hello-world\1.0-SNAPSHOT\hello-world-1.0-SNAPSHOT.jar 
[INFO] 
------------------------------------------------------------------------ 
[INFO] BUILD SUCCESSFUL 
… 
在打包之后，我们又执行了安装任务install:install，
从输出我们看到该任务将项目输出的jar安装到了Maven本地仓库中，
我们可以打开相应的文件夹看到Hello World项目的pom和jar。
之前讲述JUnit的POM及jar的下载的时候，我们说只有构件被下载到本地仓库后，才能由所有Maven项目使用，
这里是同样的道理，只有将Hello World的构件安装到本地仓库之后，其他Maven项目才能使用它。
我们已经将体验了Maven最主要的命令：mvn clean compile、mvn clean test、mvn clean package、mvn clean install。
执行test之前是会先执行compile的，执行package之前是会先执行test的，
而类似地，install之前会执行package。我们可以在任何一个Maven项目中执行这些命令，而且我们已经清楚它们是用来做什么的。

到目前为止，我们还没有运行Hello World项目，不要忘了HelloWorld类可是有一个main方法的。
默认打包生成的jar是不能够直接运行的，因为带有main方法的类信息不会添加到manifest中
(我们可以打开jar文件中的META-INF/MANIFEST.MF文件，将无法看到Main-Class一行)。
为了生成可执行的jar文件，我们需要借助maven-shade-plugin，配置该插件如下：
Java代码 
<plugin> 
<groupId>org.apache.maven.plugins</groupId> 
<artifactId>maven-shade-plugin</artifactId> 
<version>1.2.1</version> 
<executions> 
<execution> 
<phase>package</phase> 
<goals> 
<goal>shade</goal> 
</goals> 
<configuration> 
<transformers> 
<transformer implementation="org.apache.maven.plugins.shade.resource.ManifestResourceTransformer"> 
<mainClass>com.juvenxu.mvnbook.helloworld.HelloWorld</mainClass> 
</transformer> 
</transformers> 
</configuration> 
</execution> 
</executions> 
</plugin> 

plugin元素在POM中的相对位置应该在<project><build><plugins>下面。
我们配置了mainClass为com.juvenxu.mvnbook.helloworld.HelloWorld，项目在打包时会将该信息放到MANIFEST中。
现在执行 mvn clean install ，待构建完成之后打开target/目录，
我们可以看到hello-world-1.0-SNAPSHOT.jar和original-hello-world-1.0-SNAPSHOT.jar，
前者是带有Main-Class信息的可运行jar，后者是原始的jar，
打开hello-world-1.0-SNAPSHOT.jar的META-INF/MANIFEST.MF，可以看到它包含这样一行信息：
Main-Class: com.juvenxu.mvnbook.helloworld.HelloWorld
现在，我们在项目根目录中执行该jar文件：
D: \code\hello-world>java -jar target\hello-world-1.0-SNAPSHOT.jar
Hello Maven
控制台输出为Hello Maven，这正是我们所期望的。
本小节介绍了Hello World项目，侧重点是Maven而非Java代码本身，
介绍了POM、Maven项目结构、以及如何编译、测试、打包，等等。
------------------------------------------------------
3.5 使用Archetype生成项目骨架 
Hello World项目中有一些Maven的约定：
在项目的根目录中放置pom.xml，
在src/main/java目录中放置项目的主代码，
在src/test/java中放置项目的测试代码。
我们称这些基本的目录结构和pom.xml文件内容称为项目的骨架，
当你第一次创建项目骨架的时候，你还会饶有兴趣地去体会这些默认约定背后的思想，
第二次，第三次，你也许还会满意自己的熟练程度，但第四、第五次做同样的事情，就会让程序员恼火了，
为此Maven提供了Archetype以帮助我们快速勾勒出项目骨架。
还是以Hello World为例，我们使用maven archetype来创建该项目的骨架，离开当前的Maven项目目录。
如果是Maven 3，简单的运行：
mvn archetype:generate
我们实际上是在运行插件maven-archetype-plugin，
注意冒号的分隔，其格式为 groupId:artifactId:version:goal ，
org.apache.maven.plugins 是maven官方插件的groupId，maven-archetype-plugin 
是archetype插件的artifactId，2.0-alpha-5 是目前该插件最新的稳定版，generate是我们要使用的插件目标。
紧接着我们会看到一段长长的输出，有很多可用的archetype供我们选择，
包括著名的Appfuse项目的archetype，JPA项目的archetype等等。
每一个archetype前面都会对应有一个编号，同时命令行会提示一个默认的编号，
其对应的archetype为maven-archetype-quickstart，我们直接回车以选择该archetype，
紧接着Maven会提示我们输入要创建项目的groupId、artifactId、 version、以及包名package，如下输入并确认：
Java代码 
Define value for groupId: : com.juvenxu.mvnbook 
Define value for artifactId: : hello-world 
Define value for version: 1.0-SNAPSHOT: : 
Define value for package: com.juvenxu.mvnbook: : com.juvenxu.mvnbook.helloworld 
Confirm properties configuration: 
groupId: com.juvenxu.mvnbook 
artifactId: hello-world 
version: 1.0-SNAPSHOT 
package: com.juvenxu.mvnbook.helloworld 
Y: : Y 

Archetype插件将根据我们提供的信息创建项目骨架。
在当前目录下，Archetype插件会创建一个名为hello-world（我们定义的artifactId）的子目录，
从中可以看到项目的基本结构：基本的pom.xml已经被创建，里面包含了必要的信息以及一个junit依赖；
主代码目录src/main/java已经被创建，在该目录下还有一个Java类com.juvenxu.mvnbook.helloworld.App，
注意这里使用到了我们刚才定义的包名，而这个类也仅仅只有一个简单的输出Hello World!的main方法；
测试代码目录src/test/java也被创建好了，并且包含了一个测试用例com.juvenxu.mvnbook.helloworld.AppTest。
Archetype可以帮助我们迅速地构建起项目的骨架，
在前面的例子中，我们完全可以在Archetype生成的骨架的基础上开发Hello World项目以节省我们大量时间。
此外，我们这里仅仅是看到了一个最简单的archetype，
如果你有很多项目拥有类似的自定义项目结构以及配置文件，
你完全可以一劳永逸地开发自己的archetype，然后在这些项目中使用自定义的archetype来快速生成项目骨架

---------------------------------------------------------------------------------------------------

1.7java-maven书籍

Maven实战 许晓斌 (2012-12出版)

 

转自：http://blog.csdn.net/chinayaosir/article/details/8978103