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,然后我们来详细的解释每一句

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

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

  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,可以这样使用

  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/永远能找到你需要的东西

ant简述的更多相关文章

  1. Ant + Jenkies +Tomcat 自动构建部署Web项目

    前言:博主资历尚浅,很多东西都还在刚起步学习的阶段,这几天开发任务比较轻,就在自己window系统下,模拟部署远程服务器,利用Jenkies + Ant + Tomcat 搭建了一个自动发布部署的环境 ...

  2. Ant + Tomcat + Jenkins 实现自动化部署

    前言:博主资历尚浅,很多东西都还在刚起步学习的阶段,这几天开发任务比较轻,就在自己window系统下,模拟部署远程服务器,利用Jenkins + Ant + Tomcat 搭建了一个自动发布部署的环境 ...

  3. ant design pro(二)布局

    一.概述 参看地址:https://pro.ant.design/docs/layout-cn 其实在上述地址ant-design上已经有详细介绍,本文知识简述概要. 页面整体布局是一个产品最外层的框 ...

  4. Jenkins+Ant+Jmeter自动化集成测试实例

    通过学习Jmeter自动化测试,接触到了Ant命令和其构建文件build.xml文件的编写,与此同时,通过将测试项目集成在jenkins上,进一步学习了jenkins的一些环境配置知识.以下是自己的初 ...

  5. Day4 - K - Ant Trip HDU - 3018

    Ant Country consist of N towns.There are M roads connecting the towns. Ant Tony,together with his fr ...

  6. Jenkins 安装的HTML Publisher Plugin 插件无法展示ant生成的JunitReport报告

    最近在做基于jenkins ant  junit 的测试持续集成,单独ant junit生成的junitreport报告打开正常,使用Jenkins的HTML Publisher Plugin 插件无 ...

  7. 简述 OAuth 2.0 的运作流程

    本文将以用户使用 github 登录网站留言为例,简述 OAuth 2.0 的运作流程. 假如我有一个网站,你是我网站上的访客,看了文章想留言表示「朕已阅」,留言时发现有这个网站的帐号才能够留言,此时 ...

  8. JavaScript单线程和浏览器事件循环简述

    JavaScript单线程 在上篇博客<Promise的前世今生和妙用技巧>的开篇中,我们曾简述了JavaScript的单线程机制和浏览器的事件模型.应很多网友的回复,在这篇文章中将继续展 ...

  9. React中使用Ant Table组件

    一.Ant Design of React http://ant.design/docs/react/introduce 二.建立webpack工程 webpack+react demo下载 项目的启 ...

随机推荐

  1. [转]Entity Framework4.0 (七) EF4的存储过程

    本文转自:http://www.cnblogs.com/marksun/archive/2011/12/21/2296500.html 前面了解了EF4的CRUD的操作,你会发现EF4使用起来比较简单 ...

  2. Nova相关命令收集

    1. nova list 2. sudo nova-manage service list 8. 创建/删除浮动IP池 nova floating-ip-bulk-create 192.168.0.2 ...

  3. CSS2系列:外边距合并问题(margincollapse)

    外边距合并 w3介绍这个问题地址:https://www.w3.org/TR/CSS2/box.html#collapsing-margins 当两个垂直方向外边距相遇,它们将形成一个折叠外边距. 合 ...

  4. HDU 1114 完全背包+判断能否装满

    题意 给出一个存钱罐里的钱币重量 给出可能的n种钱币重量以及价值 求存钱罐中钱币的最小价值 若不可能另有输出 在裸的完全背包上加了一点东西 即判断这个背包能否被装满 初始化 dp[0]=0 其余的都使 ...

  5. BKDRhash实现

    参考了一些有关于哈希算法的博客,里面都有提到BKDR哈希算法,在博客:各种字符串Hash函数中有对各种hash算法进行测试,测试关于哈希冲突,以及散列的质量,得到的结果可以参考以上博文. BKDRha ...

  6. PHP 设计模式 笔记与总结(5)PHP 魔术方法的使用

    PHP 魔术方法的使用 ① __get/__set:将对象的属性进行接管 当访问一个不存在的对象属性时: index.php <?php define('BASEDIR',__DIR__); / ...

  7. 使用photoshop,把图片背景变成透明

    鄙人使用的是photoshop CS6,win7系统,好了废话不多说,我们开始吧 1.打开photoshop,选择一个要编辑的图片 2.在右下角的图层面板上用鼠标左键快速双击背景图层为图片解锁 3.在 ...

  8. Bootstrap页面布局17 - BS选项卡

    代码结构: <div class='container-fluid'> <h2 class='page-header'>Bootstrap 选项卡</h2> < ...

  9. linux进程查找及杀死

    根据进程名称查找 ps aux|grep python(进程名) 杀死进程: kill -s 9 进程id

  10. js之操作JSON数据

    JSON(JavaScript Object Notation) 是一种轻量级的数据交换格式,采用完全独立于语言的文本格式,是理想的数据交换格式.同时,JSON是 JavaScript 原生格式,这意 ...