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 地址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，然后我们来详细的解释每一句
<?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 了
但是时刻记住http://www.apache.org/永远能找到你需要的东西

==================================================================================
Ant的一些核心概念：

XML:构建文件是以XML文件来描述的，采用XML格式有很多好处。这里就不一一列举。

陈述式语法：构建文件短小精悍，且易于理解。

每个构建文件包含一个工程(project)。

每个工程包含若干个目标(target)。

目标可以依赖于其他的目标(depends)。

目标包含任务(task)。

易于使用Java语言增加新的任务---易于扩展（自定义）。

 

Ant的结构如下图所示：

======================================================================================

一、ant关键元素

1. project元素

    project 元素是 Ant 构件文件的根元素， Ant 构件文件至少应该包含一个 project 元素，否则会发生错误。在每个 project 元素下，可包含多个 target 元素。接下来向读者展示一下 project 元素的各属性。

1) name 属性

    用于指定 project 元素的名称。

2) default 属性

    用于指定 project 默认执行时所执行的 target 的名称。

3) basedir 属性

    用于指定基路径的位置。该属性没有指定时，使用 Ant 的构件文件的附目录作为基准目录。

<?xml version="1.0" ?><project name ="antPro" default ="getBaseDir" basedir ="C:/ThinkInJavaCode">        <target  name="getBaseDir">               <echo message="The base dir is: ${basedir}"/>        </target></project>

    从上例可以看出，在这里定义了default 属性的值为getBaseDir ，即当运行ant 命令时，如果没有指明待执行的target，则将执行默认的target--getBaseDir 。此外，还定义了basedir 属性的值为 "C:/ThinkInJavaCode" ，进入"C:/ThinkInJavaCode" 后运行ant 命令，得一下结果：

Buildfile: C:\ThinkInJavaCode\build.xmlsayBaseDir:     [echo] The base dir is: C:\ThinkInJavaCodeBUILD SUCCESSFULTotal time: 0 seconds

2. target 元素

   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 功能的简短描述和说明。

    举例说明如下：

<?xml version="1.0" ?> <project name ="targetPro" default="targetB"> <target name="targetA" if ="ant.java.version">         <echo message ="Java Version: ${ant.java.version}"/>     </target>     <target name="targetB"  depends ="targetA" unless ="philander">         <description>             a depend example!         </description>         <echo message ="The base dir is: ${basedir}"/>     </target> </project>

    从以下结果后可以看到，我们运行的是名为 targetB 的target ，由于它依赖于targetA ，所以 targetA 将首先被执行，同时因为系统配置了JDK，所以 ant.java.version 属性存在，执行了targetA，输出信息："[echo] Java Version: 1.6 "，targetA 执行完毕后，接着执行 targetB ，因为philander不存在，而unless属性是在不存在时进入所在target 的，由此可知 targetB 得以执行，输出信息："[echo] The base dir is: C:\ThinkInJavaCode"。

Buildfile: C:\ThinkInJavaCode\build.xmltargetA:     [echo] Java Version: 1.6targetB:     [echo] The base dir is: C:\ThinkInJavaCodeBUILD SUCCESSFULTotal time: 0 seconds

3. property 元素

    property元素可看作参量或者参数的定义，project 的属性可以通过 property 元素来设定，也可在 Ant 之外设定。若要在外部引入某文件，例如 build.properties 文件，可以通过如下内容将其引入：

<property file=” build.properties”/>

property 元素可用作 task 的属性值。在 task 中是通过将属性名放在“ ${ ”和“ } ”之间，并放在 task 属性值的位置来实现的。

    Ant 提供了一些内置的属性，它能得到的系统属性的列表与 Java 文档中 System.getPropertis() 方法得到的属性一致，这些系统属性可参考 sun 网站的说明。同时， Ant 还提供了一些它自己的内置属性，如下：

    basedir:project 基目录的绝对路径；   

    ant.file:buildfile的绝对路径，上例中ant.file值为C:\ThinkInJavaCode\build.xml；

    ant.version:Ant 的版本信息，本文为1.8.1 ；

    ant.project.name:当前指定的project的名字，即前文说到的project的name属性值； 

    ant.java.version:Ant 检测到的JDK版本，本文为 1.6 。

    举例说明如下：

<? xml version="1.0" ?><project  name ="propertyPro"  default ="example">    <property  name ="name"  value ="philander"/>    <property  name ="age"  value ="25"/>    <target  name ="example">         <echo  message ="name: ${name}, age: ${age}"/>    </target></project>

    上例中用户设置了名为name 和age的两个属性，这两个属性设置后，在下文中可以通过 ${name} 和 ${age} 分别取得这两个属性值。

二、ANT常用命令

1. copy 命令

    copy主要用来对文件和目录的复制功能。举例如下：

eg1. 复制单个文件：

<copy file="original.txt" tofile="copied.txt"/>

eg2. 对文件目录进行复制：

<copy todir="../dest_dir">      <fileset dir="src_dir"/> </copy>

eg3. 将文件复制到另外的目录：

<copy file="source.txt" todir="../home/philander"/>

2. delete 命令

    对文件或目录进行删除，举例如下：

eg1. 删除某个文件：

<delete file="/home/photos/philander.jpg"/>

eg2. 删除某个目录：

<delete dir="/home/photos"/>

eg3. 删除所有的备份目录或空目录：

<delete includeEmptyDirs="true">       <fileset dir="." includes="**/*.bak"/></delete>

3. mkdir 命令

    创建目录。 eg ：

<mkdir dir="/home/philander/build/classes"/>

4. move 命令

    移动文件或目录，举例如下：

eg1. 移动单个文件：

<move file="sourcefile" tofile=”destfile”/>

eg2. 移动单个文件到另一个目录：

<move file="sourcefile" todir=”movedir”/>

eg3. 移动某个目录到另一个目录：

<move todir="newdir"> <fileset dir="olddir"/></move>

5. echo 命令

    该任务的作用是根据日志或监控器的级别输出信息。它包括 message 、 file 、 append 和 level 四个属性，举例如下

<echo message="Hello,ANT" file="/home/philander/logs/ant.log" append="true">

三、利用ant 构建和部署Java项目

    Ant 可以代替使用 javac 、 java 和 jar 等命令来执行 java 操作，从而达到轻松的构建和部署 Java 项目的目的。

1. 利用ant 的javac命令来编译Java程序

    Ant 的javac命令用于实现编译Java 程序的功能。下面来看一个简单的例子：首先我们建立名为 JavaTestPro的Java项目，建立src目录为源代码目录，在src目录下建立HelloWorld.java这个类文件。该类文件的内容如下：

public class HelloWorld {     public static void main(String[] args) {System.out.println("hello world!");     }}

    同时在JavaTestPro项目的根目录下建立build.xml 文件，在该文件中编译sr 目录下的Java文件，并将编译后的class文件放入build/classes 目录中，整个项目的目录结构如下：

|JavaTestPro

      |src

      |build

            |classes

      |build.xml

     在编译前，需清除classes 目录，该文件的内容如下：

<?xml version="1.0" ?><project name ="javacTest" default="compile" basedir=".">    <target name="clean">        <delete dir="${basedir}/build"/>    </target>    <target name="compile"  depends ="clean">        <mkdir dir ="${basedir}/build/classes"/>        <javac srcdir ="${basedir}/src" destdir ="${basedir}/build/classes"/>    </target></project>

    在项目根目录(C:\ThinkInJavaCode\JavaTestPro)执行ant命令后，可在该目录下发现新生成的build/classes子目录，编译后生成的HelloWorld.class文件就在该目录下。

2. 使用java命令执行Java程序

    Ant 中可以使用 java命令实现运行Java程序的功能。可以在上面的build.xml基础上做修改来实现：

<?xml version="1.0" ?><project name ="javacTest" default="run" basedir=".">    <target name="clean">        <delete dir="${basedir}/build"/>    </target>    <target name="compile"  depends ="clean">        <mkdir dir ="${basedir}/build/classes"/>        <javac srcdir ="${basedir}/src" destdir ="${basedir}/build/classes"/>    </target>     <target name="run"  depends ="compile">        <java classname ="HelloWorld">            <classpath>               <pathelement path="${basedir}/build/classes"/>            </classpath>        </java>    </target></project>

接着，就可以在控制台看见输出："[java] hello world!"

3. 使用jar命令生成jar文件

    还可以在上例的基础上更进一步，来生成jar包，可在run 这个 target 下再加上如下 target ：

<?xml version="1.0" ?><project name ="javacTest" default="jar" basedir=".">    <target name="clean">        <delete dir="${basedir}/build"/>    </target>    <target name="compile"  depends ="clean">        <mkdir dir ="${basedir}/build/classes"/>        <javac srcdir ="${basedir}/src" destdir ="${basedir}/build/classes"/>    </target>    <target name="run"  depends="compile">          <java classname ="HelloWorld"><classpath>                   <pathelement path="${basedir}/build/classes"/>                 </classpath>           </java>    </target>    <target name="jar" depends="run">           <jar destfile="helloworld.jar" basedir="${basedir}/build/classes">                <manifest>    <attribute name="Main-class" value="HelloWorld"/>                </manifest>            </jar>    </target ></project>

    其中，project的default 属性设置为应设为jar，ant运行完毕后，可看到在项目的根目录下生成了一个 helloworld.jar的jar包 。可通过运行以下命令来执行该jar包：

java -jar helloworld.jar

4. 使用war命令打包JavaEE项目

    建立一个JavaEE项目，其中src 为Java源代码目录，WebContent为各jsp存放目录，lib 为项目引用的的包的目录。在WebTest项目目录下建立了build.xml 文件，该文件为该工程的 Ant 构件文件。

|WebContent

    |src

    |build

        |classes

    |WebContent

        |META-INF

            |MANIFEST.MF

        |WEB-INF

            |lib

            |classes

        |HelloJSP.jsp

    |build.xml

    读者可以 src 目录下放入在前续例子中开发的 HelloWorld.java 文件，并在 WebContent下建立 HelloJSP.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=UTF-8"><title>war test for ant</title></head><body>      Hello JSP!Hello Ant!</body></html>

    接下来编写 build.xml 文件，其内容如下:

<?xml version="1.0" encoding="UTF-8" ?><project name ="WebTest" default ="war" basedir =".">    <property  name ="classes" value ="${basedir}/build/classes"/>    <property  name ="build" value ="${basedir}/build"/>    <property  name ="lib" value ="${basedir}/WebContent/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 ="${basedir}/src"  destdir ="${classes}"/>     </target>     <!--  打war 包-->     <target name ="war" depends ="compile">            <war destfile ="${build}/WebTest.war"  webxml ="${basedir}/WebContent/WEB-INF/web.xml">            <!--  拷贝WebRoot 下除了WEB-INF 和META-INF 的两个文件夹-->             <fileset dir ="${basedir}/WebContent"  includes ="**/*.jsp"/>            <!--  拷贝lib 目录下的jar 包-->            <lib dir ="${lib}"/>            <!--  拷贝build/classes 下的class 文件-->            <classes dir ="${classes}"/>        </war>     </target></project>

     在C:\ThinkInJavaCode\WebTest目录下运行ant后，就生成了WebTest.war 文件了，然后可以将其放入Web容器(如Tomcat)的相应目录下(${Tomcata安装目录}\webapps)运行该web项目了。

=====================eclipse项目搭建====================================================================================

创建以下目录结构：

650) this.width=650;" align=center vspace=1 border=1 isImg="false" http: blog.51cto.com viewpic.php?refimg=" + this.src='http://www.yesky.com/image20010518/208897.jpg';">

　　新建一个build.xml，放在工程根目录下。build.xml定义了Ant要执行的批处理命令。虽然Ant也可以使用其它文件名，但是遵循标准能更使开发更规范，同时易于与别人交流。

　　通常，src存放Java源文件，classes存放编译后的class文件，lib存放编译和运行用到的所有jar文件，web存放JSP等web文件，dist存放打包后的jar文件，doc存放API文档。

　　然后在根目录下创建build.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.5">

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

　　以上xml依次定义了init（初始化），compile（编译），test（测试），doc（生成文档），pack（打包）任务，可以作为模板。

　　选中Hello工程，然后选择“Project”，“Properties”，“Builders”，“New…”，选择“Ant Build”：

650) this.width=650;" align=center vspace=1 border=1 isImg="false" http: blog.51cto.com viewpic.php?refimg=" + this.src='http://www.yesky.com/image20010518/208898.jpg';">

　　填入Name：Ant_Builder；Buildfile：build.xml；Base Directory：${workspace_loc:/Hello}（按“Browse Workspace”选择工程根目录），由于用到了junit.jar包，搜索Eclipse目录，找到junit.jar，把它复制到Hello/lib目录下，并添加到Ant的Classpath中：

650) this.width=650;" align=center vspace=1 border=1 isImg="false" http: blog.51cto.com viewpic.php?refimg=" + this.src='http://www.yesky.com/image20010518/208899.jpg';">

　　然后在Builder面板中钩上Ant_Build，去掉Java Builder：

650) this.width=650;" align=center vspace=1 border=1 isImg="false" http: blog.51cto.com viewpic.php?refimg=" + this.src='http://www.yesky.com/image20010518/208900.jpg';">

　　再次编译，即可在控制台看到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 standard tags: @todo. To avoid potential overrides, use at least one period character (.) 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解压目录＞，Path=…;%ANT_HOME%\bin，在命令行提示符下切换到Hello目录，简单地键入ant即可。

=========================================================================================================================

下面这个要顶。。感谢他的分享

使用ant部署eclipse开发的web工程到tomcat

博客分类：
• Java EE

TomcatEclipseWebAntMyeclipse

由于myeclipse体积的不断膨胀，搞的现在的开发很痛苦，一直在等它"活"过来，就算不计较效率了，人也忍受不了。所以觉得使用eclipse，毕竟它比myeclipse轻巧的多。但是eclipse开发的web工程要部署到tomcat服务器上好像不可以(我指的是像myeclipse那样将工程拷贝到tomcat的目录下)，至少到目前为止，我个人没发现使用eclipse本身能把web工程部署到tomcat服务器上。恕小弟愚见，如果哪位大侠知道eclipse有这样的功能还请赐教。而且eclipse自己配置的服务器个人感觉也不是很爽，居然建立了一个Servers目录！为了解决以上所提到的问题。我想到了Ant，使用Ant工具应该是可以完成这样的需求的。Ant以前也没写过，边学边写，基本上是搞定了以上的问题。特与各位大侠分享：

首先，我们说web工程的部署实际上是将WebConten(myeclipse是WebRoot)目录下的所以东东拷贝到tomcat服务器上，奔于这样的想法，所以就用ant的copy命令复制就是，看代码：

Xml代码

1. <!--部署web工程-->  
2.  <target name="copyPro" depends="clean">  
3.     <!--在tomcat下建立工程的目录-->  
4.     <mkdir dir="${apps.dir}"/>  
5.     <!--copy应用的目录到tomcat的webapps下-->  
6.     <copy todir="${apps.dir}" >  
7.      <fileset dir="${srcDic.dir}"></fileset>  
8.     </copy>  
9.   <!--copy已编译的class文件到WEB-INF目录下-->  
10.   <copy todir="${apps.dir}\WEB-INF" >  
11.    <fileset dir="${basedir}\build"></fileset>  
12.   </copy>  
13.    </target>  

<!--部署web工程--> <target name="copyPro" depends="clean">    <!--在tomcat下建立工程的目录-->    <mkdir dir="${apps.dir}"/>    <!--copy应用的目录到tomcat的webapps下-->    <copy todir="${apps.dir}" >     <fileset dir="${srcDic.dir}"></fileset>    </copy>  <!--copy已编译的class文件到WEB-INF目录下-->  <copy todir="${apps.dir}\WEB-INF" >   <fileset dir="${basedir}\build"></fileset>  </copy>   </target>

以上是之前写的代码，2011-11-21新的如下：以供参考

Xml代码

1. <?xml version="1.0" encoding="UTF-8"?>  
2. <project name="familymanager" basedir="." default="deploy">  
3. <property name="dir.src" location="${basedir}\src" />  
4. <property name="jdk.dir" location="C:\Java\jdk1.6.0_16"/>  
5. <property name="srcDic.dir" value="${basedir}\WebRoot"/>  
6. <property name="dir.lib" location="${basedir}\WebRoot\WEB-INF\lib" />  
7. <property name="dir.classes" location="${srcDic.dir}\WEB-INF\classes"></property>      
8. <property name="server.dir" value="D:\apache-tomcat-6.0.20"></property>    
9. <property name="apps.dir" value="${server.dir}\webapps\${ant.project.name}"></property>    
10.     <!--清理工程目录-->  
11.     <target name="cleanwebserver" description="清理服务器端工程">  
12.         <delete dir="${apps.dir}"></delete>  
13.     </target>  
14.     <target name="clean" description="清理编译的class文件">     
15.         <echo message="---->clean class files ...."></echo>  
16.         <delete dir="${dir.classes}"></delete>  
17.     </target>  
18.        
19.     <target name="compile" depends="clean" description="编译Java代码">  
20.         <echo message="---->compile java files...."></echo>  
21.           <mkdir dir="${dir.classes}"/>  
22.             <javac debug="on" includes="**/*.java" destdir="${dir.classes}" executable="${jdk.dir}/bin/javac.exe" compiler="javac1.6" source="1.6" target="1.6" fork="yes" encoding="utf-8" listfiles="yes" memoryInitialSize="128m" memoryMaximumSize="256m">  
23.                 <src path="${dir.src}">  
24.                 </src>                   
25.                 <classpath>  
26.                     <fileset dir="${dir.lib}" includes="**/*.jar" />  
27.                     <fileset dir="${dir.lib}" includes="**/*.zip" />  
28.                 </classpath>                 
29.             </javac>  
30.     </target>  
31.        
32.     <target name="deploy" depends="compile" description="部署工程">  
33.         <echo message="---->deploy project...."></echo>  
34.             <!--在tomcat下建立工程的目录-->  
35.             <mkdir dir="${apps.dir}"/>  
36.             <!--copy应用的目录到tomcat的webapps下-->  
37.             <copy todir="${apps.dir}" >  
38.                 <fileset dir="${srcDic.dir}"></fileset>  
39.             </copy>  
40.             <copy todir="${apps.dir}\WEB-INF\classes" >  
41.                 <fileset dir="${dir.src}" includes="*.xml"></fileset>  
42.                 <fileset dir="${dir.src}" includes="*.properties"></fileset>  
43.             </copy>  
44.         </target>  
45.     <target name="copy-jsp"  description="复制jsp">  
46.             <echo message="---->copy jsp file...."></echo>  
47.                 <!--在tomcat下建立工程的目录-->  
48.                 <mkdir dir="${apps.dir}"/>  
49.                 <!--copy应用的目录到tomcat的webapps下-->  
50.                 <copy todir="${apps.dir}" >  
51.                     <fileset dir="${srcDic.dir}"></fileset>  
52.                 </copy>  
53.                 <copy todir="${apps.dir}\WEB-INF\classes" >  
54.                     <fileset dir="${dir.src}" includes="*.xml"></fileset>  
55.                     <fileset dir="${dir.src}" includes="*.properties"></fileset>  
56.                 </copy>  
57.             </target>  
58.        
59. </project>  

<?xml version="1.0" encoding="UTF-8"?><project name="familymanager" basedir="." default="deploy"><property name="dir.src" location="${basedir}\src" /><property name="jdk.dir" location="C:\Java\jdk1.6.0_16"/><property name="srcDic.dir" value="${basedir}\WebRoot"/><property name="dir.lib" location="${basedir}\WebRoot\WEB-INF\lib" /><property name="dir.classes" location="${srcDic.dir}\WEB-INF\classes"></property><property name="server.dir" value="D:\apache-tomcat-6.0.20"></property><property name="apps.dir" value="${server.dir}\webapps\${ant.project.name}"></property><!--清理工程目录--> <target name="cleanwebserver" description="清理服务器端工程"> <delete dir="${apps.dir}"></delete> </target><target name="clean" description="清理编译的class文件"><echo message="---->clean class files ...."></echo><delete dir="${dir.classes}"></delete></target>  <target name="compile" depends="clean" description="编译Java代码"><echo message="---->compile java files...."></echo>  <mkdir dir="${dir.classes}"/><javac debug="on" includes="**/*.java" destdir="${dir.classes}" executable="${jdk.dir}/bin/javac.exe" compiler="javac1.6" source="1.6" target="1.6" fork="yes" encoding="utf-8" listfiles="yes" memoryInitialSize="128m" memoryMaximumSize="256m"><src path="${dir.src}"></src><classpath><fileset dir="${dir.lib}" includes="**/*.jar" /><fileset dir="${dir.lib}" includes="**/*.zip" /></classpath></javac></target><target name="deploy" depends="compile" description="部署工程"><echo message="---->deploy project...."></echo>  <!--在tomcat下建立工程的目录-->  <mkdir dir="${apps.dir}"/>  <!--copy应用的目录到tomcat的webapps下-->  <copy todir="${apps.dir}" >  <fileset dir="${srcDic.dir}"></fileset>  </copy><copy todir="${apps.dir}\WEB-INF\classes" ><fileset dir="${dir.src}" includes="*.xml"></fileset><fileset dir="${dir.src}" includes="*.properties"></fileset></copy>  </target><target name="copy-jsp"  description="复制jsp"><echo message="---->copy jsp file...."></echo>  <!--在tomcat下建立工程的目录-->  <mkdir dir="${apps.dir}"/>  <!--copy应用的目录到tomcat的webapps下-->  <copy todir="${apps.dir}" >  <fileset dir="${srcDic.dir}"></fileset>  </copy><copy todir="${apps.dir}\WEB-INF\classes" ><fileset dir="${dir.src}" includes="*.xml"></fileset><fileset dir="${dir.src}" includes="*.properties"></fileset></copy>  </target></project>

 

是不是很简单，到这，eclipse下工程的部署就算完成了。

其次，我们再解决tomcat启动的问题，我们同样可以使用Ant解决，使用Ant启动tomcat和关闭tomcat，看代码：

Xml代码

1. <!--启动tomcat服务器-->  
2. <target name="start tomcat" description="start    tomcat ....">  
3.      <exec executable="${server.dir}/bin/startup.bat" spawn="true" vmlauncher="false">     
4.          <env key="CATALINA_HOME" value="${server.dir}" />     
5.          <arg line="/c start ${server.dir}/bin/startup.bat" />             
6.      </exec>             
7. </target>  
8. <!--关闭tomcat服务器-->  
9. <target name="stop tomcat">     
10.     <java jar="${server.dir}/bin/bootstrap.jar" fork="true">     
11.         <jvmarg value="-Dcatalina.home=${server.dir}"/>     
12.         <arg line="stop"/>     
13.     </java>     
14.     <waitfor maxwait="5" maxwaitunit="second">     
15.           <available file="errors.log"/>     
16.     </waitfor>         
17. </target>   

<!--启动tomcat服务器--><target name="start tomcat" description="start    tomcat ...."> <exec executable="${server.dir}/bin/startup.bat" spawn="true" vmlauncher="false">    <env key="CATALINA_HOME" value="${server.dir}" />       <arg line="/c start ${server.dir}/bin/startup.bat" />     </exec>          </target><!--关闭tomcat服务器--><target name="stop tomcat">  <java jar="${server.dir}/bin/bootstrap.jar" fork="true">  <jvmarg value="-Dcatalina.home=${server.dir}"/>  <arg line="stop"/>  </java>  <waitfor maxwait="5" maxwaitunit="second">        <available file="errors.log"/>  </waitfor>    </target> 

 这样启动的tomcat是最原始的黑窗口显示，如果代码出现问题不便于调试，所以这里推荐一个tomcat的插件，网上很多人推荐的，那就是Sysdeo Tomcat plugin东西，要想去官方网站，还得去google下，百度对国外网站没办法，不过这个东西官方再没更新，321这个版本都好长时间了，幻想着有更方便的应用。下载后将里面的文件整个扔到eclipse的drops目录下启动tomcat即可完成安装。安装完成后进行简单的配置即可，是不是感觉世界又美好了一点点呢。

最后说明一下注意事项：

1.Ant脚本的<project name="XXX" basedir=".">位置的XXX必须保证和工程的名称一致；

2.工程所以用到的jar文件都必须放到lib目录下，因为本脚本局势copyWebContent目录。

3.好像没啥注意的了，哦，对了，注意：我将这个Ant脚本连同那个插件放到附件上，呵呵!