使用Ant执行程序

    之前我们讲解了一个构建过程来编译和测试JAVA源代码，在测试表明代码是正确的之后，我们就该运行它了。这意味着应该探索Ant执行外部程序的能力的时候了。这些可外部程序可以是JAVA程序也可以是本地程序。

1.       使用Ant执行外部程序的原因：
由于Ant得益于其内置的任务，所以可以自己完成很多工作而不需要求助于外部代码。但是在大型工程中，很快就会发现它们需要使用外部程序，既可能使用本地程序，又可能使用JAVA应用程序。
      实际的构建或测试应用程序是最常见的Ant内部运行的程序，这些程序的任务就是在主程序中进行单元测试、系统测试和载入测试。其他常见的外部程序就是“遗留构建步骤”：软件的某些部分需要一个本地编译器、Perl脚本或仅仅是一些用在构建中的本地工具程序。
      从Ant内部运行程序时，有两个方案：
l         编写一个定制的Ant任务来调用程序，适用于需要在很多构建文件中使用同一个外部程序的情况。（适用于长期项目，经常工程编写Ant任务包装器）。
l         编写一个新的Ant任务，这个任务只是从构建文件中调用程序。从构建文件中直接调用程序是编写定制任务的基础。
Ant可以包装本地应用程序，而JAVA应用程序可以在Ant的JVM中运行，也可以在其外部运行。无论执行什么类型的应用程序，也无论怎样执行它，Ant都会挂起构建本身直至程序结束。程序的所有控制台输出都会加入到Ant的日志工具里，通常显示到屏幕里。被包装的程序无法读取控制台的输出，因此需要用户输入的程序无法运行。
2.       运行JAVA程序：
启动JAVA程序是Ant的拿手好戏。这种方法最好的一个特性就是可以轻而易举的指定classpath。它比在编写批处理或者是SHELL脚本时手工指定每个类库要容易得多；它可以将classpath中的lib/**/*.jar拥有的 所有文件统统包含近来。
Ant执行JAVA程序另一个好处是它可以在当前的JVM中运行程序。即使指定的classpath是由定制的类载入器提供的，也可以做到。在当前的JVM内运行的程序可以减少启动延迟；它只在载入新类时消耗时间，因此有助于构建保持快速。然而，在新的JVM中执行代码也有很多理由，”forking”(建立新进程)，它在一些情形下更适用：
l         如果不建立新进程，就无法指定一个新的工作路径。
l         当你在建立新进程时，如果遇到与类载入器有关的奇怪的错误或者安全冲突，这很可能是因为在两个载入器里载入了同一个类：原先Ant中的类载入器和一个新的类载入器。在父类载入器或子类载入器中建立新进程或者追踪错误的JAR，然后移除它。
l         不能在同一个的JVM中执行JAR；而必须建立新的进程。
l         需要大量内存或leaky的JAVA程序应当运行在它们自己的JVM里，并给这个JVM分配适当的内存空间。
l         建立一个新进程也允许在另一个版本的虚拟机中运行代码。这个版本可以不同于启动ANT的虚拟机版本。
a)       首先介绍一下<java>任务：
建立一个JAVA类，然后打印入口参数，为了讲解classpath，这里我们引入一个记录日志的软件包，log4j来记录日志：
工程目录如下：


类代码如下：
package com.neusoft.test;

import org.apache.log4j.Logger;

publicclass TestJava {
      privatestatic Logger logger = Logger.getLogger(TestJava.class);

      /**
       *enterpointmethod
       *
       *@paramargs
       *            enterpoingarguments
       */
      publicstaticvoid main(String[] args) {
           if (args.length <= 0) {
                 logger.error("Bad arguments!");
                 System.out.println("Usage:\n\tjava TestJava arg1 args2 ...");
                 System.exit(-1);
           }
           for (int i = 0; i < args.length; i++) {
                 logger.info("arg" + i + "=" + args[i]);
                 System.out.println("arg" + i + "=" + args[i]);
           }
      }
}
在不输入入口参数的情况下，打印帮助信息，并退出程序，在输入入口参数的情况下，执行程序，并打印参数。
其中log4j需要一个配置文件，示例如下：
<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE log4j:configuration SYSTEM "log4j.dtd">
<log4j:configuration xmlns:log4j="http://jakarta.apache.org/log4j/">
      <appender name="error" class="org.apache.log4j.FileAppender">
           <param name="File" value="${user.dir}/logs/error.log" />
           <layout class="org.apache.log4j.PatternLayout">
                 <param name="ConversionPattern"
                      value="%d{yyyy/MM/dd HH:mm:ss},%p,%C.%M,%m%n" />
           </layout>
      </appender>
      <root>
           <priority value="DEBUG" />
           <appender-ref ref="error" />
      </root>
</log4j:configuration>
这里设置了一个文件类型的日志输出器，所有日志输出都将被输出到用户目录的logs/error.log文件中，关于log4j的知识，请参考本blog其他文章。运行完成后的工程目录如下图所示：

error.log中将记录日志信息。

下面我们来创建构建文件：
<target name="run " depends="compile">
<echo>running a search</echo>
<java classname="com.neusoft.test.TestJava">
<arg value="The"/>
<arg value="current"/>
<arg value="dir"/>
<arg value="is"/>
<arg file="."/>
</java>
</target>

这样设置还不够，还需要指定classpath，否则可能会出现如下错误：
Buildfile: C:\eclipse\workspace\Ant_Chapater5\build.xml
init:
    [mkdir] Created dir: C:\eclipse\workspace\Ant_Chapater5\build
    [mkdir] Created dir: C:\eclipse\workspace\Ant_Chapater5\build\classes
compile:
    [javac] Compiling 1 source file to C:\eclipse\workspace\Ant_Chapater5\build\classes
run:
     [java] Could not find com.neusoft.test.TestJava. Make sure you have it in your classpath
      ……
BUILD SUCCESSFUL
Total time: 4 seconds

因为我们没有配置classpath。当任何指定的classpath都不存在时，<java>任务就使用Ant自身的classpath:诸如ant.jar以及其他任何位于ANT_HOME/lib目录下的类库，再加上系统CLASSPATH环境变量的内容。就几乎所有<java>任务而言，应该另外指定一个classpath。当这样做的时候，已经存在的所有非java和javax包的classpath中的内容就不再可用了。这种方式与<javac>不同，在<javac>中如果够文件不指定其他值，则自动包含Ant运行时classpath。

添加classpath很容易：在<classpath>元素中写路径或者提供classpath属性一个字符串形式的路径。如果想做多个不同的地方使用classpath，最好先设置好classpath，然后再通过classpathref属性引用它。一个常见的惯例是：
用第二个包含有新的生成类的classpath来扩展第一个编译时classpath，而不管这个新的生成类是档案文件形式还是.class文件的目录树形式。
我们也采用这种办法，一个用于编译，一个用于执行：
<path id="compile.classpath">
<pathelement path="src/log4j-1.2.13.jar"/>
</path>
<path id="run.classpath">
<path refid="compile.classpath"/>
<pathelement location="${build.dir}/classes"/>
</path>
第一个classpath包含编译时所需要的类库，第二个添加我们刚刚编写的代码。易于维护，任何编译时所需要新的类库都会自动传递到运行时classpath。
      此时可以修改<java>任务如下：
<java classname=" com.neusoft.test.TestJava"
classpathref="run.classpath">
<arg value="The"/>
<arg value="current"/>
<arg value="dir"/>
<arg value="is"/>
<arg file="."/>
</java>

现在构建文件如下：
<?xml version="1.0" encoding="UTF-8" ?>
<projectname="run-java-application"default="run">

      <propertyname="build.dir"value="build"/>
      <pathid="compile.classpath">
           <pathelementlocation="src/log4j-1.2.13.jar"/>
      </path>
      <pathid="run.classpath">
           <pathrefid="compile.classpath"/>
           <pathelementlocation="${build.dir}/classes"/>
      </path>
      <targetname="init">
           <deletedir="${build.dir}"/>
           <deletedir="logs"/>
           <mkdirdir="${build.dir}"/>
           <mkdirdir="${build.dir}/classes"/>
      </target>
      <targetname="compile"depends="init">
           <javacsrcdir="src"destdir="${build.dir}/classes">
                 <classpathrefid="compile.classpath"/>
           </javac>
      </target>
      <targetname="run"depends="compile">
           <javaclassname="com.neusoft.test.TestJava">
                 <classpathrefid="run.classpath"/>
                 <argvalue="The"/>
                 <argvalue="current"/>
                 <argvalue="dir"/>
                 <argvalue="is"/>
                 <argfile="."/>
           </java>
      </target>
</project>

构建过程运行如下：
Buildfile: C:\eclipse\workspace\Ant_Chapater5\build.xml
init:
    [mkdir] Created dir: C:\eclipse\workspace\Ant_Chapater5\build
    [mkdir] Created dir: C:\eclipse\workspace\Ant_Chapater5\build\classes
compile:
    [javac] Compiling 1 source file to C:\eclipse\workspace\Ant_Chapater5\build\classes
run:
     [java] log4j:WARN No appenders could be found for logger (com.neusoft.test.TestJava).
     [java] log4j:WARN Please initialize the log4j system properly.
     [java] arg0=The
     [java] arg1=current
     [java] arg2=dir
     [java] arg3=is
     [java] arg4=C:\eclipse\workspace\Ant_Chapater5
BUILD SUCCESSFUL
Total time: 4 seconds

执行完成后工程目录如下：


但是，可以看到，由于构建过程中不能找到log4j的配置文件，所以有如下警告：
[java] log4j:WARN No appenders could be found for logger (com.neusoft.test.TestJava).
[java] log4j:WARN Please initialize the log4j system properly.

也就没有生成logs/error.log日志文件。这个原因本人也在探索中，试图将log4j.xml添加到classpath中，但是还是出问题。如果有遇到类似问题的朋友，希望帮忙解决。
个人初步分析原因是：不能在同一个的JVM中执行JAR；而必须建立新的进程。因为写日志相当于执行了log4j档案文件中的类，所以不能在同一个JVM中运行。

3.       参数：
在<java>任务中，最重要的可选参数是嵌套参数列表。可以通过一个简单值，一行文本，一个用于参数列表优先级解析的文件，或者一个路径来命名一个参数。可以在任务的<arg>元素里指定它们，<arg>元素支持以下四个属性，Ant按这些参数声明的顺序将它们传递给JAVA程序：
value:字符串值。（对XML的特殊记号要进行转义:>变为&gt;   &#x0a;代表换行）
file:文件或目录，在使用之前解析为绝对地址。然后再传递。
line:传递给程序的整个行
path:一个字符串，包含有用冒号或分号隔开的文件或目录。

4.       定义系统特性：
系统是那些要传给JAVA命令行（如：-Dproperty=value）的参数的定义。嵌套的<sysproperty>元素可以用来定义要传递的特性。
<sysproperty key="socksProxyHost" value="socks-server"/>
<sysproperty key="socksProxyPort" value="1080"/>
有两种可选方法能代替value参数：file和path。就如带参数一样，file属性为文件命名；Ant对相对引用进行解析并传入绝对文件名，并使用本地平台的文件分隔符。path属性与之类似，只是允许列入多个文件：
<sysproperty key="configuration.file" file="./config.properties"/>
<sysproperty key="searchpath" path="build/classes:lib/j2ee.jar" />

5.       在新的JVM中运行程序
<java>任务将运行在当前的JVM中，除非fork属性被设置为true，这将减少程序启动的时间。做为实验，我们可以将TestJava放在一个新的JVM中运行。
<target name="run-search-fork" depends="create-jar">
<echo>running a search</echo>
<java classname="com.neusoft.test.TestJava"
classpathref="run.classpath"
fork="true">
<argvalue="The"/>
                 <argvalue="current"/>
                 <argvalue="dir"/>
                 <argvalue="is"/>
<argfile="."/>
</java>
</target>

6.       设置环境变量：
你可以在一个建立新进程的JVM里使用嵌套元素<env>来设置环境变量。这个元素的语法与<sysproperty>元素是一样的。

7.       控制新的JVM

可以选择不同于Ant的JAVA运行时环境，只要通过jvm属性设置JVM命令就可以了，这对与从一个旧的JVM中运行程序时是非常有用的，诸如运行在JAVA1.1系统里的测试，或者可能在JAVA的一个未来版本的BETA版。可以给这个JVM指定参数来控制它，最常用的选项就是设置内存数量，属性maxmemory，这个属性具有一些幕后只能 可以区分JAVA 1.1和1.2系统，生成合适的命令。
可以通过<java>嵌套的<jvmarg>元素提供通用的 JVM参数。这些参数的确切用法与<arg>元素相同。
<target name="run-search-jvmargs" depends="create-jar">
<property name="Search.JVM.extra.args" value="-Xincgc"/>
<java classname=" com.neusoft.test.TestJava"
classpathref="run.classpath"
fork="true"
maxmemory="64m">
<jvmarg line="${Search.JVM.extra.args}"/>
<argvalue="The"/>
                 <argvalue="current"/>
                 <argvalue="dir"/>
                 <argvalue="is"/>
<argfile="."/>
</java>
</target>

当fork=”false”时，所有的JVM选项都不起作用；仅仅显示一行警告信息。
8.       使用failonerror处理错误
尽管核心的构建步骤(compile和JAR)必须完成后才可以认为整个构建是成功的，但是一些其他的构建过程中的任务，它们的失败并不重要。例如发送进度报告的电子邮件并不因为邮件服务器确实而终止构建，同样配置过程中的很多方面，诸如停止一个WEB服务器等，并不会因失败而终止构建。
一些Ant任务有一个共同的属性，failonerror，它可以控制当任务失败时是否终止构建。多数任务的默认值是”true”，意思是任何构建过程中任务的失败都会导致构建失败，并导致ANT的BUILD FAILED信息。
<java>任务支持这个属性，但仅在新的JVM中才支持，如果JAVA程序的返回值不等于0，则终止构建。当JVM内部调用System.exit()时，整个构建过程会因为JAVA停止运行而突然停止并且不显示BUILD FAILED信息：这个调用退出了ANT以及程序。
例如我们将failonerror设置为true,并且不传递任何参数给程序，将调用System.exit(-1)，此时JAVA程序的输出为：

<target name="run-search-invalid" depends="compile">
<echo>running a search</echo>
<java classname="com.neusoft.test.TestMain"
classpathref="run.classpath"
failonerror="true"
fork="true">
<argvalue="The"/>
                 <argvalue="current"/>
                 <argvalue="dir"/>
                 <argvalue="is"/>
<argfile="."/>
</java>
</target>
构建输出如下：
run-search-invalid:
[echo] running a search
[java] Usage:
java TestJava arg1 args2 ...
BUILD FAILED
C:\AntBook\app\tools\build.xml:532: Java returned: -1

9.       执行JAR文件：
当一个JAR文件由命令行中的java –jar命令启动时，该JAR文件可以在清单(manifest)上列出一个类的名字做为执行入口，ANT也可以类似地运行JAR文件，但只能在建立新进程的JVM中。这是因为执行JAR文件的过程会载入classpath列表中所列的文件，而其他细节则与JAVA的“扩展”有关。通过一个jar属性设置为文件的文职可以运行JAR文件：
<target name="run-search-jar" depends="create-jar">
<echo>running a search</echo>
<java
jar="${jarfile.path}"
classpathref="run.classpath"
failonerror="true"
fork="true">
<arg value="The" />
                 <arg value="current" />
                 <arg value="dir" />
                 <arg value="is" />
<arg file="." />
</java>
</target>

这个目标并不能实际工作，因为还没有设置清单(manifest)，这些内容等到下一章再讲解。

10.       调用第三方程序：
可以使用任务运行由第三方提供的程序，假设我们部署过程的一个环节中包含了停止WEB SERVER的操作，比如TOMCAT 5.5，这在部署中是个常见的动作；为了从构建中进行部署，必须实现自动化每个步骤。幸运的是多数WEB SERVER都提供了这样或那样的方法来做到这一点：从TOMCAT的启动脚本中提取命令来完成<javac>任务：
<property environment="env"/> //获取环境变量
<target name="stop-tomcat"
description="stop tomcat if it is running">
<java classname="org.apache.tomcat.startup.Tomcat">
<classpath>
<fileset dir="${env.TOMCAT_HOME}/lib">
<include name="**/*.jar"/>
</fileset>
</classpath>
<arg value="-stop"/>
<sysproperty key="tomcat.home"
value="${env.TOMCAT_HOME}"/> //将TOMCAT的HOME目录向下传递
</java>
</target>
执行该目标有以下几种结果：
l         TOMCAT存在而且库文件位于预先假设的位置，成功停止TOMCAT
l         本地目前没有任何版本的TOMCAT在运行，无法停止TOMCAT
l         即使已经设置classpath，但是因为TOMCAT未安装或者环境变量未正确设置，因此造成库目录确实而无法创建classpath
这时我们需要预先判断。

11.       在调用之前探察JAVA程序：
在准备调用一个JAVA类之前，在classpath上查找它是很容易的，这样做使得显示警告信息成为可能。对于TOMCAT问题，可以使用<available>任务，或者采用<condition>任务会更好，后者能够通过检测环境变量组合<available>测试：
<target name="validate-tomcat"
<condition property="tomcat.available">
<and>
<isset property="env.TOMCAT_HOME"/>
<available classname="org.apache.tomcat.startup.Tomcat">
<classpath>
<fileset dir="${env.TOMCAT_HOME}/lib">
<include name="**/*.jar"/>
</fileset>
</classpath>
</available>
</and>
</condition>
<echo>tomcat.available=${tomcat.available}</echo>
</target>

这里声明了，当且仅当env.TOMCAT_HOME已经定义，且要调用的类org.apache.tomcat.startup.Tomcat位于TOMCAT目录下的classpath时，特性tomcat.available才会被设置成true。由于<and>的捷径效应，第一个测试失败时不运行第二个，因为第一个失败时，classpath是不合法的。
      这个测试可以用语带条件的任务，或者当一个程序必须存在时，带条件的<fail>任务将被用于立即终止构建。当找不到TOMCAT时，通过使用将目标依赖于检验目标，且将条件设置为tomcat.available特性而选择了简单的略过测试：
<target name="stop-tomcat"
if="tomcat.available"
depends="validate-tomcat"
description="stop tomcat if it is running">
<java classname="org.apache.tomcat.startup.Tomcat">
<classpath>
<fileset dir="${env.TOMCAT_HOME}/lib">
<include name="**/*.jar"/>
</fileset>
</classpath>
<arg value="-stop"/>
<!— 传递给JAVA命令行的参数的定义 -->
<sysproperty key="tomcat.home"
value="${env.TOMCAT_HOME}"/>
</java>
</target>

12.       设置超时
Ant1.5为<java>任务扩展了timeout属性，允许以毫秒的方式指定一个JAVA应用程序最大的运行时间。只能在建立新进程的JVM中使用这一个特性。

第二部分：使用<exec>启动本地程序
      JAVA执行并不能给予构建文件访问底层操作系统的全部能力，或者访问本地平台的构建步骤，除非JAVA程序调用本地程序。由于本地程序的移植性很差，因此为了实现以跨平台的方式定制任务，应提供可移植性的包装方式。
      在运行程序之前让构建文件去探测这些程序存在与否（用上一节的知识）。这是个功能强大的技巧，就如同多数与维护相关的编码，通过不懈的努力能满足绝大部分的情形。
      要在Ant内运行一个外部程序，应该使用<exec>任务，它可以执行以下操作：
l         指定程序名称和要传入的参数
l         命名运行目录
l         使用failonerror标志来控制当应用程序失败时是否终止构建
l         指定一个最大程序持续时间，时间超过则终止程序。任务在这时被认为是失败，但是至少构建会终止，而不是挂起，这对于自动构建是很重要的。
l         将输出存入一个文件或特性
l         指定JAVA调用本地程序时需要预先设定的环境变量
有一件事是它所做不到的，那就是使用一个OsFamily标志将操作限制到操作系统家族，诸如Windows或者Unix，否则将是非常方便的。<condition>任务确实拥有一个OsFamily测试可用于具有条理性的操作系统测试，但是这样的话整个目标都变成有条件的。
将<exec>与特定的操作系统绑定在一起是不好的做法，除非这个调用直接对应操作系统的底层功能。而检测相应程序，如果存在就调用它则好的多。
例子：
<exec executable="ln">
<arg value="-s"/>
<arg location="execution.xml"/>
<arg location="symlink.xml"/>
</exec>
这个任务的用途是给文件创建符号连接，因为内置JAVA命令没有这个功能。如果可执行程序在当前路径或者在系统path目录中，则无需指定其完整路径。
1.       设置环境变量：
正如<java>任务支持将系统属性作为嵌套元素一样，<exec>任务允许<env>子元素设置环境变量。它与<sysproperty>元素具有相同的语法，以不同的元素名分隔。<exec>的一个特别的功能，是你可以选择程序是否继承当前的环境。通常情况下继承当前的所有设置是有意义的，诸如PATH和TEMP，但是有时候可能希望通过参数进行绝对控制：
<exec executable="preprocess"
newenvironment="true" >
<env key="PATH" path="${dist.dir}/win32;${env.PATH}"/>
<env key="TEMPLATE" file="${src.dir}/include/template.html"/>
<env key="USER" value="self"/>
</exec>

即使通过newenvironment=”false”（默认值）继承已有的环境，任何显示定义的环境变量也将覆盖所传入环境变量的值。

2.       处理错误
<exec>属于这样一类Ant任务：这类任务默认情况下failonerror=”false”。这是有原因的：最初没有返回值校验，因此当它被实现时，校验将被设为false以避免与已有构建冲突。即使JAVA任务与其他多数任务不同，但它至少和本地执行任务有统一的默认值。
      声明failonerror为true和false，而忽略其默认值，这样使构建文件可读性好。”什么情况下出错就终止”/”什么情况下出错但不终止”。
      failonerror并不控制在程序运行时系统对失败如何反映，在Ant 1.5中,<exec>加入了第二个失败检查，failIfExecuteFails，它控制了实际的执行失败是否被忽略。
3.       处理超时
运行超时杀死任务，以免陷入挂起。<exec>支持一个timeout属性，以毫秒为单位。如果设置了该属性则一个监视计时器就会启动运行。当外部程序占用时间超时后就“杀死”它。当超时发生时，监视器不会明确告诉你超时发生了，但是执行文件的返回代码被设为”1”。如果failonerror被设置，则将会终止构建。如果没有设置，那么它就会悄悄的不被忽略。
<target name="sleep-fifteen-seconds" >
<echo message="sleeping for 15 seconds" />
<exec executable="sleep"
failonerror="true"
timeout="2000">
<arg value="15" />
</exec>
</target>
运行该目标，当遇到超时就会产生一个错误：
sleep-fifteen-seconds:
[echo] sleeping for 15 seconds
[exec] Timeout: killed the sub-process
BUILD FAILED
execution.xml:18: exec returned: 1

如果外部程序设置成将结果传入一个特性，并将failonerror设置为off，那么就没办法将为1的结果和超时区分开。
需要在构建中插入一个暂停时，可以使用<sleep>任务，该任务可以工作在所有平台上。

4.       运行shell命令
使用：
<exec executable="cmd" failonerror="true"/>
<arg line="/c echo hello &gt; hello.txt"/>
</exec>
而不是
<exec command="/c echo hello &gt; hello.txt" failonerror="true"/>
</exec>

在shell中也是一样：应该使用
<exec command="ps -ef | grep java &gt; processes.txt"
failonerror="false"/>

而不是
<exec executable="sh" failonerror="true"/>
<arg line="-c 'ps -ef | grep java &gt; processes.txt'"/>
</exec>

因为整个一行的内容需要shell来解释。

5.       在程序被调用之前进行探测
有时候当程序不可用时，可以略过一个构建步骤，或者提供有帮助的错误并终止。如果你知道程序所在的位置，就可以调用<available>任务对其进行测试，但是假如只是要求该程序在指定目录中怎么办呢？<available>任务可以在整个文件路径下搜索指定的文件，因此探测一个程序是否存在就是个简单的事情了，只要沿着环境变量PATH查找程序名字就可以了，当然，在跨平台的方式下，这并不简单：MS-DOC和UNIX系统以不同的方式命名可执行文件，有时甚至连路径变量也不同。将这些纳入考虑之中，对文件的探测就变成了一个多情况的测试，测试必须以带.exe和不带.exe扩展名两种方式来寻找可执行文件，并且MS-DOC/Windows可执行文件必须同时通过环境变量的两个选项进行搜索。Path和PATH：
<target name="probe_for_gcc" >
<condition property="found.gcc">
<or>
<available file="gcc" filepath="${env.PATH}" />
<available file="gcc.exe" filepath="${env.PATH}" />
<available file="gcc.exe" filepath="${env.Path}" />
</or>
</condition>
</target>

可以通过编写依赖的目标，如果程序不存在，要么使用<fail>任务，要么仅仅跳出某个执行步骤：
<target name="compile_cpp" depends="verify_gcc" if="found.gcc">
<exec executable="gcc" ... />
</target>

第三部分: 使用<apply>进行批量运行
将一个文件列表传递给外部可执行文件程序的特性问题，可以使用<apply>任务来解决，这个任务接受一个文件集并将其传递给指定的应用程序，既可以一次传完，也可以逐个传递。
      <apply>是作为<exec>的一个子类而被实现，所以<exec>任务的所有属性，都可以用于<apply>；除此之外，它还包括一个批处理的附加功能。
例如有一个本地程序，可以将XML文件转换为PDF，它有两个参数：XML文件的路径，以及对应的PDF文件的路径：
<apply executable="cmd" dest="docs">
<arg line="/c echo"/>
<arg value="convert"/>
<srcfile/>
<targetfile/>
<fileset dir ="." includes="*.xml"/>
<mapper type="glob" from="*.xml" to="*.pdf"/>
</apply>

在Windows平台上运行，并使用内置echo命令，必须将可执行文件设置为cmd以便echo可以正常工作，打开/c开关使得命令行shell在echo完成后自动退出。对于同一个目录下数个xml文件的执行，输出如下：
[apply] convert C:\AntBook\Sections\Learning\callingotherprograms\apply.xml
C:\AntBook\Sections\Learning\callingotherprograms\docs\apply.pdf
[apply] convert C:\AntBook\Sections\Learning\callingotherprograms\execution.
xml C:\AntBook\Sections\Learning\callingotherprograms\docs\execution.pdf
[apply] convert C:\AntBook\Sections\Learning\callingotherprograms\java.xml C
:\AntBook\Sections\Learning\callingotherprograms\docs\java.pdf
[apply] convert C:\AntBook\Sections\Learning\callingotherprograms\probes.xml
C:\AntBook\Sections\Learning\callingotherprograms\docs\probes.pdf
[apply] convert C:\AntBook\Sections\Learning\callingotherprograms\shells.xml
C:\AntBook\Sections\Learning\callingotherprograms\docs\shells.pdf

到目前为止，它所做的全部工作就是显示我们要执行的命令，但是并没有实际执行它。
<apply>隐含依赖关系检查。目标文件新于源文件，它就被忽略。

一旦对echo的输出结果满意，看到它为每个文件将执行预期的命令行，就可以把属性值由convert修改为executable，去掉/c echo参数，然后再回到正题。

该任务的parallel选项的意思是”一次传入全部的文件”，而不是”并行执行该任务多次”。

第四部分：处理输出：
以上介绍的三个任务：<java>，<exec>和<apply>这三个任务，都允许你使用output参数将输出结果保存到文件中，可以将这个文件传入别的程序，或者一个ant任务，其中的两个任务<exec>和<apply>，还可以将调用的值存入特性，该特性接下来可以被扩展应用为其他任务的参数。例如：可以将构建阶段的结果发email给其他人：
<exec executable="unregbean" output="beans.txt" >
<arg value="-d"/>
</exec>
<mail from="build" tolist="operations"
subject="list of installed beans for ${user.name}"
failonerror="false"
files="beans.txt"/>
这种将生成的文件和报告用email发出去的办法，在自动化的构建和测试系统中是常见的功能。