Ant是什麼？

Ant是什麼？
Ant是一種基於Java和XML的build工具。

2 下載、安裝Ant
安裝Ant
下載.zip文件，解壓縮到c:\ant1.3(後面引用爲%ANT_HOME%)

2.1 在你運行Ant以前須要作一些配置工做。
? 將bin目錄加入PATH環境變量。
? 設定ANT_HOME環境變量，指向你安裝Ant的目錄。在一些OS上，Ant的腳本能夠猜想ANT_HOME（Unix和Windos NT/2000）－但最好不要依賴這一特性。
? 可選地，設定JAVA_HOME環境變量（參考下面的高級小節），該變量應該指向你安裝JDK的目錄。
注意：不要將Ant的ant.jar文件放到JDK/JRE的lib/ext目錄下。Ant是個應用程序，而lib/ext目錄是爲JDK擴展使用的（如JCE，JSSE擴展）。並且經過擴展裝入的類會有安全方面的限制。
2.2 運行Ant

運行Ant很是簡單，當你正確地安裝Ant後，只要輸入ant就能夠了。

n 沒有指定任何參數時，Ant會在當前目錄下查詢build.xml文件。若是找到了就用該文件做爲buildfile。若是你用 -find 選項。Ant就會在上級目錄中尋找buildfile，直至到達文件系統的根。要想讓Ant使用其餘的buildfile，能夠用參數 -buildfile file，這裏file指定了你想使用的buildfile。

n 能夠指定執行一個或多個target。當省略target時，Ant使用標籤<project>的default屬性所指定的target。

命令行選項總結：
ant [options] [target [target2 [target3] ...]]
Options:
-help print this message
-projecthelp print project help information
-version print the version information and exit
-quiet be extra quiet
-verbose be extra verbose
-debug print debugging information
-emacs produce logging information without adornments
-logfile file use given file for log output
-logger classname the class that is to perform logging
-listener classname add an instance of class as a project listener
-buildfile file use specified buildfile
-find file search for buildfile towards the root of the filesystem and use the first one found
-Dproperty=value set property to value
例子
ant
使用當前目錄下的build.xml運行Ant，執行缺省的target。
ant -buildfile test.xml
使用當前目錄下的test.xml運行Ant，執行缺省的target。
ant -buildfile test.xml dist
使用當前目錄下的test.xml運行Ant，執行一個叫作dist的target。
ant -buildfile test.xml -Dbuild=build/classes dist
使用當前目錄下的test.xml運行Ant，執行一個叫作dist的target，並設定build屬性的值爲build/classes。

3 編寫build.xml

Ant的buildfile是用XML寫的。每一個buildfile含有一個project。

buildfile中每一個task元素能夠有一個id屬性，能夠用這個id值引用指定的任務。這個值必須是惟一的。（詳情請參考下面的Task小節）

3.1 Projects

project有下面的屬性：
Attribute Description Required
name 項目名稱. No
default 當沒有指定target時使用的缺省target Yes
basedir 用於計算全部其餘路徑的基路徑。該屬性能夠被basedir property覆蓋。當覆蓋時，該屬性被忽略。若是屬性和basedir property都沒有設定，就使用buildfile文件的父目錄。 No
項目的描述以一個頂級的<description>元素的形式出現（參看description小節）。

一個項目能夠定義一個或多個target。一個target是一系列你想要執行的。執行Ant時，你能夠選擇執行那個target。當沒有給定target時，使用project的default屬性所肯定的target。

3.2 Targets

一個target能夠依賴於其餘的target。例如，你可能會有一個target用於編譯程序，一個target用於生成可執行文件。你在生成可執行文件以前必須先編譯經過，因此生成可執行文件的target依賴於編譯target。Ant會處理這種依賴關係。

然而，應當注意到，Ant的depends屬性只指定了target應該被執行的順序－若是被依賴的target沒法運行，這種depends對於指定了依賴關係的target就沒有影響。

Ant會依照depends屬性中target出現的順序（從左到右）依次執行每一個target。然而，要記住的是隻要某個target依賴於一個target，後者就會被先執行。
<target name="A"/>
<target name="B" depends="A"/>
<target name="C" depends="B"/>
<target name="D" depends="C,B,A"/>
假定咱們要執行target D。從它的依賴屬性來看，你可能認爲先執行C，而後B，最後A被執行。錯了，C依賴於B，B依賴於A，因此先執行A，而後B，而後C，最後D被執行。

一個target只能被執行一次，即時有多個target依賴於它（看上面的例子）。

若是（或若是不）某些屬性被設定，才執行某個target。這樣，容許根據系統的狀態（java version, OS, 命令行屬性定義等等）來更好地控制build的過程。要想讓一個target這樣作，你就應該在target元素中，加入if（或unless）屬性，帶 上target因該有所判斷的屬性。例如：
<target name="build-module-A" if="module-A-present"/>
<target name="build-own-fake-module-A" unless="module-A-present"/>
若是沒有if或unless屬性，target總會被執行。

可選的description屬性可用來提供關於target的一行描述，這些描述可由-projecthelp命令行選項輸出。

將你的tstamp task在一個所謂的初始化target是很好的作法，其餘的target依賴這個初始化target。要確保初始化target是出如今其餘target依賴表中的第一個target。在本手冊中大多數的初始化target的名字是"init"。

target有下面的屬性：
Attribute Description Required
name target的名字 Yes
depends 用逗號分隔的target的名字列表，也就是依賴表。 No
if 執行target所須要設定的屬性名。 No
unless 執行target須要清除設定的屬性名。 No
description 關於target功能的簡短描述。 No

3.3 Tasks

一個task是一段可執行的代碼。

一個task能夠有多個屬性（若是你願意的話，能夠將其稱之爲變量）。屬性只可能包含對property的引用。這些引用會在task執行前被解析。

下面是Task的通常構造形式：
<name attribute1="value1" attribute2="value2" ... />
這裏name是task的名字，attributeN是屬性名，valueN是屬性值。

有一套內置的（built-in）task，以及一些可選task，但你也能夠編寫本身的task。

全部的task都有一個task名字屬性。Ant用屬性值來產生日誌信息。

能夠給task賦一個id屬性：
<taskname id="taskID" ... />
這裏taskname是task的名字，而taskID是這個task的惟一標識符。經過這個標識符，你能夠在腳本中引用相應的task。例如，在腳本中你能夠這樣：
<script ... >
task1.setFoo("bar");
</script>
設定某個task實例的foo屬性。在另外一個task中（用java編寫），你能夠利用下面的語句存取相應的實例。
project.getReference("task1").
注意1：若是task1尚未運行，就不會被生效（例如：不設定屬性），若是你在隨後配置它，你所做的一切都會被覆蓋。

注意2：將來的Ant版本可能不會兼容這裏所提的屬性，由於頗有可能根本沒有task實例，只有proxies。

3.4 Properties

一個project能夠有不少的properties。能夠在buildfile中用property task來設定，或在Ant以外設定。一個property有一個名字和一個值。property可用於task的屬性值。這是經過將屬性名放在"${" 和"}"之間並放在屬性值的位置來實現的。例如若是有一個property builddir的值是"build"，這個property就可用於屬性值：${builddir}/classes。這個值就可被解析爲 build/classes。

內置屬性

若是你使用了<property> task 定義了全部的系統屬性，Ant容許你使用這些屬性。例如，${os.name}對應操做系統的名字。

要想獲得系統屬性的列表可參考the Javadoc of System.getProperties。

除了Java的系統屬性，Ant還定義了一些本身的內置屬性：
basedir project基目錄的絕對路徑 (與<project>的basedir屬性同樣)。
ant.file buildfile的絕對路徑。
ant.version Ant的版本。
ant.project.name 當前執行的project的名字；由<project>的name屬性設定.
ant.java.version Ant檢測到的JVM的版本； 目前的值有"1.1", "1.2", "1.3" and "1.4".
???
例子
<project name="MyProject" default="dist" basedir=".">

<!-- set global properties for this build -->
<property name="src" value="."/>
<property name="build" value="build"/>
<property name="dist" value="dist"/>
???
<target name="init">
<!-- Create the time stamp -->
<tstamp/>
<!-- Create the build directory structure used by compile -->
<mkdir dir="${build}"/>
</target>
?
<target name="compile" depends="init">
<!-- Compile the java code from ${src} into ${build} -->
<javac srcdir="${src}" destdir="${build}"/>
</target>

<target name="dist" depends="compile">
<!-- Create the distribution directory -->
<mkdir dir="${dist}/lib"/>
<!-- Put everything in ${build} into the MyProject-${DSTAMP}.jar file -->
<jar jarfile="${dist}/lib/MyProject-${DSTAMP}.jar" basedir="${build}"/>
</target>

<target name="clean">
<!-- Delete the ${build} and ${dist} directory trees -->
<delete dir="${build}"/>
<delete dir="${dist}"/>
</target>

</project>

3.5 Path-like Structures
你能夠用":"和";"做爲分隔符，指定相似PATH和CLASSPATH的引用。Ant會把分隔符轉換爲當前系統所用的分隔符。

當須要指定相似路徑的值時，可使用嵌套元素。通常的形式是
<classpath>
<pathelement path="${classpath}"/>
<pathelement location="lib/helper.jar"/>
</classpath>
location屬性指定了相對於project基目錄的一個文件和目錄，而path屬性接受逗號或分號分隔的一個位置列表。path屬性通常用做預約義的路徑－－其餘狀況下，應該用多個location屬性。

爲簡潔起見，classpath標籤支持本身的path和location屬性。因此：
<classpath>
<pathelement path="${classpath}"/>
</classpath>
能夠被簡寫做：
<classpath path="${classpath}"/>
也可經過<fileset>元素指定路徑。構成一個fileset的多個文件加入path-like structure的順序是未定的。
<classpath>
<pathelement path="${classpath}"/>
<fileset dir="lib">
<include name="**/*.jar"/>
</fileset>
<pathelement location="classes"/>
</classpath>
上面的例子構造了一個路徑值包括：${classpath}的路徑，跟着lib目錄下的全部jar文件，接着是classes目錄。

若是你想在多個task中使用相同的path-like structure，你能夠用<path>元素定義他們（與target同級），而後經過id屬性引用－－參考Referencs例子。

path-like structure可能包括對另外一個path-like structurede的引用（經過嵌套<path>元素）：
<path id="base.path">
<pathelement path="${classpath}"/>
<fileset dir="lib">
<include name="**/*.jar"/>
</fileset>
<pathelement location="classes"/>
</path>
<path id="tests.path">
<path refid="base.path"/>
<pathelement location="testclasses"/>
</path>
前面所提的關於<classpath>的簡潔寫法對於<path>也是有效的，如：
<path id="tests.path">
? <path refid="base.path"/>
<pathelement location="testclasses"/>
</path>
可寫成：
<path id="base.path" path="${classpath}"/>
命令行變量

有些task可接受參數，並將其傳遞給另外一個進程。爲了能在變量中包含空格字符，可以使用嵌套的arg元素。
Attribute Description Required
value 一個命令行變量；可包含空格字符。 只能用一個
line 空格分隔的命令行變量列表。
file 做爲命令行變量的文件名；會被文件的絕對名替代。
path 一個做爲單個命令行變量的path-like的字符串；或做爲分隔符，Ant會將其轉變爲特定平臺的分隔符。

例子
<arg value="-l -a"/>
是一個含有空格的單個的命令行變量。
<arg line="-l -a"/>
是兩個空格分隔的命令行變量。
<arg path="/dir;/dir2:\dir3"/>
是一個命令行變量，其值在DOS系統上爲\dir;\dir2;\dir3；在Unix系統上爲/dir:/dir2:/dir3 。

References

buildfile元素的id屬性可用來引用這些元素。若是你須要一遍遍的複製相同的XML代碼塊，這一屬性就頗有用－－如屢次使用<classpath>結構。

下面的例子：
<project ... >
<target ... >???
<rmic ...>?????
<classpath>???????
<pathelement location="lib/"/>???????
<pathelement path="${java.class.path}/"/>???????
<pathelement path="${additional.path}"/>?????
</classpath>???
</rmic>?
</target>
<target ... >
<javac ...>
<classpath>
<pathelement location="lib/"/>
<pathelement path="${java.class.path}/"/>
<pathelement path="${additional.path}"/>
</classpath>
</javac>
</target>
</project>
能夠寫成以下形式：
<project ... >
<path id="project.class.path">?
<pathelement location="lib/"/>
<pathelement path="${java.class.path}/"/>??
<pathelement path="${additional.path}"/>
</path>
<target ... >
<rmic ...>
<classpath refid="project.class.path"/>
</rmic>
</target>
<target ... >
<javac ...>
<classpath refid="project.class.path"/>
</javac>
</target>
</project>
全部使用PatternSets, FileSets 或 path-like structures嵌套元素的task也接受這種類型的引用。

4.1 File（Directory）類
4.1.1 Mkdir
n 建立一個目錄，若是他的父目錄不存在，也會被同時建立。
n 例子：
<mkdir dir="build/classes"/>
n 說明： 若是build不存在，也會被同時建立
4.1.2 Copy
n 拷貝一個（組）文件、目錄
n 例子：
1. 拷貝單個的文件：
<copy file="myfile.txt" tofile="mycopy.txt"/>
2. 拷貝單個的文件到指定目錄下
<copy file="myfile.txt" todir="../some/other/dir"/>
3. 拷貝一個目錄到另一個目錄下
? <copy todir="../new/dir">
??? <fileset dir="src_dir"/>
? </copy>
4. 拷貝一批文件到指定目錄下
? <copy todir="../dest/dir">
??? <fileset dir="src_dir">
????? <exclude name="**/*.java"/>
??? </fileset>
? </copy>

? <copy todir="../dest/dir">
??? <fileset dir="src_dir" excludes="**/*.java"/>
? </copy>
5. 拷貝一批文件到指定目錄下，將文件名後增長。Bak後綴
? <copy todir="../backup/dir">
??? <fileset dir="src_dir"/>
??? <mapper type="glob" from="*" to="*.bak"/>
? </copy>
6. 拷貝一組文件到指定目錄下，替換其中的@標籤@內容
? <copy todir="../backup/dir">
??? <fileset dir="src_dir"/>
??? <filterset>
????? <filter token="TITLE" value="Foo Bar"/>
??? </filterset>
? </copy>
4.1.3 Delete
n 刪除一個（組）文件或者目錄
n 例子
1. 刪除一個文件
<delete file="/lib/ant.jar"/>
2. 刪除指定目錄及其子目錄
? <delete dir="lib"/>
3. 刪除指定的一組文件
? <delete>
??? <fileset dir="." includes="**/*.bak"/>
? </delete>
4. 刪除指定目錄及其子目錄，包括他本身
? <delete includeEmptyDirs="true">
??? <fileset dir="build"/>
? </delete>
4.1.4 Move
n 移動或重命名一個（組）文件、目錄
n 例子：
1. 移動或重命名一個文件
<move file="file.orig" tofile="file.moved"/>
2. 移動或重命名一個文件到另外一個文件夾下面
<move file="file.orig" todir="dir/to/move/to"/>
3. 將一個目錄移到另一個目錄下
<move todir="new/dir/to/move/to">
<fileset dir="src/dir"/>
</move>
4. 將一組文件移動到另外的目錄下
<move todir="some/new/dir">
<fileset dir="my/src/dir">
<include name="**/*.jar"/>
<exclude name="**/ant.jar"/>
</fileset>
</move>
5. 移動文件過程當中增長。Bak後綴
<move todir="my/src/dir">
<fileset dir="my/src/dir">
<exclude name="**/*.bak"/>
</fileset>
<mapper type="glob" from="*" to="*.bak"/>
</move>

時間：2007-3-8 10:51:13 | 打開原文

Ant參考教程(一)

ant教程

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 地址 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，而後咱們來詳細的解釋每一句
<?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

<?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文件了

<?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文件,每一個裏邊加入以下內容
<!--include a xml file ,it can be common propery ,can be also a target? -->
<!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" ?>
<!--include a xml file ,it can be common propery ,can be also a target? -->
<!DOCTYPE project [
<!ENTITY share-variable SYSTEM "file:../include.xml">
]>
<project name="HelloWorld" default="run" basedir=".">
?<!--use the include? -->
?&share-variable;
?<!--defined the property-->
?<!--via include
?<property name="src" value="src"/>
?<property name="dest" value="classes"/>
?-->
?<property name="hello_jar" value="hello1.jar"/>
?<!--define the op-->
?<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，能夠這樣使用
<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了

可是時刻記住 www.apache.org 永遠能找到你須要的東西

?

時間：2007-3-8 10:49:58 | 打開原文

快速搭建本身的CVS

相信有過團隊開發經歷的人，都用過這樣或者那樣的版本控制系統。好比，咱們就使用CVS（併發版本系統）來管理源代碼。它的好處，對於用過的人天然不用多說。

而之前對於CVS的使用也僅限於工做的須要，對於本身的文件和源代碼並無涉及使用， 爲此也吃過一些苦頭，好比輕易刪除的一段代碼又要費勁的重寫出來。爲了不悲劇重演，我給本身搭建了一套CVS，而後將本身還在更新的文件和源代碼放入統 一的目錄中打上了CVS的標記。這樣只要天天提交更新不誤，就不會再出現刪除後的抓狂了……

????????? 既然CVS這麼有用，你也來爲本身的資料加道保險吧。

?

CVS服務器咱們選擇開源的CVSNT，能夠從 http://www.cvsnt.org/ 獲得。因爲我的使用的工做環境通常爲Windows，因此咱們主要演示Windows平臺下的安裝配置。對應Windows平臺下載獲得的是一個安裝文件，安裝過程沒有什麼好說的，重啓機器後CVSNT就安裝完畢了。

CVSNT會在你的機器中啓動兩個服務：

?

?

?????? 固然如今的CVSNT還不能使用，你還要給CVSNT指定數據倉庫的位置。在你準備存放版本控制信息 的目錄下，添加做爲數據倉庫的文件夾，好比我在d盤下建立srcBase做爲數據倉庫。在「開始」菜單裏選擇CVSNT的子選項「CVSNT Control Panel」。在彈出的窗口中，選擇「Repository configuration」Tab窗口：

?

?

?????? 點擊Add按鈕，在彈出窗口中，指定好你將做爲數據倉庫的位置，點擊肯定完成操做。這樣就可使用CVSNT服務器了。

?????? 另外在第三個Tab窗口「Server settings」中，能夠設定使用者的身份、訪問端口、temp目錄和加密等屬性。其中temp目錄默認在C盤，你能夠指定到其它的地方。

?????? 對於CVS的更多設置，好比遠程用戶的訪問（這是團隊開發不可少的配置，而本文假設服務器和客戶端存在於一臺機器），能夠參見安裝目錄下的幫助文檔，或者在連接 http://cvsdoc-zh.gro.clinux.org/cvsdoc/zh_CN/html/1_12_13/index.html#toc_Top 中獲得中文手冊。

??????

?????? 如今你就能夠經過命令行的方式來管理你的資料了。可是這樣用起來老是不太方便，還要記住不一樣命令和參數。因此咱們須要CVS客戶端來簡化這個工做。原來我使用的是 wincvs ，這是一個不錯的軟件；可是如今我更喜歡使用 TortoiseCVS 。

Wincvs採用相似於管理器的方式來操做所管理的文件：

?

?

而TortoiseCVS則將全部的操做集成在了右鍵彈出菜單上了，使用起來更加方便，並且圖標醒目易辨別。另外TortoiseCVS提供了很好的中文支持，包括中文的幫助手冊：

?

?

二者安裝的過程都很是簡單，只是使用 WinCVS可能須要安裝Python工做環境。這裏以 TortoiseCVS爲例，簡單的介紹一下客戶端的配置。

選擇你要進行版本控制的文件夾，右鍵選擇「CVS—〉建立新模塊」。在彈出的窗口中，首先會讓你配置CVS服務器，若是是第一次使用，則全部選項都是空的：

?

?

按照圖中的配置方式完成對服務器的配置。其中用戶能夠是任意的系統用戶。點擊肯定之後就能夠輸入密碼完成新模塊的建立。而後你將要管理的文件經過「 CVS添加」功能打上標示，美好的旅程在更新、提交中就開始了……

?

下面簡要的介紹些TortoiseCVS中經常使用的功能：

右鍵「CVS—〉選項」或者「開始」菜單「TortoiseCVS—〉Preferences」，打開「參數選擇」窗口。在裏面能夠設置知足本身要求的軟件設置。

右鍵「CVS更新」，將本地指定的文件更新爲CVS服務器中最新版本。

右鍵「CVS提交」，將本地指定的文件提交到CVS服務器中。

右鍵「CVS添加」，將本地指定的文件最爲初始版本提交到CVS服務器中。

右鍵「CVS」中則集合了各類有用的功能。好比：能夠查看某個文件的歷史和版本分支圖；設置分支等等。

時間：2007-3-7 14:04:51 | 打開原文

Java 5.0的新語言特性

2004 年下半年，Sun公司發佈了開發代號爲「Tiger」的J2SE 5.0，揭開了Java發展的一個重要里程碑。在過去的Java升級中更多的是進行一些庫函數的改進，而此次則直接從語法層面上進行了加強。直接從1.4 跳到5.0（Sun原本是打算用1.5.0這個版本號的），單從版本號的變化上就能夠看出此次升級的力度是如此之大。那麼，到底有些什麼改變呢？下面就請 隨我窺視一二（其中所舉的代碼例子均摘自於《J2SE 5.0 in a Nutshell》）：

?

範型（Generics）

在之前，咱們須要爲不一樣的數據類型分別創建相對應的方法、類或接口，例如一個加法方法add可能須要分別定義int add(int a, int b)，String add(String a, String b)，MyClass add(MyClass a, MyClass b)等多個方法，即使這些方法中的處理邏輯徹底相同（只是數據類型不一樣）也是這樣。

跟C++中的模板（template）同樣，範型使程序員能建立通用的方法、類和接口，這種狀況下他們所操做數據的類型是經過參數指定的。經過 使用範型，使得只建立一個類就能自動工做於不一樣數據類型。所以，範型擴展了程序員複用代碼的能力。另外，範型也增長了類型安全。使用範型之後，咱們再也不需 要顯式的強制轉換（cast），這樣能在編譯時就發現類型不符，避免到運行時出現類型轉換錯誤。

下面是使用範型先後的代碼對比：

使用範型前：

ArrayList list = new ArrayList();

list.add(0, new Integer(42));

int total = ((Integer)list.get(0)).intValue();

使用範型後（下面還有進一步利用自動裝箱/拆箱特性之後更簡潔的代碼）：

ArrayList<Integer> list =? new ArrayList<Integer>();

list.add(0, new Integer(42));

int total = list.get(0).intValue();

順便提到一點，很是遺憾，運算符重載沒有可以跟範型一塊兒被加入進來。若是Java可以支持運算符重載的話，在使用範型的時候感受就更好了（不過，那樣Java就愈來愈像C++了）。

?

元數據（Metadata）

新的元數據工具更可能是爲將來考慮而增長的，它讓你可以在程序中嵌入註解（annotation），這些註解可以被不一樣的編程工具處理。例如，工 具能夠根據註解（annotation）的要求生成Java源代碼，這樣只要程序員指定一種動做，而後就能夠將實際提供代碼的事情留給工具了，從而大大降 低了程序員必須手工輸入的重複代碼的數量。

下面是使用元數據先後的代碼對比：

使用前：

public interface PingIF extends Remote {

????? public void ping() throws RemoteException;

}

public class Ping implements PingIF {

???? public void ping() {

????????? ……

???? }

}

使用後：

public class Ping {

???? public @remote void ping() {

????????? ……

???? }

}

?

自動裝箱（Autoboxing）和自動拆箱（Auto-Unboxing）

從Java誕生以來，簡單數據類型（int，long，float等）和其對應的包裝類型（Integer，Long，Float等）之間一直 不能自動轉換，這爲咱們帶來了不少麻煩。如今Java終於添加了自動裝箱（Autoboxing）和自動拆箱（Auto-unboxing），爲咱們解決 了這個問題。自動裝箱（Autoboxing）特性讓Java自動包裝一個簡單數據類型（例如int）到對應的包裝類型中（例如Integer）中。自動 拆箱（Auto-unboxing）是相反的過程，即將一個包裝類型（例如Integer）自動轉換爲它所對應的簡單數據類型（例如int）。舉例以下：

之前：

ArrayList<Integer> list = new ArrayList<Integer>();

list.add(0, new Integer(42));

int total = (list.get(0)).intValue();

之後（請對照範型部分使用範型前的例子代碼）：

ArrayList<Integer> list = new ArrayList<Integer>();

list.add(0, 42);

int total = list.get(0);

?

枚舉（Enumeration）

不少編程語言中都是有枚舉類型，而在Java誕生的時候， Java的創造者沒有把這個東東包含Java中來，這致使咱們在程序中寫了許多public static final。如今枚舉終於被加入到Java中來了。

本質上，一個枚舉是一個命名常量的列表。枚舉類型經過新的關鍵字enum來支持。下面是定義一個枚舉的例子代碼：

public enum StopLight { red, amber, green };

再順便提到一點，很是遺憾，常量沒有可以跟範型一塊兒被加入進來，這意味着使用public static final的命運尚未終結。

?

加強的for循環

Java 5.0中添加了「for-each」形式的循環。這個加強爲大量集合、數組等的循環處理提供了便利，併爲咱們防止數組越界提供有益的幫助，還避免了原來必需的強制類型轉換（case），讓咱們能在編譯時就發現類型不符，避免到運行時出現類型轉換錯誤。。

下面是在使用新的for循環先後的代碼對比：

使用前：

ArrayList<Integer> list = new ArrayList<Integer>();

for (Iterator i = list.iterator(); i.hasNext();) {

???????? Integer value=(Integer)i.next();

????????????? ……

}

使用後：

ArrayList<Integer> list = new ArrayList<Integer>();

for (Integer i : list) {

?????? ……

}

?

不定參數（Varargs）

在實際開發過程當中，有時候會遇到方法參數不固定的狀況。在過去，爲了解決問題，咱們常常採用將參數包裝到一個數組或者集合中的方式。如今有 Varargs幫助咱們解決這個問題了。Varargs讓一個方法能夠帶有可變數目參數。Varargs的加入使得建立帶有可變數目參數的方法變的更加容 易。下面是使用不定參數的例子：

// 方法定義

void argtest(Object ... args) {

????? for (int i=0;i <args.length; i++) {

????? }

}

// 調用方式

argtest("test", "data");

?

靜態導入（Static Import）

過去使用靜態成員一般咱們須要進行這種形式的調用：YourClassName.staticMember，在每次使用靜態成員的時候咱們都要 把這個靜態成員所屬類的名字寫一遍。如今靜態導入可讓咱們沒必要每次都去寫類的名字了，能夠直接經過靜態成員的名字來訪問它們。下面是使用靜態導入的例 子：

// 靜態導入

import static java.awt.BorderLayout.*;

// 調用靜態成員

getContentPane().add(new JPanel(), CENTER);

?

其它改變

?????? 上面所列的主要是一些Java 5在語言層面的升級，Java 5在基礎類庫、用戶界面、虛擬機、執行效率等其它方面也進行了大量的升級。例如在基礎類庫方面，爲範型的出現更新了集合框架，爲方便多線程開發對線程同步 進行了改進，爲方便輸入輸出增長了新的Formatter和Scanner 類。

對於這些方面我在這裏就再也不列舉了，若是須要你能夠查找相應的文檔進行學習。

時間：2007-3-7 14:04:10 | 打開原文

第三十七天 用Timer在Web工程中實現相似觸發器的機制

用java.util.Timer在Web工程中實現相似觸發器的機制

如今正在作的項目要實現一個定時出賬的觸發器, 開始打算用Spring整合的Quartz工具來實現(同時Spring也提供了對java.util.Timer的支持),

Spring對Quartz整合的方式,是在配置文件中經過bean的property項設置一個cronTrigger表達式來實現精確的時 點觸發,可是因爲Spring只有在啓動的時候對注入值進行讀取,這樣的話就很難實現經過運行時讀取配置參數,達到不用重啓服務便可改變出賬時間的目的, 因此只好本身尋找好一點的解決方案.

在網上找到了一篇文章,看了很受啓發,我略作了一些修改,實現了在每月的某一天的某一個時間進行任務操做的功能.

代碼及註釋以下:

先要實現一個系統的監聽器:

/**
?* <p>Title: </p>
?* <p>Description: </p>
?* <p>Copyright: Copyright (C)Chen Meng 2005</p>
?* <p>Company: 陳盟 </p>
?*
?* @author <a href=" mailto:chen_meng@hotmail.com ">陳盟</a>
?* @version 1.0
?* @since 2005-1-13 / 17:26:41
?*/
?
package com.wellsoon.cttbj.vab.background;

import java.util.Date;

import javax.servlet.ServletContextEvent;
import javax.servlet.ServletContextListener;

public class SettleAccountListener implements ServletContextListener {
???
??? private java.util.Timer timer = null;

???
??? /*
???? * @see javax.servlet.ServletContextListener#contextInitialized(javax.servlet.ServletContextEvent)
???? */
??? public void contextInitialized(ServletContextEvent event) {
??????? Date taskRun = null;
???????
??????? // TODO Auto-generated method stub
??????? taskRun = new Date();
??????? timer = new java.util.Timer(true);
??????? event.getServletContext().log("定時器已啓動");
/在這裏每隔一分鐘輪詢一次出賬任務,若是任務間隔比較大的話建議把這個值設的大一點,但此設置值將間接影響可設定的觸發精度.
??????? timer.schedule(new SettleAccountTask(), 0, 60*1000); /
??????? event.getServletContext().log("已經添加任務調度表");

??? }

??? /*
???? * @see javax.servlet.ServletContextListener#contextDestroyed(javax.servlet.ServletContextEvent)
???? */
??? public void contextDestroyed(ServletContextEvent event) {
??????? // TODO Auto-generated method stub
??????? timer.cancel();
??????? event.getServletContext().log("定時器銷燬");

??? }

}

接着來看SettleAccountTask的實現:

/**
?* <p>Title: </p>
?* <p>Description: </p>
?* <p>Copyright: Copyright (C)Chen Meng 2005</p>
?* <p>Company: 陳盟 </p>
?*
?* @author <a href=" mailto:chen_meng@hotmail.com ">陳盟</a>
?* @version 1.0
?* @since 2005-1-13 / 17:35:55
?*/

package com.wellsoon.cttbj.vab.background;

import java.util.Calendar;
import java.util.Date;
import java.util.TimerTask;

public class SettleAccountTask extends TimerTask {

??? private static boolean isRunning = false;
??? private static long doTaskMillis = 0l;

??? public void run() {
??????? System.out.println(doTaskMillis);
//下面兩個值表明每個月的哪一天幾點進行實際任務操做.能夠經過數據庫查詢得到
??????? int C_SCHEDULE_DATE = 10;
??????? int C_SCHEDULE_HOUR = 4;
??????? Calendar cal = Calendar.getInstance();
//若是任務量很大,在下次輪詢時仍在執行上次輪詢的任務,則跳過本次執行,直接錯過.
??????? if (!isRunning) {
//若是當前系統時間的DAY_OF_MONTH和HOUR_OF_DAY不知足如下條件,則跳過實際操做.
??????????? if (C_SCHEDULE_DATE == cal.get(Calendar.DAY_OF_MONTH) && C_SCHEDULE_HOUR == cal.get(Calendar.HOUR_OF_DAY)) {
//若是上次執行任務的時間距這次輪詢時間間隔過短,則跳過實際操做.
??????????????? if((doTaskMillis + 2*60*60*1000) < cal.getTimeInMillis()) {
//????????????????? 詳細任務
??????????????????? isRunning = true;
??????????????????? System.out.println("執行出賬操做");
??????????????????? doTaskMillis = cal.getTimeInMillis();
??????????????????? System.out.println(doTaskMillis);
??????????????????? isRunning = false;
??????????????? }
??????????? }
??????? } else {
??????????? System.out.println("錯過");
??????? }
??? }
}

最後,在web.xml中加上
?<listener>
? <listener-class>com.xxx.background.SettleAccountListener</listener-class>
?</listener>

就能夠了.

若是有更好的解決方式, 但願您回覆.