Ant的概念 ：在Eclipse中使用Ant Ant是Java平臺下非常棒的批處理命令執行程式，能非常方便地自動完成編譯，測試，打包，部署等等一系列任務，大大提高開發效率。


Ant和make命令很像。當編譯Linux核心及一些軟體的源程式時，經常要用這個命令。Make命令其實就是一個專案管理工具，而Ant所實現功能與此類似。像make，gnumake和nmake這些編譯工具都有一定的缺陷，但是Ant卻克服了這些工具的缺陷。


Ant執行需要的XML格式的檔案不是Shell命令檔案，它是由一個Project組成的，而一個Project又可分成可多target，target再細分又分成很多task，每一個task都是通過一個實現特定介面的java類來完成的。


Ant是由一個內建任務和可選任務組成的。Ant執行時需要一個XML檔案(構建檔案)。Ant通過呼叫target樹，就可以執行各種task。每個task實現了特定介面物件。由於Ant構建檔案時XML格式的檔案，所以和容易維護和書寫，而且結構很清晰。 


Ant 開發---Ant的構建檔案 


當開始一個新的專案時，首先應該編寫Ant構建檔案。構建檔案定義了構建過程，並被團隊開發中每個人使用。Ant構建檔案預設命名為build.xml，也可以取其他的名字。只不過在執行的時候把這個命名當作引數傳給Ant。構建檔案可以放在任何的位置。一般做法是放在專案頂層目錄中，這樣可以保持專案的簡潔和清晰。下面是一個典型的專案層次結構：

(1) src存放檔案。 
(2) class存放編譯後的檔案。 
(3) lib存放第三方JAR包。 
(4) dist存放打包，釋出以後的程式碼。 
Ant構建檔案是XML檔案。每個構建檔案定義一個唯一的專案(Project元素)。每個專案下可以定義很多目標(target元素)，這些目標之間可以有依賴關係。當執行這類目標時，需要執行他們所依賴的目標。 每個目標中可以定義多個任務，目標中還定義了所要執行的任務序列。Ant在構建目標時必須呼叫所定義的任務。任務定義了Ant實際執行的命令。Ant中的任務可以為3類：

（1） 核心任務。核心任務是Ant自帶的任務。 
（2） 可選任務。可選任務實來自第三方的任務，因此需要一個附加的JAR檔案。 
（3） 使用者自定義的任務。使用者自定義的任務實使用者自己開發的任務。 
1.<project>標籤 
   每個構建檔案對應一個專案。<project>標籤時構建檔案的根標籤。它可以有多個內在屬性，就如程式碼中所示，其各個屬性的含義分別如下。 

(1) default表示預設的執行目標，這個屬性是必須的。 
(2) basedir表示專案的基準目錄。 
(3) name表示專案名。 
(4) description表示專案的描述。 
每個構建檔案都對應於一個專案，但是大型專案經常包含大量的子專案，每一個子專案都可以有自己的構建檔案。


2.<target>標籤 
一個專案標籤下可以有一個或多個target標籤。一個target標籤可以依賴其他的target標籤。例如，有一個target用於編譯程式，另一個target用於聲稱可執行檔案。在生成可執行檔案之前必須先編譯該檔案，因策可執行檔案的target依賴於編譯程式的target。Target的所有屬性如下。 
(1).name表示標明，這個屬性是必須的。 
(2).depends表示依賴的目標。 
(3)if表示僅當屬性設定時才執行。 
(4)unless表示當屬性沒有設定時才執行。 
(5)description表示專案的描述。 
Ant的depends屬性指定了target的執行順序。Ant會依照depends屬性中target出現順序依次執行每個target。在執行之前，首先需要執行它所依賴的target。程式中的名為run的target的depends屬性compile，而名為compile的target的depends屬性是prepare，所以這幾個target執行的順序是prepare->compile->run。 一個target只能被執行一次，即使有多個target依賴於它。如果沒有if或unless屬性，target總會被執行。

3.<mkdir>標籤 
該標籤用於建立一個目錄，它有一個屬性dir用來指定所建立的目錄名，其程式碼如下： 
<mkdir dir=”＄{class.root}”/> 
通過以上程式碼就建立了一個目錄，這個目錄已經被前面的property標籤所指定。

4<jar>標籤 
該標籤用來生成一個JAR檔案，其屬性如下。 
(1) destfile表示JAR檔名。 
(2) basedir表示被歸檔的檔名。 
(3) includes表示別歸檔的檔案模式。 
(4) exchudes表示被排除的檔案模式。

5．<javac標籤> 
該標籤用於編譯一個或一組java檔案，其屬性如下。 
(1).srcdir表示源程式的目錄。 
(2).destdir表示class檔案的輸出目錄。 
(3).include表示被編譯的檔案的模式。 
(4).excludes表示被排除的檔案的模式。 
(5).classpath表示所使用的類路徑。 
(6).debug表示包含的除錯資訊。 
(7).optimize表示是否使用優化。 
(8).verbose 表示提供詳細的輸出資訊。 
(9).fileonerror表示當碰到錯誤就自動停止。

6．<java>標籤 
該標籤用來執行編譯生成的.class檔案，其屬性如下。 
(1).classname 表示將執行的類名。 
(2).jar表示包含該類的JAR檔名。 
(3).classpath所表示用到的類路徑。 
(4).fork表示在一個新的虛擬機器中執行該類。 
(5).failonerror表示當出現錯誤時自動停止。 
(6).output 表示輸出檔案。 
(7).append表示追加或者覆蓋預設檔案。

7.<delete>標籤 
該標籤用於刪除一個檔案或一組檔案，去屬性如下。 
(1)/file表示要刪除的檔案。 
(2).dir表示要刪除的目錄。 
(3).includeEmptyDirs 表示指定是否要刪除空目錄，預設值是刪除。 
(4).failonerror 表示指定當碰到錯誤是否停止，預設值是自動停止。 
(5).verbose表示指定是否列出所刪除的檔案，預設值為不列出。

8.<copy>標籤 
該標籤用於檔案或檔案集的拷貝，其屬性如下。 
(1).file 表示原始檔。 
(2).tofile 表示目標檔案。 
(3).todir 表示目標目錄。 
(4).overwrite 表示指定是否覆蓋目標檔案，預設值是不覆蓋。 
(5).includeEmptyDirs 表示制定是否拷貝空目錄，預設值為拷貝。 
(6).failonerror 表示指定如目標沒有發現是否自動停止，預設值是停止。 
(7).verbose 表示制定是否顯示詳細資訊，預設值不顯示。

Ant的資料型別 
在構建檔案中為了標識檔案或檔案組，經常需要使用資料型別。資料型別包含在org.apache.tool.ant.types包中。下面鏡簡單介紹構建檔案中一些常用的資料型別。

1. argument 型別 
由Ant構建檔案呼叫的程式，可以通過<arg>元素向其傳遞命令列引數，如apply,exec和java任務均可接受巢狀<arg>元素，可以為各自的過程呼叫指定引數。以下是<arg>的所有屬性。 

(1).values 是一個命令引數。如果引數種有空格，但又想將它作為單獨一個值，則使用此屬性。 
(2).file表示一個引數的檔名。在構建檔案中，此檔名相對於當前的工作目錄。 
(3).line表示用空格分隔的多個引數列表。 
(4).path表示路徑。

2.ervironment 型別 
   由Ant構建檔案呼叫的外部命令或程式，<env>元素制定了哪些環境變數要傳遞給正在執行的系統命令，<env>元素可以接受以下屬性。 
(1).file表示環境變數值得檔名。此檔名要被轉換位一個絕對路徑。 
(2).path表示環境變數的路徑。Ant會將它轉換為一個本地約定。 
(3).value 表示環境變數的一個直接變數。 
(4).key 表示環境變數名。 
注意   file path 或 value只能取一個。


3.filelist型別 
Filelist 是一個支援命名的檔案列表的資料型別，包含在一個filelist型別中的檔案不一定是存在的檔案。以下是其所有的屬性。 
(1).dir是用於計算絕對檔名的目錄。 
(2).files 是用逗號分隔的檔名列表。 
(3).refid 是對某處定義的一個<filelist>的引用。 
注意   dir 和 files 都是必要的，除非指定了refid(這種情況下，dir和files都不允許使用)。


4.fileset型別 
Fileset 資料型別定義了一組檔案，並通常表示為<fileset>元素。不過，許多ant任務構建成了隱式的fileset,這說明他們支援所有的fileset屬性和巢狀元素。以下為fileset 的屬性列表。 

(1).dir表示fileset 的基目錄。 
(2).casesensitive的值如果為false，那麼匹配檔名時，fileset不是區分大小寫的，其預設值為true. 
(3).defaultexcludes 用來確定是否使用預設的排除模式，預設為true。 
(4).excludes 是用逗號分隔的需要派出的檔案模式列表。 
(5).excludesfile 表示每行包含一個排除模式的檔案的檔名。 
(6).includes 是用逗號分隔的，需要包含的檔案模式列表。 
(7).includesfile 表示每行包括一個包含模式的檔名。


5.patternset 型別 
Fileset 是對檔案的分組，而patternset是對模式的分組，他們是緊密相關的概念。
<patternset>支援4個屬性：includes excludex includexfile 和 excludesfile,與fileset相同。Patternset 還允許以下巢狀元素：include,exclude,includefile 和 excludesfile.

6.filterset 型別 
Filterset定義了一組過濾器，這些過濾器將在檔案移動或複製時完成檔案的文字替換。 
主要屬性如下： 
(1).begintoken 表示巢狀過濾器所搜尋的記號，這是標識其開始的字串。 
(2).endtoken表示巢狀過濾器所搜尋的記號這是標識其結束的字串。 
(3).id是過濾器的唯一標誌符。 
(4).refid是對構建檔案中某處定義一個過濾器的引用。

7.Path型別 
Path元素用來表示一個類路徑，不過它還可以用於表示其他的路徑。在用作揖個屬性時，路經中的各項用分號或冒號隔開。在構建的時候，此分隔符將代替當前平臺中所有的路徑分隔符，其擁有的屬性如下。 
(1).location 表示一個檔案或目錄。Ant在內部將此擴充套件為一個絕對路徑。 
(2).refid 是對當前構建檔案中某處定義的一個path的引用。 
(3).path表示一個檔案或路徑名列表。


8.mapper型別 
Mapper型別定義了一組輸入檔案和一組輸出檔案間的關係，其屬性如下。 
(1).classname 表示實現mapper類的類名。當內建mapper不滿足要求時，用於建立定製mapper. 
(2).classpath表示查詢一個定製mapper時所用的型別路徑。 
(3).classpathref是對某處定義的一個類路徑的引用。 
(4).from屬性的含義取決於所用的mapper. 
(5).to屬性的含義取決於所用的mapper. 
(6).type屬性的取值為identity，flatten glob merge   regexp   其中之一，它定義了要是用的內建mapper的型別。

Ant 的執行 

安裝好Ant並且配置好路徑之後，在命令列中切換到構建檔案的目錄，輸入Ant命令就可以執行Ant.若沒有指定任何引數，Ant會在當前目錄下查詢build.xml檔案。如果找到了就用該檔案作為構建檔案。如果使用了 –find 選項，Ant 就會在上級目錄中找構建檔案，直至到達檔案系統得跟目錄。如果構建檔案的名字不是build.xml ，則Ant執行的時候就可以使用 –buildfile file,這裡file 指定了要使用的構建檔案的名稱，示例如下： 

Ant 
如下說明了表示當前目錄的構建檔案為build.xml 執行 ant 執行預設的目標。
Ant –buildfile   test.xml 
使用當前目錄下的test.xml 檔案執行Ant ,執行預設的目標
ant的build.xml檔案例項分析
以build_for_ejb_templet.xml為示例，講解Ant中常用的元素和任務。 
約定： "…"表示這裡有很多程式碼，未列出 


build_for_ejb_templet.xml任務的分為以下幾大部分 
i. 開始 
ii. 初始化 
iii. 定義classpath 
iv. 為編譯作準備 
v. 編譯EJB部分 
vi. 編譯WEB部分 
vii. 編譯J2EE Application 
viii. 部署Application 
ix. 建立元件的API 
x. 確定build的目標 


build_for_ejb_templet.xml的講解 


開始 
<?xml version="1.0" encoding="UTF-8"?> 
講解：encoding="UTF-8"表示XML檔案採用UTF-8編碼格式，如果要使用GBK編碼，需定義為encodeing="GBK"。


<!--  
   Build file for 'componentName'  
   Creation date : $Date: yyyy-m-d $  
   Updated date : $Date: yyyy-m-d $  
   Author:   developerName
   Copyright 2002 CompanyName, Inc. All rights reserved.  
-->  
講解：此部分為檔案內容的簡介，包括檔名稱、建立日期、最後修改日期、建立檔案的作者、版權。
componentName 表示 檔名稱
yyyy-m-dd 表示 建立日期、最後修改日期的格式，如2002-5-1
developerName 表示 建立檔案的作者
CompanyName 表示 公司名稱或URL


<project name="componentName" default="core" basedir=".">
…
</project>
講解：此部分定義了一個名稱為componentName的專案元素，預設的任務為"core"任務，根目錄為當前目錄。componentName表示元件的名稱，這裡指EJB的名稱。






初始化 
<target name="init">
…
</target>
講解：此部分用於初始化所有的變數


<property file="../../build.properties" />
講解：匯入專案根目錄下build.properties中的全域性變數，開發人員也可以在此檔案中重新定義全域性變數。


<property name="jboss.lib" value="${jboss.home}/lib" />  
<property name="jboss.client" value="${jboss.home}/client" />  
<property name="jboss.deploy" value="${jboss.home}/server/${jboss.configuration}/deploy" />  
…
<property name="jboss.dir"       value="${jboss.home}" />  
…
<property name="deploy.ormi"     value=""/>  
<property name="deploy.username" value=""/>  
<property name="deploy.password" value=""/>
講解：定義和Jboss Application Server有關的變數，包括lib目錄、client目錄、
deploy目錄和J2EE Application部署要用到的一些變數。


<property name="name"   value="componentName"/>  
講解：定義元件的名稱


<property name="src.dir" value="${basedir}/src"/>  
講解：定義原始碼目錄路徑


<property name="etc.dir" value="${basedir}/etc"/>  
講解：定義資源目錄路徑


<property name="lib.dir" value="${basedir}/lib"/>  
講解：定義庫目錄路徑


<property name="build.dir" value="${basedir}/build"/>  
講解：定義build目錄路徑


<property name="src.main.dir" value="${src.dir}/main"/>
講解：定義原始碼的主目錄路徑


<property name="src.ejb.dir" value="${src.main.dir}/ejb"/>  
講解：定義存放EJB的原始碼目錄路徑


<property name="src.javabean.dir" value="${src.main.dir}/javabean"/>
講解：定義存放JavaBean的原始碼目錄路徑


<property name="src.servlet.dir" value="${src.main.dir}/servlet"/>
講解：定義存放Servlet的原始碼目錄路徑


<property name="src.web.dir" value="${src.main.dir}/web"/>  
講解：定義存放WEB部分檔案（包括JSP程式、HTML檔案、圖片、CSS檔案、JS指令碼等）的目錄路徑


<property name="javadoc.dir" value="${lib.dir}/docs/api"/> 
講解：定義存放元件API的開發檔案目錄路徑


<property name="ejb-classes.dest" value="${lib.dir}/ejb"/>  
講解：定義存放EJB的編譯程式碼目錄路徑


<property name="javabean-classes.dest" value="${lib.dir}/javabean"/>  
講解：定義存放JavaBean的編譯程式碼目錄路徑


<property name="web-classes.dest" value="${lib.dir}/web/WEB-INF/classes" />
講解：定義WEB目錄的類目錄路徑


<property name="web-lib.dest" value="${lib.dir}/web/WEB-INF/lib" />  
講解：定義WEB目錄的庫目錄名稱


<property name="pkg-dist.name" value="${name}-pkg"/>  
講解：定義壓縮文件的名稱


<property name="ProjectName.components.home" value="../../components" />  
講解：定義專案的元件目錄路徑


<!-- Define componentName Component -->
講解：這段為註釋，說明以下是定義當前元件的變數


<property name="ProjectName.componentName.name" value="componentName"/>
講解：定義當前元件的名稱


<property name="ProjectName.componentName.home" value="${ProjectName.components.home}/componentName"/>
講解：定義當前元件的目錄路徑


<property name="ProjectName.componentName.classbindir" 
value="${ProjectName.componentName.home}/lib/ejb"/>
講解：定義當前元件的EJB編譯目錄路徑
<property name="ProjectName.componentName.ejbjar" 
value="${ProjectName.componentName.home}/build/componentName-ejb.jar"/>
講解：定義當前元件內的EJB包的路徑


<property name="ProjectName.componentName.ejbjar.client" 
value="${ProjectName.componentName.home}/build/componentName-ejb-client.jar"/>
講解：定義當前元件內的EJB客戶端包的路徑


<!-- Define referencesComponentName Component -->
講解：這段為註釋，說明以下是定義引入其它元件的變數


<property name="ProjectName.referencesComponentName.name" 
value="referencesComponentName"/>
講解：定義指定元件的名稱


<property name="ProjectName.referencesComponentName.home" 
value="${ProjectName.components.home}/referencesComponentName"/>
講解：定義指定元件的目錄路徑


<property name="ProjectName.referencesComponentName.classbindir" 
value="${ProjectName.referencesComponentName.home}/lib/ejb"/>
講解：定義指定元件的EJB編譯目錄路徑


<property name="ProjectName.referencesComponentName.ejbjar" 
value="${ProjectName.referencesComponentName.home}
/build/referencesComponentName-ejb.jar"/>
講解：定義指定元件內的EJB包的路徑


<property name="ProjectName.referencesComponentName.ejbjar.client" 
value="${ProjectName.referencesComponentName.home}
/build/referencesComponentName-ejb-client.jar"/>
講解：定義指定元件內的EJB客戶端包的路徑


<property name="build.classpath" 
value="${jboss.client}/jboss-j2ee.jar:${jboss.client}
/jnp-client.jar:${jboss.client}/jnp-client.jar:${jboss.client}
/jbossmq-client.jar:${jboss.client}/jbosssx-client.jar:${jboss.client}
/concurrent.jar:${jboss.client}/jaas.jar:${jboss.lib}
/jboss-jmx.jar:${jboss.home}/server/${jboss.configuration}
/lib/jbosssx.jar:${jboss.home}/server/${jboss.configuration}
/lib/mail.jar:${servlet-lib.path}:${ejb-classes.dest}:
${web-classes.dest}:${ProjectName.componentName.classbindir}:
${ProjectName.componentName.ejbjar.client}:
${ProjectName.referencesComponentName.classbindir}:
${ProjectName.referencesComponentName.ejbjar.client}" />
講解：定義classpath，編譯bean時要用到。這是定義classpath的一種方法，下面還有另一種方法。


定義classpath 
<!-- ================================================================== -->  
   <!-- Define the classpath for compile the component                     -->
   <!-- ================================================================== -->  
   <path id="base.path">  
       <pathelement location="${jboss.client}/jboss-j2ee.jar" />  
       <pathelement location="${jboss.client}/jnp-client.jar" />  
       <pathelement location="${jboss.client}/jbossmq-client.jar" />  
       <pathelement location="${jboss.client}/jbosssx-client.jar" />  
       <pathelement location="${jboss.client}/concurrent.jar" /> 
       <pathelement location="${jboss.client}/jaas.jar" />  
       <pathelement location="${jboss.lib}/jboss-jmx.jar" />  
       <pathelement 
location="${jboss.home}/server/${jboss.configuration}/lib/jbosssx.jar" />  
       <pathelement 
location="${jboss.home}/server/${jboss.configuration}/lib/mail.jar" />  
</path>  
講解：此段定義應用伺服器中包檔案，如支援ejb的jboss-j2ee.jar、支援客戶端程式的jnp-client.jar、jbossmq-client.jar、jbosssx-client.jar、支援JavaMail的mail.jar等。


   <path id="project.path">  
       <path refid="base.path"/>
       <pathelement location="${ProjectName.componentName.classbindir}"/>
       <pathelement location="${ProjectName.componentName.ejbjar.client}"/>
       <pathelement
location="${ProjectName.referencesComponentName.classbindir}"/>
       <pathelement location="${ProjectName.referencesComponentName.ejbjar.client}"/>
   </path>  
講解：此段定義專案中要用到的包檔案。


   <path id="web.path">
         <path refid="project.path"/>
         <pathelement location="${servlet-lib.path}"/>
         <pathelement location="${ejb-classes.dest}"/>
   </path>
講解：此段定義在編譯servlet時的classpath，${ servlet-lib.path }是系統指定的Servlet引擎包。


為編譯作準備工作 
<!--=============================================================== -->  
   <!-- Removes all created files and directories                       -->  
   <!-- ============================================================== -->  
   <target name="clean" depends="init">  
       <delete dir="${lib.dir}" />  
       <delete dir="${build.dir}" />  
   </target>
講解：清除build、lib目錄下的所有檔案和目錄。


   <!-- ================================================================ -->  
   <!-- Makes sure the needed directory structure is in place               -->  
   <!-- ================================================================ -->  
   <target name="prepare" depends="init,clean">  
       <mkdir dir="${lib.dir}" />  
       <mkdir dir="${lib.dir}/ejb" />  
       <mkdir dir="${lib.dir}/ejb/META-INF" />  
       <mkdir dir="${lib.dir}/web" />  
       <mkdir dir="${lib.dir}/web/WEB-INF" />  
       <mkdir dir="${lib.dir}/web/WEB-INF/classes" />  
       <mkdir dir="${lib.dir}/web/WEB-INF/lib" />  
       <mkdir dir="${lib.dir}/j2ee" />  
       <mkdir dir="${lib.dir}/META-INF" />  
       <mkdir dir="${lib.dir}/docs/api" />
       <mkdir dir="${build.dir}" />  
   </target>  
講解：建立build中要用到的所有目錄，根據需要可以加入自定義的目錄如：
       <mkdir dir="${lib.dir}/javabean/ " />


編譯EJB部分
<!-- ================================================================ -->  
   <!-- Compilation of the EJB part of the application                     -->  
   <!-- ================================================================ -->  
   <target name="ejb-classes" depends="prepare">  
       <javac srcdir="${src.ejb.dir}"  
             destdir="${ejb-classes.dest}"  
             includes="com/**"  
             classpathref="base.path" />
   </target>  
講解：此小段用來完成編譯ejb和其它help classes。根據需要可以加入一個非常有用的元素：
             encoding="${javac.encoding}"


   <target name="ejb-meta-inf" depends="prepare">  
       <copy file="${etc.dir}/ejb-jar.xml"  
             tofile="${lib.dir}/ejb/META-INF/ejb-jar.xml" />  
       <copy file="${etc.dir}/jaws.xml"  
             tofile="${lib.dir}/ejb/META-INF/jaws.xml" />  
       <copy file="${etc.dir}/jboss.xml"  
             tofile="${lib.dir}/ejb/META-INF/jboss.xml" />  
       <copy file="${etc.dir}/jbosscmp-jdbc.xml"  
             tofile="${lib.dir}/ejb/META-INF/jbosscmp-jdbc.xml" />  
   </target>
講解：此小段用來拷貝EJB部署檔案，在JAS中EJB部署檔案有jaws.xml、jboss.xml、jbosscmp-jdbc.xml。


   <target name="ejb-jar" depends="ejb-classes,ejb-meta-inf">  
       <jar jarfile="${build.dir}/${name}-ejb.jar"  
           basedir="${lib.dir}/ejb" />  
   </target>  
講解：此小段用來把class和部署檔案壓縮成包檔案，這個包檔案就是一個EJB元件。


   <target name="ejbclientjar" depends="ejb-jar,web-classes">
       <copy 
file="${ProjectName.referencesComponentName.home}/build/
${ProjectName.referencesComponentName.name}-ejb-client.jar"  
           tofile="${build.dir}/${ProjectName.referencesComponentName.name}
           -ejb-client.jar" />  
       <jar jarfile="${build.dir}/${name}-ejb-client.jar"  
           basedir="${lib.dir}/ejb"
           excludes="com/ProjectName/componentName/ejb/ComponentNameEJB.class" />  
   </target>
講解：此小段用來把class和部署檔案壓縮成包檔案，以支援客戶端執行。


編譯WEB部分
<!-- ================================================================== -->  
   <!-- Compilation of the web part of the application                     -->  
   <!-- ================================================================== -->  
   <target name="web-classes" depends="prepare,ejb-jar">  
       <javac srcdir="${src.servlet.dir}"  
             destdir="${lib.dir}/web/WEB-INF/classes"  
             includes="com/**"  
             classpath="${build.classpath}" />  
   </target>  
講解：此小段用來完成編譯servlet。


   <target name="web-web-inf" depends="prepare">
       <copy file="${etc.dir}/jboss-web.xml"  
             tofile="${lib.dir}/web/WEB-INF/jboss-web.xml" />  
       <copy file="${etc.dir}/web.xml"  
             tofile="${lib.dir}/web/WEB-INF/web.xml" />  
   </target>
講解：此小段用來拷貝WEB部署檔案，在JAS中WEB部署檔案有jboss-web.xml。


   <target name="war" depends="web-classes,web-web-inf">  
       <copy todir="${lib.dir}/web" >
       <fileset dir="${src.web.dir}"/>
       </copy>
       <copy
file="${build.dir}/${ProjectName.referencesComponentName.name}-ejb-client.jar"  
tofile="${lib.dir}/web/WEB-INF/lib/${ProjectName.referencesComponentName.name}
-ejb-client.jar" />    
     <jar jarfile="${build.dir}/${name}-web.war"  
           basedir="${lib.dir}/web" />  
   </target>
講解：此小段用來把所有的JSP程式、Html、Css、圖片和部署檔案等壓縮成WAR檔案。


編譯J2EE Application
<!-- ================================================================== -->  
   <!-- Compilation of the complete J2EE application (both web and EJB)     -->  
   <!-- ================================================================== -->  
   <target name="j2ee-meta-inf" depends="prepare">  
       <copy file="${etc.dir}/application.xml"  
             tofile="${lib.dir}/j2ee/META-INF/application.xml" />  
   </target>  
講解：此小段用來拷貝Application的部署檔案。


   <target name="ear" depends="ejb-jar,war,j2ee-meta-inf">  
       <copy file="${build.dir}/${name}-ejb.jar"  
             tofile="${lib.dir}/j2ee/${name}-ejb.jar" />  
       <copy file="${build.dir}/${name}-web.war"  
             tofile="${lib.dir}/j2ee/${name}-web.war" />  
       <jar jarfile="${build.dir}/${name}.ear"  
           basedir="${lib.dir}/j2ee" />  
   </target>  
講解：此小段用來把EJB元件、支援客戶端執行的包和部署檔案壓縮成EAR檔案，它就是一個J2EE Application。這裡要說明，在進行build時，根據需要可以不生成EAR檔案。


部署Application
<!-- ================================================================ -->
   <!-- Deploy EAR file                                                   -->
   <!-- ================================================================ -->
   <target name="deploy-server" depends="ear,war">  
       <copy todir="${jboss.deploy}">  
         <fileset dir="${build.dir}" includes="*.ear">  
         </fileset>  
       </copy>  
   </target>  
講解：此小段用來部署Application，在JAS3.0中${jboss.deploy}是JAS的熱部署目錄。


建立元件的API
<!-- =================================================================== -->
   <!-- Create class and package usage pages                                 -->
   <!-- =================================================================== -->
   <target name="docs" depends="init">
     <javadoc locale="${javadoc.locale}" packagenames="${package.names}.${name}.*"  
             destdir="${javadoc.dir}"  
             classpath="${build.classpath}"
             encoding="${javadoc.encoding}"
             author="${javadoc.author}"
version="${javadoc.version}" 
use="${javadoc.usage}"  
             windowtitle="${project.name} ${name} Component API"
             doctitle="${project.name} ${name} Component"  
             bottom="Copyright ${sign.copyright} ${project.date} 
${company.signature}. All Rights Reserved.">  
<classpath >
         <pathelement path="${lib.dir}/ejb"/>  
       </classpath>
       <sourcepath>
         <pathelement path="${src.main.dir}/ejb"/>
       </sourcepath>
     </javadoc>
   </target>
講解：此小段用來建立元件的API。這裡強烈要求類設計人員和編碼人員按照Javadoc定義的標籤對原始碼進行註釋。






確定build的目標
<target name="startbanner">
       <echo>+---------------------------------------+</echo>
       <echo>+     Building ${name} Component         +</echo>
       <echo>+---------------------------------------+</echo>
   </target>
   <target name="endbanner" depends="main" >
       <echo>+---------------------------------------+</echo>
       <echo>+     Finished ${name} Component         +</echo>
       <echo>+---------------------------------------+</echo>
   </target>
   <target name="main" depends="startbanner, ejb-jar, ejbclientjar" />
   <target name="main2" depends="startbanner, ejb-jar,
ejbclientjar,war" />
   <target name="main3" depends="startbanner, ejb-jar, 
ejbclientjar,war,ear,deploy-server" />
   <target name="core" depends="ejb-war" />
   <target name="ejb-war" depends="main2,endbanner" />
   <target name="deploy" depends="main3,endbanner" />
   <target name="all" depends="core, docs" />
講解：此小段用來確定build的目標。預設目錄為core，所以在build不加引數時，系統將只生成jar檔案和war檔案。如果 build時加上引數，系統將根據需要來生成檔案，例如：在命令列輸入ant deploy，系統將生成jar檔案、war檔案、ear檔案，同時將ear檔案進行部署。


eclipse中整合ant，建立工程舉例：


Eclipse中已經集成了Ant，我們可以直接在Eclipse中執行Ant。 


以前面建立的Hello工程為例，建立以下目錄結構： 






新建一個build.xml，放在工程根目錄下。build.xml定義了Ant要執行的批處理命令。雖然Ant也可以使用其它檔名，但是遵循標準能更使開發更規範，同時易於與別人交流。 


通常，src存放Java原始檔，classes存放編譯後的class檔案，lib存放編譯和執行用到的所有jar檔案，web存放JSP等web檔案，dist存放打包後的jar檔案，doc存放API文件。 


然後在根目錄下建立build.xml檔案，輸入以下內容： 


Xml程式碼  


<?xml version="1.0"?>  


<project name="Hello world" default="doc">  


<!-- properies -->  


     <property name="src.dir" value="src" />  


     <property name="report.dir" value="report" />  


     <property name="classes.dir" value="classes" />  


     <property name="lib.dir" value="lib" />  


     <property name="dist.dir" value="dist" />  


<property name="doc.dir" value="doc"/>  


     <!-- 定義classpath -->  


     <path id="master-classpath">  


         <fileset file="${lib.dir}/*.jar" />  


         <pathelement path="${classes.dir}"/>  


     </path>  


     <!-- 初始化任務 -->  


     <target name="init">  


     </target>  


     <!-- 編譯 -->  


     <target name="compile" depends="init" description="compile the source files">  


         <mkdir dir="${classes.dir}"/>  


         <javac srcdir="${src.dir}" destdir="${classes.dir}" target="1.4">  


             <classpath refid="master-classpath"/>  


         </javac>  


     </target>  


     <!-- 測試 -->  


     <target name="test" depends="compile" description="run junit test">  


         <mkdir dir="${report.dir}"/>  


         <junit printsummary="on"  


                 haltonfailure="false"  


                 failureproperty="tests.failed"  


                 showoutput="true">  


             <classpath refid="master-classpath" />  


             <formatter type="plain"/>  


             <batchtest todir="${report.dir}">  


                 <fileset dir="${classes.dir}">  


                     <include name="**/*Test.*"/>  


                 </fileset>  


             </batchtest>  


         </junit>  


         <fail if="tests.failed">  


         ***********************************************************   


         ****   One or more tests failed!   Check the output ...   ****   


         ***********************************************************   


         </fail>  


     </target>  


     <!-- 打包成jar -->  


     <target name="pack" depends="test" description="make .jar file">  


      <mkdir dir="${dist.dir}" />  


         <jar destfile="${dist.dir}/hello.jar" basedir="${classes.dir}">  


             <exclude name="**/*Test.*" />  


             <exclude name="**/Test*.*" />  


         </jar>  


     </target>  


     <!-- 輸出api文件 -->  


     <target name="doc" depends="pack" description="create api doc">  


      <mkdir dir="${doc.dir}" />  


      <javadoc destdir="${doc.dir}"  


             author="true"  


             version="true"  


             use="true"  


             windowtitle="Test API">  


             <packageset dir="${src.dir}" defaultexcludes="yes">  


                 <include name="example/**" />  


             </packageset>  


             <doctitle><![CDATA[<h1>Hello, test</h1>]]></doctitle>  


             <bottom><![CDATA[<i>All Rights Reserved.</i>]]></bottom>  


             <tag name="todo" scope="all" description="To do:" />  


         </javadoc>  


     </target>  


</project>  


<span style="font-size:12px;"><span style="color:#3366ff;"><p style="margin-top: 0px; margin-bottom: 10px; padding-top: 0px; padding-bottom: 0px;"></p><p style="margin-top: 0px; margin-bottom: 10px; padding-top: 0px; padding-bottom: 0px;"></p></span></span>
以上xml依次定義了init（初始化），compile（編譯），test（測試），doc（生成文件），pack（打包）任務，可以作為模板。 


選中Hello工程，然後選擇“Project”，“Properties”，“Builders”，“New…”，選擇“Ant Build”： 






填入Name：Ant_Builder；Buildfile：build.xml；BaseDirectory：${workspace_loc: /Hello}（按“BrowseWorkspace”選擇工程根目錄），由於用到了junit.jar包，搜尋Eclipse目錄，找到 junit.jar，把它複製到Hello/lib目錄下，並新增到Ant的Classpath中： 






然後在Builder面板中鉤上Ant_Build，去掉Java Builder： 






再次編譯，即可在控制檯看到Ant的輸出： 


Buildfile: F:\eclipse-projects\Hello\build.xml 


init: 


compile: 


        [mkdir] Created dir: F:\eclipse-projects\Hello\classes 


        [javac] Compiling 2 source files to F:\eclipse-projects\Hello\classes 


test: 


        [mkdir] Created dir: F:\eclipse-projects\Hello\report 


        [junit] Running example.HelloTest 


        [junit] Tests run: 1, Failures: 0, Errors: 0, Time elapsed: 0.02 sec 


pack: 


        [mkdir] Created dir: F:\eclipse-projects\Hello\dist 


          [jar] Building jar: F:\eclipse-projects\Hello\dist\hello.jar 


doc: 


        [mkdir] Created dir: F:\eclipse-projects\Hello\doc 


      [javadoc] Generating Javadoc 


      [javadoc] Javadoc execution 


      [javadoc] Loading source files for package example... 


      [javadoc] Constructing Javadoc information... 


      [javadoc] Standard Doclet version 1.4.2_04 


      [javadoc] Building tree for all the packages and classes... 


      [javadoc] Building index for all the packages and classes... 


      [javadoc] Building index for all classes... 


      [javadoc] Generating F:\eclipse-projects\Hello\doc\stylesheet.css... 


      [javadoc] Note: Custom tags that could override future standardtags:   @todo. To avoid potential overrides, use at least one periodcharacter (.) in custom tag names. 


      [javadoc] Note: Custom tags that were not seen:   @todo 


BUILD SUCCESSFUL 


Total time: 11 seconds 


Ant依次執行初始化，編譯，測試，打包，生成API文件一系列任務，極大地提高了開發效率。將來開發J2EE專案時，還可加入部署等任務。並且，即使脫離了Eclipse環境，只要正確安裝了Ant，配置好環境變數ANT_HOME=<Ant解壓目錄&gt;， Path=…;%ANT_HOME%\bin，在命令列提示符下切換到Hello目錄，簡單地鍵入ant即可。




生成build.xml
Eclipse 自動生成 Ant的Build.xml 配置檔案,生成的方法很隱蔽
選擇你要生成Build.xml檔案的專案,右鍵. Export-> General -> Ant Buildfiles .
點Next,選擇專案，再點Finish.
生成完畢.
編寫build.xml
[html] view plaincopyprint?在CODE上檢視程式碼片派生到我的程式碼片
<?xml version="1.0" encoding="UTF-8" standalone="no"?>  
      
<!-- 每個構建檔案對應一個專案。<project>標籤時構建檔案的根標籤。它可以有多個內在屬性，就如程式碼中所示，其各個屬性的含義分別如下。  
(1) default表示預設的執行目標，這個屬性是必須的。   
(2) basedir表示專案的基準目錄。   
(3) name表示專案名。   
(4) description表示專案的描述。   
 -->  
<project default="build" name="Sort">  
    <!-- 設定屬性或檔案路徑，讀取屬性使用${property}，value路徑預設專案根目錄 -->  
    <property file="ant/builds.properties" />  
  
    <property name="src.dir" value="src/statics" />  
      
    <property name="classes.dir" value="ant/classes" />  
  
    <property name="lib.dir" value="lib" />  
  
    <property name="dist.dir" value="ant/dist" />  
      
    <!-- 定義classpath -->  
    <path id="master-classpath">  
        <fileset file="${lib.dir}/*.jar" />  
        <pathelement path="${classes.dir}" />  
    </path>  
      
    <!--一個專案標籤Project包含多個target標籤，一個target標籤可以依賴其他的target標籤  
        在生成可執行檔案之前必須先編譯該檔案，因策可執行檔案的target依賴於編譯程式的 target。  
          
        (1).name表示標明，這個屬性是必須的。   
        (2).depends表示依賴的目標。   
        (3)if表示僅當屬性設定時才執行。   
        (4)unless表示當屬性沒有設定時才執行。   
        (5)description表示專案的描述。    
        Ant的depends屬性指定了target的執行順序。Ant會依照depends屬性中target出現順序依次執行每個target。在執行之前，首先需要執行它所依賴的target。  
     -->  
    <!-- 初始化任務 -->  
    <target name="init">  
        <!-- 輸出標籤 ，${init}是builds.properties中的屬性 -->  
        <echo message="  Available Targets:"/>    
        <echo message="-------------------------------------------------------"/>    
        <echo message="  init ${init}   ..."/>    
        <echo message="-------------------------------------------------------"/>   
    </target>  
  
    <!-- 編譯 -->  
    <target name="compile" depends="init" description="compile the source files">  
        <!-- 刪除資料夾 -->  
        <delete dir="${classes.dir}" />  
        <!-- 建立資料夾 -->  
        <mkdir dir="${classes.dir}" />  
        <!-- 編譯java生成class檔案 ，其屬性如下  
            (1).srcdir表示源程式的目錄。   
            (2).destdir表示class檔案的輸出目錄。   
            (3).include表示被編譯的檔案的模式。   
            (4).excludes表示被排除的檔案的模式。   
            (5).classpath表示所使用的類路徑。   
            (6).debug表示包含的除錯資訊。   
            (7).optimize表示是否使用優化。   
            (8).verbose 表示提供詳細的輸出資訊。   
            (9).fileonerror表示當碰到錯誤就自動停止。  
         -->  
        <javac srcdir="${src.dir}" destdir="${classes.dir}">  
            <!-- 編譯需要的jar包 引用前面設定的class-path -->  
            <classpath refid="master-classpath" />  
        </javac>  
    </target>  
  
  
    <!-- 打包成jar -->  
    <target name="pack" description="make .jar file">  
  
        <delete dir="${dist.dir}" />  
  
        <mkdir dir="${dist.dir}" />  
        <!-- 該標籤用來生成一個JAR檔案，其屬性如下  
            (1) destfile表示JAR檔名。   
            (2) basedir表示被歸檔的檔名。要操作的檔案路徑   
            (3) includes表示別歸檔的檔案模式。   
            (4) exchudes表示被排除的檔案模式。   
         -->  
        <jar destfile="${dist.dir}/hello.jar" basedir="${classes.dir}">  
            <!-- 不包含的類或內容 -->  
            <exclude name="**/*Test.*" />  
        </jar>  
  
    </target>  
  
    <!-- 生成zip壓縮包 -->  
    <target name="zip">  
        <delete dir="${release-dir}" />  
        <mkdir dir="${release-dir}" />  
        <!-- 該標籤用來生成一個zip檔案，其屬性如下  
            (1) destfile表示zip檔名。   
            (2) basedir表示被歸檔的檔名。 要操作的檔案路徑  
            (3) includes表示別歸檔的檔案模式。   
            (4) exchudes表示被排除的檔案模式。   
         -->  
        <zip destfile="${release-dir}/antTest.zip" update="true"   
                   basedir="ant" />  
    </target>   
</project>  




ant教程詳解--javac，java，jar，war，delete，copy，mkdir：

Ant 的關鍵元素 ---結合例項分析

 target 元素 
它為 Ant 的基本執行單元，它可以包含一個或多個具體的任務。多個 target 可以存在相互依賴關係。它有如下屬性： 
1 ） name 屬性 
指定 target 元素的名稱，這個屬性在一個 project 元素中是唯一的。我們可以通過指定 target 元素的名稱來指定某個 target 。 
2 ） depends 屬性 
用於描述 target 之間的依賴關係，若與多個 target 存在依賴關係時，需要以“ , ”間隔。 Ant 會依照 depends 屬性中 target 出現的順序依次執行每個 target 。被依賴的 target 會先執行。 
3 ） if 屬性 
用於驗證指定的屬性是否存在，若不存在，所在 target 將不會被執行。 
4 ） unless 屬性 
該屬性的功能與 if 屬性的功能正好相反，它也用於驗證指定的屬性是否存在，若不存在，所在 target 將會被執行。 
5 ） description 屬性 
該屬性是關於 target 功能的簡短描述和說明。 
下面帶領讀者來看一個各屬性綜合使用的例子。修改 E:"build.xml 檔案，修改後的內容如下： 
<? xml version="1.0" ?> 
< project  name ="targetStudy"> 
< target  name ="targetA"  if ="ant.java.version"> 
< echo  message ="Java Version: ${ant.java.version}"/> 
</ target > 
< target  name ="targetB"  depends ="targetA"  unless ="amigo"> 
< description > 
a depend example!
</ description > 
< echo  message ="The base dir is: ${basedir}"/> 
</ target > 
</ project > 
進入 E 盤後執行 ant targetB ，可看到如下圖所示的執行結果：


讀者分析結果後可以看到，我們執行的是名為 targetB 的 target ，因該 target 依賴於 targetA ，所以 targetA 將首先被執行，同時因為系統安裝了 java 環境，所以 ant.java.version 屬性存在，執行了 targetA 這個 target ，輸出資訊： [echo] Java Version: 1.5 ， targetA 執行完畢後，接著執行 targetB ，因為 amigo 不存在，而 unless 屬性是在不存在時進入所在的 target 的，由此可知 targetB 得以執行，輸出資訊： The base dir is: E:" 。 
 property 元素 
該元素可看作參量或者引數的定義， project 的屬性可以通過 property 元素來設定，也可在 Ant 之外設定。若要在外部引入某檔案，例如 build.properties 檔案，可以通過如下內容將其引入： <property file=” build.properties”/> 
property 元素可用作 task 的屬性值。在 task 中是通過將屬性名放在“ ${ ”和“ } ”之間，並放在 task 屬性值的位置來實現的。 
Ant 提供了一些內建的屬性，它能得到的系統屬性的列表與 Java 文件中 System.getPropertis() 方法得到的屬性一致，這些系統屬性可參考 sun 網站的說明。 
同時， Ant 還提供了一些它自己的內建屬性，如下： 
basedir ： project 基目錄的絕對路徑，該屬性在講解 project 元素時有詳細說明，不再贅述； 
ant.file ： buildfile 的絕對路徑，如上面的各例子中， ant.file 的值為 E:"build.xml ； 
ant.version ： Ant 的版本，在本文中，值為 1.7.0 ； 
ant.project.name ：當前指定的 project 的名字，即前文說到的 project 的 name 屬性的值； 
ant.java.version ： Ant 檢測到的 JDK 的版本，在上例執行結果中可看到為 1.5 。 
下面讓讀者來看一個 property 元素使用的簡單例子。修改 E:"build.xml 檔案，內容如下： 
<? xml version="1.0" ?> 
< project  name ="propertyStudy"  default ="example"> 
< property  name ="name"  value ="amigo"/> 
< property  name ="age"  value ="25"/> 
< target  name ="example"> 
< echo  message ="name: ${name}, age: ${age}"/> 
</ target > 
</ project > 
該例的執行結果如下圖所示：由此讀者可以看出，通過如下兩個語句： 
<property name="name" value="amigo"/> 
<property name="age" value="25"/> 
我們設定了名為 name 和 age 的兩個屬性，這兩個屬性設定後，讀者在下文中可以通過 ${name} 和 ${age} 分別取得這兩個屬性的值。 


Ant 的常用任務 
在 Ant 工具中每一個任務封裝了具體要執行的功能，是 Ant 工具的基本執行單位。在本小節中，主要引導讀者來看下 Ant 的常用任務及其使用舉例。 
1.   copy 任務 
該任務主要用來對檔案和目錄的複製功能。舉例如下： 
Eg1. 複製單個檔案： <copy file="file.txt" tofile="copy.txt"/> 
Eg2. 對檔案目錄進行復制： 
<copy todir="../newdir/dest_dir"> 
<fileset dir="src_dir"/> 
</copy> 
Eg3. 將檔案複製到另外的目錄： 
<copy file="file.txt" todir="../other/dir"/> 
2.  delete 任務 
對檔案或目錄進行刪除，舉例如下： 
Eg1. 刪除某個檔案： <delete file="photo/amigo.jpg"/> 
Eg2. 刪除某個目錄： <delete dir="photo"/> 
Eg3. 刪除所有的備份目錄或空目錄： 
<delete includeEmptyDirs="true"> 
<fileset dir="." includes="**/*.bak"/> 
</delete> 
3.   mkdir 任務 
建立目錄。 eg ： <mkdir dir="build"/> 
4.   move 任務 
移動檔案或目錄，舉例如下： 
Eg1. 移動單個檔案： <move file="fromfile" tofile=”tofile”/> 
Eg2. 移動單個檔案到另一個目錄： <move file="fromfile" todir=”movedir”/> 
Eg3. 移動某個目錄到另一個目錄： 
<move todir="newdir"> 
<fileset dir="olddir"/> 
</move> 
5.  echo 任務 
該任務的作用是根據日誌或監控器的級別輸出資訊。它包括 message 、 file 、 append 和 level 四個屬性，舉例如下： 
<echo message="Hello,Amigo" file="logs/system.log" append="true"> 
利用 Ant 構建和部署 Java 工程 

Ant 可以代替使用 javac 、 java 和 jar 等命令來執行 java 操作，從而達到輕鬆的構建和部署 Java 工程的目的。下面來看幾個知識點。 

1.  利用 Ant 的 javac 任務來編譯 java 程式 
Ant 的 javac 任務用於實現編譯 Java 程式的功能。下面來看一個簡單的例子： 
首先我們建立名為 antstudy 的 Java 工程，建立 src 目錄為原始碼目錄，在 src 目錄下建立 HelloWorld.java 這個類檔案。該類檔案的內容如下： 
public   class  HelloWorld  {
public   static   void  main(String[] args)  {
System.out.println("Hello,Amigo");
}
} 
同時在 antstudy 工程的根目錄下建立 build.xml 檔案，在該檔案中編譯 src 目錄下的 java 檔案，並將編譯後的 class 檔案放入 build/classes 目錄中，在編譯前，需清除 classes 目錄，該檔案的內容如下： 
<? xml version="1.0" ?> 
< project  name ="javacTest" default ="compile"  basedir ="."> 
< target  name ="clean"> 
< delete  dir ="build"/> 
</ target > 


< target  name ="compile"  depends ="clean"> 
< mkdir  dir ="build/classes"/> 
< javac  srcdir ="src"  destdir ="build/classes"/> 
</ target > 
</ project > 

執行該 build.xml 檔案，可在工程中看到新增了 build/classes 目錄，並在該目錄中生成了編譯後的 HelloWorld.class 檔案。 

2.   使用 Ant 的 java 任務執行 Java 程式 
Ant 中可以使用 java 任務實現執行 Java 程式的功能。下面在 1 的例子中進行如下的修改，修改後的 build.xml 檔案的內容如下： 
<? xml version="1.0" ?> 
< project  name ="javaTest"  default ="jar"  basedir ="."> 
< target  name ="clean"> 
< delete  dir ="build"/> 
</ target > 

< target  name ="compile"  depends ="clean"> 
< mkdir  dir ="build/classes"/> 
< javac  srcdir ="src"  destdir ="build/classes"/> 
</ target > 

< target  name ="run"  depends ="compile"> 
< java  classname ="HelloWorld"> 
< classpath > 
< pathelement  path ="build/classes"/> 
</ classpath > 
</ java > 
</ target > 
</ project > 

執行該 build.xml 檔案，可在控制檯看到 HelloWorld 的 main 方法的輸出。 

3. 使用 Ant 的 jar 任務生成 jar 檔案 
讀者可以在上例的基礎上更進一步，來生成 jar 包，可在 run 這個 target 下再加上如下 target ： 
< target  name ="jar"  depends ="run"> 
< jar  destfile ="helloworld.jar"  basedir ="build/classes"> 
< manifest > 
< attribute  name ="Main-class"  value ="HelloWorld"/> 
</ manifest > 
</ jar > 
</ target > 
此時將 ant 的 project 的 default 屬性設定為 jar ，同時執行該 build.xml 檔案，執行完畢後，可看到在工程目錄下生成了一個 jar 包 HelloWorld.jar 。 
4. 使用 Ant 的 war 任務打包 J2EE Web 專案 
建立一個 J2EE Web 工程，其目錄結構如下圖所示：
其中 src 為原始碼目錄， WebRoot 為各 jsp 存放目錄， lib 為工程的包目錄。在 antwebproject 工程目錄下建立了 build.xml 檔案，該檔案為該工程的 Ant 構件檔案。讀者可以 src 目錄下放入在前續例子中開發的 HelloWorld.java 檔案，並在 WebRoot 下建立 index.jsp 檔案，其內容很簡單，就是輸出 Hello 資訊，程式碼如下所示： 
<% @ page language="java" contentType="text/html; charset="UTF-8" pageEncoding="UTF-8" %> 
<! DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd" > 
< html > 
< head > 
< meta  http-equiv ="Content-Type"  content ="text/html; charset=ISO-8859-1"> 
< title > ant 打包測試 </ title > 
</ head > 
< body > 
Hello,Ant
</ body > 
</ html > 
接下來編寫 build.xml 檔案，其內容如下： 
<? xml version="1.0" ?> 
< project  name ="antwebproject"   default ="war" basedir ="."> 
< property  name ="classes"  value ="build/classes"/> 
< property  name ="build" value ="build"/> 
< property  name ="lib" value ="WebRoot/WEB-INF/lib"/> 
<!--  刪除build 路徑--> 
< target  name ="clean"> 
< delete  dir ="build"/> 
</ target > 
<!--  建立build/classes 路徑，並編譯class 檔案到build/classes 路徑下--> 
< target  name ="compile"  depends ="clean"> 
< mkdir  dir ="${classes}"/> 
< javac  srcdir ="src"  destdir ="${classes}"/> 
</ target > 
<!--  打war 包--> 
< target  name ="war"  depends ="compile"> 
< war  destfile ="${build}/antwebproject.war"  webxml ="WebRoot/WEB-INF/web.xml"> 
<!--  拷貝WebRoot 下除了WEB-INF 和META-INF 的兩個資料夾--> 
< fileset  dir ="WebRoot"  includes ="**/*.jsp"/> 


<!--  拷貝lib 目錄下的jar 包--> 
< lib  dir ="${lib}"/> 
<!--  拷貝build/classes 下的class 檔案--> 
< classesdir ="${classes}"/> 
</ war > 
</ target > 
</ project > 
各 target 的作用在內容中已經進行說明，在此不再贅述。執行該 build 檔案，更新目錄後，可看到在 build 目錄下生成了 antwebproject.war 檔案，解開後可看到其目錄結構如下： 
--META-INF 
--MANIFEST.MF 
--index.jsp 
--WEB-INF 
--lib 
--log4j-1.2.9.jar 
--classes 
--HelloWorld.class 
--web.xml 
讀者可以將該 war 包拷貝到 Tomcat 的目錄下看一下執行結果。