Java_Ant詳解（轉載）

時間  2019-11-12
標籤 java ant 詳解 轉載 欄目 Java 简体版
原文   原文鏈接

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

[xhtml] view plain copy print ?
  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任務完成了。  

 

一,何時使用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.xmllinux

[xhtml] view plain copy print ?
  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>  

 

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文件了c++

 

[xhtml] view plain copy print ?
  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. <!--include a xml file ,it can be common propery ,can be also a target   -->  
  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. <!--include a xml file ,it can be common propery ,can be also a target   -->  
  67. <!DOCTYPE project [  
  68. <!ENTITY share-variable SYSTEM "file:../include.xml">  
  69. ]>  
  70. <project name="HelloWorld" default="run" basedir=".">  
  71. <!--use the include   -->  
  72. &share-variable;  
  73. <!--defined the property-->  
  74. <!--via include  
  75. <property name="src" value="src"/>  
  76. <property name="dest" value="classes"/>  
  77. -->  
  78. <property name="hello_jar" value="hello1.jar"/>  
  79. <!--define the op-->  
  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>  

 

掌握了上邊的那些內容以後，你就知道如何去寫一個好的ant，可是你會發現當你真的想去作的時候，你不能立刻做出好的build.xml，由於你知道太少的ant的默認提供的命令.這
個時候若是你想完成任務，並提升本身，有不少辦法：
1,不少開源的程序都帶有build.xml，看看它們如何寫的
2,ant的document，裏邊詳細列寫了ant的各類默認命令，及其豐富
3,google，永遠不要忘記它
ok,在這以後隨着你寫的ant build愈來愈多，你知道的命令就越多，ant在你的手裏也就愈來愈強大了。
這個是一個慢慢積累的過程。

ant的例子很好找，各類開源框架都會帶有一個build.xml仔細看看，會有很大收穫
另一個常常會用到的，可是在開源框架的build.xml通常沒有的是cvs
若是使用的是遠程的cvs，能夠這樣使用apache

 

[xhtml] view plain copy print ?
  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>  

 

在eclipse裏邊先天支持ant，因此你能夠在eclipse裏邊直接寫build.xml
由於eclipse提供了提示功能，自動補充功能，它能讓你事半功倍。
使用方法，只須要創建一個工程，而後創建一個叫build.xml的文件。而後就能夠在裏邊寫你的ant build了
可是時刻記住http://www.apache.org/永遠能找到你須要的東西編程

相關文章
相關標籤/搜索
每日一句
    每一个你不满意的现在，都有一个你没有努力的曾经。
本站公眾號
   歡迎關注本站公眾號,獲取更多信息
聯繫我們 最近搜索 最新文章 沪ICP备13005482号-10 MyBatis教程 SQL 教程 MySQL教程 Java 教程 Thymeleaf 教程 Hibernate教程 Spring教程 Redis教程