zoukankan      html  css  js  c++  java
  • Ant教程

    Ant教程(一)

    本文以最新发布的Ant 1.5.1为例,介绍这款优秀的Build工具的安装配置、基本应用和一些高级话题。最新的Ant下载地址是 http://jakarta.apache.org/ant/

    Ant是一种基于Java的Build工具。理论上来说,它有些类似于C中的make,但比make优越。现在存在的大多数Build工具,如make、gnumake、nmake、jam等都存在这样或那样的不足,比如依赖于特定的平台、配置文件过于复杂或者对格式无法检查而容易出错等。与这些工具相比较,Ant的两个特性决定了它是一款优秀的Build工具:

    1. 基于Java的实现。具有良好的跨平台性,同时可以通过增加新的Java类来扩展Ant的功能,而无需去了解不同平台上不同的脚本语言。

    2.基于XML的配置文件。Ant以XML树来描述Target/Task的关系,文件结构清晰、易读易写,并且利用XML对格式的控制来避免由于配置文件的错误造成的Build操作失败。

    安装与配置

    Ant的安装非常简单,把从网上下载的jakarta-ant-1.5.1-bin.zip解开到一个目录下即可(以下假定安装在目录D:/jakarta-ant-1.5.1)。接下来需要进行环境变量配置:

    SET ANT_HOME=D:/jakarta-ant-1.5.1 //注意是Ant的安装目录,不是bin子目录
    SET PATH=%PATH%;%ANT_HOME%/bin;


    在配置环境变量之前,请确认已经正确设置了JAVA_HOME系统变量。输入ant命令,看到如下输出说明已成功安装了Ant工具:

    Buildfile: build.xml does not exist!
    Build failed


    提示信息表明在当前目录不存在build.xml配置文件,但这本身已经说明Ant成功运行了。

    快速入门

    下面用一个最简单也是最经典的例子-HelloWorld来感受一下Ant吧。

    //HelloWorld.java
    package com.sharetop.antdemo;
    public class HelloWorld {
    public static void main( String args[] ) {
    System.out.println("Hello world. ");
    }
    }


    要让Ant编译这个文件,首先需要编写一个Build配置文件。在一般情况下,这个文件被命名为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="hello.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="com.sharetop.antdemo.HelloWorld" classpath="${hello_jar}"/>
    </target>
    </project>


    来看一下这个文件的内容,它描述了以下信息:工程的名字为HelloWorld,工程有四个target,分别是init、compil、build和run,缺省是run。compile只有一个任务javac,源文件位于src目录下,输出的类文件要放在classes目录下。build的任务是jar,生成的jar文件为hello.jar,它打包时以classes为根目录。而run则是执行这个HelloWorld类,用hello.jar作为classpath。这四个target之间有一个依赖关系,这种关系用depends来指定。即如果Target A依赖于Target B,那么在执行Target A之前会首先执行Target B。所以从下面运行缺省Target(run)的输出看,这四个Target的执行顺序是:init→compile→build→run。文件目录结构如图1所示。HelloWorld.java文件在src/com/sharetop/antdemo子目录下。


    图1 ant_demo应用的目录结构


    在命令行输入命令:ant,然后运行,可以看到如下输出:

    如果配置文件名不是build.xml,比如是build_front.xml,那么,可以使用-buildfile命令参数指定:

    G:/myDoc/ant_demo>ant -buildfile build_front.xml


    也可以单独执行指定的某个target,比如,只编译不打包执行,可以使用下面输入命令即可:

    G:/myDoc/ant_demo>ant compile

    在相应的目录下会找到编译出的HelloWorld.class文件。

    再看看上面的build.xml配置文件,文件开头定义了3个属性,分别指定了源文件输出路径、类文件输出路径和生成的Jar文件名,后面对这些路径的引用都通过一个${property name}来引用。所以,要注意这样一个原则“目录的定义与目录的引用应该分开”。 (未完待续)

    Ant教程(二)

    基本应用

    建立工程的目录

    一般要根据工程的实际情况来建立工程的目录结构。但是,有一些比较通用的组织形式可供参考,比如所有的jakarta项目都使用类似的目录结构。下面让我们来看一下这种目录结构的特点。

    表1

    目录 文件
    bin 公共的二进制文件,以及运行脚本
    build 临时创建的文件,如类文件等
    dist 目标输出文件,如生成Jar文件等。
    doc/javadocs 文档。
    lib 需要导出的Java包
    src 源文件

    对于一个简单的工程,一般包括表1的几个目录。其中bin、lib、doc和src目录需要在CVS的控制之下。当然在这样的目录结构上,也可以做一些调整,例如,可以建立一个extra目录来放置需要发布的Jar文件、Inf文件及图像文件等。同样,如果开发Web应用可以建立一个Web目录放置JSP、HTML等文件。

    如果我们开发的是一个比较复杂的项目,包括多个子项目,并且各个子项目是由不同的开发人员来完成的,那么要如何来设计它的目录结构?首先有一点是需要确定的,不同的子项目应该拥有不同的Build文件,并且整个项目也应该有一个总的Build文件。可以通过Ant任务或是AntCall任务调用子项目的Build文件,如下例:

    <target name="core" depends="init">
    <ant dir="components" target="core"/>
    <ant dir="waf/src" target="core"/>
    <ant dir="apps" target="core"/>
    </target>


    在各个子项目的耦合不是非常紧密的情况下,各个子项目应该有各自独立的目录结构,也就是说它们可以有自己的src、doc、build、dist等目录及自己的build.xml文件,但是可以共享lib和bin目录。而对于那些耦合紧密的子项目,则推荐使用同一个src目录,但是不同的子项目有不同的子目录,各个子项目的build.xml文件可以放在根目录下,也可以移到各个子项目的目录下。

    编写Build文件

    要用好Ant工具,关键是要编写一个build.xml文件。要编写出一个结构良好、灵活可扩展的Build文件,有两个问题要考虑,一是了解Build文件的基本结构,二是了解Ant定义的大量任务。

    Ant的Build文件是一个标准的XML文件,它包含一个根节点Project,每个Project定义了至少一个或多个Target,每个Target又是一系列Task的集合。它们之间的关系如图2所示。


    图2 build.xml文件的结构


    每个Task是一段可被执行的代码,比如,前例中的javac、jar就是两个最常用的Task。Ant定义了大量的核心Task,我们要考虑的第二个问题正是如何去掌握这大量的Task。其实唯一的方法就是边学习边实践,这方面最好的参考就是官方的Ant使用手册。

    外部文件的使用

    使用外部的Property文件可以保存一些预设置的公共属性变量。这些属性可以在多个不同的Build文件中使用。

    可以将一个外部的XML文件导入Build文件中,这样多个项目的开发者可以通过引用来共享一些代码,同样,这也有助于Build文件的重用,示例代码如下所示:

    <!DOCTYPE project [
    <!ENTITY share-variable SYSTEM "file:../share-variable.xml">
    <!ENTITY build-share SYSTEM "file:../build-share.xml">
    ]>
    <project name="main" default="complie" basedir=".">
    &share-variable;
    &build-share;
    ... ...


    在J2EE项目中的应用

    只要掌握了Ant的使用方法,在J2EE项目中的应用与在其它项目中的应用并没有太大的不同,但是仍有几点是需要注意的。

    一是要清楚War和Jar文件的目录结构,主要是War的配置文件web.xml文件的位置和EJB的配置文件(ejb-jar.xml和weblogic-ejb-jar.xml等)的位置,在调用Jar任务打包文件时一定要记得把它们也包含进来。一般在编译之前就要注意把这些需打包的文件拷入相应目录下。二是在J2EE项目中可能会涉及到一些特殊的任务,比如在Weblogic中会调用ejbc预编译EJB的代码存根,或者需要在Ant中同时发布Jar到相应的服务器中等。可以用两种途径实现这些任务,一是扩展Ant任务实现这些任务,二是直接用Java任务来执行这些命令。下面是打包、发布一个EJB的build.xml配置文件片断,代码如下:

    <target name="deploy_HelloEJB" depends="compile">
    <delete dir="${temp}/ejb_make"/> <!-- 首先删除临时目录 -->
    <delete file="${temp}/helloEJB.jar"/>
    <!-- 删除WebLogic域中老版本的EJB -->
    <delete file="${weblogic.deploy.dest}/helloEJB.jar"/>
    <!-- 创建META-INF目录,放置ejb-jar.xml和weblogic-ejb-jar.xml -->
    <mkdir dir="${temp}/ejb_make/META-INF"/>
    <!-- 拷贝ejb-jar.xml和weblogic-ejb-jar.xml 到临时目录-->
    <copy todir="${temp}/ejb_make/META-INF">
    <fileset dir="etc/baseinfo">
    <include name="*.xml"/>
    </fileset>
    </copy>
    <!-- 拷贝所有的helloEJB类到临时目录 -->
    <copy todir="${temp}/ejb_make/">
    <fileset dir="${dest.classes}/"> <!-- dest.classes是输出的类文件目录 -->
    <include name="${dest.classes}/helloEJB/**"/>
    </fileset>
    </copy>
    <!-- 将所有这些文件打包成helloEJB.jar -->
    <jar jarfile="${temp}/helloEJB.jar" basedir="${temp}/ejb_make"/>
    <!-- 进行weblogic.ejbc编译 -->
    <java classpath="${wl_cp}" classname="weblogic.ejbc" fork="yes" >
    <classpath>
    <fileset dir="lib">
    <include name="*.jar" />
    </fileset>
    </classpath>
    <arg value="${temp}/helloEJB.jar" />
    <arg value="${temp}/helloEJB_deploy.jar" />
    </java>
    <!-- 拷贝/发布到WebLogic的{DOMAIN}/applications目录 -->
    <copy file="${temp}/helloEJB_deploy.jar" todir="${weblogic.deploy.dest}"/>
    </target>


    用Ant配合JUnit实现单元测试

    Ant 提供了JUnit任务,可以执行单元测试代码。如何使用JUnit,以及如何编写测试用例(TestCase),感兴趣的读者可以参阅JUnit的相关文档。在Ant中使用JUnit的方法非常简单,首先需要把junit.jar拷入ANT_HOME/lib下,确认在这个目录下有optional.jar,因为JUnit是Ant的扩展任务,需要引用这个扩展包。然后就是在Build文件中加入JUnit的任务,代码如下:

    <target name="run" depends="client">
    <junit printsummary="yes" fork="yes" haltonfailure="yes">
    <classpath>
    <pathelement location="client.jar" />
    </classpath>
    <formatter type="plain" />
    <test name="com.sharetop.antdemo.HelloWorldTest" />
    </junit>
    </target>


    高级话题

    为Ant开发扩展任务

    为Ant实现扩展任务其实是非常容易的,只需按照以下几个步骤即可:

    1. 创建一个Java类继承org.apache.tools.ant.Task类;

    2. 对每个属性实现set方法。Ant会根据需要自动完成类型转换;

    3. 如果扩展的任务需要嵌套其它的Task,那么这个Java类必需实现接口org.apache.tools.ant.TaskContainer;

    4. 如果扩展的任务要支持Text,需要增加一个方法void addText(String);

    5. 对每个嵌套的元素,实现create、add 或 addConfigured 方法;

    6. 实现public void execute方法;

    7. 在build.xml文件中使用 <taskdef> 来引用自定义的Task。

    下面以一个简单的例子来说明如何为Ant增加一个hello任务,它可以连续打印多条信息,打印的次数由属性count指定,而打印的内容则由它内嵌的一个helloinfo任务的message属性指定,看上去这非常类似JSP中自定义标签的一些概念,实现代码如下:

    //HelloInfoTask.java
    package com.sharetop.antdemo;
    import org.apache.tools.ant.*;
    public class HelloInfoTask {
    private String msg;
    public void execute() throws BuildException {
    System.out.println(msg);
    }
    public void setMessage(String msg) {
    this.msg = msg;
    }
    }


    下面是外部Task类的代码:

    //HelloTask.java
    package com.sharetop.antdemo;
    import org.apache.tools.ant.*;
    public class HelloTask extends Task implements org.apache.tools.ant.TaskContainer
    {
    private Task info;
    private int count;
    public void execute() throws BuildException {
    for(int i=0;i<count;i++)
    info.execute();
    }
    public void setCount(int c){
    this.count=c;
    }
    public void addTask(Task t){
    this.info=t;
    }
    }


    实现了这两个Task,在build.xml文件中定义它的task name,就可以在Target中执行它了。如果你不想使用 <taskdef> 标签来定义Task,也可以通过修改default.properties文件来实现引入新Task,这个文件位于org.apache.tools.ant.taskdefs 包里。下例是一个使用 标签来引入新Task的Build文件部分:

    <target name="hello" depends="client">
    <taskdef name="hello"
    classname="com.sharetop.antdemo.HelloTask" classpath="client.jar"/>
    <taskdef name="helloinfo"
    classname="com.sharetop.antdemo.HelloInfoTask" classpath="client.jar"/>
    <hello count="3" >
    <helloinfo message="hello world" />
    </hello>
    </target>
    (未完待续)

    http://www.javaresearch.org/article/66130.htm

    Ant参考教程(一)
    liuxiao 转贴   更新:2007-04-07 21:50:59  版本: 1.0   

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

  • 相关阅读:
    HDU 2955 Robberies(01背包)
    HDU 2602 Bone Collector(01背包)
    HUST 1352 Repetitions of Substrings(字符串)
    HUST 1358 Uiwurerirexb jeqvad(模拟解密)
    HUST 1404 Hamming Distance(字符串)
    HDU 4520 小Q系列故事――最佳裁判(STL)
    HDU 2058 The sum problem(枚举)
    【破解】修改程序版权、添加弹窗
    HDU 1407 测试你是否和LTC水平一样高(枚举)
    HDU 1050 Moving Tables(贪心)
  • 原文地址:https://www.cnblogs.com/pocter/p/3684541.html
Copyright © 2011-2022 走看看