• 丰搜首页
• 文档中心
• 视频中心
• 丰搜贴吧
• 问题集锦
• 更多功能

选择显示字体大小

• 最大
• 较大
• 标准

maven起步-教你开始使用maven

maven起步
作者：timothy m.o'brien, vincent massol
翻译：revenger

版权声明：可以任意转载，转载时请务必以超链接形式标明文章原始出处和作者信息及本声明
英文原文地址:
http://www.onjava.com/pub/a/onjava/excerpt/mavenadn_ch01/index.html
中文地址:
http://www.matrix.org.cn/resource/article/43/43661_maven.html
关键词： maven ant java




编者注：

如果你已经有十次输入同样的ant targets来编译你的代码、jar或者war、生成javadocs，你一定会自问，是否有有一个重复性更少却能同样完成该工作的方法。maven便提供了这样一种选择，将你的注意力从作业层转移到项目管理层。maven项目已经能够知道如何构建和捆绑代码，运行测试，生成文档并宿主项目网页。

o'reilly's的新书maven:a developer's notebook帮你提升你的项目、使其尽快的运行起来，同时也提供了对maven插件及其团队协作等高级特性的深度考察。在“maven jump-start” (656k pdf)的示范章节中，作者vincent massol和timothy m.o'brien向你展示了如何安装maven，如何开始你初次的构建，研究如何使其与ides集成极其资源管等特性。

vincent massol是jakarta catus framework（框架）的创建者。其后他花费4年的时间在几个大项目（主要是j2ee）的架构技术上。他现在是pivolis的创办人和cto,这是一家专注于应用敏捷方法进行软件开发的公司。他现在居住在法国的首都city of light（巴黎）。

timothy m. o'brien作为一个专业的歌手/程序员现正在芝加哥地区工作和生活。




让我们开始使用maven。在本章结束时，你应该能够从头建立一个maven的项目，使用maven进行相关管理，创建基于某些感兴趣报告的简单的web站点。

安装maven
开始本书以前，你有一些必备的安装工作。本书中的例子用java1.4.2编写，maven能够兼容java1.4.2和java1.5.0。本书中所写maven的最新版本是在编写本书时发布的—maven 1.0.2。除jdk和maven1.0.2之外，你还需要连接到inte.net，maven将通过公网站点下载相关其需要的。那么，前进，安装maven吧。

我该如何做？
从apache software foundation(asf)下载maven。进入http://maven.apache.org/从左侧的导航菜单中的getting maven菜单选择下载。它将带你进入一个让你选择windows 安装包、zip文件、tar'd.bzip文件或者tar'd.gzip文件。下载适合你平台的分类。

我该如何做？
从apache software foundation(asf)下载maven。进入http://maven.apache.org/从左侧的导航菜单中的getting maven菜单选择下载。它将带你进入一个让你选择windows 安装包、zip文件、tar'd.bzip文件或者tar'd.gzip文件。下载适合你平台的分类。

提示
某些developer's notebook中涉及的插件未与maven1.0.2
绑定。请参考第6章并且附录a有安装maven所需插件的全部
列表以及详细说明。


在microsoft windows平台，下载windows安装包（maven-1.0.2.exe），跟随自动安装过程中的提示。在使用maven windows 安装器进行安装后，你应该定义一个用户环境变量，maven_home，指向你本地的maven安装。你此时需要进入控制面版→系统→高级选择环境变量按钮，添加%maven_home%\bin到你的path环境变量。进入命令提示行运行cmd.exe，如果maven安装成功，你将能够看到命令行有下面的输出：
c:\dev\mavenbook\code>maven -v
__  __
  \/  __ _apache__ ___
\/ / _` \ v / -_) ' \  ~ intelligent projects ~
_  _\__,_\_/\_____  v. 1.0.2

如果你愿意安装maven到一个除了c:\program files\apache software foundation\maven 1.0.2的目录，你也可以下载maven1.0.2.zip文件，解压缩到任何目录。设置maven_home指 向到maven解压缩的目录，并且添加%maven_home%\bin到你的path环境变量。

在unix平台，下载tar'd.zip文件（maven-1.0.2.tar.gz）并接压缩tar xvzf maven-1.0.2.tar.gz到你选择的目录。本试验假设你解压maven到/usr/local/maven-1.0.2目录下。你此时需要设置两个环境变量，maven_home和path。下面的命令为这两个变量设置适当的值：
[tobrien@mavenbook tobrien]$ export maven_home=/usr/local/maven-1.0.2
[tobrien@mavenbook tobrien]$ export path=${path}:${maven_home}/bin
如果maven被成功安装到你的机器，你能够看到与windows系统同样的输出。恭喜！你已经成安装了maven。

提示
有些人喜欢保存本地应用程序在unix下的/opt目录或
windows下的c:\apps。你可以根据个人喜好安装maven。

刚刚发生了什么？
你刚刚安装了maven1.0.2并且配置了一些环境变量。是的！一旦你对maven_home进行了有效的设置或是maven.bat或maven.sh已经存在，你已经能够完成developer's notebook本次的实验。

关于....
          ..maven 2?
是时机提及maven 2（有时也被称为“m2”）。maven 2完成了对maven 1的重写。重写的首要目的是要提供了强大的jave构建和包含api的项目，允许maven被植入任何地方，尤其是高级别的产品如ides、质量工具、报告工具等这些。maven 2构建生命周期的概念正式话，其比maven更易扩展。

maven 1和maven 2有许多共同点，但它们还有几个主要的不同之处。在书中的各个部分我们尽可能提示你所希望了解的那些不同之处。更多关于maven 2的信息，请转到http://maven.apache.org/下载maven 2的体验版本，并加入maven用户或开发者邮件列表。如果你听过continuous integration，你可能也想看一看命名为continuum的maven子项目，地址在http://maven.apache.org/continuum。

开始一个新的项目
创建新项目的争论一部分在于有很大部分的工作努力被用到在“发展基础设施”上—自动构建、单元测试、文档、项目报告等。使用maven你可以加速这个过程，生成项目的框架使其作为新应用的种子。


我该如何做？
maven拥有一个应用程序生成插件（genapp）你能通过其创建一个新项目。首先创建一个空的目录c:\dev\mavenbook\code\genapp\test-application这将成为应用程序生成后的处所。通过执行genapp这个目标来运行genapp插件，选择默认的模版并且提供一些你的新项目的相关信息。
c:\dev\mavenbook\code\genapp\test-application>maven genapp

__ __
 \/ __ _apache__ ___
 \/ / _` \ v / -_) ' \ ~ intelligent projects ~
_ _\__,_\_/\_____ v. 1.0.2
attempting to download commons-jelly-tags-interaction-20030211.143817.jar.
4k downloaded
enter a project template to use: [default]
[enter]
please specify an id for your application: [app]
test-application
please specify a name for your application: [example application]
test application
please specify the package for your application: [example.app]
mdn.testapp
build:start:
genapp:
[copy] copying 1 file to c:\dev\mavenbook\code\genapp\test-application\
src\java\mdn\testapp
[copy] copying 3 files to c:\dev\mavenbook\code\genapp\test-application\
src\test\mdn\testapp
[copy] copying 1 file to c:\dev\mavenbook\code\genapp\test-application\
[copy] copying 2 files to c:\dev\mavenbook\code\genapp\test-application\
build successful

本插件会要求用户一些输入，从这个输出内容你可以看到你使用了默认的（defalut）应用程序模板，并且你提供了新项目的应用程序id、name，和包名。默认的（default）应用程序模板创建了一个单独的类，mdn.testapp.app，和一个静态main函数和两个junit测试。

maven的应用程序生成插件生成了下面的目录和文件：

test-application/
project.properties
project.xml
src/
conf/
app.properties
java/mdn/testapp/
app.java
test/mdn/testapp/
abstracttestcase.java
apptest.java
naughtytest.java

所有maven项目有一个参考了项目对象模型（pom）的标准目录结构, （as described shortly）。如果你有一些现存的类你想添加到一个项目，添加它们到src/java，如果你有一些单元测试将它们添加到src/test。如果这些已有的类和单元测试依赖一些外部的苦，你将在随后的章节看到如何添加一个附属。xdos目录包含了格式为xdoc的项目文档。

提示
请注意maven1.0.2装载的genapp插件版本创建了非标准
的布局。在maven项目中src/java和src/test不再出现
在固有的源代码和单元测试位置。取而代之的是你可
以使用src/main/java和src/test/java。为了改变这些，
修改你项目的xml文件，改变src/java的引用为src/main-
/java，src/test的引用为src/test/java。更多的信息，
请参见“maven conventions”,地址在
http://maven.apache.org/-reference/conventions.html。

project.xml是项目的描述符；它是一个内容为pom的xml文件。让我们看看这个project.xml的拷贝，其已经定义了这个项目：

<project>
<pomversion>3</pomversion>
<artifactid>test-application</artifactid>
<name>test application</name>
<currentversion>1.0</currentversion>
<organization>
<name>your organization</name>
<url>http://www.someorganization.biz/</url>
<logo>http://www.someorganization.biz/logo.gifjpg...</logo>
</organization>
<inceptionyear>2005</inceptionyear>
<package>mdn.testapp</package>
<logo>http://yourproject/logo.jpggif...</logo>
<description>
an example project
</description>
<shortdescription>
how to use maven in different situations
</shortdescription>
<!-- many elements omitted (see generated pom) -->
<dependencies/>
<build>
<sourcedirectory>src/java</sourcedirectory>
<unittestsourcedirectory>src/test</unittestsourcedirectory>
<unittest>
<includes>
<include>**/*test.java</include>
</includes>
<excludes>
<exclude>**/naughtytest.java</exclude>
</excludes>
</unittest>
<resources>
<resource>
<directory>src/conf</directory>
<includes>
<include>*.properties</include>
</includes>
</resource>
</resources>
</build>
</project>

该文件告诉maven有关你项目的全部。build元素定位应用程序原码，单元测试和资源文件包的位置。name, artifactid, currentversion, inceptionyear, description。
shortdescription标识该项目并且提供了该项目的信息被用作完成品的名字来创建项目。

提示
如果你工作在已有的maven项目，你应该看到id元素在
artifactid的位置。该id元素已经不被赞成使用，
你可以用artifactid替代。

resources元素被用于jar插件拷贝资源到jar生成物。在该元素你指定一批资源到资源库。本例中，自src/conf的资源将被复制到classpath的根目录。换言之，app.properties资源将被复制到所生成的jar生成物的根目录。如果你想所有位于src/conf的*.properties资源和*.xml资源在mdn.testapp包中生成的jar有效，你可以按照以下来指定targetpath：

<resource>
<directory>src/conf</directory>
<targetpath>mdn/testapp</targetpath>
<includes>
<include>*.properties</include>
<include>*.xml</include>
</includes>
</resource>

project.properties让你能够定制maven及其插件在本项目中的行为。你将在看过本书之后使用该文件定制所生成web站点的品质和jar文件的内容。

提示
关于在没有genapp插件来生成新maven项目的快速入
门指导，参见brettporter的“the ten minute test”，
地址在http://maven.apache.org/start/ten-minute-
test.html。

关于...
... maven在有关协作项目中跟踪信息的能力？
为简化本例，我们从project.xml文件中去掉了一些初期显示的描
述项目邮件列表、知识库、开发者和web站点的元素。第4、5章深
入更多有关使用maven发布web站点和在现有源码库中工作的细节。


在代理服务器下使用maven
maven依赖于inte.net连接，其通过http下载相关的插件。如果你工作在公共环境，你可能需要配置maven来与工作代理服务器系统。


我该如何做？
你可能需要设置你项目中project.properties文件的一些属性。project.properties文件允许你通过设置命名的属性来定制maven的行为。配置代理服务器，放置下面的project.properties到与你项目中project.xml文件同样的位置：
maven.proxy.host = proxy.company.com
maven.proxy.port = 80
并且，如果你需要连接到一个代理服务器必须有ntlm的授
权，设置以下属性：
maven.proxy.ntlm.username = tobrien
maven.proxy.ntlm.password = myp@ssw0rd

提示
在第二章，你将学到user-specific属性将被定义在
~/build.properties或%userprofile%\build.properties 文件。现在，如果你需要完成本试验，在 project.properties里定义这些属性。

编译和测试一个项目
你拥有了一个包含一个类文件和单元测试文件的项目。下
面，让我们够见这个项目和运行应用程序类吧。

我该如果做？
通过执行jar:jar goal来创建一个包含应用程序的类的jar
文件。jar插件定义了一个速记目标命名为jar其依赖之前的jar:jar goal。执行任何一个目标将得到相同的结果。所有的插件都定义了一条这样的捷径；例如，测试目标执行的是test插件里的test:test goal。执行jar goal和maven jar：

c:\dev\mavenbook\code\genapp\test-application>maven jar
__ __
 \/ __ _apache__ ___
 \/ / _` \ v / -_) ' \ ~ intelligent projects ~
_ _\__,_\_/\_____ v. 1.0.2
attempting to download junit-3.8.1.jar.
118k downloaded
build:start:
java:prepare-filesystem:
[mkdir] created dir: c:\dev\mavenbook\code\genapp\test-application\
target\classes
java:compile:
[echo] compiling to c:\dev\mavenbook\code\genapp\test-application/
target/classes
[echo]
[javac] compiling 1 source file to c:\dev\mavenbook\code\genapp\testapplication\
target\classes
java:jar-resources:
copying 1 file to c:\dev\mavenbook\code\genapp\test-application\target\
classes
test:prepare-filesystem:
compiling and testing a project 9
[mkdir] created dir: c:\dev\mavenbook\code\genapp\test-application\
target\test-classes
[mkdir] created dir: c:\dev\mavenbook\code\genapp\test-application\
target\test-reports
test:test-resources:
test:compile:
[javac] compiling 3 source files to c:\dev\mavenbook\code\genapp\testapplication\
target\test-classes
test:test:
[junit] running mdn.testapp.apptest
[junit] tests run: 1, failures: 0, errors: 0, time elapsed: 0.078 sec
jar:jar:
[jar] building jar: c:\dev\mavenbook\code\genapp\test-application\
target\test-application-1.0.jar
build successful
total time: 9 seconds

maven创建一个target（目标）目录来保存中间文件和jar文件。在jar首次被建立后，按照下面执行app类。

c:\dev\mavenbook\code\genapp\test-application> java ^
more? target\test-application-1.0.jar mdn.testapp.app
hello world!

如果你想重复此项工作，运行maven clean来移除target目录重新构建。

刚刚发生了什么？
当你运行jar目标时，maven使用jar插件来创建了一个jar生成物。首先，maven找到一系列的目标以便能够创建这个应用程序的jar文件；jar插件有一个其它目标所依赖于目标的jar:jar goal，反过来，它也依赖于其他的目标。maven找出下列需要的目标来执行：java:prepare-filesystem，java:compile，java:jarresources，
test:prepare-filesystem，test:test-resources，test:compile，and test:test。

maven查看其需要执行目标中的test插件来执行单元测试，并且检查本地maven库中的junit jar文件。因为你还没有使用过maven，所以它将从位于http://www.ibiblio.org/
maven/的maven默认库中下载junit-3.8.1.jar。你将在本章后学习到有关maven本地库和maven强大的相关管理能力的内容。


与项目对象模型一同工作
project object model（pom）是maven的重要部分，你将与其一同工作贯穿本书。


我该如何做？
pom同样涉及到项目的描述。project.xml描述了项目的源代码、开发者、源控制，许可和标示信息譬如项目名称和发起组织。maven打破了过去传统的构建系统；取而代之的是为每个构建提供了外在说明，maven使用声名的方法管理构建。换句话说，你不用过多的告诉maven做什么，maven知道去查找基于project.xml中的内容。另一方面，ant以命令方式进行项目构建；你最终要告诉ant编译这个文件，建立这个目录，绑定这些文件到war等等。maven维护一个插件的分类来与标准的pom—一个结构声明、标示和内容工作。

如果你看了上次练习所生成的project.xml文件，你将注意到许多元素都在上次讨论中被忽略。下面的xml列出了pom中顶级的元素，（in the order in which they are expected:
）：

<project>
<extend/>
<pomversion/>
<id/>
<name/>
<groupid/>
<currentversion/>
<organization/>
<inceptionyear/>
<package/>
<logo/>
<gumprepositoryid/>
<description/>
<shortdescription/>
<url/>
<issuetrackingurl/>
<siteaddress/>
<sitedirectory/>
<distributionsite/>
<distributiondirectory/>
<repository/>
<versions/>
<branches/>
<mailinglists/>
<developers/>
<contributors/>
<licenses/>
<dependencies/>
<build/>
<reports/>
<properties/>
</project>

本章探究更多以上xml列出的元素，包括contributors，developers，dependencies，reports和repository。本章的式样将提供这些细节，但你应该使用上面xml的摘录来以适当的顺序放置这些元素到你的project.xml中。

列出有效的goals
当你使用maven时，你将执行目标。maven插件是一组相关的插件。例如，要为一个项目创建jar文件，你将如下所示执行jar插件中的jar:jar goal。
c:\dev\mavenbook\code\genapp> maven jar:jar
冒号之前的jar分类这个目标属于jar插件。查看全部的jar插件列表，键入以下命令：
c:\dev\mavenbook\code\genapp> maven -p jar
__ __
\/ __ _apache__ ___
\/ / _` \ v / -_) ' \ ~ intelligent projects ~
_ _\__,_\_/\_____ v. 1.0.2
goals in jar
============
[jar] create the deliverable jar file.
deploy ......................... deploy a jar to the remote repository
deploy-snapshot ................ deploy a snapshot jar to the remote
repository
install ........................ install the jar in the local repository
install-snapshot ............... install a snapshot jar in the local
repository
jar ............................ create the deliverable jar file.
snapshot ....................... create a snapshot jar, ie '
id-yyyymmdd.hhmmss.jar'
plugin for creating jar files. requires maven 1.0 rc2.

如果你需要查看每个有效的插件和目标，输入下面内容：
c:\dev\mavenbook\code\genapp\test-application> maven -g more
全部的插件可能使人有些畏惧，maven有关于一切的插件，从生成项目文件到ides到生成war文件以及开始和停止应用服务器。你将在下面的实验中学习到一些更有用的插件。

生成调试信息
现在，你可能已经注意到maven执行了许多繁重的工作。如果你使用ant，你可能已经开始编写ant的build.xml文件并且添加编译.jar任务和单元测试。maven隐藏了许多复杂性，但当调试问题时，它也能够查看“幕后”。这个能力运行于maven的调试模式并且这个工具打印输出每个构建的细节重要的是你可以根据需要来验证构建是否正确执行。


我该如何做？
本次实验，参考上一个测试应用程序。当你运行maven test，你将收到如下信息：

java:compile:
[echo] compiling to 
c:\dev\mavenbook\code\genapp\test-application/
target/classes
[echo]
java:jar-resources:
[...]

在执行java:comile或java:jar-resources目标时到底发生了什么？执行构建项目中运行maven -x test将显示全部目标的调试信息。让我们来是一下，把注意力放在最早的第三个目标上。运行maven -x test生成下面的输出：

[...]
java:compile:
[echo] compiling to c:\dev\mavenbook\code\genapp\test-application/
target/classes
[javac] [debug] fileset: setup scanner in dir
c:\dev\mavenbook\code\genapp\test-application\src\java with
patternset{ includes: [ ] excludes: [**/package.html] }
[javac] [verbose] mdn\testapp\app.java omitted as mdn/testapp/app.class
is up to date.
java:jar-resources:
[debug] fileset: setup scanner in dir
c:\dev\mavenbook\code\genapp\test-application\src\conf with
patternset{ includes: [*.properties] excludes: [ ] }
[verbose] app.properties omitted as app.properties is up to date.
[...]

java:compile的打印输出任务可能看起来很熟悉。它是ant的echo和javac任务的输出。maven常常使用ant的进程来执行常用操作如：拷贝、删除、编译和创建jar文件。

刚刚发生了什么？
这两个目标执行的都是非常简单的调试输出。java:compile目标简单的扫描源目录中java源码中较新的相关类文件。java:jar-resources目标寻找资源中包含的jar文件。更复杂的如test:test将产生有关虚拟机和类加载器的调试信息。

当maven有问题或某个目标抛出异常，maven将简单打印较少的错误信息来告诉你有错误发生。如果你需要等多信息，并且看到堆栈跟踪，添加-e标志到命令行。与-e标志一起，maven将打印完整的堆栈信息当其遇到错误时。

添加依赖关系
你有了一个拥有单个类文件并且已经成功编译执行的项目。下面，你将添加一个依赖关系到项目描述器并且开始使用maven管理项目依赖关系。本次实验的目的是，假设你需要工作在spring框架中。添加spring框架-spring-core-1.1.4.jar和spring-web-1.1.4.jar的依赖关系。


我该如何做？
首先，你需要根据需要定位maven默认中心源码库中的jar文件。ibiblio.org在http://www.ibiblio.org/maven/提供了这些。在web浏览器中加载这个url你将看到一系列的目录；我们关心的是springframework的目录，springframework下子目录的结构如下所示：
http://www.ibiblio.org/maven
/springframework
/jars
spring-core-1.1.4.jar
spring-dao-1.1.4.jar
spring-web-1.1.4.jar

依照人造物，你使用dependency—groupid, artifactid和version三个元素。你能够添加两个依赖关系的完成品以替代test-application/project.xml中的dependencies元素如下所示：

<dependencies>
<dependency>
<groupid>springframework</groupid>
<artifactid>spring-core</artifactid>
<version>1.1.4</version>
</dependency>
<dependency>
<groupid>springframework</groupid>
<artifactid>spring-web</artifactid>
<version>1.1.4</version>
</dependency>
</dependencies>

现在，运行jar目标并且看看maven的输出吧；它将包含下面如下这些。

attempting to download spring-core-1.1.4.jar.
266k downloaded
attempting to download spring-web-1.1.4.jar.
111k downloaded

图1-1显示了jar目标触发的一系列事件：
1.maven查看pom,依据project.xml的定义，看到在springframework组中的两个人造物的依赖关系。它将载你本地maven的资源库中检查spring-core-1.1.4.jar和spring-web-1.1.4.jar。
2.当maven找不到这些文件，它将到http://www.ibiblio.org/maven/springframework/jars/寻找jar文件。这些jar文件会被下载并放置于你本地maven的资源库中。它们也被添加到你项目的classpath中。下次在你的项目查询这些文件时，maven将在你本地的资源库中提供它们。


图1-1.maven本地和远程资源库为test application项目提供的spring jar。

刚刚发生了什么？
maven为你节省了相当的时间和不必要的麻烦。maven到来之前，依赖关系常常被捆绑到一个项目的目录或者项目应该指向到添加正确的jar到你的classpath。使用maven管理依赖关系显然有着明显的优势；作为初学者，如果你的项目依赖30个外部的jar文件，这就不需要在你的资源库中存储成兆的jar文件。这意味着当你在项目的外部检查资源控制的时候更少的存储空间和更快的下载时间。另外，如果你有多个项目依赖相同的外部依赖，maven仅需要下载一次依赖关系，并且每个项目引用一个单独的副本在你本地的资源库中。当依赖关系能够从maven资源库远程下载的时候，没有强制的原因让你存储你项目的依赖关系的版本。

当maven下载依赖关系，其在你本地的机器上从远程的maven资源库拷贝一个文件到你本地的maven资源库。maven如何定位依赖关系的？它使用project.xml中dependency元素的信息，如图1-2所示。


图1-2.pom和maven资源库的映射。

指定的groupid告诉maven查看特定的目录-springframework。指定type告诉maven查找特定的子目录如jar和war（注意s是maven附加到type元素上的）；本例中，type是被忽略的，jar类型是默认类型。当你指定了artifactid，你正告诉maven哪个文件将从jar目录下载。顶级目录表现为组标示符，jar文件名的第一部分表现为artifact标示符，文件名最后的部分，包括扩展名表现为version标示符。maven使用下面的公式来决定一个来自于资源库中的依赖关系。[repo_root]参考你远程的资源库：

&#91;repo_root&#93;/<groupid>/<type>s/<artifactid>-<currentversion>.<type>

提示
maven2.0的说明中，资源库可能开始于类似java包的
结构。作为springframework的替代，groupid被提议
的结构为org.springframework。另外，每个版本将有
一个分隔目录用以增加maven资源库的效率。更多有关
改变的提交建议，参见http://docs.codehaus.org/display/
maven/repository+layout+-+final。

一个本地的资源库来处理依赖关系。在unix机器上，你的maven资源库能在~/.maven/repository目录找到，在windows机器上，你的maven的资源库在你的%userprofile%目录。如果你看一看本地maven的资源库，你将会注意到它正包含一个springframework的目录。%userprofile%\.maven\repository\springframework\jars目录包含spring-core依赖关系的两个：spring-core-1.1.4.jar文件和spring-core-1.1.4.jar.md5文件,其包含md5文件用于验证sprint-core jar文件的完整性。maven 1当前并没有使用md5来验证完成品的完整性，但在将来的版本可能会用其来验证完成品的完整性。

提示
在windows机器上，%userprofile%通常决定于c:\d-
ocuments and settings\vmassol这种目录。%userpr-
ofile%被用在unix的主目录。（%userprofile% is
used in the spirit of the abbreviation for a unix home directory。）

关于...
...使用id元素?

如果你工作在现存的maven项目，你可能有依赖关系使用id元素。下面的dependencies元素示范了使用单独id元素来附加jakarta commons math的1.0版本：

<dependencies>
<dependency>
<id>commons-math</id>
<version>1.0</version>
</dependency>
</dependencies>

单独使用id元素工作仅在groupid和artifactid匹配时，如果你浏览maven资源库，你将看到下面的目录结构：
/commons-math
/jars
commons-math-1.0.jar
commons-math-1.1.jar

使用id元素工作，单独的id标记已经不被赞成使用并在maven 2中消失。当你看到别的maven项目中使用dependencies的速记符号时，请尝试使用groupid和artifactid来标识你的依赖关系。

依赖快照
如果你开发的程序依赖的依赖关系经常改变，你可能想将依赖的每个依赖关系替代为最近构件的硬编码的版本。在一个项目依赖的依赖关系还处在beta的版本，或你正开发一系列项目依赖的maven项目时时特别有用，这将在第3章论述。本实验，你将学习到如何依靠快照。


我该如何做？
在你的依赖关系块儿中指定一个明确的版本，使用snapshot关键字作为版本名称的一部分。每次你执行maven目标时，maven将从远程资源库中检查较新的依赖关系。如果远程资源库的版本较新maven将下载其到本地资源库。例如：下面的依赖关系将一直下载spring的新版jar文件。

<dependency>
<groupid>springframework</groupid>
<artifactid>spring</artifactid>
<version>1.2-snapshot</version>
</dependency>

刚刚发生了什么？
当你使用snapshot依赖关系，你正告诉maven使用远程资源库的最新版本。在你使用多项目插件或者当你依赖的一个完成品尚处于开发阶段这将得心应手。在你工作的团队仅有较少的开发者组成时，最好也常这么做。你将使用snapshot依赖关系当你的项目依赖一个最近的开发或者非正式版本的特别组件。snapshot依赖关系应该在开发阶段被保留，并且，概括说，你不用改发布一个依赖于snapshot依赖关系的项目。

执行脱机构建
如果你需要在一个离线的情况下使用maven，你可能需要知道如何确使maven不检查最新的snapshot依赖关系。本实验将向你展示如何用maven执行脱机构建。


我该如何做？
这个方法很简单：仅仅使用-o命令行选项。例如，如果你没有网络连接，但又想执行测试目标，运行maven -o test。maven将执行这个test目标而不检查依赖关系。如果你的项目没有依赖snapshot构建，你也可以断看你的环境来添加-o标志。如果你依赖snapshot构建，你将需要使用-o标志，maven将在每次执行目标时尝试检查最新的snapshot。在这种情况下不使用-o标志本项目将不会构建成功。


关于...
... 执行离线构建如果你不想下载任何完成品？
当然，这将不会工作。离线构建的工作，你必须已经有必需的依赖关系在你本地的资源库。项目最简单的获得maven下载依赖
关系的方法是在每个maven项目实例简单的运行“noop”目标，build:start。这个目标执行之前任何其它的目标并不执行任何动作。如果你运行build:start，maven将从project.xml获得获取任何依赖关系。


使用maven控制台
如果你再三的从命令行运行maven，你可以通过maven控制台来节省时间。maven控制台提供一个“外壳”，在这你可以键入目标的名称来执行maven。通过使用maven可以避免每次载你想运行一个maven目标时java virtual machine（jvm）启动的等待。


我该如何做？
maven console是一个插件，你可以通过键入maven console在命令提示符。这将产生下面的输出：

__ __
 \/ __ _apache__ ___
 \/ / _` \ v / -_) ' \ ~ intelligent projects ~
_ _\__,_\_/\_____ v. 1.0.2
the following commands are available:
list - list all available goals
help - this message
<goalname> - attain a goal
quit - quits the console
test-application 1.0 >

目前，你可以在命令行执行任何你能执行的目标。开始是一下；键入 java:compile。maven将执行 java:compile目标并返回提示符其它的目标。在一个序列中运行两个目标，你可以在提示符处输入它们，通过“空格”-例如， clean test。众所周知作为“goal chaining”这是你想通过maven获得指定一系列目标的方法。退出maven console，键入quit，查看有效目标列表，键入list。

刚刚发生了什么？
在maven console下maven执行java:compile目标非常之快，不信么？当你使用maven console时你所执行的目标是在一个现成的jvm下。当你从命令行运行maven时，你每次运行一个目标都不得不等待jvm的启动。如果你不确信其对性能的提升，自己试试看。在命令行下运行java:complie 10次，再在maven console下同样运行java:compile 10次。注意时间的差别，你将发现jvm启动的时间开始增加。如果你找到你自己常用的maven目标，maven console将通过启动jvm一次为来节省时间。


生成eclipse项目
我打赌你一定想在ide下工作。maven通过插件来与eclipse,inellij,idea,jbuilder,jdeveloper以及emacs集成。maven很好的与全部这些工作集成，本实验关注其在eclipse上的集成，一个开源的ide。


我该如何做？
这个过程很简单；仅仅执行eclipse插件：

c:\dev\mavenbook\code\genapp\test-application> maven eclipse
build:start:
eclipse:generate-project:
[echo] creating c:\dev\mavenbook\code\genapp\test-application/.project ...
eclipse:generate-classpath:
[echo] creating c:\dev\mavenbook\code\genapp\test-application/.classpath ...
[echo] contains junit tests
[echo] setting compile of src/test to target/test-classes
plugin 'cactus-maven' in project 'test application' is not available
[echo] setting default output directory to target/classes
eclipse:
[echo] now refresh your project in eclipse (right click on the project
and select "refresh")
build successful
total time: 2 seconds

maven创建两个文件以识别eclipse的项目：.project和.classpath。在eclipse中，你就可以通过下面的步骤导入这个工程了：
1.启动eclipse。
2.从菜单栏选择file→import...
3.选择现存项目放入workspace并单击next按钮。
4.在import对话框选择c:\dev\mavenbook\code\genapp\test-application目录，并单击finish按钮。

你稍候将执行更多步来指向eclipse到本地maven资源库。eclipse使用一个名叫maven_repo来指向到本地maven资源库。你能通过在命令行执行下面的操作设置maven_repo来使用maven:
maven -dmaven.eclipse.workspace=c:\eclipse\workspace eclipse:add-maven-repo
执行这个目标可以设置位于目录c:\eclipse\workspace的全局变量maven_repo。
作为选择，你可以按照这些步骤手工配置该变量：
1.从菜单栏中选择window→打开eclipse preferences选择preferences。
2.在树型菜单左手边的preferences对话框，选择java→build path→classpath变量。
3.单击new按钮来创建一个新的变量；这可以带入到新变量对话框。
4.输入maven_repr到name域。
5.单击folder按钮选择你本地的maven资源库。
6.单击ok并重新构建你的项目。

你可能需要配置maven_repo仅一次；该变量是全局的它可以与全部eclipse项目共享。

关于...
... jbuilder, jdeveloper, and intellij idea？
所有这些ide有着eclipse一样简单的插件。为jbuilder 项目生成必需的文件，运行mave jbuilder，对于jdeveloper运行mave jdeveloper，为intellij idea项目运行mave idea。


使用maven的eclipse插件
是的，这是一个你可以使用的高品质的maven插件。它提供了许多有趣的特性，如编辑project.xml文件的能力，支持maven自定义，maven资源库浏览等其他功能。


我该如何做？
mevenide (http://mevenide.codehaus.org/mevenide-ui-eclipse/update/index.html) 是一个eclipse插件其允许你使用maven在eclipse中工作。你能够按照如下指导从eclipse更新站点上下载它：
1.启动eclipse。
2.从菜单中选择help→software updates→find and install。
3.在install/update和更新的对话框中，选择“search for new feature to install,”并单击下一步。
4.在install对话框中，单击new remote site。
5.在new update site对话框中，键入mevenide在name域，其位置在eclipse updates站点的url区域。mavenid在eclipse update站点中的位置是http://mevenide.codehaus.org/release/eclipse/update/site.xml。
6.当单词mevenide出现在install对话框中，选择两个子目标，maven和mevenide并单击next。
7.直到maven和mevenide被下载和安装，重起eclipse。

首先你会注意到mevenide标注所有project.xml文件为绿色图标。在project object model编辑器中打开project.xml，右击任何project.xml文件并选择open with...→project object model编辑器。该编辑器如下图1-3所显示。



mevenide在eclipse中提供了一系列tab让你编辑不同的project.xml片断。如果你学到了很多的project.xml语法，就知道mevenide的project object model编辑器提供了gui接口来维护这个xml文件。如果你仍然希望直接编辑这个xml，你能够选择最右边的source tab。
除pom编辑器之外，mevenide也为你提供了eclipse以外执行maven目标的方法。要在eclipse中执行一个maven目标，选择run→external tools…→external tools…你就能够创建一个maven的配置并从全部有效的目标中选择你希望执行的目标。当目标在eclipse中被执行，通过console视图有效得显示它的输出。

mevenide提供的另一个有趣的功能是repository browser。这个工具允许你检查许多远程资源库的内容。打开repository browser，选择window→show view…→other…，此时在maven目录的结果对话框中选择repository browser。repository browser简单的以树型显示了资源库中的全部依赖关系（dependency），如图1-4所示，其显示了httpclient和abbot group的依赖关系。


图1-4.mevenide repository browser view

如果你想搜索资源库中完成品的细节，mevenide同样提供了资源库搜索功能。这将是得心应手的因为为了某个依赖关系的细节搜索http://www.ibiblio.org/maven是非常恼人的。检查mevenide；它将为你节省时间。

关于...
....netbeans和jbuilder？
mevenide当前的版本支持这两个ide的表现。更多详情参见http://mevenide.codehaus.org/。
... intellij？
idea插件维持了一些目标如同你在eclipse中使用的目标。更多详情参见位于http://maven.apache.org/reference/plugins/idea/goals.html的idea插件的联机文档。


生成ant构建文件
当你想用apache的ant构建的某些时候。可能你的项目使用自动化处理正依赖于ant，又可能你有一些团队成员没有完成到maven的转换并且他们希望继续使用ant。目前为止许多ide提供通过ant构建项目文件，你能够使用maven生成build.xml文件这样你的项目就能够被apache的ant所构建。


我该如何做？
运行ant插件。运行maven ant将创建build.xml文件其包含到聚合的依赖关系的目标，build和test你的应用程序。看看运行默认的jar目标的输出：

c:\dev\mavenbook\code\genapp\test-application>ant
buildfile: build.xml
init:
[mkdir] created dir: c:\dev\mavenbook\code\genapp\target\lib
get-deps:
[get] getting: http://www.ibiblio.org/maven/springframework/jars/
spring-core-1.1.4.jar
[get] getting: http://www.ibiblio.org/maven/springframework/jars/
spring-web-1.1.4.jar
compile:
[copy] copying 1 file to c:\dev\mavenbook\code\genapp\target\classes
junit-present:
[echo] = = = = = = ============ warning = = = == = = = = = = = = = = = = = = = = = = =
[echo] junit isn't present in your ${ant_home}/lib directory. tests not
executed.
[echo] = = ==============================================
compile-tests:
internal-test:
test:
jar:
[jar] building jar: c:\dev\mavenbook\code\genapp\test-application\
target\test-application-1.0.jar
build successful
total time: 2 seconds

你可能注意到这里存在一个问题，这是个说明性的问题。apache ant没有自动管理依赖关系用于可选的ant任务。如果你向运行junit单元测试，你就需要从本地maven资源库拷贝junit-3.8.1.jar到${ant_home}/lib下。这个构建文件包含了一个get-deps的目标其从位于http://www.ibiblio.org/maven的远程maven资源库为所有的项目依赖关系执行ant获得任务到gran。

关于...
... 试图离开ant?maven是ant的替代者么？
是或不是。ant并不“差”，并且多数工具仍然同ant工作。没有理由不提供与apache ant的交互，一旦你学到更多关于第2章的jelly，你将发现ant工作在maven里应用的更广泛。许多项目使用持续集成的系统如其期望的ant构建文件。运行maven ant provides很容易找到继续支持这些工具。


移植一个ant项目到maven
一定数量的项目使用ant作为构建系统，你可能打算移植到maven上来。


我该如何做？
从头开始。创建一个默认的maven模版，并且移动你的代码到适当的位置。不要设法使maven适合你项目的目录和构建位置。maven强过一个构建工具；它是一个标准方式考虑到项目的布局和管理。如果你试图使maven适应你项目的想法来构建，你将结束使用maven。如果你的项目由一个复杂的buil.xml文件组成其产生许多不同的交付结果，你将需要“组件化”你的项目请跟随第3章的多项目描述。你可能要开始移动你项目的目录结构转向标准的maven项目目录结构。换而言之，不要试图生搬硬套你的项目到maven。
如果你对迁移到ant感兴趣，但你没有时间停止开发，你可以使用maven调用你现存的ant目标。如果你这么做，你将错失使用maven的大部分益处，但仅仅是可能。更多信息参见位于http://maven.apache.org/using/migrating.html的“migrating from ant”。

关于...
... 灵活性和选择？
灵活性和选择是个比较老的问题了。我们保证maven将改变你构建和维护项目的方式方法，重要的是应该有意的使用maven。ant和maven间的差别是什么呢？ant提供块构建的可重用任务如copy,move,delete和junit，maven提供了可重用的任务构建。maven是一个“构建容器”，其允许你在一系列项目上重用任务构建。以单元测试为例，使用ant，你将通过在你项目的build.xml文件里包含下面来执行junit测试。

<junit printsummary=&quot;yes&quot; haltonfailure=&quot;yes&quot;>
<classpath>
<pathelement location=&quot;${build.tests}&quot;/>
<pathelement path=&quot;${java.class.path}&quot;/>
</classpath>
<formatter type=&quot;plain&quot;/>
<test name=&quot;my.test.testcase&quot; haltonfailure=&quot;no&quot; outfile=&quot;result&quot;>
<formatter type=&quot;xml&quot;/>
</test>
<batchtest fork=&quot;yes&quot; todir=&quot;${reports.tests}&quot;>
<fileset dir=&quot;${src.tests}&quot;>
<include name=&quot;**/*test*.java&quot;/>
<exclude name=&quot;**/alltests.java&quot;/>
</fileset>
</batchtest>
</junit>

该片断省略的不同路经和变量的定义如build.tests和java.class.path，同时也省略的ant目标的定义。另外一些单元测试类，你也需要定义一个标以目标在源文件和单元测试中，并且一个目标对应创建一个目录。每个项目需要定义同样的逻辑以执行单元测试。最后，大多数的ant项目使用了相似的目录结构，并且构建逻辑重用是通过拷贝和粘贴到build.xml文件。时间推移，项目将变的更复杂和用户化，目录标准增加并且每个项目趋于不同的编译、测试方法和包；久而久之，build.xml变成项目中的一部分了。你定制的ant构建文件越大，越多的(entropy creeps)会进入到你的构建工作。ant作为一个构建工具的能力要少于其作为语言提供构特性的api。1.6的ant，含有了ant库和宏。在完成全局可重用的表现上与maven相比ant还有一段很长的路要走。

利用maven的test插件为所有项目定义通用逻辑其需要编译和执行单元测试。单元测试插件为编译和执行单元测试获得了最好的实践，并且它为所有项目达成了最有效的实践。当你运行maven test，maven从pom传递信息到test插件，test插件则依赖于java插件来执行编译。在maven中没有一处你明确的告诉构建容器如何执行junit单元测试。如果你这么做了，在ant中你将会面对同样的问题。正如你不用告诉你的servlet容器如何解压war文件一样，你不用告诉maven如何构建你的项目。maven是一个构建容器。许多人最初被maven吸引是因为它提供了依赖关系管理，但maven最大的好处是它提供了标准的开发结构来访问多个项目。依赖关系管理仅仅是标准开发结构的一个简单的副产品。

提示
maven提供了开发结构，统一了项目布局，在最后你可
以尝试让maven照管许多构建任务的细节。与其花费你
重要的时间来写构建脚本，不如使用maven插件来把焦
点放到编写你应用程序上来。

下面的章节将向你展示如何调整和定制maven，但你需要确定你并不要求maven成为另一个ant。很有可能你有一个巨大的重建于ant的build.xml文件充满了jelly脚本（见第2章）并且的maven项目和一个大的maven.xml文件。但如果这么做你则失去了所有maven的指向。如果你发想自己包含了很多构建相关的逻辑在你的maven构建，你需要慎重考虑使用maven。高定制化的maven构建是矛盾的；你的maven项目应该对现存插件起到杠杆作用。例如，如果你的项目需要编译jave源文件，创建jar文件，使用jave插件和jar插件。如果你忽略重用maven插件使用maven的ant集成则是重复制造轮子，你最好不要使用maven。不要滥用maven；合理使用maven，省省你的火气。

生成项目文档
如果你正开发java应用程序或者库，你可能想生成javadoc。

我该如何做？
简单的执行javadoc目标，maven将生成项目的文档。下面是执行javadoc目标的输出：

c:\dev\mavenbook\code\genapp\test-application>maven javadoc
__ __
 \/ __ _apache__ ___
 \/ / _` \ v / -_) ' \ ~ intelligent projects ~
_ _\__,_\_/\_____ v. 1.0.2
build:start:
xdoc:init:
maven-javadoc-plugin:report:
[mkdir] created dir: c:\dev\mavenbook\code\genapp\test-application\
target\javadoc\src
[javadoc] generating javadoc
[javadoc] javadoc execution
[javadoc] loading source files for package mdn.testapp...
[javadoc] constructing javadoc information...
[javadoc] standard doclet version 1.5.0_01
[javadoc] building tree for all the packages and classes...
[javadoc] generating c:\dev\mavenbook\code\genapp\test-application\
target\docs\apidocs\constant-values.html...
[javadoc] copying file c:\documents and settings\tobrien\.maven\cache\
maven-javadoc-plugin-1.7\plugin-resources\stylesheet.css to file c:\dev\
mavenbook\code\genapp\test-application\target\docs\apidocs\stylesheet.css...
[javadoc] building index for all the packages and classes...
[javadoc] building index for all classes...
[delete] deleting directory c:\dev\mavenbook\code\genapp\testapplication\
target\javadoc\src
build successful
total time: 7 seconds
once this goal has been executed, javadoc is available in testapplication/
target/javadoc/src.

刚刚发生了什么？
再次，maven作了全部繁重的工作。你想要javedoc，你告诉maven生成javedoc，故事结束。注意你不用告诉maven任何你项目的情况；它“知道”如何做，maven这很多这样的事都是直截了当的；在你告诉maven有关你的项目后你就不用做什么了。maven操作细节。



介绍maven给你的团队
maven是一个伟大的协作工具，你能够使用它生成开发者活动报告，项目捐赠者和邮件列表。


我该如何做？
许多项目有一个邮件列表其被用于讨论架构和实现。并且，通过透视图，如tomcat，maven和ant等项目，并不仅仅是一个开发者社区来共享捐赠到同样的邮件列表。邮件列表不仅用于开源项目；许多组织开始使用同样的协作模型用于开启，发布开发。因为邮件列表是协作的关键部分，maven提供了在一个项目的project.xml中指定邮件列表的途径。下面引用project.xml添加邮件列表的元素：

<mailinglists>
<mailinglist>
<name>maven user list</name>
<subscribe>users-subscribe@maven.apache.org</subscribe>
<unsubscribe>users-unsubscribe@maven.apache.org</unsubscribe>
<archive>http://marc.theaimsgroup.com/?l=turbine-maven-user</archive>
</mailinglist>
<mailinglist>
<name>maven developer list</name>
<subscribe>dev-subscribe@maven.apache.org</subscribe>
<unsubscribe>dev-unsubscribe@maven.apache.org</unsubscribe>
<archive>http://marc.theaimsgroup.com/?l=turbine-maven-dev</archive>
</mailinglist>
</mailinglists>

有两种类型的团队成员位于maven项目中：捐赠者和开发者。这种定义可能改变你的项目，捐赠者通常被认为是开源社区中捐赠过补丁或文档者，开发者是一个项目的核心成员。在asf，提交者和捐献者可以一同捐献一个项目，但捐献者既不写资源库代码又不提交大的项目决定。下面引用了project.xml添加contributor和developer元素到project.xml文件：

<developers>
<developer>
<name>vincent massol</name>
<id>vmassol</id>
<email>vmassol@apache.org</email>
<organization>apache software foundation</organization>
<roles>
<role>author</role>
<role>developer</role>
</roles>
<url>http://www.massol.net</url>
<timezone>+1</timezone>
</developer>
</developers>
<contributors>
<contributor>
<name>tim obrien</name>
<email>tobrien@apache.org</email>
<organization>apache software foundation</organization>
<roles>
<role>author</role>
<role>developer</role>
</roles>
<url>http://www.oreill.net.com/pub/au/1738</url>
<timezone>-6</timezone>
</contributor>
</contributors>

刚刚发生了什么？
你告诉maven谁在这个项目工作，对于今后你生成项目的web站点很有用。开发者和捐赠者的信息在pom中以列表的通过站点生成插件，很多插件为资源控制生成报告。跟资源控制对话...。


向maven到资源控制
你使用资源控制么？把它告诉给maven，在本书的下面你将能够生成一些有兴趣的描述报告。一旦你关联了源代码资源库到你的项目，你将能够是用maven的source control management(scm)插件，其提供了许多目标（goal）用于从诸如cvs和其子版本的版本控制系统更新和发布。


我该如何做？
你需要添加一个respository元素到你项目的project.xml文件。下面的respository元素来自于apache struts项目，并且它指向到位于有效的子版本资源库http://svn.apache.org/repos/asf/struts/core/trunk：

<repository>
<connection>
scm:svn:http://svn.apache.org/repos/asf/struts/core/trunk
</connection>
<developerconnection>
scm:svn:https://svn.apache.org/repos/asf/struts/core/trunk
</developerconnection>
<url>http://svn.apache.org/repos/asf/struts/core/trunk</url>
</repository>

connection元素告诉maven有关scm只读的位置。scm标识该url起始于scm位置，svn告诉maven该url将是资源库的子项目，并且最终的片断定位于项目的trunk。你可能也指定了developerconnection，你使用该元素在你需要分隔观众人群的不可写访问和一般人群的可写访问源代码。url元素提供了能够被浏览的资源库的url。在struts的案例中，他们选择了指向资源库到它自己，它能够被一个正常的浏览器所浏览。struts团队也可以指向到viewcvs实例配置指向到asf的资源库的子版本，它能够在http://cvs.apache.org/viewcvs.cgi/struts/core/trunk/?root=apache-svn的位置找到。

当你在一个详细的资源控制系统指定了project.xml，你也可以指向到一个详细项目的不同版本和分之。下面的xml展示了简化版的apache struts项目的version和branche元素。

<versions>
<version>
<id>1.2.0</id>
<name>1.2.0</name>
<tag>struts_1_2_0</tag>
</version>
<version>
<id>1.2.6</id>
<name>1.2.6</name>
<tag>struts_1_2_6</tag>
</version>
</versions>
<branches>
<branch>
<tag>struts_1_1_branch</tag>
</branch>
<branch>
<tag>struts_1_2_branch</tag>
</branch>
</branches>

version被用于几个插件，如announcements插件，其用于为每个版本创建发布纪录。

关于...
... cvs？
如果你的项目使用cvs，在jakatta catus项目中你将需要添加一个如repository元素的资源库元素如下所示：

<repository>
<connection>
scm:cvs:pserver:anoncvs@cvs.apache.org:/home/cvspublic:jakarta-cactus
</connection>
<url>http://cvs.apache.org/viewcvs.cgi/jakarta-cactus/</url>
</repository>

在使用cvs paserver如果你暴露你的资源库上面的引用是合适的。如果你在ssh之上访问cvs，你就需要按照下面的语法设置你的cvs_rsh环境变量。

<repository>
<connection>
scm:cvs:pserver:anoncvs@cvs.apache.org:/home/cvspublic:jakarta-cactus
</connection>
<url>http://cvs.apache.org/viewcvs.cgi/jakarta-cactus/</url>
<developerconnection>
scm:cvs:ext:tobrien@somehost:/home/cvs/repository:modulename
</developerconnection>
</repository>

创建项目web站点
maven能够创建项目web页，包含项目的有关信息。


我该如何做？
创建一个maven项目web站点，使用site插件运行下面的maven目标：
c:\dev\mavenbook\code\genapp\test-application> maven site
运行site插件将在test-application/target/docs/index.html目录创建默认的项目站点。如果你加载这个html，你将发现这个站点与众不同的maven感观。图1-5展示了一个轻量的定制web站点，包含定制的组织logo和项目logo。作为替换向你展示了人工的web站点，你能够看出这个站点的项目当前正使用maven的构建系统-jaxen。


图1-5.简单的maven项目站点。

许多maven站点有一个项目导航部分用于提供链接系统向所有的maven项目。项目信息包含项目的有关信息，项目的邮件列表，项目的资源控制及问题跟踪（你将在第4章找到所有的这些）。通过在xdocs目录里创建和修改xml标记生成maven web站点的目录。在图5，项目包含5个项目细节文档：overview,faq,releases,cvs access和status。这些文档因为被包括在xdocs/navigation.xml文件中所以他们被包含在左边的导航栏。xdocs目录是maven存放xml xdoc格式的项目细节文档的地方。下面是jaxen的navigation.xml文档的内容：

<?xml version=&quot;1.0&quot; encoding=&quot;iso-8859-1&quot;?>
<project name=&quot;jaxen&quot; repository=&quot;jaxen&quot; href=&quot;http://jaxen.org&quot;>
<title>jaxen: universal java xpath engine</title>
<body>
<links>
<item name=&quot;the werken company&quot; href=&quot;http://www.werken.com/&quot;/>
</links>
<menu name=&quot;jaxen&quot;>
<item name=&quot;overview&quot; href=&quot;/index.html&quot;/>
<item name=&quot;faq&quot; href=&quot;/faq.html&quot;/>
<item name=&quot;releases&quot; href=&quot;/releases.html&quot;/>
<item name=&quot;cvs access&quot; href=&quot;/cvs-usage.html&quot;/>
<item name=&quot;status&quot; href=&quot;/status.html&quot;/>
</menu>
</body>
</project>

link元素放置一个链接http://www.werken.com到页面的右手边，项目的logo之下，menu元素包含了用以显示的左右边的导航区域。菜单中的一个文件是xdocs/index.xml。下面是jaxen的xdocs/index.xml文件的简短目录：

<?xml version=&quot;1.0&quot;?>
<document url=&quot;http://jaxen.org/index.xml&quot;>
<properties>
<author email=&quot;bob@eng.werken.com&quot;>bob mcwhirter</author>
<title>jaxen</title>
</properties>
<body>
<section name=&quot;news&quot;>
<p>
added the slidedeck from my
<a href=&quot;/pdf/intro-slides.pdf&quot;>sd-west presentation</a>.
</p>
<p>
check out these
<a href=&quot;http://dom4j.org/benchmarks/xpath/index.html&quot;>performance
benchmarks</a> comparing dom4j and jaxen against xerces and xalan.
</p>
</section>
&#91;...&#93;
</document>

一旦你生成了你的项目站点，加载target/docs/index.html到一个浏览器来查看你项目的web站点。

关于...
... 这些文件的语法？
你能在maven xdoc插件的faq（http://maven.apache.org/reference/plugins/xdoc/faq.html）找到navigation.xml文件的更多相关语法和格式信息。并且你也能在maven xdoc plug-in page（http://maven.apache.org/reference/plugins/xdoc/index.html）上找到更多有关individual pages格式的信息。这个插件也面也包含更多定制站点生成插件的输出和行为的说明。
看第4章有关多样化报告的更深的分析，这样你句能够把项目活动和结构搞清楚了。


定制站点报告
站点生成创建了许多有用的报告，但依照你的风格，你可能想取出其中的某些报告。


我该如何做？
修改project.xml中的reports元素内容来改变maven站点生成对报告的生成。下面是reports元素中的几个有效的报告活动：

<reports>
<report>maven-changelog-plugin</report>
<report>maven-changes-plugin</report>
<report>maven-checkstyle-plugin</report>
<report>maven-clover-plugin</report>
<report>maven-cruisecontrol-plugin</report>
<report>maven-developer-activity-plugin</report>
<report>maven-faq-plugin</report>
<report>maven-file-activity-plugin</report>
<report>maven-license-plugin</report>
<report>maven-linkcheck-plugin</report>
customizing site reports 37
<report>maven-javadoc-plugin</report>
<report>maven-jdepend-plugin</report>
<report>maven-jira-plugin</report>
<report>maven-junit-report-plugin</report>
<report>maven-jxr-plugin</report>
<report>maven-pmd-plugin</report>
<report>maven-simian-plugin</report>
<report>maven-tasklist-plugin</report>
</reports>

从maven的站点生成中排除一个报告，仅需要移除reports元素中的report的插件元素。maven项目并未指定reports元素生成一套默认的报告：jdepend，checkstyle，changes，changelog，developer-activity，file-activity，license，javadoc，jxr，junit，linkcheck和tacklist。当你添加一个reports元素到你项目的project.xml文件，你必须列出所有你希望获得的报告。

刚刚发生了什么？
reports元素列出了所有这些多样的reports，但你可能想了解报告提供的全部这些。表1-1提供了报告的一些摘要描述。


更多全面的插件和报告列表，参见：
maven插件: http://maven.apache.org/reference/plugins/index.html
maven插件沙箱: http://maven.apache.org/plugins-sandbox/index.html
maven 在sourceforge上的插件: http://maven-plugins.sourceforge.net/
第三方maven插件: http://maven.apache.org/reference/3rdparty.html

 

关键字 本文所属关键字

相关 与本文相关文章

分类 所有文章关键字导航

标准 网站致力的规范