Ant - 快速指南

---

蚂蚁 - 简介

ANT 代表另一个简洁的工具。它是来自计算机软件开发公司 Apache 的基于 Java 的构建工具。在详细介绍 Apache Ant 之前，让我们首先了解为什么需要构建工具。

需要构建工具

平均而言，开发人员花费大量时间执行构建和部署等平凡任务，其中包括 -

• 编译代码

• 打包二进制文件

• 将二进制文件部署到测试服务器

• 测试更改

• 将代码从一个位置复制到另一位置

为了自动化和简化上述任务，Apache Ant 很有用。它是一个可以从命令行执行的操作系统构建和部署工具。

Apache Ant 的历史

Ant 是由软件开发人员 James Duncan Davidson 创建的，他也是 Web 服务器应用程序 Tomcat 的原始创建者。

Ant 最初用于构建 Tomcat，并作为 Tomcat 发行版的一部分捆绑在一起。

它是由于与 Apache Make 工具相关的问题和复杂性而诞生的。

它于 2000 年在 Apache 中作为独立项目进行推广。截至 2021 年 10 月，Apache Ant 的最新版本是1.10.12。

Apache Ant 的特点

Apache Ant 的功能如下：

• 它是可用的最完整的 Java 构建和部署工具。

• 它是平台中立的，可以处理平台特定的属性，例如文件分隔符。

• 它可用于执行特定于平台的任务，例如使用“touch”命令修改文件的修改时间。

• Ant 脚本是使用纯 XML 编写的。如果您已经熟悉 XML，那么您可以很快学会 Ant。

• Ant 擅长自动执行复杂的重复性任务。

• Ant 附带了大量预定义任务。

• Ant 提供了开发自定义任务的接口。

• Ant 可以轻松地从命令行调用，并且可以与免费和商业 IDE 集成。

Ant - 环境设置

Apache Ant 根据 Apache 软件许可证进行分发，该许可证是经过开源倡议认证的成熟开源许可证。

最新的 Apache Ant 版本，包括其完整源代码、类文件和文档，可以在https://ant.apache.org上找到。

安装 Apache Ant

假设您已经在计算机上下载并安装了 Java Development Kit (JDK)。如果没有，请按照file:///C:/java/java_environment_setup.htm中提供的说明进行操作

• 确保 JAVA_HOME 环境变量设置为安装 JDK 的文件夹。

• 从https://ant.apache.org下载二进制文件

• 使用 Winzip、winRAR、7-zip 或类似工具将 zip 文件解压缩到方便的位置 c:\folder。

• 创建一个名为ANT_HOME的新环境变量，该变量指向 Ant 安装文件夹。在本例中，它是c:\apache-ant-1.10.12-bin文件夹。

• 将 Apache Ant 批处理文件的路径附加到 PATH 环境变量。在我们的例子中，这将是c:\apache-ant-1.10.12-bin\bin文件夹。

验证安装

要验证您的计算机上是否已成功安装 Apache Ant，请在命令提示符下键入 ant。

您应该看到如下所示的输出 -

C:\>ant -version
Apache Ant(TM) version 1.10.12 compiled on October 13 2021

如果您没有看到上述输出，请验证您是否正确遵循了安装步骤。

安装Eclipse

本教程还介绍了 Ant 与 Eclipse 集成开发环境 (IDE) 的集成。因此，如果您尚未安装Eclipse，请下载并安装Eclipse。

安装Eclipse的步骤

• 从www.eclipse.org下载最新的 Eclipse 二进制文件

• 将 Eclipse 二进制文件解压缩到一个方便的位置，例如 c:\folder。

• 从 c:\eclipse\eclipse.exe 运行 Eclipse。

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 声明之前不应有空行或空格。如果您允许它们，则在执行 ant 构建时会出现以下错误消息 -

The processing instruction target matching "[xX][mM][lL]" is not allowed. 
All build files require the project element and at least one target element.

XML 元素项目具有三个属性，如下所示 -

目标是您想要作为一个单元运行的任务的集合。在我们的示例中，我们有一个简单的目标来向用户提供信息性消息。

目标可以依赖于其他目标。例如，部署目标可以具有对包目标的依赖性，包目标可以具有对编译目标的依赖性等等。依赖关系使用dependent属性来表示。

例如 -

<target name="deploy" depends="package">
   
   ....
</target>
<target name="package" depends="clean,compile">
   ....
</target>
<target name="clean" >
   ....
</target>
<target name="compile" >
   ....
</target>

目标元素具有以下属性 -

上面示例中的echo任务是一个打印消息的简单任务。在我们的示例中，它打印消息Hello World。

要运行 ant 构建文件，请打开命令提示符并导航到 build.xml 所在的文件夹，然后输入ant info。您也可以输入ant来代替。两者都可以工作，因为info是构建文件中的默认目标。

您应该看到以下输出 -

C:\>ant
Buildfile: C:\build.xml

info: [echo] Hello World - Welcome to Apache Ant!

BUILD SUCCESSFUL
Total time: 0 seconds

C:\>

Ant - 属性任务

Ant 构建文件是用 XML 编写的，它不允许像您最喜欢的编程语言那样声明变量。然而，正如您可能想象的那样，如果 Ant 允许声明项目名称、项目源目录等变量，那将会很有用。

Ant 使用property元素来指定属性。这允许将属性从一个构建更改为另一个构建或从一个环境更改为另一个环境。

蚂蚁地产

默认情况下，Ant 提供以下可在构建文件中使用的预定义属性 -

Ant 还使系统属性（示例：file.separator）可供构建文件使用。

除了上述内容之外，用户还可以使用property元素定义其他属性。

以下示例显示如何定义名为sitename的属性-

<?xml version="1.0"?>
<project name="Hello World Project" default="info">

   <property name="sitename" value="www.tutorialspoint.com"/>
   <target name="info">
      <echo>Apache Ant version is ${ant.version} - You are at ${sitename} </echo>
   </target>
</project>

在上面的构建文件上运行 Ant 会产生以下输出 -

C:\>ant
Buildfile: C:\build.xml

info: [echo] Apache Ant version is Apache Ant(TM) version 1.10.12
   compiled on October 13 2021 - You are at www.tutorialspoint.com

BUILD SUCCESSFUL
Total time: 0 seconds
C:\>

Ant - 属性文件

如果您正在使用少量属性，则直接在构建文件中设置属性就可以了。但是，对于大型项目，将属性存储在单独的属性文件中是有意义的。

好处

将属性存储在单独的文件中具有以下优点 -

• 它允许您重用相同的构建文件，并针对不同的执行环境使用不同的属性设置。例如，可以为 DEV、TEST 和 PROD 环境单独维护构建属性文件。

• 当您预先不知道某个属性的值（在特定环境中）时，它很有用。这允许您在属性值已知的其他环境中执行构建。

没有硬性规则，但通常属性文件被命名为build.properties并放置在build.xml文件旁边。您可以根据部署环境创建多个构建属性文件 - 例如build.properties.dev和build.properties.test。

构建属性文件的内容与普通的 java 属性文件类似。它们每行包含一个属性。每个属性都由名称和值对表示。

名称和值对由等号 (=) 分隔。强烈建议使用适当的注释对属性进行注释。使用井号 (#) 字符列出注释。

以下示例显示了build.xml文件及其关联的build.properties文件 -

构建.xml

下面给出了 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.tutorialspoint.com
buildversion=3.3.2

在上面的示例中，sitename是映射到网站名称的自定义属性。您可以用这种方式声明任意数量的自定义属性。

上面示例中列出的另一个自定义属性是 buildversion ，在本例中，它指的是构建的版本。

除了上述内容之外，Ant 还提供了许多预定义的构建属性，这些属性已在上一节中列出，但下面再次给出以供您参考。

本章介绍的示例使用ant.version内置属性。

Ant - 数据类型

Ant 提供了许多预定义的数据类型。不要将术语“数据类型”与编程语言中可用的术语混淆。相反，请将它们视为一组已内置于产品中的服务。

Ant 中的数据类型

以下数据类型由 Apache Ant 提供。

文件集

文件集数据类型表示文件的集合。它用作过滤器来包含或排除与特定模式匹配的文件。

例如，参考以下代码。这里，src属性指向项目的源文件夹。

<fileset dir="${src}" casesensitive="yes">
   <include name="**/*.java"/>
   <exclude name="**/*Stub*"/>
</fileset>

文件集选择源文件夹中除包含单词“Stub”之外的所有 .java 文件。区分大小写的过滤器将应用于文件集，这意味着名称为 Samplestub.java 的文件不会从文件集中排除。

图案集

模式集是一种允许根据某些模式轻松过滤文件或文件夹的模式。可以使用以下元字符创建模式 -

• ？- 只匹配一个字符。

• - 匹配零个或多个字符。

• ** - 递归匹配零个或多个目录。

以下示例描述了模式集的用法。

<patternset id="java.files.without.stubs">
   <include name="src/**/*.java"/>
   <exclude name="src/**/*Stub*"/>
</patternset>

然后可以将模式集与文件集一起重用，如下所示 -

<fileset dir="${src}" casesensitive="yes">
   <patternset refid="java.files.without.stubs"/>
</fileset>

文件列表

文件列表数据类型与文件集类似，但存在以下差异 -

• 它包含明确命名的文件列表，并且不支持通配符。

• 此数据类型可应用于现有或不存在的文件。

让我们看看以下文件列表数据类型的示例。这里，属性webapp.src.folder指向项目的Web应用程序源文件夹。

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

过滤器组

通过将过滤器集数据类型与复制任务一起使用，您可以用替换值替换与模式匹配的所有文件中的某些文本。

一个常见的示例是将版本号附加到发行说明文件中，如以下代码所示。

<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指向项目的当前版本文件夹。

• 复制任务，顾名思义，用于将文件从一个位置复制到另一个位置。

小路

路径数据类型通常用于表示类路径。路径中的条目使用分号或冒号分隔。但是，这些字符在运行时会被执行系统的路径分隔符替换。

类路径设置为项目中的 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 文件来编译 java 类并将它们放置在 WEB-INF\classes 文件夹中。

考虑以下项目结构 -

• 数据库脚本存储在db文件夹中。

• java源代码存放在src文件夹中。

• 图片、js、META-INF、样式（css）存储在war文件夹中。

• Java 服务器页面 (JSP) 存储在jsp文件夹中。

• 第三方jar文件存储在lib文件夹中。

• java 类文件存储在WEB-INF\classes文件夹中。

该项目构成了本教程其余部分的Hello World传真应用程序。

C:\work\FaxWebApplication>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

这是该项目所需的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>

首先，让我们声明源文件夹、Web 文件夹和构建文件夹的一些属性。

<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 指的是项目的Web源文件夹，您可以在其中找到JSP、web.xml、css、javascript和其他Web相关文件

• build.dir指的是项目编译的输出文件夹。

属性可以引用其他属性。如上面的示例所示，build.dir属性引用了web.dir属性。

在此示例中，src.dir指的是项目的源文件夹。

我们项目的默认目标是编译目标。但首先，让我们看看干净的目标。

顾名思义，clean 目标会删除构建文件夹中的文件。

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

最后，构建目标是构建文件。

首先，我们创建build目录，如果不存在，那么，我们执行javac命令（指定jdk1.5作为我们的目标编译）。我们向 javac 任务提供源文件夹和类路径，并要求它将类文件放入构建文件夹中。

<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:\build.xml

BUILD SUCCESSFUL
Total time: 6.3 seconds

文件被编译并放置在build.dir文件夹中。

Ant - 构建文档

文档在任何项目中都是必须的。文档在项目的维护中发挥着重要作用。Java 通过使用内置的javadoc工具使文档编写变得更加容易。Ant 通过按需生成文档使这一切变得更加容易。

如您所知，javadoc 工具非常灵活，并允许许多配置选项。Ant 通过 javadoc 任务公开这些配置选项。如果您不熟悉 javadoc，我们建议您从这个 Java 文档教程开始。

以下部分列出了 Ant 中最常用的 javadoc 选项。

属性

可以使用sourcepath、sourcepathref或sourcefiles指定源。

• sourcepath用于指向源文件的文件夹（例如 src 文件夹）。

• sourcepathref用于引用路径属性引用的路径（例如，delegates.src.dir）。

• 当您想要将各个文件指定为逗号分隔列表时，请使用sourcefiles 。

目标路径是使用destdir文件夹（例如build.dir）指定的。

您可以通过指定要包含的包名称来过滤javadoc任务。这是通过使用packagenames属性（逗号分隔的包文件列表）来实现的。

您可以过滤 javadoc 进程以仅显示公共、私有、包或受保护的类和成员。这是通过使用private、public、package和protected属性来实现的。

您还可以使用相应的属性告诉 javadoc 任务包含作者和版本信息。

您还可以使用 group 属性将包分组在一起，以便于导航。

把它们放在一起

让我们继续Hello world传真应用程序的主题，并将文档目标添加到我们的传真应用程序项目中。

下面给出了我们项目中使用的 javadoc 任务示例。在此示例中，我们指定 javadoc 使用 src.dir作为源目录，并使用doc作为目标。

我们还自定义了 Java 文档页面上显示的窗口标题、页眉和页脚信息。

此外，我们创建了三个组 -

• 一个用于我们源文件夹中的实用程序类，

• 一个用于用户界面类，以及

• 一个用于数据库相关的类。

您可能会注意到数据包组有两个包——faxapp.entity 和faxapp.dao。

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

让我们执行 javadoc Ant 任务。它生成 java 文档文件并将其放置在 doc 文件夹中。

当执行javadoc 目标时，它会产生以下结果 -

C:\>ant generate-javadoc
Buildfile: C:\build.xml

java doc has been generated!

BUILD SUCCESSFUL
Total time: 10.63 second

java 文档文件现在位于doc文件夹中。

通常，javadoc 文件是作为发布或包目标的一部分生成的。

Ant - 创建 JAR 文件

编译 java 源文件后，下一个逻辑步骤是构建 java 存档，即 Java 存档 (JAR) 文件。通过jar任务，使用 Ant 创建 JAR 文件非常容易。

属性

jar 任务的常用属性如下 -

继续我们的Hello World传真应用程序项目，让我们添加一个新目标来生成 jar 文件。

但在此之前，让我们考虑一下下面给出的 jar 任务。

<jar destfile="${web.dir}/lib/util.jar"
   basedir="${build.dir}/classes"
   includes="faxapp/util/**"
   excludes="**/Test.class"
/>

这里，web.dir属性指向 Web 源文件的路径。在我们的例子中，这是放置 util.jar 的位置。

本示例中的build.dir属性指向构建文件夹，其中可以找到util.jar的类文件。

在此示例中，我们使用faxapp.util.*包中的类创建一个名为util.jar的jar文件。但是，我们排除以名称 Test 结尾的类。输出 jar 文件将放置在 Web 应用程序 lib 文件夹中。

如果我们想让 util.jar 成为可执行的 jar 文件，我们需要添加带有Main-Class元属性的清单。

因此，上述示例将更新如下 -

<jar destfile="${web.dir}/lib/util.jar"
   basedir="${build.dir}/classes"
   includes="faxapp/util/**"
   excludes="**/Test.class" class="ts"
   <manifest class="ts"
      <attribute name="Main-Class" value="com.tutorialspoint.util.FaxUtil"/>
   </manifest class="ts"
</jar class="ts"

要执行 jar 任务，请将其包装在目标（最常见的是构建或打包目标）内，然后执行它们。

<target name="build-jar" class="ts"
<jar destfile="${web.dir}/lib/util.jar"
   basedir="${build.dir}/classes"
   includes="faxapp/util/**"
   excludes="**/Test.class" class="ts"
   <manifest class="ts"
      <attribute name="Main-Class" value="com.tutorialspoint.util.FaxUtil"/>
   </manifest class="ts"
</jar class="ts"
</target class="ts"

在此文件上运行 Ant 会为我们创建 util.jar 文件。

以下结果是运行 Ant 文件的结果 -

C:\ class="ts"ant build-jar
Buildfile: C:\build.xml

BUILD SUCCESSFUL
Total time: 1.3 seconds

util.jar 文件现已放置在输出文件夹中。

Ant - 创建 WAR 文件

使用 Ant 创建 Web Archive (WAR) 文件非常简单，并且与创建 JAR 文件任务非常相似。毕竟，WAR 文件与 JAR 文件一样，只是另一个 ZIP 文件。

WAR 任务是 JAR 任务的扩展，但它有一些很好的附加功能来操作 WEB-INF/classes 文件夹中的内容，并生成 web.xml 文件。WAR 任务对于指定 WAR 文件的特定布局非常有用。

由于 WAR 任务是 JAR 任务的扩展，因此 JAR 任务的所有属性都适用于 WAR 任务。

继续我们的Hello World传真应用程序项目，让我们添加一个新目标来生成 jar 文件。但在此之前，让我们先考虑一下战争任务。

考虑以下示例 -

<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 文件是从Web 源文件夹中获取的。web 下“WebContent”文件夹中的所有文件都将复制到 WAR 文件中。

WEB-INF/lib 文件夹中填充有thirdpartyjars 文件夹中的jar 文件。但是，我们排除了 portlet.jar，因为它已经存在于应用程序服务器的 lib 文件夹中。最后，我们从构建目录的 web 文件夹中复制所有类并将它们放入 WEB-INF/classes 文件夹中。

将 war 任务包装在 Ant 目标（通常是包）内并运行它。这将在指定位置创建 WAR 文件。

完全可以嵌套类、lib、metainf 和 webinf 目录，以便它们位于项目结构中任何位置的分散文件夹中。但是，最佳实践建议您的 Web 项目应该具有与 WAR 文件结构类似的 Web 内容结构。传真应用程序项目的结构是使用这一基本原则概述的。

要执行 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:\build.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 - 包装应用

我们已经使用Hello World Fax Web 应用程序零碎地了解了 Ant 的不同方面。

现在，是时候将所有内容放在一起创建一个完整的 build.xml 文件了。请考虑build.properties和build.xml文件，如下所示 -

构建属性

下面给出了 build.properties 文件。

deploy.path=c:\tomcat6\webapps

构建.xml

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>

在上面提到的例子中 -

• 我们首先在构建属性文件中将Tomcat 中的webapps 文件夹的路径声明为deploy.path变量。

• 我们还在src.dir变量中声明 java 文件的源文件夹。

• 然后，我们在web.dir变量中声明 Web 文件的源文件夹。javadoc.dir是存放java文档的文件夹，build.dir是存放构建输出文件的路径。

• 之后，我们声明 Web 应用程序的名称，在我们的例子中是传真。

• 我们还定义了主类路径，其中包含项目的 WEB-INF/lib 文件夹中存在的 JAR 文件。

• 我们还将build.dir中存在的类文件包含在主类路径中。

• Javadoc 目标生成项目所需的 javadoc，而使用目标用于打印构建文件中存在的公共目标。

上面的示例显示了两个部署目标——deploy和deploywar。

部署目标将文件从 Web 目录复制到部署目录，并保留最后修改的日期时间戳。当部署到支持热部署的服务器时，这非常有用。

clean 目标会清除所有先前构建的文件。

部署war目标构建war文件，然后将war文件复制到应用程序服务器的deploy目录。

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=https://www.tutorialspoint.com:8080/manager
tomcat.manager.username=tutorialspoint
tomcat.manager.password=secret

构建.xml

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 中的 webapp 文件夹。

可以使用 Tomcat 管理器应用程序停止和启动 Tomcat 中的应用程序。管理器应用程序的 URL、用户名和密码也在 build.properties 文件中指定。

接下来，我们声明一个包含catalina-ant.jar的新 CLASSPATH 。通过 Apache Ant 执行 Tomcat 任务需要此 jar 文件。

任务

catalina-ant.jar 提供以下任务 -

重新加载任务需要额外的参数，如下所示 -

• 管理器应用程序的 URL。

• 用于重新启动 Web 应用程序的用户名。

• 重新启动 Web 应用程序的密码。

• 要重新启动的 Web 应用程序的名称。

让我们发出deploy-war命令将webapp 复制到Tomcat webapps 文件夹，然后重新加载Fax Web 应用程序。以下结果是运行 Ant 文件的结果 -

C:\>ant deploy-war
Buildfile: C:\build.xml

BUILD SUCCESSFUL
Total time: 6.3 seconds

C:\>ant reload
Buildfile: C:\build.xml

BUILD SUCCESSFUL
Total 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:\>ant
Buildfile: C:\build.xml

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

BUILD SUCCESSFUL
Total time: 1 second

在此示例中，java 代码做了一件简单的事情，即发送电子邮件。我们可以使用内置的 Ant 任务来做到这一点。

不过，现在您已经有了想法，您可以扩展构建文件来调用执行复杂操作的 java 代码。例如 - 加密您的源代码。

Ant-Eclipse 集成

如果您已经下载并安装了 Eclipse，那么您几乎不需要做任何事情就可以开始使用。Eclipse 预先捆绑了 Ant 插件，可供使用。

按照简单的步骤，将 Ant 集成到 Eclipse 中。

• 确保 build.xml 是 java 项目的一部分，并且不位于项目外部的位置。

• 通过以下方式启用 Ant View：Window → Show View → Other → Ant → Ant。

• 打开 Project Explorer，将 build.xml 拖到 Ant 视图中。

您的 Ant 视图看起来类似于下面给出的视图 -

单击目标，build/clean/usage 将使用该目标运行 Ant。

点击“传真”将执行默认目标-usage。

Ant Eclipse 插件还附带了一个很好的编辑器，用于编辑 build.xml 文件。该编辑器了解 build.xml 架构，可以帮助您完成代码。

要使用 Ant 编辑器，请右键单击 build.xml（从 Project Explorer）并选择 Open with > Ant Editor。Ant 编辑器应该看起来类似于 -

Ant 编辑器在右侧列出了目标。目标列表充当书签，允许您直接跳到编辑特定目标。

Ant-JUnit 集成

JUnit 是基于 Java 开发的常用单元测试框架。它易于使用且易于扩展。有许多可用的 JUnit 扩展。如果您不熟悉 JUnit，您应该从www.junit.org下载它并阅读其手册。

本章介绍如何使用 Ant 执行 JUnit 测试。使用 Ant 可以直接完成 JUnit 任务。

JUnit 任务的属性如下所示：

让我们继续Hello World Fax Web 应用程序的主题并添加一个 JUnit 目标。

以下示例显示了一个简单的 JUnit 测试执行 -

<target name="unittest">
   <junit haltonfailure="true" printsummary="true">
      <test name="com.tutorialspoint.UtilsTest"/>
   </junit>
</target>

此示例显示了 JUnit 在 com.tutorialspoint.UtilsTest junit 类上的执行。

运行上面的代码会产生以下输出 -

test:
[echo] Testing the application
[junit] Running com.tutorialspoint.UtilsTest
[junit] Tests run: 12, Failures: 0, Errors: 0, Time elapsed: 16.2 sec
BUILD PASSED

Ant - 扩展 Ant

Ant 附带了一组预定义的任务，但是您可以创建自己的任务，如下例所示。

自定义 Ant 任务应该扩展org.apache.tools.ant.Task类并且应该扩展execute() 方法。

下面是一个简单的例子 -

package com.tutorialspoint.ant;
import org.apache.tools.ant.Task;
import org.apache.tools.ant.Project;
import org.apache.tools.ant.BuildException;
public class MyTask extends Task {
   String message;
   public void execute() throws BuildException {
      log("Message: " + message, Project.MSG_INFO);
   }
   public void setMessage(String message) {
      this.message= message;
   }
}

要执行自定义任务，您需要将以下内容添加到Hello World Fax Web 应用程序 -

<target name="custom">
   <taskdef name="custom" classname="com.tutorialspoint.ant.MyTask" />
   <custom message="Hello World!"/>
</target>

执行上述自定义任务会打印消息“Hello World!”

c:\>ant custom
test:
[custom] Message : Hello World!
elapsed: 0.2 sec
BUILD PASSED

这只是一个简单的例子。您可以使用 Ant 的强大功能来改进构建和部署过程。

ANT - 使用令牌过滤器

Ant Filter 允许为当前项目设置令牌过滤器。令牌由 @ 符号分隔，也可以使用属性文件读取。

脚步

• 步骤 1 - 使用 @@ 定义令牌。

This is a sample text written in @year@.

• 步骤 2 - 设置过滤器。

<filter token="year" value="2021"/>

• 步骤 3 - 使用过滤器。所有任务都将用 2021 替换 @year@ 的出现。

<copy todir="${dest.dir}" filtering="true">
   <fileset dir="${src.dir}"/>
</copy>

过滤任务属性

以下是关键属性 -

要提供令牌和值或过滤器文件到过滤器任务才能正常工作。

例子

使用包含以下内容的 text1.txt 文件创建 src 文件夹 -

This is a sample text written in @year@.

使用以下内容创建 build.xml -

<?xml version="1.0"?>
<project name="sample" basedir="." default="copy">
   <property name="src.dir" value="src"/>
   <property name="dest.dir" value="build"/>
   <target name="copy">
      <filter token="year" value="2021"/>
      <copy todir="${dest.dir}" filtering="true">
         <fileset dir="${src.dir}"/>
      </copy>
   </target>
</project>

输出

在上面的构建文件上运行 Ant 会产生以下输出 -

F:\tutorialspoint\ant>ant
Buildfile: F:\tutorialspoint\ant\build.xml

copy:
   [copy] Copying 1 file to F:\tutorialspoint\ant\build

BUILD SUCCESSFUL
Total time: 1 second

F:\tutorialspoint\ant>

验证复制到构建文件夹的文件的内容。

This is a sample text written in 2021.

Ant - 使用命令行参数

Ant 可以轻松读取命令行参数以将数据传递给其任务。

命令行参数选项

ant [options] [target [target2 [target3] ...]]
Options:
   -help,          -h              print this message and exit
   -projecthelp,   -p              p