TutorialsPoint Ant 教程

来源：易百教程

Apache ANT 教程

Apache Ant是由Apache软件基金会一个基于Java的构建工具。Apache Ant的构建文件是用XML编写，并采取了开放的标准，便于携带和易于理解的XML性质的优势。

本教程将教你如何使用Apache Ant 自动构建和部署过程。

读者

本教程是专为初学者，帮助他们了解了Apache Ant工具来自动构建和部署过程的基本功能。

必备要求

我们假设你有软件开发知识使用编程语言，Java编程和软件构建和部署过程。

ANT简介 - 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应用程序

Apache Ant功能

Ant 是最完整的Java构建和部署工具。

Ant是平台无关的，可以处理特定平台的属性，如文件分隔符。

Ant 可以用于执行特定任务的平台，例如使用“触摸'命令修改文件的修改时间。

Ant 脚本使用的是纯XML编写的。如果你已经熟悉XML，你可以学习Ant 很快。

Ant擅长复杂的自动化重复的任务。

Ant 自带的预定义任务的大名单。

Ant提供了开发自定义任务的界面。

Ant可以在命令行中很容易地调用，它可以与免费的和商业的IDE集成。

ANT环境安装设置 - 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 -version
Apache 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

通常情况下，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元素的项目有三个属性：

属性 | 描述
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

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

直接在构建文件中设置属性是好的，如果你使用的是少数属性。然而，对于一个大型项目，是要存储在一个单独的属性文件中。

存储在一个单独的文件中的属性可以让你重复使用相同的编译文件，针对不同的执行环境不同的属性设置。例如，生成属性文件可以单独维持DEV，TEST和PROD环境。

指定在一个单独的文件属性是有用的，当你不知道一个属性（在一个特定的环境中）前面的值。这使您可以在属性值是已知的其他环境进行构建。

没有硬性规定，但一般属性文件名为build.properties文件，并放在沿一侧的build.xml文件。如build.properties.dev和build.properties.test - 你可以根据部署环境中创建多个生成属性文件

构建属性文件的内容类似于普通的Java属性文件。他们每行包含一个属性。每个属性由一个名称和一个值对来表示。名称和值对由等号分开。强烈建议属性标注了正确的注释。注释列出所使用的哈希字符。

下面显示了一个build.xml文件和相关build.properties文件

build.xml

<?xml version="1.0"?>
<project name="Hello World Project" default="info">
   <property file="build.properties"/>
      <target name="info">
         <echo>Apache Ant version is ${ant.version} - You are
         at ${sitename} </echo>
     </target>
</project>

build.properties

# The Site Name
sitename=www.yiibai.com
buildversion=3.3.2

在上面的例子中，站点名是被映射到该站点的名称自定义属性，可以声明任意数目以这种方式自定义属性。在上面的例子中所列的另一个自定义属性是buildversion，其中，在这种情况下指的是创建的版本。除上述者外，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.version。

Ant数据类型 - 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

现在，我们已经了解了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构建文档 - 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-javadoc
Buildfile: C:uild.xml

java doc has been generated!

BUILD SUCCESSFUL
Total time: 10.63 second

Java文档文件现在出现在doc文件夹。

通常情况下，产生的释放或包的目标部分的Javadoc文件。

Ant创建JAR文件 - ANT

编译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文件 - ANT

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

我们已经知道Ant使用的Hello World Fax 的Web应用程序中零碎的不同。

现在是时候把一切融合在一起，以创建一个完整的和完整的build.xml文件。考虑build.properties和build.xml文件列表如下：

build.properties

deploy.path=c:    omcat6webapps

build.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部署应用程序 - 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}/lib
appserver.lib=${appserver.home}/lib

deploy.path=${appserver.home}/webapps

tomcat.manager.url=http://www.yiibai.com:8080/manager
tomcat.manager.username=yiibai
tomcat.manager.password=secret

build.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-war
Buildfile: C:uild.xml

BUILD SUCCESSFUL
Total time: 6.3 seconds

C:>ant reload
Buildfile: C:uild.xml

BUILD SUCCESSFUL
Total time: 3.1 seconds

一旦上述任务运行时，Web应用程序部署和Web应用程序重新加载。

Ant执行Java代码 - ANT

您可以使用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:>ant
Buildfile: C:uild.xml

notify:
     [java] Administrator admin@test.com has been notified

BUILD SUCCESSFUL
Total time: 1 second

在这个例子中，java代码做一个简单的事情 - 发送电子邮件。我们也可以使用内置的Ant任务来做到这一点。不过，现在你已经得到了你的想法可以扩展你的构建文件来调用java代码执行复杂的东西，例如：加密你的源代码。

Ant和Eclipse集成 - ANT

如果您已经下载并已经安装了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集成 - ANT

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 sec
BUILD PASSED