目录
ANT简介
理解Apache Ant定义之前，必须了解需要一个构建工具。为什么我需要Ant，或者更具体地说，为什么我需要一个构建工具？
花你一天做以下工作？
- 编译代码
- 打包二进制文件
- 部署二进制文件到测试服务器
- 测试您的代码更改
- 从一个位置复制代码到另一个地方
如果你回答是肯定的上述任何一项，那么现在是时候实现过程的自动化。
平均而言，开发人员花费3小时（工作日超出 8小时）做这样构建和部署平凡的任务。难道你会很高兴多要回3个小时？
Apache Ant是可以在命令行中执行一个操作系统构建和部署工具。
Apache Ant的历史
- Ant 代表着另一种简洁的工具
- Ant 是由詹姆斯·邓肯·戴维森（Tomcat的原作者）创建的，在他欧洲飞往美国时。
- Ant 最初是用来构建Tomcat，被捆绑Tomcat作为分发的一部分
- Ant 诞生制造工具出有关的问题和复杂性
- Ant 于2000年晋升为在Apache的一个独立项目。
- Apache Ant（截至2011年7月）的当前版本是1.8.2
- NAnt 是.NET构建工具，它类似于Ant，但用于构建.NET应用程序
- Ant 是最完整的Java构建和部署工具。
- Ant是平台无关的，可以处理特定平台的属性，如文件分隔符。
- Ant 可以用于执行特定任务的平台，例如使用“触摸'命令修改文件的修改时间。
- Ant 脚本使用的是纯XML编写的。如果你已经熟悉XML，你可以学习Ant 很快。
- Ant擅长复杂的自动化重复的任务。
- Ant 自带的预定义任务的大名单。
- Ant提供了开发自定义任务的界面。
- Ant可以在命令行中很容易地调用，它可以与免费的和商业的IDE集成。
ANT环境安装设置
安装Apache Ant
假定您已经下载并安装Java开发工具包（JDK）在您的电脑上。如果没有，请按照这里的说明。
Apache Ant是Apache软件许可证，由开放源码倡议认证一个完全成熟的开源许可下发布。
最新的Apache Ant版本，包括完整的源代码，类文件和文档可以在这里找到 http://ant.apache.org.
- 确保将JAVA_HOME环境变量设置到安装JDK的文件夹。
- 下载的二进制文件从http://ant.apache.org
- 使用Winzip，WinRAR，7-zip或类似工具解压缩zip文件到一个方便的位置 c:folder.
- 创建一个名为ANT_HOME，一个新的环境变量指向Ant的安装文件夹，在 c:apache-ant-1.8.2-bin 文件夹。
- 附加的路径Apache Ant批处理文件添加到PATH环境变量中。在我们的例子是 c:apache-ant-1.8.2-binin文件夹。
验证Apache Ant的安装
要验证Apache Ant已成功安装在您的计算机上，打开一个命令提示符，然后输入ant。
你应该会看到类似的输出：
C:>ant -versionApache Ant(TM) version 1.8.2 compiled on December 20 2010如果您看不到上面的，那么请确认您已遵循安装步骤正确。
安装 Eclipse
本教程还包括集成Ant 到 Eclipse IDE中。所以，如果你还没有安装Eclipse，请下载并安装Eclipse
想要Eclipse:
- 从下载最新的Eclipse二进制文件 www.eclipse.org
- 解压Eclipse的二进制文件到一个方便的位置如 c:
- 运行 c:eclipseeclipse.exe
Ant构建文件
通常情况下，Ant构建文件build.xml应该在项目的基础目录。可以自由使用其他文件名或将构建文件中其他位置。
在本练习中，创建一个名为build.xml 在电脑的任何地方的文件。
<?xml version="1.0"?>
<project name="Hello World Project" default="info">
<target name="info">
<echo>Hello World - Welcome to Apache Ant!</echo>
</target>
</project>
请注意，应该有XML声明之前没有空行或空格。该处理指令目标匹配"[xX][mM][lL]" 是不允许的 - 如果你这样做，这可能在运行Ant构建时造成的错误消息。
所有构建文件要求项目元素和至少一个目标元素。
XML元素的项目project有三个属性：
| 属性 | 描述 |
| name | The Name of the project. (Optional) |
| default | The default target for the build script. A project may contain any number of targets. This attribute specifies which target should be considered as the default. (Mandatory) |
| basedir | The base directory (or) the root folder for the project. (Optional) |
一个目标是要作为一个单元运行的任务的集合。在我们的例子中，我们有一个简单的目标，以提供一个信息性消息给用户。
目标可以对其他目标的依赖关系。例如，部署目标可能对封装对象的依赖和包的目标可能具有依赖于compile目标等等。依赖关系是使用依赖属性表示。例如：
<target name="deploy" depends="pacakge">
....
</target>
<target name="pacakge" depends="clean,compile">
....
</target>
<target name="clean" >
....
</target>
<target name="compile" >
....
</target>
目标元素具有以下属性：
| 属性 | 描述 |
| name | The name of the target (Required) |
| depends | Comma separated list of all targets that this target depends on. (Optional) |
| description | A short description of the target. (optional) |
| if | Allows the execution of a target based on the trueness of a conditional attribute. (optional) |
| unless | Adds the target to the dependency list of the specified Extension Point. An Extension Point is similar to a target, but it does not have any tasks. (Optional) |
在上面的例子中的echo 任务是打印一条消息一个简单的任务。在我们的例子，它打印出Hello World消息。
要运行Ant构建文件，打开命令提示符并导航到build.xml文件所在的文件夹，然后输入ant info。也可以只输入ant来代替。既会工作，因为信息是默认的目标在构建文件。应该看到下面的输出：
C:>ant
Buildfile: C:uild.xml
info:
[echo] Hello World - Welcome to Apache Ant!
BUILD SUCCESSFUL
Total time: 0 seconds
C:>
Ant属性任务
Ant构建文件是用XML编写的，它不迎合声明变量，你在最喜欢的编程语言做的。然而，正如你可能已经想到，它会如果允许Ant声明变量，如项目名称，项目源代码目录等有用
Ant使用属性元素，它允许你指定的属性。这允许属性从一个版本改变为另一个。或者从一个环境到另一个。
默认情况下，Ant提供了可以在构建文件中使用下列预定义的属性
| 属性 | 描述 |
| ant.file | The full location of the build file. |
| ant.version | The version of the Apache Ant installation. |
| basedir | The basedir of the build, as specified in the basedir attribute of theproject element. |
| ant.java.version | The version of the JDK that is used by Ant. |
| ant.project.name | The name of the project, as specified in the name atrribute of theproject element |
| ant.project.default-target | The default target of the current project |
| ant.project.invoked-targets | Comma separated list of the targets that were invoked in the current project |
| ant.core.lib | The full location of the ant jar file |
| ant.home | The home directory of Ant installation |
| ant.library.dir | The home directory for Ant library files - typically ANT_HOME/lib folder. |
Ant也使得系统性能（例如：文件分割符），可用于构建文件。
除了以上所述，用户可以使用属性元素定义附加属性。一个例子介绍如下展示了如何定义一个名为站点名称（sitename）属性：
<?xml version="1.0"?>
<project name="Hello World Project" default="info">
<property name="sitename" value="www.yiibai.com"/>
<target name="info">
<echo>Apache Ant version is ${ant.version} - You are
at ${sitename} </echo>
</target>
</project>
上述构建文件运行ant应该产生下面的输出：
C:>ant
Buildfile: C:uild.xml
info:
[echo] Apache Ant version is Apache Ant(TM) version 1.8.2
compiled on December 20 2010 - You are at www.yiibai.com
BUILD SUCCESSFUL
Total time: 0 seconds
C:>
Ant数据类型
Ant提供了一些预定义的数据类型。不要混淆，也可在编程语言中的数据类型，而是考虑数据类型的设置被内置到产品中服务。
下面是一个由Apache Ant的提供的数据类型的列表
文件集合
该文件集的数据类型表示文件的集合。该文件集的数据类型通常是作为一个过滤器，以包括和排除匹配特定模式的文件。
例如：
<fileset dir="${src}" casesensitive="yes"> <include name="**/*.java"/> <exclude name="**/*Stub*"/></fileset>在上面的例子中的src属性指向项目的源文件夹。
在上面的例子中，文件集的选择，除了那些包含在其中单词“Stub”源文件夹中的所有java文件。在大小写敏感的过滤器应用到文件集这意味着名为Samplestub.java一个文件不会被排除在文件集
模式集
一个模式集是一个模式，可以非常方便地筛选基于某种模式的文件或文件夹。可以使用下面的元字符来创建模式。
- ? - 只匹配一个字符
- * - 匹配零个或多个字符
- ** - 匹配零个或多个目录递归
下面的例子应该给一个模式集的用法的想法。
<patternset id="java.files.without.stubs"> <include name="src/**/*.java"/> <exclude name="src/**/*Stub*"/></patternset>patternset 可以用一个文件集重用如下：
<fileset dir="${src}" casesensitive="yes"> <patternset refid="java.files.without.stubs"/> </fileset>文件列表
在文件列表的数据类型类似设置，除了在文件列表中包含显式命名的文件列表，不支持通配符的文件
文件列表和文件组的数据类型之间的另一个主要区别是，在文件列表的数据类型可应用于可能会或可能还不存在的文件。
以下是文件列表的数据类型的一个例子
<filelist id="config.files" dir="${webapp.src.folder}"> <file name="applicationConfig.xml"/> <file name="faces-config.xml"/> <file name="web.xml"/> <file name="portlet.xml"/></filelist>在上面的例子中webapp.src.folder属性指向该项目的Web应用程序的源文件夹。
过滤器集
使用与复制任务筛选器集的数据类型，你可以匹配一个替代值的模式，所有的文件替换一定的文本。
一个常见的例子是附加版本号的发行说明文件，如下面的示例所示
<copy todir="${output.dir}"> <fileset dir="${releasenotes.dir}" includes="**/*.txt"/> <filterset> <filter token="VERSION" value="${current.version}"/> </filterset></copy>在上面的例子中output.dir属性指向项目的输出文件夹。
在上面的例子点releasenotes.dir属性的发行说明的项目文件夹中。
在上面的例子中current.version属性指向的项目的当前版本中的文件夹。
副本任务，顾名思义是用来从一个位置复制到另一个文件。
路径
path 数据类型通常用来代表一个类路径。在路径项用分号或冒号隔开。然而，这些字符会被正在运行的系统的路径分隔符替换一个运行时间。
最常见的类路径设置为项目中的jar文件和类的列表，如下面的例子：
<path id="build.classpath.jar"> <pathelement path="${env.J2EE_HOME}/${j2ee.jar}"/> <fileset dir="lib"> <include name="**/*.jar"/> </fileset></path>在上面的例子中env.J2EE_HOME属性指向环境变量J2EE_HOME。
在上面的例子中的j2ee.jar属性指向在J2EE基础文件夹J2EE的jar文件的名称。
Ant构建项目
现在，我们已经了解了Ant数据类型，现在是时候把这些转化为行动。考虑下面的项目结构
项目将形成的Hello World传真应用程序项目在本教程的其余部分。
C:workFaxWebApplication>tree
Folder PATH listing
Volume serial number is 00740061 EC1C:ADB1
C:.
+---db
+---src
. +---faxapp
. +---dao
. +---entity
. +---util
. +---web
+---war
+---images
+---js
+---META-INF
+---styles
+---WEB-INF
+---classes
+---jsp
+---lib
解释一下项目结构。
- 数据库脚本存储在 db 文件夹。
- Java源代码存储在src文件夹。
- 图像，JS，META-INF，样式（CSS）被存储在 war 文件夹。
- JSP被保存在jsp中文件夹。
- 第三方jar文件都存储在lib文件夹。
- Java类文件将被存储在WEB-INF classes文件夹。
这个练习的目的是建立一个编译的java类，并将它们放置在WEB-INF classes文件夹Ant文件。
下面是项目所需的build.xml文件。让我们看看它内容：
<?xml version="1.0"?>
<project name="fax" basedir="." default="build">
<property name="src.dir" value="src"/>
<property name="web.dir" value="war"/>
<property name="build.dir" value="${web.dir}/WEB-INF/classes"/>
<property name="name" value="fax"/>
<path id="master-classpath">
<fileset dir="${web.dir}/WEB-INF/lib">
<include name="*.jar"/>
</fileset>
<pathelement path="${build.dir}"/>
</path>
<target name="build" description="Compile source tree java files">
<mkdir dir="${build.dir}"/>
<javac destdir="${build.dir}" source="1.5" target="1.5">
<src path="${src.dir}"/>
<classpath refid="master-classpath"/>
</javac>
</target>
<target name="clean" description="Clean output directories">
<delete>
<fileset dir="${build.dir}">
<include name="**/*.class"/>
</fileset>
</delete>
</target>
</project>
首先，让我们为源，网上声明某些属性，并建立文件夹。
<property name="src.dir" value="src"/>
<property name="web.dir" value="war"/>
<property name="build.dir" value="${web.dir}/WEB-INF/classes"/>
在这个例子中，对于src.dir是指项目（即，这里的java源文件可以找到）的源文件夹。
web.dir 指的是项目的网页源文件夹。在这里，您可以找到JSP，web.xml，CSS，JavaScript和其他Web相关的文件
最后，build.dir是指在项目编译的输出文件夹。
属性可以参考其他属性。如图所示，在上述例子中，build.dir属性使得参考web.dir属性。
在这个例子中，对于src.dir是指项目的源的文件夹。
我们的项目的默认目标compile目标。但首先，让我们看看clean目标。
clean目标，顾名思义删除build文件夹中的文件。
<target name="clean" description="Clean output directories">
<delete>
<fileset dir="${build.dir}">
<include name="**/*.class"/>
</fileset>
</delete>
</target>
在主类路径保存在类路径的信息。在这种情况下，它包含在build文件夹中的类和在lib文件夹中的jar文件。
<path id="master-classpath">
<fileset dir="${web.dir}/WEB-INF/lib">
<include name="*.jar"/>
</fileset>
<pathelement path="${build.dir}"/>
</path>
最后，构建目标构建文件。首先，我们创建构建目录，如果它不存在。然后我们执行javac命令（指定JDK1.5作为我们的目标编译）。我们提供的源文件夹和类路径javac任务，并要求它砸在build文件夹中的类文件。
<target name="build" description="Compile main source tree java files">
<mkdir dir="${build.dir}"/>
<javac destdir="${build.dir}" source="1.5" target="1.5" debug="true"
deprecation="false" optimize="false" failonerror="true">
<src path="${src.dir}"/>
<classpath refid="master-classpath"/>
</javac>
</target>
在这个文件运行ant将编译java源文件，并将类build文件夹中。
下面的结果是运行Ant文件的结果：
C:>ant
Buildfile: C:uild.xml
BUILD SUCCESSFUL
Total time: 6.3 seconds
该文件被编译并放置在build.dir文件夹中。
Ant构建文档
文档是一个为任何项目所必须的。文档在项目的维护起到了极大的作用。通过使用内置的javadoc工具的Java使得文档更容易。Ant使得它甚至产生对需求文档更容易。
如你所知，javadoc工具具有高度的灵活性，并允许一些配置选项。Ant通过Javadoc任务公开这些配置选项。如果您不熟悉javadoc，建议在开始使用此Java文档教程。
以下部分列出了使用的Ant最常用的Javadoc选项。
属性
源可以使用源路径，sourcepathref或将源文件的规定。源路径是用来指向源文件（如src文件夹）的文件夹。 Sourcepathref用于参考，是由路径属性（例如，delegates.src.dir）引用的路径。而当你要指定的单个文件以逗号分隔的列表时的源文件使用。
使用destdir文件夹（例如build.dir）指定的目标路径
你可以由指定要包含在包名过滤Javadoc任务。这是通过使用packagenames属性来实现，用逗号分隔的包文件列表。
你可以过滤javadoc的过程中，只显示了公共，私有，包装或保护类和成员。这是通过使用（不奇怪）的私有，公共，封装和保护的属性来实现。
你也可以告诉javadoc的任务，包括使用相应属性的作者和版本信息。
你也可以组包一起使用的组属性，因此，它是易于浏览。
全部放在一起
让我们继续我们的主题 Hello world Fax 应用程序。让我们添加一个文件的目标我们的传真应用程序项目。
下面是我们的项目中使用的例子Javadoc任务。
<target name="generate-javadoc"> <javadoc packagenames="faxapp.*" sourcepath="${src.dir}" destdir="doc" version="true" windowtitle="Fax Application"> <doctitle><![CDATA[= Fax Application =]]></doctitle> <bottom> <![CDATA[Copyright © 2011. All Rights Reserved.]]> </bottom> <group title="util packages" packages="faxapp.util.*"/> <group title="web packages" packages="faxapp.web.*"/> <group title="data packages" packages="faxapp.entity.*:faxapp.dao.*"/> </javadoc> <echo message="java doc has been generated!" /></target>在这个例子中，我们指定使用对于src.dir作为源目录和文档作为目标目录中的javadoc。我们还定制了窗口标题，页眉和出现的Java文档页面上的页脚信息。
此外，我们已经创建了三组。一个用于为用户界面类和一组数据库相关类在我们的源文件夹，一组实用程序类。你可能会注意到数据包组有两个包 - faxapp.entity和faxapp.dao。
运行javadoc的Ant任务现在将生成并放置在doc文件夹中的Java文档文件。
当执行javadoc target，它会产生以下结果：
C:>ant generate-javadocBuildfile: C:uild.xml java doc has been generated! BUILD SUCCESSFULTotal time: 10.63 secondJava文档文件现在出现在doc文件夹。
通常情况下，产生的释放或包的目标部分的Javadoc文件。
Ant创建JAR文件
编译Java源文件后的下一个合乎逻辑的步骤，是建立在Java归档，JAR文件。创建JAR文件与Ant用jar任务很容易。以下展示的是jar任务的常用属性
| 属性 | 描述 |
| basedir | The base directory for the output JAR file. By default, this is set to the base directory of the project. |
| compress | Advises ant to compress the file as it creates the JAR file. |
| keepcompression | While the compress attribute is applicable to the individual files, thekeepcompression attribute does the same thing, but it applies to the entire archive. |
| destfile | The name of the output JAR file |
| duplicate | Advises Ant on what to do when duplicate files are found. You could add, preserve or fail the duplicate files. |
| excludes | Advises Ant to not include these comma separated list of files in the package. |
| excludesfile | Same as above, except the exclude files are specified using a pattern. |
| inlcudes | Inverse of excludes |
| includesfile | Inverse of excludesfile. |
| update | Advises ant to overwrite files in the already built JAR file. |
继续我们的Hello World传真应用程序项目，让我们添加一个新的目标，产生的jar文件。但在此之前，让我们考虑一下jar任务：
<jar destfile="${web.dir}/lib/util.jar"
basedir="${build.dir}/classes"
includes="faxapp/util/**"
excludes="**/Test.class"
/>
在这个例子中，web.dir属性指向的网页源文件的路径。在我们的例子中，这是其中的util.jar将被放置。
在这个例子中，build.dir属性指向build文件夹在哪里可以找到 util.jar的类文件。
在这个例子中，我们创建了一个名为util.jar使用的类从faxapp.util一个jar文件。*包。然而，我们不包括用名称测试结束课程。输出的jar文件会发生在webapp的lib文件夹。
如果我们想使util.jar一个可执行JAR文件，我们需要添加清单与主Classmeta属性。
因此，上面的例子将被更新为：
<jar destfile="${web.dir}/lib/util.jar"
basedir="${build.dir}/classes"
includes="faxapp/util/**"
excludes="**/Test.class">
<manifest>
<attribute name="Main-Class" value="com.yiibai.util.FaxUtil"/>
</manifest>
</jar>
要执行jar任务，一个目标里面把它包（最常见，构建或包的目标，并运行它们。
<target name="build-jar">
<jar destfile="${web.dir}/lib/util.jar"
basedir="${build.dir}/classes"
includes="faxapp/util/**"
excludes="**/Test.class">
<manifest>
<attribute name="Main-Class" value="com.yiibai.util.FaxUtil"/>
</manifest>
</jar>
</target>
在这个文件运行Ant会为我们创建util.jar文件
下面的结果是运行Ant文件的结果：
C:>ant build-jar
Buildfile: C:uild.xml
BUILD SUCCESSFUL
Total time: 1.3 seconds
现在的util.jar文件放置在输出文件夹。
Ant创建WAR文件
创建WAR文件与Ant是非常简单，非常类似于创建JAR文件的任务。毕竟WAR文件是像JAR文件只是另一个ZIP文件。
WAR任务是一个扩展的JAR任务，但它有一些很好的补充操纵什么进入的WEB-INF/classes文件夹中，并生成web.xml文件。在WAR的任务是非常有用的指定WAR文件的特定布局。
由于WAR的任务是jar任务的扩展，jar任务的所有属性应用到WAR任务。下面是被指定到WAR任务的扩展属性：
| Attributes | 描述 |
| webxml | Path to the web.xml file |
| lib | A grouping to specify what goes into the WEB-INFlib folder. |
| classes | A grouping to specify what goes into the WEB-INFclasses folder. |
| metainf | Specifies the instructions for generating the MANIFEST.MF file. |
继续我们Hello World传真应用程序项目，让我们添加一个新的目标，产生的jar文件。但在此之前，让我们考虑WAR任务。请看下面的例子：
<war destfile="fax.war" webxml="${web.dir}/web.xml">
<fileset dir="${web.dir}/WebContent">
<include name="**/*.*"/>
</fileset>
<lib dir="thirdpartyjars">
<exclude name="portlet.jar"/>
</lib>
<classes dir="${build.dir}/web"/>
</war>
按照前面的例子中，web.dir变量指的是源Web文件夹，即包含了JSP的文件夹，CSS，JavaScript文件等。
build.dir变量是指输出文件夹 - 这是在哪里可以找到类的WAR包。通常情况下，这些类将被捆绑到WAR文件的WEB-INF/classes文件夹中。
在这个例子中，我们创建一个名为fax.war 的 war文件。从网页源文件夹中获得的web.xml文件。所有从网上下了“WebContent”文件夹中的文件复制到WAR文件。
WEB-INF/lib文件夹中填充了来自第三方的jar文件夹中的jar文件。然而，我们不包括portlet.jar，因为这是已经存在于应用服务器的lib文件夹。最后，我们从构建目录的Web文件夹中复制所有的类和放入放在WEB-INF/classes文件夹中。
包裹WAR任务的Ant目标（通常包）内，并运行它。这将在指定的位置创建WAR文件。
这是完全可以嵌套类，库，metainf和WEBINF董事，使他们生活在分散的文件夹中的项目结构的任何地方。但最佳实践建议，您的Web项目应具备的Web内容结构类似于WAR文件的结构。Fax应用程序项目都有使用这个基本原则概述结构。
要执行WAR任务，一个目标里面把它包裹（最常见，构建或包的目标，并运行它们。
<target name="build-war">
<war destfile="fax.war" webxml="${web.dir}/web.xml">
<fileset dir="${web.dir}/WebContent">
<include name="**/*.*"/>
</fileset>
<lib dir="thirdpartyjars">
<exclude name="portlet.jar"/>
</lib>
<classes dir="${build.dir}/web"/>
</war>
</target>
在这个文件运行Ant会为我们创建了fax.war文件
下面的结果是运行Ant文件的结果：
C:>ant build-war
Buildfile: C:uild.xml
BUILD SUCCESSFUL
Total time: 12.3 seconds
现在的fax.war文件放置在输出文件夹。 war文件的内容将是：
fax.war:
+---jsp This folder contains the jsp files
+---css This folder contains the stylesheet files
+---js This folder contains the javascript files
+---images This folder contains the image files
+---META-INF This folder contains the Manifest.Mf
+---WEB-INF
+---classes This folder contains the compiled classes
+---lib Third party libraries and the utility jar files
WEB.xml Configuration file that defines the WAR package
Ant打包应用
我们已经知道Ant使用的Hello World Fax 的Web应用程序中零碎的不同。
现在是时候把一切融合在一起，以创建一个完整的和完整的build.xml文件。考虑build.properties和build.xml文件列表如下：
build.properties
deploy.path=c: omcat6webappsbuild.xml
<?xml version="1.0"?> <project name="fax" basedir="." default="usage"> <property file="build.properties"/> <property name="src.dir" value="src"/> <property name="web.dir" value="war"/> <property name="javadoc.dir" value="doc"/> <property name="build.dir" value="${web.dir}/WEB-INF/classes"/> <property name="name" value="fax"/> <path id="master-classpath"> <fileset dir="${web.dir}/WEB-INF/lib"> <include name="*.jar"/> </fileset> <pathelement path="${build.dir}"/> </path> <target name="javadoc"> <javadoc packagenames="faxapp.*" sourcepath="${src.dir}" destdir="doc" version="true" windowtitle="Fax Application"> <doctitle><![CDATA[<h1>= Fax Application =</h1>]]></doctitle> <bottom><![CDATA[Copyright © 2011. All Rights Reserved.]]></bottom> <group title="util packages" packages="faxapp.util.*"/> <group title="web packages" packages="faxapp.web.*"/> <group title="data packages" packages="faxapp.entity.*:faxapp.dao.*"/> </javadoc> </target> <target name="usage"> <echo message=""/> <echo message="${name} build file"/> <echo message="-----------------------------------"/> <echo message=""/> <echo message="Available targets are:"/> <echo message=""/> <echo message="deploy --> Deploy application as directory"/> <echo message="deploywar --> Deploy application as a WAR file"/> <echo message=""/> </target> <target name="build" description="Compile main source tree java files"> <mkdir dir="${build.dir}"/> <javac destdir="${build.dir}" source="1.5" target="1.5" debug="true" deprecation="false" optimize="false" failonerror="true"> <src path="${src.dir}"/> <classpath refid="master-classpath"/> </javac> </target> <target name="deploy" depends="build" description="Deploy application"> <copy todir="${deploy.path}/${name}" preservelastmodified="true"> <fileset dir="${web.dir}"> <include name="**/*.*"/> </fileset> </copy> </target> <target name="deploywar" depends="build" description="Deploy application as a WAR file"> <war destfile="${name}.war" webxml="${web.dir}/WEB-INF/web.xml"> <fileset dir="${web.dir}"> <include name="**/*.*"/> </fileset> </war> <copy todir="${deploy.path}" preservelastmodified="true"> <fileset dir="."> <include name="*.war"/> </fileset> </copy> </target> <target name="clean" description="Clean output directories"> <delete> <fileset dir="${build.dir}"> <include name="**/*.class"/> </fileset> </delete> </target> </project>在这个例子中，我们首先声明的路径的webapps文件夹中的Tomcat在生成属性文件作为deploy.path变量。我们还声明的源文件夹src.dir的变量的java文件。然后我们声明的源文件夹中web.dir变量的网页文件。 javadoc.dir是用于存储Java文档的文件夹，build.dir是用于存储生成的输出文件的路径。
然后我们声明的Web应用程序，这是 Fax 在我们的例子中的名称。
我们还定义了主类路径的conains存在于项目的WEB-INF/lib文件夹中的JAR文件。我们还包括了类文件呈现在build.dir在主类路径
Javadoc的目标生产项目所需的Javadoc和使用对象是用来打印，是目前在构建文件的共同目标。
上面的例子显示了两个部署目标 - 部署和deploywar目标
部署目标文件从web目录下的文件复制到deploy目录保留最后修改的日期时间戳记。部署到支持热部署一台服务器时，这是很有用的。
clean目标清除所有先前建立的文件。
部署war目标构建war文件，然后复制war文件到应用服务器的部署目录。
Ant部署应用程序
在前面的章节中，我们已经学会了如何打包应用程序并将其部署到一个文件夹中。在这个例子中，我们打算把它更进一步。
我们要部署Web应用程序直接到应用程序的服务器的部署文件夹，然后我们将添加一些Ant目标来启动和停止服务。让我们继续的Hello World传真的Web应用程序。这是一个延续前一章，新元件在突出红色
build.properties
# Ant properties for building the springapp appserver.home=c:\install\apache-tomcat-7.0.19# for Tomcat 5 use $appserver.home}/server/lib# for Tomcat 6 use $appserver.home}/libappserver.lib=${appserver.home}/lib deploy.path=${appserver.home}/webapps tomcat.manager.url=http://www.yiibai.com:8080/managertomcat.manager.username=yiibaitomcat.manager.password=secretbuild.xml
<?xml version="1.0"?> <project name="fax" basedir="." default="usage"> <property file="build.properties"/> <property name="src.dir" value="src"/> <property name="web.dir" value="war"/> <property name="javadoc.dir" value="doc"/> <property name="build.dir" value="${web.dir}/WEB-INF/classes"/> <property name="name" value="fax"/> <path id="master-classpath"> <fileset dir="${web.dir}/WEB-INF/lib"> <include name="*.jar"/> </fileset> <pathelement path="${build.dir}"/> </path> <target name="javadoc"> <javadoc packagenames="faxapp.*" sourcepath="${src.dir}" destdir="doc" version="true" windowtitle="Fax Application"> <doctitle><![CDATA[<h1>= Fax Application =</h1>]]></doctitle> <bottom><![CDATA[Copyright © 2011. All Rights Reserved.]]></bottom> <group title="util packages" packages="faxapp.util.*"/> <group title="web packages" packages="faxapp.web.*"/> <group title="data packages" packages="faxapp.entity.*:faxapp.dao.*"/> </javadoc> </target> <target name="usage"> <echo message=""/> <echo message="${name} build file"/> <echo message="-----------------------------------"/> <echo message=""/> <echo message="Available targets are:"/> <echo message=""/> <echo message="deploy --> Deploy application as directory"/> <echo message="deploywar --> Deploy application as a WAR file"/> <echo message=""/> </target> <target name="build" description="Compile main source tree java files"> <mkdir dir="${build.dir}"/> <javac destdir="${build.dir}" source="1.5" target="1.5" debug="true" deprecation="false" optimize="false" failonerror="true"> <src path="${src.dir}"/> <classpath refid="master-classpath"/> </javac> </target> <target name="deploy" depends="build" description="Deploy application"> <copy todir="${deploy.path}/${name}" preservelastmodified="true"> <fileset dir="${web.dir}"> <include name="**/*.*"/> </fileset> </copy> </target> <target name="deploywar" depends="build" description="Deploy application as a WAR file"> <war destfile="${name}.war" webxml="${web.dir}/WEB-INF/web.xml"> <fileset dir="${web.dir}"> <include name="**/*.*"/> </fileset> </war> <copy todir="${deploy.path}" preservelastmodified="true"> <fileset dir="."> <include name="*.war"/> </fileset> </copy> </target> <target name="clean" description="Clean output directories"> <delete> <fileset dir="${build.dir}"> <include name="**/*.class"/> </fileset> </delete> </target> <!-- ============================================================ --> <!-- Tomcat tasks --> <!-- ============================================================ --> <path id="catalina-ant-classpath"> <!-- We need the Catalina jars for Tomcat --> <!-- * for other app servers - check the docs --> <fileset dir="${appserver.lib}"> <include name="catalina-ant.jar"/> </fileset> </path> <taskdef name="install" classname="org.apache.catalina.ant.InstallTask"> <classpath refid="catalina-ant-classpath"/> </taskdef> <taskdef name="reload" classname="org.apache.catalina.ant.ReloadTask"> <classpath refid="catalina-ant-classpath"/> </taskdef> <taskdef name="list" classname="org.apache.catalina.ant.ListTask"> <classpath refid="catalina-ant-classpath"/> </taskdef> <taskdef name="start" classname="org.apache.catalina.ant.StartTask"> <classpath refid="catalina-ant-classpath"/> </taskdef> <taskdef name="stop" classname="org.apache.catalina.ant.StopTask"> <classpath refid="catalina-ant-classpath"/> </taskdef> <target name="reload" description="Reload application in Tomcat"> <reload url="${tomcat.manager.url}" username="${tomcat.manager.username}" password="${tomcat.manager.password}" path="/${name}"/> </target></project>在本练习中，我们使用Tomcat作为我们的应用服务器。首先，在构建属性文件中，我们定义了一些附加属性。
- appserver.home应用指向安装路径到Tomcat应用服务器。
- appserver.lib指向Tomcat的安装文件夹中的库文件。
- deploy.path变量现在指向Tomcat中的web应用文件夹。
在Tomcat中的应用程序可以停止和startedusing Tomcat管理应用程序。也是在build.properties文件中指定的URL管理器应用程序，使用用户名和密码。接下来我们声明一个新的CLASSPATH中包含catalina-ant.jar文件。这个jar文件是必需通过Apache Ant来执行Tomcat 任务。
catalina-ant.jar 文件提供了以下任务：
| Properties | 描述 |
| InstallTask | Installs a web application. Class Name: org.apache.catalina.ant.InstallTask |
| ReloadTask | Reload a web application. Class Name: org.apache.catalina.ant.ReloadTask |
| ListTask | Lists all web applications. Class Name: org.apache.catalina.ant.ListTask |
| StartTask | Starts a web application. Class Name: org.apache.catalina.ant.StartTask |
| StopTask | Stops a web application. Class Name: org.apache.catalina.ant.StopTask |
| ReloadTask | Reloads a web application without stopping. Class Name: org.apache.catalina.ant.ReloadTask |
重装任务需要以下附加参数。
- 1）URL到管理器应用程序
2）用户名重新启动Web应用程序
3）密码重新启动Web应用程序重新启动Web应用程序
4）名称
让我们发出的deploy-war命令的web应用程序复制到Tomcat的webapps文件夹中，然后让我们重新加载该传真的Web应用程序。下面的结果是运行Ant文件的结果：
C:>ant deploy-warBuildfile: C:uild.xml BUILD SUCCESSFULTotal time: 6.3 seconds C:>ant reloadBuildfile: C:uild.xml BUILD SUCCESSFULTotal time: 3.1 seconds一旦上述任务运行时，Web应用程序部署和Web应用程序重新加载。
Ant执行Java代码
您可以使用Ant来执行java代码。在下面这个例子中，java类中取一个参数（管理员的电子邮件地址），并发送了一封电子邮件。
public class NotifyAdministrator{ public static void main(String[] args) { String email = args[0]; notifyAdministratorviaEmail(email); System.out.println("Administrator "+email+" has been notified"); } public static void notifyAdministratorviaEmail(String email) { //...... }}下面是执行这个java类简单的构建。
<?xml version="1.0"?><project name="sample" basedir="." default="notify"> <target name="notify"> <java fork="true" failonerror="yes" classname="NotifyAdministrator"> <arg line="admin@test.com"/> </java> </target></project>当执行构建时，它会产生以下结果：
C:>antBuildfile: C:uild.xml notify: [java] Administrator admin@test.com has been notified BUILD SUCCESSFULTotal time: 1 second在这个例子中，java代码做一个简单的事情 - 发送电子邮件。我们也可以使用内置的Ant任务来做到这一点。不过，现在你已经得到了你的想法可以扩展你的构建文件来调用java代码执行复杂的东西，例如：加密你的源代码。
Ant和Eclipse集成
如果您已经下载并已经安装了Eclipse，你很少做上手。 Eclipse中预装捆绑在一起的Ant的插件，随时供您使用。
按照简单的步骤，到Ant集成到Eclipse中。
- 确保build.xml文件就是java项目的一部分，并没有生活在一个位置，是外部的项目。
- 通过将启用Ant视图 Window > Show View > Other > Ant > Ant
- 打开项目资源管理器中，拖动的build.xml到Ant视图
Ant视图中显示现在看起来类似于：
点击目标，build / clean / usage将运行Ant你的目标。
点击"fax" ，将执行默认的目标 - usage
Ant的Eclipse插件还附带了一个很好的编辑器来编辑的build.xml文件。该编辑器是知道的build.xml架构，可以帮助您提供代码完成。
要使用Ant编辑器，右键单击您的build.xml（从项目资源管理器），然后选择打开方式>Ant Editor。 Ant Editor应该loook类似于：
Ant 编辑器列出了右手边的目标，该目标列表作为一个书签，让你直接跳到编辑特定的目标。
Ant Junit集成
JUnit 是基于Java常用的单元测试框架进行开发。它是易于使用和易于延伸。有许多JUnit扩展可用。如果你不熟悉Junit的，你应该从www.junit.org下载JUnit和阅读JUnit的使用手册。
本教程讨论了关于执行使用Ant 的JUnit测试。Ant 通过这个简单Junit 的任务变得简单。
以下展示的是JUnit 任务的属性。
| Properties | 描述 |
| dir | Where to invoke the VM from. This is ignored when fork is disabled. |
| jvm | Command used to invoke the JVM. This is ignored when fork is disabled. |
| fork | Runs the test in a separate JVM |
| errorproperty | The name of the property to set if there is a Junit error |
| failureproperty | The name of the property to set if there is a Junit failure |
| haltonerror | Stops execution when a test error occurs |
| haltonfailure | Stops execution when a failure occurs |
| printsummary | Advices Ant to display simple statistics for each test |
| showoutput | Adivces Ant tosend the output to its logs and formatters |
| tempdir | Path to the temporary file that Ant will use |
| timeout | Exits the tests that take longer to run than this setting (in milliseconds). |
让我们继续的Hello World fax web应用程序的主题，并添加一个JUnit目标。
下面的例子展示了一个简单的JUnit测试执行
<target name="unittest"> <junit haltonfailure="true" printsummary="true"> <test name="com.yiibai.UtilsTest"/> </junit></target>上面的例子显示的Junit对com.yiibai.UtilsTest JUnit类执行。运行上面会产生下面的输出
test:[echo] Testing the application[junit] Running com.yiibai.UtilsTest[junit] Tests run: 12, Failures: 0, Errors: 0, Time elapsed: 16.2 secBUILD PASSED
1585
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
