Ant - 快速指南

---

---

Ant - 簡介

ANT 代表 **Another Neat** 工具。它是由計算機軟體開發公司 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 開發工具包 (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 元素 **project** 有三個屬性，如下所示：

目標是您希望作為一個單元執行的任務的集合。在我們的示例中，我們有一個簡單的目標來向用戶提供資訊訊息。

目標可以依賴於其他目標。例如，**deploy** 目標可能依賴於 package 目標，**package** 目標可能依賴於 compile 目標，依此類推。依賴關係使用 **depends** 屬性表示。

例如：

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

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 提供以下預定義屬性，可以在構建檔案中使用：

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** 檔案：

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

以下是 build.properties 檔案的示例：

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

在上面的示例中，**sitename** 是一個自定義屬性，它對映到網站名稱。您可以以這種方式宣告任意數量的自定義屬性。

在上面的示例中列出的另一個自定義屬性是 **buildversion**，在本例中，它指的是構建的版本。

除了上述內容之外，Ant 還帶有一些預定義的構建屬性，這些屬性在上一節中列出，但為了方便參考，這裡再次列出。

本章中提供的示例使用了 **ant.version** 內建屬性。

Ant - 資料型別

Ant 提供了許多預定義的資料型別。不要將“資料型別”一詞與程式語言中可用的資料型別混淆。相反，將其視為已內建到產品中的一組服務。

Ant 中的資料型別

Apache Ant 提供以下資料型別。

Fileset

fileset 資料型別表示檔案的集合。它用作過濾器，用於包含或排除與特定模式匹配的檔案。

例如，請參考以下程式碼。這裡，src 屬性指向專案的原始檔夾。

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

fileset 選擇原始檔夾中的所有 .java 檔案，但包含單詞“Stub”的檔案除外。區分大小寫的過濾器應用於 fileset，這意味著名為 Samplestub.java 的檔案不會從 fileset 中排除。

模式集

模式集是一種模式，允許基於某些模式輕鬆過濾檔案或資料夾。可以使用以下元字元建立模式：

• ? - 僅匹配一個字元。

• * - 匹配零個或多個字元。

• ** - 遞迴匹配零個或多個目錄。

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

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

然後可以將 patternset 與 fileset 結合使用，如下所示：

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

檔案列表

filelist 資料型別類似於檔案集，但存在以下區別：

• 它包含顯式命名的檔案列表，並且不支援萬用字元。

• 此資料型別可以應用於現有檔案或不存在的檔案。

讓我們看看 filelist 資料型別的以下示例。這裡，屬性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>

過濾器集

透過將 filterset 資料型別與 copy 任務一起使用，您可以將與模式匹配的所有檔案中的某些文字替換為替換值。

一個常見的例子是在釋出說明檔案中追加版本號，如下面的程式碼所示。

<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指向專案的當前版本資料夾。

• copy 任務顧名思義，用於將檔案從一個位置複製到另一個位置。

路徑

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 檔案，該檔案編譯 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引用專案的原始檔夾。

我們專案的預設目標是compile目標。但首先，讓我們看看clean目標。

clean 目標顧名思義，刪除構建資料夾中的檔案。

<target name="clean" description="Clean output directories">
   <delete>
      <fileset dir="${build.dir}">
         <include name="**/*.class"/>
      </fileset>
   </delete>
</target>

master-classpath 儲存類路徑資訊。在本例中，它包括構建資料夾中的類和 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 任務，並要求它將類檔案放到構建資料夾中。

<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 原始檔並將類放置在構建資料夾中。

以下結果是執行 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用於引用 path 屬性引用的路徑（例如，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) 檔案。使用 Ant 建立 JAR 檔案非常簡單，只需使用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元屬性的manifest。

因此，上面的示例將更新如下：

<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 任務，請將其包裝在目標（最常見的是 build 或 package 目標）內並執行它們。

<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 存檔 (WAR) 檔案非常簡單，並且與建立 JAR 檔案的任務非常相似。畢竟，WAR 檔案與 JAR 檔案一樣，只是另一個 ZIP 檔案。

WAR 任務是 JAR 任務的擴充套件，但它增加了一些很好的功能來操作 WEB-INF/classes 資料夾中的內容，以及生成 web.xml 檔案。WAR 任務可用於指定 WAR 檔案的特定佈局。

由於 WAR 任務是 JAR 任務的擴充套件，因此 JAR 任務的所有屬性都適用於 WAR 任務。

繼續我們的 **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 檔案是從 web 原始檔夾中獲取的。web 下 'WebContent' 資料夾中的所有檔案都複製到 WAR 檔案中。

WEB-INF/lib 資料夾填充了來自 thirdpartyjars 資料夾的 jar 檔案。但是，我們排除了 portlet.jar，因為應用程式伺服器的 lib 資料夾中已經存在此檔案。最後，我們複製構建目錄 web 資料夾中的所有類，並將它們放入 WEB-INF/classes 資料夾中。

將 war 任務包裝在一個 Ant 目標（通常是 package）中並執行它。這將在指定位置建立 WAR 檔案。

完全可以巢狀 classes、lib、metainf 和 webinf 目錄，以便它們位於專案結構中任何分散的資料夾中。但是，最佳實踐建議您的 Web 專案應具有與 WAR 檔案結構類似的 Web 內容結構。傳真應用程式專案使用此基本原理概述了其結構。

要執行 war 任務，請將其包裝在一個目標中，最常見的是 build 或 package 目標，然後執行它們。

<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** 傳真 web 應用程式的 Ant 的不同方面。

現在，是時候將所有內容整合在一起，建立一個完整且完整的 build.xml 檔案。請考慮如下所示的 **build.properties** 和 **build.xml** 檔案 -

build.properties

build.properties 檔案如下所示。

deploy.path=c:\tomcat6\webapps

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

在上面提到的示例中：

• 我們首先在 build properties 檔案中將 Tomcat 中 webapps 資料夾的路徑宣告為 **deploy.path** 變數。

• 我們還聲明瞭 **src.dir** 變數中 java 檔案的原始檔夾。

• 然後，我們宣告 **web.dir** 變數中 web 檔案的原始檔夾。**javadoc.dir** 是儲存 java 文件的資料夾，**build.dir** 是儲存構建輸出檔案的路徑。

• 之後，我們宣告 web 應用程式的名稱，在本例中為 **fax**。

• 我們還定義了主類路徑，其中包含專案 WEB-INF/lib 資料夾中存在的 JAR 檔案。

• 我們還在主類路徑中包含 **build.dir** 中存在的類檔案。

• Javadoc 目標生成專案所需的 javadoc，而 usage 目標用於列印構建檔案中存在的常用目標。

上面的示例顯示了兩個部署目標 - **deploy** 和 **deploywar**。

deploy 目標將檔案從 web 目錄複製到 deploy 目錄，同時保留最後修改日期時間戳。這在部署到支援熱部署的伺服器時非常有用。

clean 目標清除所有先前構建的檔案。

deploywar 目標構建 war 檔案，然後將 war 檔案複製到應用程式伺服器的 deploy 目錄。

Ant - 部署應用程式

在上一章中，我們學習瞭如何打包應用程式並將其部署到資料夾中。

在本章中，我們將直接將 web 應用程式部署到應用程式伺服器的 deploy 資料夾，然後新增一些 Ant 目標來啟動和停止服務。

讓我們繼續使用 **Hello World** 傳真 web 應用程式。這是上一章的延續；新元件以 **粗體** 突出顯示。

build.properties

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

build.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 作為我們的應用程式伺服器。

首先，在 build properties 檔案中，我們定義了一些其他屬性，如下所述 -

• **appserver.home** 指向 Tomcat 應用程式伺服器的安裝路徑。

• **appserver.lib** 指向 Tomcat 安裝資料夾中的庫檔案。

• **deploy.path** 變數現在指向 Tomcat 中的 webapp 資料夾。

可以使用 Tomcat 管理器應用程式停止和啟動 Tomcat 中的應用程式。管理器應用程式的 URL、使用者名稱和密碼也在 build.properties 檔案中指定。

接下來，我們宣告一個新的 CLASSPATH，其中包含 **catalina-ant.jar**。此 jar 檔案是透過 Apache Ant 執行 Tomcat 任務所必需的。

任務

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

reload 任務需要以下其他引數 -

• 管理器應用程式的 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 應用程式將被部署並重新載入。

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 檢視 **視窗 → 顯示檢視 → 其他 → Ant → Ant**。

• 開啟專案資源管理器，將 build.xml 拖到 Ant 檢視中。

您的 Ant 檢視看起來類似於下面所示 -

單擊目標 build/clean/usage 將使用該目標執行 Ant。

單擊“fax”將執行預設目標 - **usage**。

Ant Eclipse 外掛還帶有一個用於編輯 build.xml 檔案的良好編輯器。編輯器瞭解 build.xml 模式，可以幫助您完成程式碼。

要使用 Ant 編輯器，請右鍵單擊您的 build.xml（來自專案資源管理器）並選擇“使用 > Ant 編輯器開啟”。Ant 編輯器應該看起來類似於 -

Ant 編輯器在右側列出了目標。目標列表用作書籤，允許您直接跳轉到編輯特定目標。

Ant - JUnit 整合

JUnit 是用於基於 Java 的開發的常用單元測試框架。它易於使用且易於擴充套件。有許多可用的 JUnit 擴充套件。如果您不熟悉 JUnit，則應從 www.junit.org 下載它並閱讀其手冊。

本章展示瞭如何使用 Ant 執行 JUnit 測試。透過 JUnit 任務，使用 Ant 使其變得非常簡單。

JUnit 任務的屬性如下所示 -

讓我們繼續 **Hello World** 傳真 web 應用程式的主題並新增一個 JUnit 目標。

以下示例顯示了一個簡單的 JUnit 測試執行 -

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

此示例顯示了在 com.tutorialspoint.UtilsTest junit 類上執行 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** 傳真 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 - 使用 Token 過濾器

Ant 過濾器允許為當前專案設定 Token 過濾器。Token 由 @ 符號分隔，也可以使用屬性檔案讀取。

步驟

• **步驟 1** - 使用 @@ 定義 Token。

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>

過濾器任務屬性

以下是關鍵屬性 -

必須提供 Token 和 Value，或者提供 filtersfile 給 Filter 任務才能正常工作。

示例

建立一個 src 資料夾，其中包含以下內容的 text1.txt 檔案 -

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>

驗證複製到 build 資料夾的檔案內容。

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              print project help information and exit
   -version                        print the version information and exit
   -diagnostics                    print information that might be helpful to diagnose or report problems and exit
   -quiet,         -q              be extra quiet
   -silent,        -S              print nothing but task outputs and build failures
   -verbose,       -v              be extra verbose
   -debug,         -d              print debugging information
   -emacs,         -e              produce logging information without adornments
   -lib          <path>            specifies a path to search for jars and classes
   -logfile      <file>            use given file for log
   -l            <file>                      ''
   -logger       <classname>       the class which is to perform logging
   -listener     <classname>       add an instance of class as a project listener
   -noinput                              do not allow interactive input
   -buildfile    <file>            use given buildfile
   -file         <file>                      ''
   -f            <file>                      ''
   -D            <property>=<value>   use value for given property
   -keep-going,    -k              execute all targets that do not depend on failed target(s)
   -propertyfile <name>            load all properties from file with -D properties taking precedence
   -inputhandler <class>           the class which will handle input requests
   -find         <file>            (s)earch for buildfile towards the root of
   -s            <file>            the filesystem and use it
   -nice         number            A niceness value for the main thread:1 (lowest) to 10 (highest); 5  is the default
   -nouserlib                      Run ant without using the jar files from ${user.home}/.ant/lib
   -noclasspath                    Run ant without using CLASSPATH
   -autoproxy                      Java 5+ : use the OS proxies
   -main         <class>           override Ant's normal entry point

我們將使用 -Dproperty 將變數傳遞到構建任務。

示例

建立一個 src 資料夾，其中包含以下內容的 text1.txt 檔案 -

This is a sample text written in 2021.

建立包含以下內容的 build.xml 檔案：

<?xml version="1.0"?>
<project name="sample" basedir="." default="copy">
   <target name="copy">
      <copy todir="${dest.dir}" filtering="true">
		<fileset dir="${src.dir}"/>
      </copy>
   </target>
</project>

輸出

這裡我們使用 src.dir 和 dest.dir 屬性，但沒有定義它們。我們將使用命令列引數傳遞它們。在上述構建檔案上執行 Ant 會產生以下輸出：

F:\tutorialspoint\ant>ant -Dsrc.dir=src -Ddest.dir=build
Buildfile: F:\tutorialspoint\ant\build.xml

copy:
   [copy] Copying 1 file to F:\tutorialspoint\ant\build
BUILD SUCCESSFUL
Total time: 0 seconds

F:\tutorialspoint\ant>

驗證複製到 build 資料夾的檔案內容。

This is a sample text written in 2021.

Ant - If Else 引數

Ant 允許根據傳遞的條件執行目標。我們可以使用if語句或unless語句。

語法

<target name="copy" if="copyFile">
   <echo>Files are copied.</echo>
</target>
<target name="move" unless="copyFile">
   <echo>Files are moved.</echo>
</target>

我們將使用 -Dproperty 將變數（如 copyFile）傳遞到構建任務。需要定義該變數，但變數的值在這裡無關緊要。

示例

建立包含以下內容的 build.xml 檔案：

<?xml version="1.0"?>
<project name="sample" basedir="." default="copy">
   <target name="copy" if="copyFile">
      <echo>Files are copied.</echo>
   </target>
   <target name="move" unless="copyFile">
      <echo>Files are moved.</echo>
   </target>
</project>

輸出

在上述構建檔案上執行 Ant 會產生以下輸出：

F:\tutorialspoint\ant>ant -DcopyFile=true
Buildfile: F:\tutorialspoint\ant\build.xml

copy:
   [echo] Files are copied.

BUILD SUCCESSFUL
Total time: 0 seconds

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

move:
   [echo] Files are moved.

BUILD SUCCESSFUL
Total time: 0 seconds

F:\tutorialspoint\ant>ant move -DcopyFile=true
Buildfile: F:\tutorialspoint\ant\build.xml

move:

BUILD SUCCESSFUL
Total time: 0 seconds

F:\tutorialspoint\ant>ant move -DcopyFile=false
Buildfile: F:\tutorialspoint\ant\build.xml

move:

BUILD SUCCESSFUL
Total time: 0 seconds

F:\tutorialspoint\ant>ant move -DcopyFile=true
Buildfile: F:\tutorialspoint\ant\build.xml

move:

BUILD SUCCESSFUL
Total time: 0 seconds

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

move:
   [echo] Files are moved.

BUILD SUCCESSFUL
Total time: 0 seconds

F:\tutorialspoint\ant>

Ant - 自定義元件

Ant 允許非常輕鬆地建立和使用自定義元件。可以透過實現 Condition、Selector、Filter 等介面來建立自定義元件。一旦類準備就緒，我們就可以使用typedef在 build.xml 中建立元件，以便在任何目標下使用。

語法

首先定義一個類作為 Ant 自定義元件，例如 TextSelector.java，然後在 build.xml 中定義一個選擇器。

<typedef name="text-selector" classname="TextSelector" classpath="."/>

然後在目標中使用該元件。

<target name="copy">
   <copy todir="${dest.dir}" filtering="true">
      <fileset dir="${src.dir}">
         <text-selector/>  
      </fileset>
   </copy>
</target>

示例

建立包含以下內容的 TextSelector.java 檔案，並將其放在與 build.xml 相同的位置：

import java.io.File;  
import org.apache.tools.ant.types.selectors.FileSelector;  
public class TextFilter implements FileSelector {  
   public boolean isSelected(File b, String filename, File f) {  
      return filename.toLowerCase().endsWith(".txt");  
   }  
}

在 src 目錄中建立一個 text1.txt 和一個 text2.java 檔案。目標是僅將 .txt 檔案複製到 build 目錄。

建立包含以下內容的 build.xml 檔案：

<?xml version="1.0"?>
<project name="sample" basedir="." default="copy">
   <property name="src.dir" value="src"/>
   <property name="dest.dir" value="build"/>
   <typedef name="text-selector" classname="TextSelector"  classpath="."/>
   <target name="copy">
      <copy todir="${dest.dir}" filtering="true">
         <fileset dir="${src.dir}">
            <text-selector/>  
         </fileset>
      </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: 0 seconds

現在僅複製了 .txt 檔案。

Ant - 監聽器和日誌記錄器

Ant 允許使用監聽器和日誌記錄器來監控構建過程。

監聽器

Ant 提供以下事件，可以使用監聽器捕獲這些事件。

• 構建開始

• 構建完成

• 目標開始

• 目標完成

• 任務開始

• 任務完成

• 記錄訊息

可以使用-listener引數在命令列上註冊自定義監聽器。

日誌記錄器

日誌記錄器擴充套件了監聽器的功能，並添加了以下功能

• 可以使用-logfile引數將資訊記錄到控制檯或檔案中

• 可以使用日誌記錄級別（如 -quiet、-verbose、-debug）進行記錄

• 支援 emacs 模式

內建監聽器/日誌記錄器

• org.apache.tools.ant.DefaultLogger - 除非使用 -logger 命令列開關覆蓋，否則隱式使用該日誌記錄器。

• org.apache.tools.ant.NoBannerLogger - 此日誌記錄器省略空目標輸出的輸出。

• org.apache.tools.ant.listener.MailLogger - 擴充套件 DefaultLogger，以便仍然以相同的方式生成輸出，並在構建完成後傳送電子郵件。

• org.apache.tools.ant.listener.AnsiColorLogger - 為構建輸出著色。

• org.apache.tools.ant.listener.Log4jListener - 將事件傳遞到 Apache Log4j 以進行高度可定製的日誌記錄。

• org.apache.tools.ant.XmlLogger - 將構建資訊寫入 XML 檔案。

• org.apache.tools.ant.TimestampedLogger - 列印構建完成的時間

• org.apache.tools.ant.listener.BigProjectLogger - 每個目標都列印專案名稱

• org.apache.tools.ant.listener.SimpleBigProjectLogger - 僅對子專案列印專案名稱，否則與 NoBannerLogger 相同（自 Ant 1.8.1 起）

• org.apache.tools.ant.listener.ProfileLogger - 預設日誌記錄器，為每個任務和目標新增開始時間、結束時間和持續時間。

示例

建立包含以下內容的 build.xml 檔案

<?xml version="1.0"?>
<project name="sample" basedir="." default="copy">
   <target name="copy">
     <echo>File Copied</echo>
   </target>
</project>

輸出

在上述構建檔案上執行 Ant 會產生以下輸出：

F:\tutorialspoint\ant>ant -logger org.apache.tools.ant.listener.TimestampedLogger
Buildfile: F:\tutorialspoint\ant\build.xml

copy:
   [echo] File Copied

BUILD SUCCESSFUL - at 03/12/21, 11:24 AM
Total time: 0 seconds

F:\tutorialspoint\ant>ant -logger org.apache.tools.ant.XmlLogger -verbose -logfile build_log.xml
Apache Ant(TM) version 1.10.12 compiled on October 13 2021
Trying the default build file: build.xml
Buildfile: F:\tutorialspoint\ant\build.xml

現在您可以檢查是否建立了包含相關日誌的 build_log.xml 檔案。