當前位置：首頁 > 编程语言 > java >内容正文

java

Java Ant 学习总结

發布時間：2025/4/14 java 13 豆豆

生活随笔收集整理的這篇文章主要介紹了 Java Ant 学习总结小編覺得挺不錯的,現在分享給大家,幫大家做個參考.

Java_Ant詳解

http://www.cnblogs.com/huozhicheng/archive/2010/04/08/2533199.html

?1,什么是ant
ant是構建工具
2,什么是構建
概念到處可查到，形象來說，你要把代碼從某個地方拿來，編譯，再拷貝到某個地方去等等操作，當然

不僅與此，但是主要用來干這個
3,ant的好處
跨平臺?? --因為ant是使用java實現的，所以它跨平臺
使用簡單--與ant的兄弟make比起來
語法清晰--同樣是和make相比
功能強大--ant能做的事情很多，可能你用了很久，你仍然不知道它能有多少功能。當你自己開發一些

ant插件的時候，你會發現它更多的功能。
4,ant的兄弟make
ant做的很多事情，大部分是曾經有一個叫make的所做的，不過對象不同，make更多應用于c/c++ ,ant更

多應用于Java。當然這不是一定的，但大部分人如此。
一,構建ant環境
要使用ant首先要構建一個ant環境，步驟很簡單：
1),安裝jdk，設置JAVA_HOME ,PATH ,CLASS_PATH(這些應該是看這篇文章的人應該知道的)
2),下載ant 地址http://www.apache.org/找一個你喜歡的版本，或者干脆最新的版本
3),解壓ant 你得到的是一個壓縮包，解壓縮它，并把它放在一個盡量簡單的目錄，例如D:/ant-1.6雖然

你不一定要這么做，但這么做是有好處的。
4),設置ANT_HOME PATH中添加ANT_HOME目錄下的bin目錄
5),測試一下你的設置,開始-->運行-->cmd進入命令行-->鍵入 ant 回車,如果看到
Buildfile: build.xml does not exist!
Build failed
那么恭喜你你已經完成ant的設置
二,體驗ant
就像每個語言都有HelloWorld一樣，一個最簡單的應用能讓人感受一下Ant
1,首先你要知道你要干什么，我現在想做的事情是：
編寫一些程序
編譯它們
把它打包成jar包
把他們放在應該放置的地方
運行它們
這里為了簡單起見只寫一個程序，就是HelloWorld.java程序代碼如下：
package test.ant;
public class HelloWorld{
public static void main(String[] args){
?? System.out.println("Hello world1");
}
};
2，為了達到上邊的目的，你可以手動的用javac 、copy 、jar、java來完成，但是考慮一下如果你有成

百上千個類，在多次調試，部署的時候，一次次的javac 、copy、jar、
java那將是一份辛苦的工作。現在看看ant怎么優雅的完成它們。
要運行ant需要有一個build.xml雖然不一定要叫這個名字，但是建議你這么做
下邊就是一個完整的build.xml，然后我們來詳細的解釋每一句

[xhtml] view plaincopyprint?
1.<?xml version="1.0" encoding="UTF-8" ?>?
2.<project name="HelloWorld" default="run" basedir=".">?
3.<property name="src" value="src"/>?
4.<property name="dest" value="classes"/>?
5.<property name="hello_jar" value="hello1.jar"/>?
6.<target name="init">?
7.?? <mkdir dir="${dest}"/>?
8.</target>?
9.<target name="compile" depends="init">?
10.?? <javac srcdir="${src}" destdir="${dest}"/>?
11.</target>?
12.<target name="build" depends="compile">?
13.?? <jar jarfile="${hello_jar}" basedir="${dest}"/>?
14.</target>?
15.<target name="run" depends="build">?
16.?? <java classname="test.ant.HelloWorld" classpath="${hello_jar}"/>?
17.</target>?
18.<target name="clean">?
19.?? <delete dir="${dest}" />?
20.?? <delete file="${hello_jar}" />?
21.</target>?
22.<target name="rerun" depends="clean,run">?
23.?? <ant target="clean" />?
24.?? <ant target="run" />?
25.</target>?
26.</project>?
27.解釋：?
28.<?xml version="1.0" encoding="UTF-8" ?>??
29.build.xml中的第一句話，沒有實際的意義?
30.<project name="HelloWorld" default="run" basedir=".">?
31.</project>?
32.ant的所有內容必須包含在這個里邊，name是你給它取的名字，basedir故名思意就是工作的根目錄 .

代表當前目錄。default代表默認要做的事情。?
33.<property name="src" value="src"/>?
34.類似程序中的變量，為什么這么做想一下變量的作用?
35.<target name="compile" depends="init">?
36.?? <javac srcdir="${src}" destdir="${dest}"/>?
37.</target>?
38.把你想做的每一件事情寫成一個target ，它有一個名字，depends是它所依賴的target，在執行這個

target 例如這里的compile之前ant會先檢查init是否曾經被執行過，如果執行?
39.過則直接直接執行compile，如果沒有則會先執行它依賴的target例如這里的init，然后在執行這個

target?
40.如我們的計劃?
41.編譯：?
42.<target name="compile" depends="init">?
43.<javac srcdir="${src}" destdir="${dest}"/>?
44.</target>?
45.做jar包:?
46.<target name="build" depends="compile">?
47.<jar jarfile="${hello_jar}" basedir="${dest}"/>?
48.</target>?
49.運行：?
50.<target name="run" depends="build">?
51.<java classname="test.ant.HelloWorld" classpath="${hello_jar}"/>?
52.</target>?
53.為了不用拷貝，我們可以在最開始定義好目標文件夾，這樣ant直接把結果就放在目標文件夾中了?
54.新建文件夾:?
55.<target name="init">?
56.<mkdir dir="${dest}"/>?
57.</target>?
58.為了更多一點的功能體現，又加入了兩個target?
59.刪除生成的文件?
60.<target name="clean">?
61.<delete dir="${dest}" />?
62.<delete file="${hello_jar}" />?
63.</target>?
64.再次運行，這里顯示了如何在一個target里邊調用其他的target?
65.<target name="rerun" depends="clean,run">?
66.<ant target="clean" />?
67.<ant target="run" />?
68.</target>?
69.好了，解釋完成了，下邊檢驗一下你的ant吧?
70.新建一個src的文件夾，然后把HelloWorld.java按照包目錄放進去?
71.做好build.xml文件?
72.在命令行下鍵入ant ,你會發現一個個任務都完成了。每次更改完代碼只需要再次鍵入ant?
73.有的時候我們可能并不想運行程序，只想執行這些步驟中的某一兩個步驟，例如我只想重新部署而不

想運行，鍵入?
74.ant build?
75.ant中的每一個任務都可以這樣調用ant + target name?
76.好了，這樣一個簡單的ant任務完成了。?
<?xml version="1.0" encoding="UTF-8" ?>
<project name="HelloWorld" default="run" basedir=".">
<property name="src" value="src"/>
<property name="dest" value="classes"/>
<property name="hello_jar" value="hello1.jar"/>
<target name="init">
?? <mkdir dir="${dest}"/>
</target>
<target name="compile" depends="init">
?? <javac srcdir="${src}" destdir="${dest}"/>
</target>
<target name="build" depends="compile">
?? <jar jarfile="${hello_jar}" basedir="${dest}"/>
</target>
<target name="run" depends="build">
?? <java classname="test.ant.HelloWorld" classpath="${hello_jar}"/>
</target>
<target name="clean">
?? <delete dir="${dest}" />
?? <delete file="${hello_jar}" />
</target>
<target name="rerun" depends="clean,run">
?? <ant target="clean" />
?? <ant target="run" />
</target>
</project>
解釋：
<?xml version="1.0" encoding="UTF-8" ?>
build.xml中的第一句話，沒有實際的意義
<project name="HelloWorld" default="run" basedir=".">
</project>
ant的所有內容必須包含在這個里邊，name是你給它取的名字，basedir故名思意就是工作的根目錄 .代

表當前目錄。default代表默認要做的事情。
<property name="src" value="src"/>
類似程序中的變量，為什么這么做想一下變量的作用
<target name="compile" depends="init">
?? <javac srcdir="${src}" destdir="${dest}"/>
</target>
把你想做的每一件事情寫成一個target ，它有一個名字，depends是它所依賴的target，在執行這個

target 例如這里的compile之前ant會先檢查init是否曾經被執行過，如果執行
過則直接直接執行compile，如果沒有則會先執行它依賴的target例如這里的init，然后在執行這個

target
如我們的計劃
編譯：
<target name="compile" depends="init">
<javac srcdir="${src}" destdir="${dest}"/>
</target>
做jar包:
<target name="build" depends="compile">
<jar jarfile="${hello_jar}" basedir="${dest}"/>
</target>
運行：
<target name="run" depends="build">
<java classname="test.ant.HelloWorld" classpath="${hello_jar}"/>
</target>
為了不用拷貝，我們可以在最開始定義好目標文件夾，這樣ant直接把結果就放在目標文件夾中了
新建文件夾:
<target name="init">
<mkdir dir="${dest}"/>
</target>
為了更多一點的功能體現，又加入了兩個target
刪除生成的文件
<target name="clean">
<delete dir="${dest}" />
<delete file="${hello_jar}" />
</target>
再次運行，這里顯示了如何在一個target里邊調用其他的target
<target name="rerun" depends="clean,run">
<ant target="clean" />
<ant target="run" />
</target>
好了，解釋完成了，下邊檢驗一下你的ant吧
新建一個src的文件夾，然后把HelloWorld.java按照包目錄放進去
做好build.xml文件
在命令行下鍵入ant ,你會發現一個個任務都完成了。每次更改完代碼只需要再次鍵入ant
有的時候我們可能并不想運行程序，只想執行這些步驟中的某一兩個步驟，例如我只想重新部署而不想

運行，鍵入
ant build
ant中的每一個任務都可以這樣調用ant + target name
好了，這樣一個簡單的ant任務完成了。
?

一,什么時候使用ant
也許你聽到別人說起ant，一時沖動準備學習一下ant，當你看完了上邊的第一個實例，也許你感覺ant真

好，也許你感覺ant不過如此，得出這些結論都不能說錯，雖然ant很好用，
但并不是在任何情況下都是最好的選擇，例如windows上有更多更簡單，更容易使用的工具，比如

eclipse+myeclipse eclipse+wtp等等，無論是編譯，部署，運行使用起來比ant更
容易，方便但有些情況則是ant發揮的好地方：
1,服務器上部署的時候
當你的程序開發完成，部署人員要部署在服務器上的時候，總不能因為因為安裝一個程序就配置一個

eclipse+myeclipse吧，ant在這個時候是個很好的選擇，因為它小巧，容易配
置，你帶著你寫好的build.xml到任何一臺服務器上，只需要做簡單的修改（一些設定，例如目錄），然

后一兩個命令完成，這難道不是一件美好的事情嗎。
2,linux上，很多時候是這樣的，程序開發是在windows下，但是程序要在linux或者unix上運行，在

linux或者
在unix(特別是unix上)部署是個麻煩的事情，這個時候ant的特點又出來了，因為ant是跨平臺的，你在

build.xml可以在大多數操作系統上使用，基本不需要修改。
3,當服務器維護者不懂編程的時候
很多人都有過這樣的經歷，使用你們程序的人，并不懂得寫程序。你得程序因為版本更新，因為修正bug

需要一次又一次得重新部署。這個時候你會發現教一個人是如此得困難。但
是有ant后，你只需要告訴他，輸入ant xxx等一兩個命令，一切ok.
以上是我遇到得一些情況。
看完以上得情況，好好考慮一下，你是否需要使用ant，如果是繼續。

進一步學習一個稍微復雜一點點的ant
在實際的工作過程中可能會出現以下一些情況，一個項目分成很多個模塊，每個小組或者部門負責一個

模塊，為了測試，他們自己寫了一個build.xml,而你負責把這些模塊組合到
一起使用，寫一個build.xml
這個時候你有兩種選擇：
1,自己重新寫一個build.xml ，這將是一個麻煩的事情
2,盡量利用他們已經寫好的build.xml，減少自己的工作
舉個例子：
假設你下邊有三個小組，每個小組負責一個部分，他們分別有一個src 和一個寫好的build.xml
這個時候你拿到他們的src，你需要做的是建立三個文件夾src1 ,src2, src3分別把他們的src和

build.xml放進去，然后寫一個build.xml

[xhtml] view plaincopyprint?
1.<?xml version="1.0" encoding="UTF-8" ?>?
2.<project name="main" default="build" basedir=".">?
3.<property name="bin" value="${basedir}/bin" />??
4.<property name="src1" value="${basedir}/src1" />??
5.<property name="src2" value="${basedir}/src2" />??
6.<property name="src3" value="${basedir}/src3" />??
7.<target name="init">?
8.?? <mkdir dir="${bin}" />?
9.</target>?
10.<target name="run">?
11.?? <ant dir="${src1}" target="run" />?
12.?? <ant dir="${src2}" target="run" />?
13.?? <ant dir="${src3}" target="run" />?
14.</target>?
15.<target name="clean">?
16.?? <ant dir="${src1}" target="clean" />?
17.?? <ant dir="${src2}" target="clean" />?
18.?? <ant dir="${src3}" target="clean" />?
19.</target>??
20.<target name="build" depends="init,call">?
21.?? <copy todir="${bin}">?
22.??? <fileset dir="${src1}">?
23.???? <include name="*.jar" />?
24.??? </fileset>?
25.??? <fileset dir="${src2}">?
26.???? <include name="*.jar" />?
27.??? </fileset>?
28.??? <fileset dir="${src3}">?
29.???? <include name="*.jar" />?
30.??? </fileset>?
31.?? </copy>?
32.</target>?
33.<target name="rebuild" depends="build,clean">?
34.?? <ant target="clean" />?
35.?? <ant target="build" />?
36.</target>?
37.</project>?
<?xml version="1.0" encoding="UTF-8" ?>
<project name="main" default="build" basedir=".">
<property name="bin" value="${basedir}/bin" />
<property name="src1" value="${basedir}/src1" />
<property name="src2" value="${basedir}/src2" />
<property name="src3" value="${basedir}/src3" />
<target name="init">
?? <mkdir dir="${bin}" />
</target>
<target name="run">
?? <ant dir="${src1}" target="run" />
?? <ant dir="${src2}" target="run" />
?? <ant dir="${src3}" target="run" />
</target>
<target name="clean">
?? <ant dir="${src1}" target="clean" />
?? <ant dir="${src2}" target="clean" />
?? <ant dir="${src3}" target="clean" />
</target>
<target name="build" depends="init,call">
?? <copy todir="${bin}">
??? <fileset dir="${src1}">
???? <include name="*.jar" />
??? </fileset>
??? <fileset dir="${src2}">
???? <include name="*.jar" />
??? </fileset>
??? <fileset dir="${src3}">
???? <include name="*.jar" />
??? </fileset>
?? </copy>
</target>
<target name="rebuild" depends="build,clean">
?? <ant target="clean" />
?? <ant target="build" />
</target>
</project>
?

ok你的任務完成了。

ok,上邊你完成了任務，但是你是否有些感觸呢，在那些build.xml中，大多數是重復的，而且更改一次

目錄需要更改不少東西。是否能讓工作做的更好一點呢，答案是肯定的。
引入兩個東西：
1,propery
2,xml include
這兩個東西都有一個功能，就是能把build.xml中<propery />中的內容分離出來，共同使用
除此之外它們各有特點：
propery的特點是維護簡單，只需要簡單的鍵值對，因為并不是所有人都喜歡xml的格式
xml include的特點是不單可以提取出屬性來，連target也可以。
還是以前的例子：
例如我們想把src1 src2 src3這三個屬性從xml中提出來，可以新建一個文件叫all.properties
里邊的內容
src1=D://study//ant//src1
src2=D://study//ant//src2
src3=D://study//ant//src3
然后你的build.xml文件可以這樣寫，別人只需要更改配置文件，而不許要更改你的build.xml文件了

[xhtml] view plaincopyprint?
1.<?xml version="1.0" encoding="UTF-8" ?>?
2.<project name="main" default="build" basedir=".">?
3.<property file="all.properties" />??
4.<property name="bin" value="${basedir}/bin" />??
5.<target name="init">?
6.?? <mkdir dir="${bin}" />?
7.</target>?
8.<target name="run">?
9.?? <ant dir="${src1}" target="run" />?
10.?? <ant dir="${src2}" target="run" />?
11.?? <ant dir="${src3}" target="run" />?
12.</target>?
13.<target name="clean">?
14.?? <ant dir="${src1}" target="clean" />?
15.?? <ant dir="${src2}" target="clean" />?
16.?? <ant dir="${src3}" target="clean" />?
17.</target>??
18.<target name="build" depends="init,call">?
19.?? <copy todir="${bin}">?
20.??? <fileset dir="${src1}">?
21.???? <include name="*.jar" />?
22.??? </fileset>?
23.??? <fileset dir="${src2}">?
24.???? <include name="*.jar" />?
25.??? </fileset>?
26.??? <fileset dir="${src3}">?
27.???? <include name="*.jar" />?
28.??? </fileset>?
29.?? </copy>?
30.</target>?
31.<target name="rebuild" depends="build,clean">?
32.?? <ant target="clean" />?
33.?? <ant target="build" />?
34.</target>?
35.<target name="test">?
36.?? <ant dir="${src1}" target="test" />?
37.?? <ant dir="${src2}" target="test" />?
38.?? <ant dir="${src3}" target="test" />?
39.</target>?
40.</project>?
41.如果你自己看的話你會看到這樣一個target?
42.<target name="test">?
43.<ant dir="${src1}" target="test" />?
44.<ant dir="${src2}" target="test" />?
45.<ant dir="${src3}" target="test" />?
46.</target>?
47.有的時候你想給每個小組的build.xml加入幾個target，一種做法是每個里邊寫，然后在這里調用?
48.但是有一種更好的方法。?
49.你可以寫一個include.xml文件，內容如下?
50.<?xml version="1.0" encoding="UTF-8" ?>?
51.<property name="src" value="src"/>?
52.<property name="dest" value="classes"/>?
53.<target name="test" >?
54.<ant target="run" />?
55.</target>?
56.然后更改你三個小組的build.xml文件,每個里邊加入如下內容?
57.?
58.<!DOCTYPE project [?
59.<!ENTITY share-variable SYSTEM "file:../include.xml">?
60.]>?
61.&share-variable;?
62.變成如下的樣子?
63.這個時候，你只要在include.xml添加propery , 添加target，三個build.xml會同時添加這些

propery和target?
64.而且不會讓三個組的build.xml變得更復雜。?
65.<?xml version="1.0" encoding="UTF-8" ?>?
66.?
67.<!DOCTYPE project [?
68.<!ENTITY share-variable SYSTEM "file:../include.xml">?
69.]>?
70.<project name="HelloWorld" default="run" basedir=".">?
71.?
72.&share-variable;?
73.?
74.?
78.<property name="hello_jar" value="hello1.jar"/>?
79.?
80.<target name="init">?
81.?? <mkdir dir="${dest}"/>?
82.</target>?
83.<target name="compile" depends="init">?
84.?? <javac srcdir="${src}" destdir="${dest}"/>?
85.</target>?
86.<target name="build" depends="compile">?
87.?? <jar jarfile="${hello_jar}" basedir="${dest}"/>?
88.</target>?
89.<target name="run" depends="build">?
90.?? <java classname="test.ant.HelloWorld" classpath="${hello_jar}"/>?
91.</target>?
92.<target name="clean">?
93.?? <delete dir="${dest}" />?
94.?? <delete file="${hello_jar}" />?
95.</target>?
96.<target name="rerun" depends="clean,run">?
97.?? <ant target="clean" />?
98.?? <ant target="run" />?
99.</target>?
100.</project>?
<?xml version="1.0" encoding="UTF-8" ?>
<project name="main" default="build" basedir=".">
<property file="all.properties" />
<property name="bin" value="${basedir}/bin" />
<target name="init">
?? <mkdir dir="${bin}" />
</target>
<target name="run">
?? <ant dir="${src1}" target="run" />
?? <ant dir="${src2}" target="run" />
?? <ant dir="${src3}" target="run" />
</target>
<target name="clean">
?? <ant dir="${src1}" target="clean" />
?? <ant dir="${src2}" target="clean" />
?? <ant dir="${src3}" target="clean" />
</target>
<target name="build" depends="init,call">
?? <copy todir="${bin}">
??? <fileset dir="${src1}">
???? <include name="*.jar" />
??? </fileset>
??? <fileset dir="${src2}">
???? <include name="*.jar" />
??? </fileset>
??? <fileset dir="${src3}">
???? <include name="*.jar" />
??? </fileset>
?? </copy>
</target>
<target name="rebuild" depends="build,clean">
?? <ant target="clean" />
?? <ant target="build" />
</target>
<target name="test">
?? <ant dir="${src1}" target="test" />
?? <ant dir="${src2}" target="test" />
?? <ant dir="${src3}" target="test" />
</target>
</project>
如果你自己看的話你會看到這樣一個target
<target name="test">
<ant dir="${src1}" target="test" />
<ant dir="${src2}" target="test" />
<ant dir="${src3}" target="test" />
</target>
有的時候你想給每個小組的build.xml加入幾個target，一種做法是每個里邊寫，然后在這里調用
但是有一種更好的方法。
你可以寫一個include.xml文件，內容如下
<?xml version="1.0" encoding="UTF-8" ?>
<property name="src" value="src"/>
<property name="dest" value="classes"/>
<target name="test" >
<ant target="run" />
</target>
然后更改你三個小組的build.xml文件,每個里邊加入如下內容

<!DOCTYPE project [
<!ENTITY share-variable SYSTEM "file:../include.xml">
]>
&share-variable;
變成如下的樣子
這個時候，你只要在include.xml添加propery , 添加target，三個build.xml會同時添加這些propery和

target
而且不會讓三個組的build.xml變得更復雜。
<?xml version="1.0" encoding="UTF-8" ?>

<!DOCTYPE project [
<!ENTITY share-variable SYSTEM "file:../include.xml">
]>
<project name="HelloWorld" default="run" basedir=".">

&share-variable;


<property name="hello_jar" value="hello1.jar"/>

<target name="init">
?? <mkdir dir="${dest}"/>
</target>
<target name="compile" depends="init">
?? <javac srcdir="${src}" destdir="${dest}"/>
</target>
<target name="build" depends="compile">
?? <jar jarfile="${hello_jar}" basedir="${dest}"/>
</target>
<target name="run" depends="build">
?? <java classname="test.ant.HelloWorld" classpath="${hello_jar}"/>
</target>
<target name="clean">
?? <delete dir="${dest}" />
?? <delete file="${hello_jar}" />
</target>
<target name="rerun" depends="clean,run">
?? <ant target="clean" />
?? <ant target="run" />
</target>
</project>
?

掌握了上邊的那些內容之后，你就知道如何去寫一個好的ant，但是你會發現當你真的想去做的時候，你

不能馬上作出好的build.xml，因為你知道太少的ant的默認提供的命令.這
個時候如果你想完成任務，并提高自己，有很多辦法：
1,很多開源的程序都帶有build.xml，看看它們如何寫的
2,ant的document，里邊詳細列寫了ant的各種默認命令，及其豐富
3,google，永遠不要忘記它
ok,在這之后隨著你寫的ant build越來越多，你知道的命令就越多，ant在你的手里也就越來越強大了。
這個是一個慢慢積累的過程。

ant的例子很好找，各種開源框架都會帶有一個build.xml仔細看看，會有很大收獲
另外一個經常會用到的，但是在開源框架的build.xml一般沒有的是cvs
如果使用的是遠程的cvs，可以這樣使用

[xhtml] view plaincopyprint?
1.<xml version="1.0" encoding="utf-8"?>?
2.<project>?
3.????? <property name="cvsroot" value=":pserver:wang:@192.168.1.2:/cvsroot"/>?
4.????? <property name="basedir" value="/tmp/testant/"/>?
5.????? <property name="cvs.password" value="wang"/>?
6.????? <property name="cvs.passfile" value="${basedir}/ant.cvspass"/>?
7.????? <target name="initpass">?
8.????????????? <cvspass cvsroot="${cvsroot}" password="${cvs.password}"

passfile="${cvs.passfile}"/>?
9.????? </target>?
10.????? <target name="checkout" depends="initpass">?
11.????????????? <cvs cvsroot="${cvsroot}" command="checkout" cvsrsh="ssh"

package="myproject" dest="${basedir}"??
12.?????????????? passfile="${cvs.passfile}"/>?
13.?????? </target>?
14.</project>?
<xml version="1.0" encoding="utf-8"?>
<project>
????? <property name="cvsroot" value=":pserver:wang:@192.168.1.2:/cvsroot"/>
????? <property name="basedir" value="/tmp/testant/"/>
????? <property name="cvs.password" value="wang"/>
????? <property name="cvs.passfile" value="${basedir}/ant.cvspass"/>
????? <target name="initpass">
????????????? <cvspass cvsroot="${cvsroot}" password="${cvs.password}"

passfile="${cvs.passfile}"/>
????? </target>
????? <target name="checkout" depends="initpass">
????????????? <cvs cvsroot="${cvsroot}" command="checkout" cvsrsh="ssh" package="myproject"

dest="${basedir}"
?????????????? passfile="${cvs.passfile}"/>
?????? </target>
</project>
?

在eclipse里邊先天支持ant，所以你可以在eclipse里邊直接寫build.xml
因為eclipse提供了提示功能，自動補充功能，它能讓你事半功倍。
使用方法，只需要建立一個工程，然后建立一個叫build.xml的文件。然后就可以在里邊寫你的ant

build了
但是時刻記住http://www.apache.org/永遠能找到你需要的東西

========

在Java中使用ANT,簡單例子

http://yunqiang-zhang-hotmail-com.iteye.com/blog/1607981

? ANT這個工具相信很多人都用過，在Java的代碼編譯打包這方面采用ANT來自動處理是非常方便的，關

于ANT本身的介紹和使用，大家可以在網上找一下，有很多說明，這里不再重復。
重點來講一下如何直接在Java代碼中調用ANT，這樣的好處是我們可以將ANT的各個功能同我們自己的軟

件緊密的結合在一起，不需要單獨配置ANT，直接在Java代碼中調用，非常方便。

1：基本環境，建議用Eclipse這個工具來做為Java的基本開發工具，用Eclipse的向導新建一個Java工程

test。

2：將ANT的以下幾個jar文件添加到剛才新建的test工程的構建引用路徑下面，即添加到classpath中去

：ant-lanucher.jar、ant.jar、ant-jakarta-log4j.jar這三個jar文件是最基本的，必須添加進去，如

果要用到ANT的一些其它類，需要添加相應的jar文件，具體可以參考ANT的幫助文件。這三個文件簡單說

明一下，ant-lanucher.jar里面的類是ANT程序啟動時必須要用到的，在Java代碼中調ANT時，是需要通

過這個包中的類來啟動ANT里面的類去執行定義的動作，這個包是啟動入口類; ant.jar這個包里面是ant

定義的一些核心功能類的class，如copy文件，刪除文件，執行數據庫腳本，打包等等，即是具體的核心

功能實現類，如果是一些附加的ant功能，則在其它jar包里面，這個只有非常核心的類在里面; ant-

jakarta-log4j.jar是ant重新包裝了log4j的類，實現ANT自己格式的log4j的日志文件記錄。

3：在test工程里面新建一個類，類里面增加一個Java的main方法，在main方法中添加如下代碼，并導入

相關的package：
PrintStream logstream = null; //這里是定義一個ANT執行時日志文件的輸出流對象
Project pj=new Project(); //初始化一個ant的Project對象
pl.setName("ant_project"); //設置project的名稱，具體的值可以隨意改成其它字符串都可以
pj.init(); //ANT自己的方法初始化Project對象

DefaultLogger cl=new DefaultLogger();
//定義一個默認的日志流，默認的日志流是采用log4j來記錄的，所以在前面要求將ant-jakarta-

log4j.jar這個文件加到classpath中去。
logstream=new PrintStream(new FileOutputStream("C:/test.log"),true);
//下面兩行是設置ANT執行過程中要輸出的一些信息流，必須設置，否則后面將得不到具體的日志消息
cl.setErrorPrintStream(logstream);
cl.setOutputPrintStream(logstream);
//設置ANT記錄日志的消息級別，MSG_VERBOSE是表示記錄詳細的日志消息
cl.setMessageOutputLevel(Project.MSG_VERBOSE);
//將前面定義好的消息記錄器綁定到Project上
pj.addBuildListenter(cl);

//生成一個Target對象，為后面添加具體的Task做準備
Target tg=new Target();
tg.setProject(pj); //設置target的Project歸屬，必須設置，Target必須屬于某一個Project
tg.setName("target1"); //設置Target的名稱
pj.addTarget(tg); //將Target添加到Project中

Copy cp=new Copy(); //具體生成一個功能Task類對象，復制文件的對象
cp.setTodir(new File("C:/bbb")); //設置要將文件復制的目的地
FileSet set=new FileSet(); //定義目錄集，這樣在后面可以自己定義一些規則
set.setDir(new File("C:/aaa")); //定義目錄集關聯的實際目錄路徑
set.createInclude().setName("**/*.txt"); //設置這個目錄集包括的規則，即這個目錄下面所有

的.txt后綴的文件
cp.addFileset(set); //將目錄集綁定到具體的對象中
cp.setOverwrite(true);//設置在復制文件時，如果目標文件己經存在，將采用直接覆蓋的方式
cp.setFailOnError(true); //設置在復制文件過程中有文件復制失敗時，則中斷執行這個過程
cp.setPreserveLastModified(true); //設置復制文件時保留文件的最后修改時間
cp.setProject(pj); //設置Task的Project歸屬
cp.setTaskName("cp"); //設置Task的名稱
tg.addTask(cp); //將Task添加到Target中，Task不能單獨存在，也不能直接添加到Project中

Throwable ta=null;
try {
pj.executeTarget(tg.getName()); //開始執行Project中指定的Target
}catch (Exception e){
ta=e;
} finally {
/*??? 在日志文件當中生成執行成功或失敗的消息，調用這個方法后，如果ANT的Project執行成功，則

會在日志文件當中生成一行“BUILD SUCCESSFUL”或"BUILD FAILED"這樣的字符串，在執行失敗時，同

時會將異常消息打印在日志文件中，所以這個方法比較重要?? */
pj.fireBuildFinished(ta);
logstream.close();
}

程序的主體內容就是這樣的，大家可以自己去測試一下，有問題時盡量多看看ANT的幫助手冊，其它ANT

的幫助手冊真的是很完整的，基本上我們需要的東西在里面都是可以找到的。

ANT本身己有的核心功能基本上能滿足我們大部分的功能需求，有些時候可能需要我們去繼承它的類，然

后根據自己的業務邏輯增加相應的處理過程和方法，這里也不做說明，建議還是多看一下幫助手冊，這

里只是講一下如果在Java代碼中直接調用ANT。

xml例子：
<?xml version="1.0" encoding="UTF-8"?>
<project name="lee_ant_test1" default="run" basedir=".">
<property name="src" value="."/>
<property name="dest" value="classes"/>
<property name="ant_test1_jar" value="ant_test.jar"/>
<target name="init">
<mkdir dir="${dest}" />
</target>

</project>

========

Ant執行Java代碼

http://www.yiibai.com/ant/ant_executing_java_code.html

您可以使用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" failοnerrοr="yes" classname="NotifyAdministrator">
????? <arg line=">
??? </java>
? </target>
</project>當執行構建時，它會產生以下結果：

C:>ant
Buildfile: C:uild.xml

notify:
???? [java] Administrator

admin@test.com has been notified

BUILD SUCCESSFUL
Total time: 1 second在這個例子中，java代碼做一個簡單的事情 - 發送電子郵件。我們也可以使用內

置的Ant任務來做到這一點。不過，現在你已經得到了你的想法可以擴展你的構建文件來調用java代碼執

行復雜的東西，例如：加密你的源代碼。

========

Ant 教程目錄

http://www.yiibai.com/ant/ant_introduction.html
Ant 教程目錄

ANT
ANT簡介
ANT環境安裝設置
Ant構建文件
Ant屬性任務
Ant屬性文件
Ant數據類型
Ant構建項目
Ant構建文檔
Ant創建JAR文件
Ant創建WAR文件
Ant打包應用
Ant部署應用程序
Ant執行Java代碼
Ant和Eclipse集成
Ant Junit集成

總結

以上是生活随笔為你收集整理的Java Ant 学习总结的全部內容，希望文章能夠幫你解決所遇到的問題。

如果覺得生活随笔網站內容還不錯，歡迎將生活随笔推薦給好友。

JAVA
ant

上一篇： Spring MVC漏洞学习总结
下一篇： TC 2.0 学习总结