精华内容
参与话题
问答
  • 3、ant 介绍以及作用、ant 下载及安装、ant build.xml 详解。 4、Jenkins 构建自动化平台、Jenkins 安装以及功能介绍、jenkins+ant+jmeter **整合,邮件服务通知设置。 5、本课程注重...
  • Ant

    千次阅读 热门讨论 2013-12-28 20:12:09
    一、Ant是什么? 面对一个很大的项目时,每次重新编译,打包,测试等都会变得非常复杂,并且会多次的重复上述的几个步骤,让人感觉非常繁琐。在java项目中,为了解决这种麻烦,ant就应运而生了。它是一个将软件编译...

    一、Ant是什么?

            面对一个很大的项目时,每次重新编译,打包,测试等都会变得非常复杂,并且会多次的重复上述的几个步骤,让人感觉非常繁琐。在java项目中,为了解决这种麻烦,ant就应运而生了。它是一个将软件编译、测试、部署等步骤联系在一起加以自动化的一个工具

    所谓的生成工具就是在软件开发中用来将源代码和其他输入文件转换为可执行文件的形式。随着应用程序的生成过程变得更加复杂,确保在每次生成期间都使用精确相同的生成步骤,同时实现尽可能多的自动化,以便及时产生一致的生成版本。


    二、Ant的特点

    上面介绍了什么是Ant。既然它受到大家的欢迎,那么它肯定有它的特别之处。

           1、跨平台性。Ant是纯Java语言编写的,所以具有很好的跨平台性。

           2、Ant可以集成到开发环境中。由于Ant的跨平台性和操作简单的特点,它很容易集成到一些开发环 境中去。

           3、操作简单。Ant是由一个内置任务和可选任务组成的。Ant运行时需要一个XML文件(一般我们命名为bulid.xml)。 Ant通过调用target树,就可以执行各种task。每个task实现了特定接口对象。

           4、容易书写。由于Ant构建文件 时XML格式的文件,所以很容易维护和书写,而且结构很清晰


    三、如何使用Ant

          1、首先是要下载.zip文件

          2、由于Ant是纯java编写的,是Apache下面的一个子项目。所以在安装Ant之前,需要安装JDK,并且配置好相应的环境变量。

         3、将zip解压缩到任意目录,假设解压缩到D:\apache-ant目录中

         4、新建一个ANT_HOME=D:\apache-ant

         5、将ANT_HOME放到path中

         6、在cmd中输入ant,显示如下就说明安装成功了

    7、下面最重要的工作就是编写build.xml文件了,这里直接给出一个例子

    <?xml version="1.0" encoding="GBK"?>  
    <project name="任意一个名字" default="生成Hibernate配置文件" basedir=".">  
         
        <property name="src.dir" value="${basedir}/src"/>  
        <property name="build.dir" value="${basedir}/bin"/>  
        <property name="webapp.dir" value="${basedir}/src/webapp"/>  
        <property name="xdoclet.home" value="D:/xdoclet/xdoclet-plugins-1.0.3"/>  
          
        <!-- Build classpath 构建任务可能用到的依赖jar包路径-->  
        <path id="xdoclet.task.classpath">  
            <fileset dir="${xdoclet.home}/lib">  
                <include name="**/*.jar"/>  
            </fileset>  
            <fileset dir="${xdoclet.home}/plugins">  
                <include name="**/*.jar"/>  
            </fileset>  
        </path>  
        <!-- 引用引入的jar包-->  
        <taskdef  
            name="xdoclet"  
            classname="org.xdoclet.ant.XDocletTask"  
            classpathref="xdoclet.task.classpath"  
        />  
      
        <target name="生成Hibernate配置文件">  
            <xdoclet>  
                <fileset dir="${src.dir}/com/bjsxt/oa/model">  
                    <include name="**/*.java"/>  
                </fileset>              
                <component  
                    classname="org.xdoclet.plugin.hibernate.HibernateConfigPlugin"  
                    destdir="${src.dir}"  
                    version="3.0"  
                    hbm2ddlauto="update"  
                    jdbcurl="jdbc:mysql://127.0.0.1/oa_200706"  
                    jdbcdriver="com.mysql.jdbc.Driver"  
                    jdbcusername="root"  
                    jdbcpassword="123456"  
                    dialect="org.hibernate.dialect.MySQLDialect"  
                    showsql="true"  
                />  
            </xdoclet>  
        </target>  
        <target name="生成hibernate映射文件">  
            <xdoclet>  
                <fileset dir="${src.dir}/com/bjsxt/oa/model">  
                    <include name="**/*.java"/>  
                </fileset>  
                <component   
                    classname="org.xdoclet.plugin.hibernate.HibernateMappingPlugin"  
                    version="3.0"  
                    destdir="${src.dir}"  
                />  
            </xdoclet>  
        </target>  
    </project>  

         8、关于build.xml的位置:可以放在任何的位置。一般做法是放在项目顶层目录中。 这样可以保持项目的简洁和清晰

        9、运行ant。在eclipse中的window--->show view ---->ant。


    四、一些扩展

          Ant的关键元素和常用元素语义说明:(来自于网络)

    1、project:

    ant构件文件的根元素,这个是必须的元素噢!它的三个属性我们都已经见到过了,分别为name、default、basedir。name属性就是指定project的名称了;default属性用于指定project默认执行的target名称;basedir属性用于指定基路径的位置,没有指定或者指定为".",则为Ant构件文件的附目标作为基准目录。

    2、target:

    Ant的基本执行单元,它可以包含一个或多个具体的执行任务。多个target可以存在相互依赖关系(depends属性),所以,看看它的一些属性:
    name属性指定target的名称,这是属性是project元素中唯一的;depends属性用于描述多个target之间的依赖关系,被依赖的先执行。比如,我们运行一个java程序之前必须先编译它,所以,我们在运行的target中指定depends依赖于编译的target。如果与多个target存在依赖关系,则要用","间隔。Ant会依照depends属性中的target出现的顺序依次执行每个target;if属性验证执行此target的成立条件;unless属性与if属性相反,验证指定属性为假时所在的target执行;description属性是对此target功能的简短描述和说明

    3、property :
         该元素说得直白些,就是一变量,project里的属性可通过property元素来设定,也可在外部引入一文件,例如build.properties(一定程度上可增加系统的维护性,一些开源项目常这么干),可通过如下方式引入:<property file="build.properties"/>。
         在引用property元素时,可通过将属性名放在"${"和"}"之间,当然了,Ant本身也提供一些内置属性,另外它也能得到的系统属性列表与Java文档中的System.getProperties()方法得到的属性一致,Ant的内置属性包括basedir()、ant.file、ant.version、ant.project.name、ant.java.version

    展开全文
  • ant

    千次阅读 2012-12-31 22:31:01
    Ant安装很简单,只要你从apache网站上下载他的zip包,然后解压到任何本地磁盘上,在环境变量中添加 Path 的值加上 %ANT_HOME%/bin 就可以了,这样在Dos提示符中就可以使用 ant 这个命令了。其他的你需要设置一下 ANT...
    1.1定义

    Ant是一种基于Java和XML的build工具。


    1.2下载安装

    Ant安装很简单,只要你从apache网站上下载他的zip包,然后解压到任何本地磁盘上,在环境变量中添加 Path 的值加上 %ANT_HOME%/bin 就可以了,这样在Dos提示符中就可以使用 ant 这个命令了。其他的你需要设置一下 ANT_HOME 这个环境变量为你解压后的目录。还有就是你要检查一下你的JDK安装目录JAVA_HOME是不是加到你的环境变量里面去了。


    1.3运行前配置
    将bin目录加入PATH环境变量。设定ANT_HOME环境变量,指向你安装Ant的目录。在一些OS上,Ant的脚本可以自动检测ANT_HOME(Unix和Windos NT/2000),但最好不要依赖这一特性。可选地,设定JAVA_HOME环境变量(参考下面的高级小节),该变量应该指向你安装JDK的目录注意:不要将Ant的ant.jar文件放到JDK/JRE的lib/ext目录下。Ant是个应用程序,而lib/ext目录是为JDK扩展使用的(如JCE,JSSE扩展)。而且通过扩展装入的类会有安全方面的限制。


    1.4运行ANT

    运行Ant非常简单,当你正确地安装Ant后,只要输入ant就可以了。没有指定任何参数时,Ant会在当前目录下查询build.xml文件。如果找到了就用该文件作为buildfile。如果你用 -find 选项,Ant就会在上级目录中寻找buildfile,直至到达文件系统的根目录。要想让Ant使用其他的buildfile,可以用参数 -buildfile file,这里file指定了你想使用的buildfile。


    ant打包:

    1.jar包

    <jar destfile="${dist}/lib/app.jar" basedir="${build}/classes"/>
    将${build}/classes下面的所有文件打包到${dist}/lib/app.jar中。

    2.war包

    对Jar的扩展,用于打包Web应用
    假设我们的文件目录如下:
    thirdparty/libs/jdbc1.jar
    thirdparty/libs/jdbc2.jar
    build/main/com/myco/myapp/Servlet.class
    src/metadata/myapp.xml
    src/html/myapp/index.html src/jsp/myapp/front.jsp
    src/graphics/images/gifs/small/logo.gif
    src/graphics/images/gifs/large/logo.gif
    下面是我们的任务的内容:

    <war destfile="myapp.war" webxml="src/metadata/myapp.xml">
    <fileset dir="src/html/myapp" />
    <fileset dir="src/jsp/myapp" />
    <lib dir="thirdparty/libs">
    <exclude name="jdbc1.jar" />
    </lib>
    <classes dir="build/main" />
    <zipfileset dir="src/graphics/images/gifs" prefix="images" />
    </war>

    完成后的结果:
    WEB-INF/web.xml
    WEB-INF/lib/jdbc2.jar
    WEB-INF/classes/com/myco/myapp/Servlet.class
    META-INF/MANIFEST.MF
    index.html front.jsp
    images/small/logo.gif
    images/large/logo.gif


    3.ear包

    <ear destfile="${build.dir}/myapp.ear" appxml="${src.dir}/metadata/application.xml">
    <fileset dir="${build.dir}" includes="*.jar,*.war" />
    </ear>



    展开全文
  • ANT

    千次阅读 2007-05-20 12:32:00
    一,构建ant环境要使用ant首先要构建一个ant环境,步骤很简单:1),安装jdk,设置JAVA_HOME ,PATH ,CLASS_PATH(这些应该是看这篇文章的人应该知道的)2),下载ant 地址http://www.apache.org/找一个你喜欢的版本,或者...

    一,构建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使用指南

    万次阅读 2019-09-13 18:02:03
    此文章是转载的:... 项目工具 概述 我们平常在写 Java 程序的时候,基本的步骤都是 打开一个集成开发环境(Eclipse 或者 Intellij IDEA)-> 开开心心的敲代码 ->...但是在实际的项目开发中,我们的项目会...

    此文章是转载的:https://blog.csdn.net/nalnait/article/details/80780682

    项目工具


    概述

    我们平常在写 Java 程序的时候,基本的步骤都是 打开一个集成开发环境(Eclipse 或者 Intellij IDEA)-> 开开心心的敲代码 ->点击 Run,就可以很有成就的看到自己辛劳的成果了。但是在实际的项目开发中,我们的项目会很大,而且在部署到服务器的时候我们需要用到一些自动化的工具(比如 jenkins),这个时候我们熟悉的集成开发环境就不存在了,因此我们需要用另外一种编译、打包、运行程序的方法。熟悉 C 语言的同学会会知道在编译 C 语言程序的时候,有种叫做 makefile 的东西,makefile 功能的强大足够支持它编译整个 Linux 系统,那对于 Java 来说有没有好用的工具呢?好在世界那么大,办法总是有的,著名的 Apache 基金会有一个叫做 Ant 的项目,是构建 Java 程序的一把好手,而且 Ant 的源码也是用 Java 实现了,用“自己”来编译“自己”,感觉也是件奇妙的事情呢! 
    说了这么多,可能有些同学还不知道 Ant 到底是什么,我们给出官方的定义:

    Apache Ant,是一个将软件编译、测试、部署等步骤联系在一起加以自动化的一个工具,大多用于 Java 环境中的软件开发。由Apache软件基金会所提供.Ant 也可以有效地用于构建非Java应用程序,例如 C 或 C++ 的应用程序。更一般地,Ant 可以用来驾驶任何类型的能在目标和任务来描述过程。

    学习好 Ant ,你将会更了解 Java 程序的构建过程。

    安装 Ant

    Windows下安装 Ant

    首先进入 Ant 的下载界面 http://ant.apache.org/bindownload.cgi,Windows 平台的同学选在下载 .zip 格式的压缩包,目前(2016-10-27)最新的版本是 1.9.7 ,所以我们这里就已这个版本在 Windows 下的安装为教程(在安装 Ant 之前,我们要确保 JDK 已经正确的安装在我们的计算机上面了,因为 Ant 的运行需要依赖 JDK)。

    1. 下载文件 
      这里写图片描述
    2. 解压 .zip文件,并放在某个目录下,我这是放在 D:\Program Files\Apache Software Foundation 目录下,解压后的文件名是 apache-ant-1.9.7
    3. 设置环境变量,右键点击计算机 -> 属性 -> 面板左上侧 高级系统设置 ->环境变量 ->(如果你的电脑是多用户电脑的话就在用户变量,如果是自己的电脑最好在系统变量)点击新建 -> 变量名:ANT_HOME,变量值:D:\Program Files\Apache Software Foundation\apache-ant-1.9.7,点击确定 -> 找到 Path 变量 -> 在其值的最后添加 ;%ANT_HOME%\bin; -> 点击确定

    到目前为止我们的 Ant 安装已经结束,不过我们需要验证 Ant 是否正确的安装。快捷键 win+R 快速打开运行窗口,然后输入 cmd 点击确定,我们就进入了 Windows 的命令行界面,然后输入 ant -version 显示如下的信息就代表我们安装成功了(大家在安装的时候可能会因为版本和笔者的不一样,显示的信息不完全一致,这是正常的,怎么可能你安装了 1.9.8 的版本还显示 1.9.7 的信息呢?显示对应的版本即可)

    Apache Ant(TM) version 1.9.7 compiled on April 9 2016
    •  

    如果失败的话,发生的原因会有很多,我建议主要检查一下几项:

    • JDK 是否安装好
    • 是否配置 JAVA_HOME 或配置错误,并且 JAVA_HOME\bin\java.exe 存在
    • 是否配置 ANT_HOEM 或配置错误,并且 ANT_HOME\bin\ant.bat 存在

    Mac OS 下安装 Ant

    使用Mac OS 的用户首先也需要进入官网下载 .zip 格式的文件,然后使用命令行进入你保存 .zip 文件的位置

    1 进入保存下载文件的位置(这里以桌面为例)

    cd ~/Desktop
    •  

    2 切换到超级用户权限(需要提供密码验证)

    sudo sh 
    •  

    3 把 .zip 文件放到合适的位置

    mv apache-ant-1.9.7-bin.zip /usr/local/  
    •  

    4 进入 .zip 文件所在目录

    cd /usr/local/
    •  

    5 解压 .zip 文件

    unzip apache-ant-1.9.7-bin.zip
    •  

    6 改变 Ant 文件的所有权,这样以后再修改 Ant 目录什么的时候就不再次需要 root 权限

    chown (your account name):(your account name) apache-ant-1.9.7
    •  

    7 给你的 Ant 目录创建一个链接,创建完链接后,你可以指定你的 Ant 目录是 /usr/local/ant,而不是/usr/local/apache-ant-1.9.7

    ln -s apache-ant-1.9.7 ant
    •  

    8 打开设置环境变量的文件

    vi /etc/bashrc
    •  

    9 修改环境变量(按 i 按键进入编辑模式,在问价的末件加入如下两行)

    
     
    1. export ANT_HOME=/usr/local/apache-ant-1.9.7

    2. export PATH=${PATH}:${ANT_HOME}/bin

    按下 Esc 键退出编辑模式,然后键入 :wq 即可退出 
    这个时候我们就需要验证 Ant 是否正确安装,方法同 Windows 下一样,这里就不再叙述了。

    Linux 下安装 Ant

    1 下载 Ant 文件,我们需要下载 .tar.gz 格式的文件,进入保存文件的目录(这里笔者以自己账户的目录为例)

    cd /home/weegee/
    •  

    2 切换到 root 权限(需要自己的密码验证)

    su
    •  

    3 移动文件到适合的位置

    mv apache-ant-1.9.7-bin.tar.gz /usr/local/
    •  

    4 进入 /usr/local/ 目录

    cd /usr/local/
    •  

    5 解压文件

    tar -vxzf apahce-ant-1.9.7-bin.tar.gz
    •  

    6 更改文件所有者,这样以后再修改 Ant 目录什么的时候就不再次需要 root 权限

    chown weegee apache-ant-1.9.7
    •  

    7 给你的 Ant 目录创建一个链接,创建完链接后,你可以指定你的 Ant 目录是 /usr/local/ant,而不是/usr/local/apache-ant-1.9.7

    ln -s apache-ant-1.9.7 ant
    •  

    8 打开设置环境变量的文件

    vi /etc/profile
    •  

    9 修改环境变量(按 i 按键进入编辑模式,在问件的末尾加入如下两行)

    
     
    1. export ANT_HOME=/usr/local/apache-ant-1.9.7

    2. export PATH=$PATH:$ANT_HOME/bin

    按下 Esc 键退出编辑模式,然后键入 :wq 即可退出 
    10 让环境变量立即生效

    source /etc/proifle
    •  

    这个时候我们就需要验证 Ant 是否正确安装,方法同 Windows 下一样,这里就不再叙述了。

    Ant 的项目结构

    打开我们解压后的 Ant 的文件,可以看到它的文件内容如下

    
     
    1. apache-ant-1.9.7

    2. |-bin

    3. |-etc

    4. |-lib

    5. |-manual

    6. | ...这是一些文件,我们不做重点介绍

    这里我主要说明下前四个文件夹的作用 
    - bin 是 ant 的程序运行入口,如果没有配置 ANT_HOME 的情况下,可以通过 bin 目录中的 bat 程序进行运行 build 任务。如:在 cmd 中运行 ant.bat 就可以执行程序,当然你选择要当前目录中存在一个 build.xml (build.xml是默认的ant执行文件,当然你可以指定其他文件) 
    - etc 目录中存放的都是一些xsl的输出模板,创建一个加强的导出各种任务的 XML 输出,使你的 build 文件摆脱过时的警告 
    - lib 目录中存放的是 ant 程序需要依赖的 jar 包 
    - manual 目录是 ant 程序的帮助文档

    一个简单的例子

    Ant 是以 build.xml 为默认的文件,如果不存在 build.xml,则 Ant 会报错,不过我们可以指定特定名称的 xml 文件作为 Ant 编译的文件。 
    首先我们创建一个 xml 文件并命名为 build.xml,其内容是:

    
     
    1. <project name="ant-project" default="example">

    2. <target name="example">

    3. <echo message="Hello World!" />

    4. </target>

    5. </project>

    上面代码的意思是,创建一个名称为 ant-project 的 Ant 工程,然后创建一个名称为 example 的执行目标,这个目标要做的事情就是打印字符串 Hello World!,很简单是不是。 
    然后我们通过命令行进入 build.xml 文件所在的目录,执行 ant 命令,可以看到输出

    
     
    1. Buildfile: F:\BIUBIU\Blog\ant\demo1\build.xml

    2.  
    3. example:

    4. [echo] Hello World!

    5.  
    6. BUILD SUCCESSFUL

    7. Total time: 1 second

    如果我们的 xml 文件的名字不是 build.xml,这个时候会发生什么呢?我们修改文件名为 ant.xml 然后同样运行 ant 命令,可以看到如下信息

    
     
    1. Buildfile: build.xml does not exist!

    2. Build failed

    很显然命令没有执行成功并提示 build.xml 不存在,那我们怎么执行 ant.xml 文件呢?可以使用如下命令

    ant -buildfile ant.xml
    •  

    输出的结果和刚才的结果一样,屏幕上打印出了 Hello World!。

    Ant 的一些命令

    经过上一小节的学习,我们已经初步了解了 Ant 的执行方式,不过在实际运行 ant 命令的时候,会有很多的可选命令,我们输入 ant -help 可以看到这些命令。 
    语法元素说明如下:

    attribute description
    -help 显示描述ant 命令及其选项的帮助信息
    -projecthelp 显示包含在构建文件中的、所有用户编写的帮助文档。即为各个中description 属性的文本,以及包含在元素中的任何文本。将有description 属性的目标列为主目标(Main target),没有此属性的目标则列为子目标(Subtarget)。
    -version 要求ant 显示其版本信息,然后退出。
    -quiet 抑制并非由构建文件中的echo 任务所产生的大多数消息。
    -verbose 显示构建过程中每个操作的详细消息。此选项与-debug 选项只能选其一。
    -debug 显示Ant 和任务开发人员已经标志为调试消息的消息。此选项与-verbose 只能选其一。
    -emacs 对日志消息进行格式化,使它们能够很容易地由Emacs 的shell 模式(shellmode)所解析;也就是说,打印任务事件,但并不缩排,在其之前也没有[taskname]。
    -logfile filename 将日志输出重定向到指定文件。
    -logger classname 指定一个类来处理Ant 的日志记录。所指定的类必须实现了org.apache.tools.ant.BuildLogger 接口。
    -listener classname 为Ant 声明一个监听类,并增加到其监听者列表中。在Ant与IDE或其他Java程序集成时,此选项非常有用。可以阅读第六章以了解有关监听者的更多信息。必须将所指定的监听类编写为可以处理Ant 的构建消息接发。
    -buildfile filename 指定Ant 需要处理的构建文件。默认的构建文件为build.xml。
    -Dproperty=value 在命令行上定义一个特性名-值对。
    -find filename 指定Ant 应当处理的构建文件。与-buildfile 选项不同,如果所指定文件在当前目录中未找到,-find 就要求Ant 在其父目录中再进行搜索。这种搜索会继续在其祖先目录中进行,直至达到文件系统的根为止,在此如果文件还未找到,则构建失败。
    -atuoproxy jdk1.5以上的可以使用代理设置
    -nouserlib 运行ant时不使用用户lib中的jar包
    -nice 设计主线程优先级
    -logfile 使用指定的log日志
    -noinput 不允许交互输入
    -keep-going, -k 执行不依赖于所有目标
    -propertyfile 加载所有属性配置文件 -d 属性文件优先

    这么多的命令我们在设计使用的时候用到的也不是很多,这里仅供大家了解,扩充知识面。

    Ant 的运行环境

    我们已经知道 Ant 是使用 Java 语言编写的,而在写 Java 程序的时候我们常常需要依赖很多外部的 jar 文件。在运行 ant 命令的时候,也需要依赖一些库文件,当需要的 jar 文件没有在 Ant 目录下的 lib 目录中提供的时候,我们可以把该文件直接放到 ant_home\lib 目录中作为全局的库使用。 
    如果你不想“污染”原始的ant程序,那么你可以把 jar 包放在当前 Windows 用户的目录下,具体位置应该是 ${user.home}/.ant/lib 下。没有以上目录可以手动建立。 
    如果你只是临时要添加 lib ,又不想把 lib 添加到当前 ant 工程中,你可以使用如下命令在运行ant程序的时候指定依赖的 lib 参数。

    ant -lib xxx.jar -f build.xml
    •  

    或者,你还可以在当前 build 工程的 classpath 目录中添加你的工程依赖 jar 包,这个就是后话了,我们会在后面的章节中介绍这种方法。

    Ant 基本元素

    在前面的 一个简单的例子 章节,我们已经看到了一个最基本的 build.xml 文件的组成

    
     
    1. <project name="ant-project" default="example">

    2. <target name="example">

    3. <echo message="Hello World!" />

    4. </target>

    5. </project>

    project 元素是一个构建xml文件必不可少的元素,且只能有一个此元素,作为最外层的元素,所有其他的元素标签都必须在其包含范围内。 
    target 元素是构建文件执行的基本单位,一个xml文件中可以有多个 target 元素,每一个 target 元素代表一个独立的任务,但是要想执行完所有的 target,我们必须制定 target 的执行顺序,不然及时我们在xml文件中写入了相应的任务,在构建的时候也不会执行。在只有一个 target 元素的xml文件中,我们可以按照例子中的方法,在 project 中的 default 属性的值制定默认的 target default="example",要是有多个 target 怎么办,default 属性的值又不能指定多个,这个时候我们就需要借助另外一个任务元素 depends。 
    depends 下面我们通过一个简单的例子简要介绍 depends 的用法。

    
     
    1. <project name="ant-project" default="next">

    2. <target name="example">

    3. <echo message="Hello World!" />

    4. </target>

    5. <target name="next" depends="example">

    6. <echo message="Hello World Again!" />

    7. </target>

    8. </project>

    我们这里写了两个 target,然后让默认的 target 是 next,看一下执行的结果是什么样

    
     
    1. example:

    2. [echo] Hello World!

    3.  
    4. next:

    5. [echo] Hello World Again!

    6.  
    7. BUILD SUCCESSFUL

    8. Total time: 0 seconds

    可以看到执行的顺序是先执行 example,然后才执行 next,这是因为 next 依赖于 example,所以在构建xml文件的时候,按照 default 的值找到了 next,但是 next 说他依赖于 example,你要想构建我,必须先构建 example,不然我就自杀:-),编译器拗不过他,只好先去构建 example,然后 next 才愉快的接受构建。 
    但是要是遇到更多的 target 我们应该怎么办呢? 
    比如有三个 target init、compile 和 run,我们知道在编译运行程序的时候首先需要初始化一个目录、文件什么的,然后再执行编译过程,编译成功之后再运行,就可以得到程序的结果,在xml文件中我们可以这样指定这三个 target 的顺序。
    方法一(这里仅做演示使用,就不写出全部的xml文件内容了)

    
     
    1. target init

    2. target compile depends init

    3. target run depends compile

    这是依次依赖的写法。 
    方法二

    
     
    1. target init

    2. target compile

    3. target run depends init,compile

    •  

    我们这里在最后一个 target 中把全部的依赖加进来,依赖按照指定的顺序依次运行。

    我们这里介绍了一个完整xml文件的最基本的元素,在 Ant 的构建物文件中,还有很多很多这样的元素,按照元素功能的不同我们又把这些元素分为两大类,Tasks 和 Types,刚才讲到的 target 和 depends 都是属于 Tasks,在实际的使用中我们也是使用 Tasks 的元素比较多,Types 的元素主要是一个文件操作的功能。

    集成环境(Eclipse、IDEA Intellij)中集成 Ant

    在实际的开发过程中,我们基本都是面对集成开发环境写代码,这个时候如果需要执行 Ant 命令还在命令行下输入就会降低效率,因此下面的内容中我就以 Eclipse 和 IDEA Intellij 为例介绍如何在集成开发环境(IDE)中集成 Ant,相信 90% 以上的读者在日常开发中都是使用这两款 IDE 吧。

    Eclipse

    Eclipse 在很早的版本就增加了对 Ant 的支持,我么可以在 Window->Perferences->Ant 页面看到 Ant的详细信息,这里可以设置 Ant 的目录以及编写 build.xml 文件时候的编译器语法显示等等。 
    其实在使用 Ant 的时候也是非常简单,我们只需要按照平常的使用编写代码就好了,最后在该项目下新建一个 build.xml 文件,然后在该文件里编写构建项目的 Ant 过程就可以了,最后右键点击该 build.xml 文件,Run As->Ant Build,就可以在控制台看到输出了。 
    有的人会觉得这样太麻烦了,这个时候我们可以采用一些偷懒的方法,在把功能代码写好了之后,然后 File->Export->General->Ant Buildfiles 就可以在该项目下导出一个由系统帮你编写好的 build.xml 文件,如果有其他的需要就可以在这个文件中修改为自己想要的功能。 
    有的时候我们不想使用 Eclipse 自带的 Ant 版本,想更换为自己的 Ant,我们就可以在 Window->Perferences->Ant->Runtime->Classpath->Ant Home Entries ,然后点击右侧的 Ant Home 修改 Ant。

    IDEA Intellij

    IDEA Intellij 中也集成了 Ant 的功能,我们也只需要在项目下新建 build.xml 文件就可,然后在 Ant Build 窗口(没有的话就在 View->Tool Windows->Ant Build)中打开,然后在 Ant Build 窗口点击加号把需要构建的 build.xml 文件加入进来(可以加入多个 build.xml 文件进行构建),然后 Run Build 就可以在 Messages 窗口看到输出(没有的话就在 View->Tool Windows->Messages)中打开。

    随着构建工具的发展,现在项目开发中我们在IDE中使用 Ant 的频率已经不那么多了,更多的是使用 Maven、Gradle,因此编写 Ant 文件比较繁琐,但是在某些场合 Ant 依然是很优秀的,而且学习 Ant 可以对项目运行过程有更加详细的了解,所以不要放弃!

    要想写好 build.xml 文件,对 Ant 的基本元素要有非常熟悉的了解,前面的章节我们介绍了 target、depends 元素,在下面的内容中我们会更加详细的介绍 Ant 的元素

    Ant Tasks

    1. project

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

    • name 属性:用于指定 project 元素的名称。
    • default 属性:用于指定 project 默认执行时所执行的 target 的名称。
    • basedir 属性:用于指定基路径的位置。该属性没有指定时,使用 Ant 的构件文件的附目录作为基准目录。
    
     
    1. <?xml version="1.0" ?>

    2. <project name="ant-project" default="print-dir" basedir=".">

    3. <target name="print-dir">

    4. <echo message="The base dir is: ${basedir}" />

    5. </target>

    6. </project>

    从上例可以看出,在这里定义了 default 属性的值为 print-dir,即当运行 ant 命令时,如果没有指明执行的 target ,则将执行默认的 target(print-dir)。此外,还定义了 basedir 属性的值为 “.” ,. 表示当前目录,进入当前目录后运行 ant 命令,得一下结果:

    
     
    1. print-dir:

    2. [echo] The base dir is: F:\BIUBIU\Blog\ant\demo1

    3.  
    4. BUILD SUCCESSFUL

    5. Total time: 0 seconds

    2. target

    target 为 ant 的基本执行单元或是任务,它可以包含一个或多个具体的单元/任务。多个 target 可以存在相互依赖关系。它有如下属性:

    • name 属性:指定 target 元素的名称,这个属性在一个 project 元素中是唯一的。我们可以通过指定 target 元素的名称来指定某个 target。
    • depends 属性:用于描述 target 之间的依赖关系,若与多个 target 存在依赖关系时,需要以 “.” 间隔。 Ant 会依照 depends 属性中 target 出现的顺序依次执行每个 target ,被依赖的 target 会先执行。
    • if 属性:用于验证指定的属性是存在,若不存在,所在 target 将不会被执行。
    • unless 属性:该属性的功能与 if 属性的功能正好相反,它也用于验证指定的属性是否存在,若不存在,所在 target 将会被执行。
    • description 属性:该属性是关于 target 功能的简短描述和说明。

    示例:

    
     
    1. <?xml version="1.0" ?>

    2. <project name="ant-target" default="print">

    3. <target name="version" if="ant.java.version">

    4. <echo message="Java Version: ${ant.java.version}" />

    5. </target>

    6. <target name="print" depends="version" unless="docs">

    7. <description>

    8. a depend example!

    9. </description>

    10. <echo message="The base dir is: ${basedir}" />

    11. </target>

    12. </project>

    从以下结果后可以看到,我们运行的是名为 print 的 target ,由于它依赖于 version 这个 target 任务,所以 version 将首先被执行,同时因为系统配置了 JDK,所以 ant.java.version 属性存在,执行了 version,输出信息: 
    [echo] Java Version: 1.8 
    version 执行完毕后,接着执行 print,因为 docs 不存在,而 unless 属性是在不存在时进入所在 target 的,由此可知 print 得以执行,输出信息: 
    [echo] The base dir is:D:\Workspace\AntExample\build

    3. property

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

    <property file="build.properties"/> 
    •  

    然后就可以使用 build.properties 中变量的名字。 
    property 元素可用作 task 的属性值。在 task 中是通过将属性名放在 ${属性名} 之间,并放在 task 属性值的位置来实现的。 
    Ant 提供了一些内置的属性,它能得到的系统属性的列表与 Java 文档中 System.getProperties() 方法得到的属性一致,这些系统属性可参考 sun 网站的说明。同时, Ant 还提供了一些它自己的内置属性,如下:

    • basedir: project 基目录的绝对路径;
    • ant.file: buildfile的绝对路径,上例中 ant.file 值为D:\Workspace\AntExample\build
    • ant.version: Ant 的版本信息,本文为 1.9.7 ;
    • ant.project.name: 当前指定的 project 的名字,即前文说到的 project 的 name 属性值;
    • ant.java.version: Ant 检测到的JDK版本,本文为 1.8 。

    举例说明如下:

    
     
    1. <project name="ant-project" default="example">

    2. <property name="name" value="jojo" />

    3. <property name="age" value="25" />

    4. <target name="example">

    5. <echo message="name: ${name}, age: ${age}" />

    6. <echo message="${ant.java.version}" />

    7. </target>

    8. </project>

    打印结果:

    
     
    1. example:

    2. [echo] name: jojo, age: 25

    3. [echo] 1.8

    4.  
    5. BUILD SUCCESSFUL

    6. Total time: 0 seconds

    上例中用户设置了名为 name 和 age 的两个属性,这两个属性设置后,在下文中可以通过 ${name} 和 ${age} 分别取得这两个属性值,并打印了 Ant 的内置属性。 
    此外我们可以通过System.getProperties()得到更多有关系统的属性,并且通过 Ant 打印出来,不过首先我们通过一个 Java 程序获得属性的 key。

    
     
    1. import java.util.Iterator;

    2. import java.util.Map;

    3. import java.util.Properties;

    4.  
    5. public class SystemProperties {

    6. @SuppressWarnings("rawtypes")

    7. public static void main(String[] args){

    8. Map map = System.getenv();

    9. for(Iterator iterator = map.keySet().iterator(); iterator.hasNext();){

    10. String key = (String) iterator.next();

    11. String value = (String) map.get(key);

    12. System.out.println(key + " : " + value);

    13. }

    14. System.out.println("---------------我是分割线---------------");

    15. Properties properties = System.getProperties();

    16. for(Iterator iterator = properties.keySet().iterator(); iterator.hasNext();){

    17. String key = (String) iterator.next();

    18. String value = (String) properties.get(key);

    19. System.out.println(key + " : " + value);

    20. }

    21. }

    22. }

    输出结果(这里只是随便截取了几个值,上面的是系统的 environment,下面的是 properties,关于 environment 我们会在下面的章节详细介绍)。

    
     
    1. PUBLIC:C:\Users\Public

    2.  
    3. NUMBER_OF_PROCESSORS:4

    4.  
    5. windir:C:\Windows

    6.  
    7. =:::::\

    8.  
    9. ---------------我是分割线---------------

    10. java.runtime.name:Java(TM) SE Runtime Environment

    11.  
    12. sun.boot.library.path:D:\Program Files\Java\jdk1.8.0_101\jre\bin

    13.  
    14. java.vm.version:25.101-b13

    然后打印一个 property 和 environment。

    
     
    1. <project name="ant-project" default="example">

    2. <property environment="env"/>

    3. <target name="example">

    4. <echo message="${java.vm.version}" />

    5. <echo message="${env.NUMBER_OF_PROCESSORS}" />

    6. </target>

    7. </project>

    输出结果:

    
     
    1. example:

    2. [echo] 25.101-b13

    3. [echo] 4

    4.  
    5. BUILD SUCCESSFUL

    6. Total time: 0 seconds

    4. copy

    copy 将文件或者 FileSet 复制到一个新的文件或者目录。 FileSet 用于指定用于复制的文件集合,如果使用了 FileSet,copy 的 todir 必须指定一个值,copy 支持的常用的 attribute 如下:

    attribute description
    file 要复制的文件
    tofile 复制到新的文件的文件名
    todir 复制到新的目录的目录名
    overwrite 默认值为false,也就是只有当被复制的文件比目标文件新的时候才复制,如果需要强制覆盖目标文件,需要将overwrite设置为true

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

    <copy file="old.txt" tofile="new.txt"/>
    •  

    对文件目录进行复制:

    
     
    1. <copy todir="../dest_dir">

    2. <fileset dir="src_dir"/>

    3. </copy>

    4.  
    5. <copy todir="../dest/dir">

    6. <fileset dir="src_dir">

    7. <exclude name="**/*.java"/>

    8. </fileset>

    9. </copy>

    10.  
    11. <copy todir="../dest/dir">

    12. <fileset dir="src_dir" excludes="**/*.java"/>

    13. </copy>

    将文件复制到另外的目录:

    <copy file="src.txt" todir="../some/other/dir"/>
    •  

    有本地的 copy 就有远程的 copy,我们可以只用 Ant 把本地的内容复制到远程的服务器上面,不过大多数情况下我们都需要先连接到远程服务器

    <sshexec host="172.17.227.186" username="root" password="feixun*123" command="service jboss stop" trust="true" />
    •  

    使用 sshexec 连接到服务器,接下来就可以使用 scp 命令复制了

    
     
    1. <scp todir="user:password@IP:/usr/local/jboss/standalone/deployment s" trust="true">

    2. <fileset dir="../build/compileDir/compileWar">

    3. <include name="**/*.war" />

    4. </fileset>

    5. </scp

    5. delete

    对文件或目录进行删除,举例如下: 
    删除某个文件:

    <delete file="/res/image/cat.jpg"/>
    •  

    删除某个目录:

    <delete dir="/res/image"/>
    •  

    删除所有的jar文件或空目录:

    
     
    1. <delete includeEmptyDirs="true">

    2. <fileset dir="." includes="**/*.jar"/>

    3. </delete>

    6. mkdir

    创建目录

    <mkdir dir="/home/philander/build/classes"/>
    •  
    
     
    1. <?xml version="1.0"?>

    2. <project name="propertyStudy" default="mkdir" description="创建目录">

    3. <target name="mkdir">

    4. <mkdir dir="mkdirTest"/>

    5. </target>

    6. </project>

    7. move

    移动文件或目录,举例如下: 
    移动单个文件:

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

    移动单个文件到另一个目录:

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

    移动某个目录到另一个目录:

    
     
    1. <move todir="newdir">

    2. <fileset dir="olddir">

    3. <include name="**/*.jar"/>

    4. <exclude name="**/ant.jar"/>

    5. </fileset>

    6. </move>

    8. echo

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

    <echo message="ant message" file="/logs/ant.log" append="true">
    •  

    9. jar

    标签用来生成一个JAR文件,其属性如下。

    • destfile表示JAR文件名。
    • basedir表示被归档的文件名。
    • includes表示别归档的文件模式。
    • exchudes表示被排除的文件模式。
    • compress表示是否压缩。

    我们在写程序的时候,会需要依赖很多第三方 jar 包,这些 jar 包就是别人写好的程序然后打成 jar 包让我们使用的,其实我们也可是自己写一些程序然后打成 jar 包,以后能用到的时候直接把 jar 包引入进来就好了。 
    示例:

    
     
    1. <jar destfile="${webRoot}/${ash_jar}" level="9" compress="true" encoding="utf-8" basedir="${dest}">

    2. <manifest>

    3. <attribute name="Implementation-Version" value="Version: 2.2"/>

    4. </manifest>

    5. </jar>

    上面的 mainfest 是jar包中的 MEAT-INF 中的 MANIFEST.MF 中的文件内容。 
    同样打包操作的的还有 war、tgz,解压操作 uzip

    
     
    1. <!-- 创建zip -->

    2. <zip basedir="${basedir}\classes" zipfile="temp\output.zip"/>

    3. <!-- 创建tgz -->

    4. <gzip src="classes\**\*.class" zipfile="output.class.gz"/>

    5. <!-- 解压zip -->

    6. <unzip src="output.class.gz" dest="extractDir"/>

    7. <!-- 建立war包 -->

    8. <war destfile="${webRoot}/ash.war" basedir="${basedir}/web" webxml="${basedir}/web/WEB-INF/web.xml">

    9. <exclude name="WEB-INF/classes/**"/>

    10. <exclude name="WEB-INF/lib/**"/>

    11. <exclude name="WEB-INF/work/_jsp/**"/>

    12. <lib dir="${lib.dir}" includes="**/*.jar, **/*.so, **/*.dll">

    13. <exclude name="${webRoot}\${helloworld_jar}"/>

    14. </lib>

    15. <lib file="${webRoot}/${helloworld_jar}"/>

    16. <classes dir="${dest}" includes="**/*.xml, **/*.properites, **/*.xsd"> </classes>

    17. </war>

    •  

    把程序打成 jar 包的一个简单例子

    
     
    1. <?xml version="1.0"?>

    2. <project name="javaTest" default="jar" basedir=".">

    3. <target name="jar" description="打JAR包">

    4. <jar destfile="helloworld.jar" basedir="build/classes">

    5. <manifest>

    6. <attribute name="Main-class" value="HelloWorld" />

    7. </manifest>

    8. </jar>

    9. </target>

    10. </project>

    •  

    这个例子只是一个最简单的构建文件,仅仅把编译后的文件坐在的目录 classes 中的 class 文件打成 jar包。

    10. javadoc

    javadoc 是一个非常复杂的 task,一共有50多个 attribute,幸好只有四个 attribute 是必须的,那就是 sourcepath、sourcefiles、sourcepathref 和 destdir,对于sourcepath、sourcefiles 和 sourcepathref 只需要指定其中一个,如果都没有指定,那么必须提供嵌套的 sourcepath、 fileset 或者 packageset,从字面上很容易理解 sourcepath、sourcefiles、sourcepathref 是源文件所在的目录,而 destdir 是生成的 javadoc API 所在的目录。 
    下面是一些我们常用的 attribute:

    attribute description
    sourcepath 源文件目录,可用嵌套的 sourcepath 代替
    sourcefiles 逗号分割的文件列表,可用嵌套的 source 代替
    destdir 输出文件所在的目录,通常我们习惯将结果保存在 doc/api 下
    packagenames 逗号分割的 java 包列表,可用嵌套的 package 代替
    packageList 指定一个文件,文件内容是 javadoc 需要处理的包的列表
    classpath 指定 class 文件所在的位置,可用嵌套的 classpath 代替
    use 生成 class 和 package 的用法
    version 生成 @version 的信息
    author 生成 @author 的信息
    windowtitle 生成的 doc 的浏览的窗口的标题
    header 每一页的 header 信息
    footer 每一页的 footer 信息
    bottom 每一页的 bottom 信息
    nodeprecated 不生成 @deprecated 的信息

    常见的可以嵌套的参数如下:packageset、fileset、package、excludepackage、source、doctitle、header、footer 和 bottom,它们的具体用法请参考官方文档。 
    javadoc 的 sourcepath、classpath 和 bootclasspath 是 path-like 机构,也就是完全可以用嵌套的 sourcepath、 classpath 和 bootclasspath 来代替。

    
     
    1. <javadoc packagenames="com.dummy.test.*"

    2. sourcepath="src"

    3. defaultexcludes="yes"

    4. destdir="docs/api"

    5. author="true"

    6. version="true"

    7. use="true"

    8. windowtitle="Test API">

    9. <classpath refid="compile.classpath"/>

    10. </javadoc>

    11.  
    12. <javadoc author="true"

    13. destdir="{javadoc.dir}"

    14. packagenames="org.example.helloworld.*"

    15. sourcepath="src"

    16. use="true"

    17. version="true"

    18. windowtitle="Helloworld api spec"

    19. private="true">

    20. <classpath refid="compile.classpath"/>

    21. </javadoc>

    22.  
    23. <javadoc destdir="docs/api" author="true" version="true" use="true" windowtitle="Test API">

    24. <packageset dir="src" defaultexcludes="yes">

    25. <include name="com/dummy/test/**" />

    26. <exclude name="com/dummy/test/doc-files/**"/>

    27. </packageset>

    28.  
    29. <doctitle>

    30. <![CDATA[<h1>Test</h1>]]>

    31. </doctitle>

    32. <bottom>

    33. <![CDATA[<i>Copyright &#169; 2000 Dummy Corp. All Rights Reserved.</i>]]>

    34. </bottom>

    35. <tag name="todo" scope="all" description="To do:" />

    36. <group title="Group 1 Packages" packages="com.dummy.test.a*"/>

    37. <group title="Group 2 Packages" packages="com.dummy.test.b*:com.dummy.test.c*"/>

    38. <link offline="true" href="::URL::http://java.sun.com/ products/jdk/1.2/docs/api/" packagelistLoc="C:/tmp"/>

    39. <link href="::URL::http://developer.java.sun.com/developer/products/xml/docs/api/"/>

    40. </javadoc>

    11. environment

    由Ant构建文件调用的外部命令或程序,env 元素制定了哪些环境变量要传递给正在执行的系统命令,env 元素可以接受以下属性。

    • file表示环境变量值的文件名。此文件名要被转换位一个绝对路径。
    • path表示环境变量的路径。Ant会将它转换为一个本地约定。
    • value 表示环境变量的一个直接变量。
    • key 表示环境变量名。

    注意 file、path 或 value 只能取一个,在 property 部分我们已经介绍了该元素的功能,这里就不重复了。

    12. arg

    由Ant构建文件调用的程序,可以通过 arg 元素向其传递命令行参数,如 apply、exec 和 java 任务均可接受嵌套 arg 元素,可以为各自的过程调用指定参数。以下是 arg 的所有属性。

    • values 是一个命令参数。如果参数中有空格,但又想将它作为单独一个值,则使用此属性。
    • file 表示一个参数的文件名。在构建文件中,此文件名相对于当前的工作目录。
    • line 表示用空格分隔的多个参数列表。
    • 表示路径,一个作为单个命令行变量的 path-like 的字符串;或作为分隔符,Ant会将其转变为特定平台的分隔符。
    • pathref 引用的 path (使用 path 元素节点定义 path)的id
    • prefix 前缀
    • suffix 后缀

    例子

    <arg value="-l -a"/> 
    •  

    是一个含有空格的单个的命令行变量。

    <arg line="-l -a"/> 
    •  

    是两个空格分隔的命令行变量。

    <arg path="/dir;/dir2:\dir3"/> 
    •  

    是一个命令行变量,其值在DOS系统上为\dir;\dir2;\dir3;在Unix系统上为/dir:/dir2:/dir3 。

    13. javac

    javac 使我们再熟悉不过的了,其功能就是把 java 程序编译成 class 文件,我们来看看在 Ant 中它又焕发可什么样的光彩。 
    先看一个基本的 javac 命令:

    javac -d build/classes -classpath %CLASSPATH%;lib/outlib.jar -sourcepath src -g
    •  

    该标签用于编译一个或一组java文件,其属性如下。

    • srcdir表示源程序的目录,相当于 javac 命令的 -sourcepath 参数,srcdir 也是 javac 的隐式 implicit 的 FileSet,因此 srcdir 支持 FileSet 的所有特征。
    • destdir表示 classes 文件的输出目录,相当于 javac 命令的 -d 参数。
    • include表示被编译的文件的模式。
    • excludes表示被排除的文件的模式。
    • classpath表示所使用的类路径。
    • debug表示包含的调试信息,debug=”yes” 相当于 javac 命令的 -g 参数,debug=”no” 相当于 javac 命令的 -g:none 参数。
    • optimize表示是否使用优化,默认是 off,optimize=”on” 相当于 javac 命令的 -o 参数。
    • verbose 表示提供详细的输出信息。
    • fileonerror如果编译错误,build 是否继续,默认是 true。
    • deprecation 输出对于那些使用了 deprecation 的API的源文件的位置,默认是 off,deprecation=”on” 相当于 javac 命令的 -deprecation 参数。
    • fork 使用外部的JDK编译器来运行 javac,默认是 no,采用 yes 可以取得更好的效率,当然对机器的要求也高。

    示例:

    
     
    1. <javac srcdir="${src}" destdir="${dest}"/>

    2. <!-- 设置jvm内存

    3. <javac srcdir="src" fork="true"/>

    4. <javac srcdir="src" fork="true" executable="d:\sdk141\bin\javac"

    5. memoryMaximumSize="128m"/>

    6. -->

    7.  
    8. <javac destdir="{build.classes.dir}"

    9. debug="{build.debug}"

    10. includeAntRuntime="yes"

    11. srcdir="{sirc.dir}">

    12. <classpath refid="compile.classpath"/>

    13. <include name="**/*.java"/>

    14. </javac>

    
     
    1. <?xml version="1.0"?>

    2. <project name="javacTest" default="compile" basedir=".">

    3. <target name="clean" description="删除编译后产生的目录及文件">

    4. <delete dir="build" />

    5. </target>

    6.  
    7. <target name="compile" depends="clean" description="编译源文件">

    8. <mkdir dir="build/classes" />

    9. <javac srcdir="src" destdir="build/classes" />

    10. </target>

    11. </project>

    •  

    14. java

    java 我们也是很熟悉,它就是用来执行编译生成的.class文件,其属性如下:

    • classname 表示将执行的类名。
    • jar表示包含该类的JAR文件名。
    • classpath所表示用到的类路径。
    • fork表示在一个新的虚拟机中运行该类。
    • failonerror表示当出现错误时自动停止。
    • output 表示输出文件。
    • append表示追加或者覆盖默认文件。

    示例

    <java classname="com.hoo.test.HelloWorld" classpath="${hello_jar}"/>
    •  

    编译并运行JAVA程序

    
     
    1. <?xml version="1.0"?>

    2. <project name="javaTest" default="run" basedir=".">

    3. <target name="clean" description="清除目录">

    4. <delete dir="build" />

    5. </target>

    6.  
    7. <target name="compile" depends="clean" description="编译">

    8. <mkdir dir="build/classes" />

    9. <javac srcdir="src" destdir="build/classes" />

    10. </target>

    11.  
    12. <target name="run" depends="compile" description="运行">

    13. <java classname="AntTest">

    14. <classpath>

    15. <pathelement path="build/classes" />

    16. </classpath>

    17. </java>

    18. </target>

    19. </project>

    •  

    在前面的部分我们会经常遇到 filelist、fileset、path等元素,这些就是 Ant 的 Types,我们在下面的内容大致介绍几个常用的 Types。

    15. filelist

    filelist 是一个支持命名的文件列表的数据类型,包含在一个 filelist 类型中的文件不一定是存在的文件。以下是其所有的属性:

    • dir是用于计算绝对文件名的目录。
    • files 是用逗号分隔的文件名列表。
    • refid 是对某处定义的一个 filelist 的引用。

    注意 dir 和 files 都是必要的,除非指定了 refid (这种情况下,dir 和 files 都不允许使用)。

    示例

    
     
    1. 文件集合 ${doc.src}/foo.xml和${doc.src}/bar.xml. 这些文件也许还是不存在的文件.

    2. <filelist id="docfiles" dir="${doc.src}" files="foo.xml bar.xml"/>

    3.  
    4. <filelist refid="docfiles"/>

    5.  
    6. <filelist id="docfiles" dir="${doc.src}">

    7. <file name="foo.xml"/>

    8. <file name="bar.xml"/>

    9. </filelist>

    •  

    16. fileset

    fileset 数据类型定义了一组文件,并通常表示为 fileset 元素。不过,许多 ant 任务构建成了隐式的 fileset,这说明他们支持所有的 fileset 属性和嵌套元素,与 filelist 不同的是 fileset 下的文件必须存在。以下为 fileset 的属性列表:

    • dir表示 fileset 的基目录。
    • casesensitive的值如果为 false,那么匹配文件名时,fileset 不是区分大小写的,其默认值为 true。
    • defaultexcludes 用来确定是否使用默认的排除模式,默认为 true。
    • excludes 是用逗号分隔的需要派出的文件模式列表。
    • excludesfile 表示每行包含一个排除模式的文件的文件名。
    • includes 是用逗号分隔的,需要包含的文件模式列表。
    • includesfile 表示每行包括一个包含模式的文件名。

    示例

    
     
    1. <fileset id="lib.runtime" dir="${lib.path}/runtime">

    2. <include name="**/*.jar"/>

    3. <include name="**/*.so"/>

    4. <include name="**/*.dll"/>

    5. </fileset>

    6.  
    7. <fileset id="lib.container" dir="${lib.path}/container">

    8. <include name="**/*.jar"/>

    9. </fileset>

    10.  
    11. <fileset id="lib.extras" dir="${lib.path}">

    12. <include name="test/**/*.jar"/>

    13. </fileset>

    •  

    17. patternset

    fileset 是对文件的分组,而 patternset 是对模式的分组,他们是紧密相关的概念。

    patternset 支持4个属性:includes、excludex、includexfile、excludesfile,这些与 fileset 相同。 
    patternset 还允许以下嵌套元素:include、exclude、includefile 和 excludesfile。

    示例

    
     
    1. <!-- 黑白名单 -->

    2. <patternset id="non.test.sources">

    3. <include name="**/*.java"/>

    4. <!-- 文件名包含Test的排除 -->

    5. <exclude name="**/*Test*"/>

    6. </patternset>

    7.  
    8.  
    9. <patternset id="sources">

    10. <include name="std/**/*.java"/>

    11. <!-- 判断条件 存在professional就引入 -->

    12. <include name="prof/**/*.java" if="professional"/>

    13. <exclude name="**/*Test*"/>

    14. </patternset>

    15.  
    16. <!-- 一组文件 -->

    17. <patternset includesfile="some-file"/>

    18. <patternset>

    19. <includesfile name="some-file"/>

    20. <patternset/>

    21.  
    22. <patternset>

    23. <includesfile name="some-file"/>

    24. <includesfile name="${some-other-file}" if="some-other-file"/>

    25. <patternset/>

    •  

    下面看一下 fileset 和 patternset 的简单使用:

    
     
    1. <fileset id="sources" dir="src"

    2. includes="**/*.java"

    3. excludes="**/test/**/*.java">

    4. </fileset>

    •  

    等价于

    
     
    1. <fileset id="sources" dir="src">

    2. <patternset>

    3. <include name="**/*.java"/>

    4. <exclude name="**/test/**/*.java"/>

    5. </patternset>

    6. </fileset>

    •  

    等价于

    
     
    1. <patternset id="non.test.source">

    2. <include name="**/*.java"/>

    3. <exclude name="**/test/**/*.java"/>

    4. </patternset>

    5. <fileset id="sources" dir="src">

    6. <patternset refid="non.test.source"/>

    7. </fileset>

    •  

    18. filterset

    filterset 定义了一组过滤器,这些过滤器将在文件移动或复制时完成文件的文本替换。 
    主要属性如下:

    • begintoken 表示嵌套过滤器所搜索的记号,这是标识其开始的字符串。
    • endtoken 表示嵌套过滤器所搜索的记号这是标识其结束的字符串。
    • id 是过滤器的唯一标志符。
    • refid 是对构建文件中某处定义一个过滤器的引用。

    示例

    
     
    1. <!-- 将目标文件build.dir目录中的version.txt文件内容中的@DATE@替换成TODAY当前日期的值,并把替换后的文件存放在dist.dir目录中 -->

    2. <copy file="${build.dir}/version.txt" toFile="${dist.dir}/version.txt">

    3. <filterset>

    4. <filter token="DATE" value="${TODAY}"/>

    5. </filterset>

    6. </copy>

    7.  
    8. <!-- 自定义变量的格式 -->

    9. <copy file="${build.dir}/version.txt" toFile="${dist.dir}/version.txt">

    10. <!-- 从version.txt中的%位置开始搜索,到*位置结束,进行替换内容中的@DATE@替换成TODAY当前日期的值-->

    11. <filterset begintoken="%" endtoken="*">

    12. <filter token="DATE" value="${TODAY}"/>

    13. </filterset>

    14. </copy>

    15.  
    16. <!-- 使用外部的过滤定义文件 -->

    17. <copy toDir="${dist.dir}/docs">

    18. <fileset dir="${build.dir}/docs">

    19. <include name="**/*.html">

    20. </fileset>

    21. <filterset begintoken="%" endtoken="*">

    22. <!-- 过来文件从外部引入,过来的属性和值配置在dist.properties文件中 -->

    23. <filtersfile file="${user.dir}/dist.properties"/>

    24. </filterset>

    25. </copy>

    26.  
    27. <!-- 使用引用方式,重复利用过滤集 -->

    28. <filterset id="myFilterSet" begintoken="%" endtoken="*">

    29. <filter token="DATE" value="${TODAY}"/>

    30. </filterset>

    31.  
    32. <copy file="${build.dir}/version.txt" toFile="${dist.dir}/version.txt">

    33. <filterset refid="myFilterSet"/>

    34. </copy>

    •  

    19. path

    path 元素用来表示一个类路径,不过它还可以用于表示其他的路径。在用作几个属性时,路经中的各项用分号或冒号隔开。在构建的时候,此分隔符将代替当前平台中所有的路径分隔符,其拥有的属性如下:

    • location 表示一个文件或目录。Ant在内部将此扩展为一个绝对路径。
    • refid 是对当前构建文件中某处定义的一个 path 的引用。
    • path表示一个文件或路径名列表。

    path 支持的嵌套元素如下:

    • 0..n 个嵌套的 pathelement, pathlelement 定义在路径下的一个或者多个文件,pathelement 支持 location 和 path 这两个 attribute,用法和 path 元素一样;
    • 0..n 个嵌套的 fileset ;
    • 0..n 个嵌套的 path;

    示例

    
     
    1. <path id="buildpath">

    2. <fileset refid="lib.runtime"/>

    3. <fileset refid="lib.container"/>

    4. <fileset refid="lib.extras"/>

    5. </path>

    6.  
    7. <path id="src.paths">

    8. <fileset id="srcs" dir=".">

    9. <include name="src/**/*.java"/>

    10. </fileset>

    11. </path>

    12.  
    13. <path>

    14. <pathelement location="{libdir}/servlet.jar"/>

    15. <pathelement location="{libdir}/logging.jar"/>

    16. <pathelement path="{builddir}"/>

    17. <pathelement path="{utilpath}"/>

    18. </path>

    •  

    path 最常用的是 classpath 这个形式,但是也用于其他用途。

    
     
    1. <classpath>

    2. <pathelement path="{builddir}"/>

    3. </classpath>

    •  

    等价于

    
     
    1. <classpath path="{builddir}"/>

    2.  
    3. <classpath>

    4. <pathelement path="{builddir1}"/>

    5. <pathelement path="{builddir2}"/>

    6. </classpath>

    •  

    等价于

    <classpath path="{builddir1};{builddir2}"/>
    •  

    20. 后续有其他的再补充,有兴趣对 Ant 深入研究的可以查看官方手册http://ant.apache.org/manual/

    一些详细的例子

    在学习 Ant 的时候,我们会发现知识太繁多,根本没兴趣一直学下来,其实学习 Ant 主要的就是 抄。 
    这里我告诉大家如何能够对 Ant 有更深的掌握。 
    1. 首先我们需要知道一些基本的元素以及使用方法,这些看前面我们讲解的内容皆可以获得; 
    2. 写一些简单的程序,然后在构建文件中使用我们讲解的元素来编译运行程序; 
    3. 遇到比较多的程序的时候,我们需要借助一些现有的构建文件,比如我们需要把一个 webproject 打成 war 包,但是我们又不会写构建文件,这个时候我们就需要一个别人写好的构建文件,然后仔细揣摩写法,遇到不懂的地方再查阅该元素的详细用法,最后修改构建文件满足自己的要求; 
    4. 遇到新的功能我们也要尝试使用 Ant 来完成,比如我们需要使用 JUnit 来测试程序,这个时候我们就需要借助 Ant 的 JUnit 任务,我们首先查阅 junit 的用法,然后在构建文件中写入该任务,不断修改直至成功运行。 
    下面我给出几个常用的构建过程,大家可以拿来仔细研究,对于不懂的部分,有些注释写的也很详细。

    打成 war 包

    
     
    1. <?xml version="1.0"?>

    2. <project name="antwebproject" default="war" basedir=".">

    3. <!--定义常量,任务可以引用-->

    4. <property name="classes" value="build/classes" />

    5. <property name="build" value="build" />

    6. <property name="lib" value="WebRoot/WEB-INF/lib" />

    7.  
    8.  
    9. <!-- 删除build路径-->

    10. <target name="clean">

    11. <delete dir="build" />

    12. </target>

    13.  
    14.  
    15. <!-- 建立build/classes路径,并编译class文件到build/classes路径下-->

    16. <target name="compile" depends="clean">

    17. <mkdir dir="${classes}" />

    18. <javac srcdir="src" destdir="${classes}" />

    19. </target>

    20.  
    21.  
    22. <!-- 打war包-->

    23. <target name="war" depends="compile">

    24. <war destfile="${build}/AntProject.war" webxml="WebRoot/WEB-INF/web.xml">

    25. <!-- 拷贝WebRoot下除了WEB-INF和META-INF的两个文件夹 , **意为:匹配0或者更多的目录-->

    26. <fileset dir="WebRoot" includes="**/*.jsp" />

    27.  
    28. <!-- 拷贝lib目录下的jar包-->

    29. <lib dir="${lib}" />

    30.  
    31. <!-- 拷贝build/classes下的class文件-->

    32. <classes dir="${classes}" />

    33.  
    34. </war>

    35. </target>

    36.  
    37. </project>

    •  
    
     
    1. <?xml version="1.0" encoding="UTF-8"?>

    2.  
    3. <project name="ant_firsttest" default="dist" basedir=".">

    4. <description>ant firsttest!</description>

    5.  
    6. <!-- set global properties for this build -->

    7. <!--设定变量,之后用。location为文件夹路径-->

    8. <property name="src" location="src"/>

    9. <property name="build" location="build"/>

    10. <property name="dist" location="dist"/>

    11. <property name="web" location="web"/>

    12.  
    13. <!--设置properties文件位置.这里没用到。-->

    14. <!--<property file="nbproject/project.properties"/>-->

    15.  
    16. <!--初始化命令-->

    17. <target name="init">

    18. <!-- Create the time stamp -->

    19. <tstamp/>

    20.  
    21. <!--mkdir是建立文件夹,${build}即刚才设定的变量。这几行都在干这事。-->

    22. <!-- Create the build directory structure used by compile -->

    23. <mkdir dir="${build}/WEB-INF/lib"/>

    24. <mkdir dir="${build}/WEB-INF/classes"/>

    25.  
    26. <mkdir dir="${build}/WEB-INF/classes/javafile/package1"/>

    27. <mkdir dir="${build}/WEB-INF/classes/javafile/package2"/>

    28.  
    29. </target>

    30.  
    31. <!--编译-->

    32. <target name="compile" depends="init"

    33. description="compile the source " >

    34.  
    35. <!-- Compile the java code from ${src} into ${build} -->

    36. <!--javac标签用来设置编译程序的参数,srcdir为java文件路径,destdir为编译后class文件的保存路径。-->

    37. <javac srcdir="${src}/javafile/package1" destdir="${build}/WEB-INF/classes/javafile/package1"/>

    38. <javac srcdir="${src}/javafile/package2" destdir="${build}/WEB-INF/classes/javafile/package2"/>

    39. <!--如果路径下还有别的文件需要一起打包,用copy 命令。-->

    40. <copy file="${src}/hello_ant.xml" tofile="${build}/WEB-INF/classes/hello_ant.xml" />

    41.  
    42. </target>

    43.  
    44. <!--编译后就要打包了。-->

    45. <target name="dist" depends="compile"

    46. description="generate the distribution" >

    47. <!-- Create the distribution directory -->

    48. <mkdir dir="${dist}"/>

    49.  
    50. <!--像jsp,jar这些直接用不用编译的文件,直接用copy命令。-->

    51. <copy file="${web}/image/a.gif" tofile="${build}/image/a.gif" />

    52. <copy file="${web}/WEB-INF/web.xml" tofile="${build}/WEB-INF/web.xml" />

    53. <copy file="${web}/WEB-INF/lib/a.jar" tofile="${build}/WEB-INF/lib/a.jar" />

    54. <copy file="${web}/index.jsp" tofile="${build}/index.jsp" />

    55.  
    56. <!--最后用jar命令打成jar/war文件,文件名和后缀随便起。basedir为欲打包的原文件路经-->

    57. <jar jarfile="${dist}/ant_firsttest.jar" basedir="${build}"/>

    58. </target>

    59.  
    60. <!--删除-->

    61. <target name="clean"

    62. description="clean up" >

    63. <!--设定删除命令要删的路径。-->

    64. <!-- Delete the ${build} and ${dist} directory trees -->

    65. <delete dir="${build}"/>

    66. <delete dir="${dist}"/>

    67. </target>

    68. </project>

    打成 jar 包

    
     
    1. <?xml version="1.0" encoding="UTF-8"?>

    2. <!-- name是当前工程的名称,default是默认执行的任务,basedir是工作目录(.代表当前根目录) -->

    3. <project name="HelloWorld" default="run" basedir=".">

    4. <!-- property类似于程序中定义简单的变量 -->

    5. <property name="src" value="src"/>

    6. <property name="dest" value="classes"/>

    7. <property name="hello_jar" value="helloWorld.jar"/>

    8. <!--

    9. target是一个事件、事情、任务, name是当前事情的名称,depends是依赖的上一件或是多件事情

    10. 如果所依赖的事情没有执行,ant会先运行依赖事情,然后再运行当前事情

    11. -->

    12.  
    13. <!-- 初始化 -->

    14. <target name="init">

    15. <!-- 建立classes目录 -->

    16. <mkdir dir="${dest}"/>

    17. <mkdir dir="temp"/>

    18. <mkdir dir="temp2"/>

    19. </target>

    20.  
    21. <!-- 编译 -->

    22. <target name="compile" depends="init">

    23. <javac srcdir="${src}" destdir="${dest}"/>

    24. <!-- 设置jvm内存

    25. <javac srcdir="src" fork="true"/>

    26. <javac srcdir="src" fork="true" executable="d:\sdk141\bin\javac"

    27. memoryMaximumSize="128m"/>

    28. -->

    29. </target>

    30.  
    31. <!-- 建立jar包 -->

    32. <target name="build" depends="compile">

    33. <!--

    34. <jar jarfile="${hello_jar}" basedir="${dest}"/>

    35. 创建一个名称是package.jar文件

    36. <jar destfile="package.jar" basedir="classes"/>

    37. -->

    38. <jar destfile="${hello_jar}" basedir="classes">

    39. <!-- 向jar包中的main文件中添加内容 -->

    40. <manifest>

    41. <attribute name="Built-By" value="${user.name}"/>

    42. <attribute name="Main-class" value="package.Main"/>

    43. </manifest>

    44. </jar>

    45. <!-- 复制jar文件 todir="复制到目录"-->

    46. <copy file="${hello_jar}" tofile="${dest}\temp.jar"/>

    47. <copy todir="temp">

    48. <!-- 不按照默认方式 defaultexcludes="" -->

    49. <fileset dir="src">

    50. <include name="**/*.java"/>

    51. </fileset>

    52. </copy>

    53.  
    54. <copy todir="temp2">

    55. <fileset dir="src">

    56. <and>

    57. <contains text="main"/>

    58. <size value="1" when="more"/>

    59. </and>

    60. </fileset>

    61. </copy>

    62.  
    63. <!-- 移动jar文件 -->

    64. <move file="${dest}\temp.jar" tofile="temp\move-temp.jar"/>

    65. <!-- 创建zip -->

    66. <zip basedir="${basedir}\classes" zipfile="temp\output.zip"/>

    67. <!-- 创建tgz -->

    68. <gzip src="classes\**\*.class" zipfile="output.class.gz"/>

    69. <!-- 解压zip -->

    70. <unzip src="output.class.gz" dest="extractDir"/>

    71. <!--替换input.txt内容中的old为new

    72. <replace file="input.txt" token="old" value="new"/>

    73. -->

    74. </target>

    75.  
    76. <!-- 运行 -->

    77. <target name="run" depends="build">

    78. <java classname="com.hoo.test.HelloWorld" classpath="${hello_jar}"/>

    79. </target>

    80.  
    81. <!-- 清除 -->

    82. <target name="clean">

    83. <!-- 删除生成的文件 -->

    84. <delete dir="${dest}"/>

    85. <delete file="${hello_jar}"/>

    86. </target>

    87.  
    88. <tstamp>

    89. <format property="OFFSET_TIME"

    90. pattern="HH:mm:ss"

    91. offset="10" unit="minute"/>

    92. </tstamp>

    93.  
    94. <!-- 重新运行 -->

    95. <target name="rerun" depends="clean,run">

    96. <echo message="###${TSTAMP}#${TODAY}#${DSTAMP}###"/>

    97. <aunt target="clean"/>

    98. <aunt target="run"/>

    99. </target>

    100. </project>

    •  
    
     
    1. <?xml version="1.0"?>

    2. <!--默认为打包操作-->

    3. <project name="structured" default="archive">

    4. <description>编译并打包一个应用程序</description>

    5. <!--在工程目录下创建输出目录:build/classes 和 dist-->

    6. <target name="init" description="创建目录">

    7. <mkdir dir="build/classes" />

    8. <mkdir dir="dist" />

    9. </target>

    10.  
    11. <!--编译输出目录:srcdir-源目录和destdir-目标目录-->

    12. <target name="compile" depends="init" description="编译">

    13. <javac srcdir="src" destdir="build/classes" />

    14. </target>

    15.  
    16. <!--打包 , depends依赖哪些target-->

    17. <target name="archive" depends="compile" description="打包">

    18. <war destfile="dist/antwebproject.war" basedir="build/classes" />

    19. <jar destfile="dist/project.jar" basedir="build/classes" />

    20. </target>

    21.  
    22. <!--清理删除-->

    23. <target name="clean" depends="init" description="清理">

    24. <delete dir="build" />

    25. <delete dir="dist" />

    26. </target>

    27. </project>

    •  

    一个良好的目录结构

    在各个地方我们都能看到目录的组织都大致按照一套标准,比如 Linux 系统中,每个目录中都存放特定的文件,有着特定的功能,组织一个良好的目录结构能够你的程序可理解性更强,比如我们文章开头介绍的 Ant 的目录结构。 
    下面我们来看看一个良好的目录结构的基本组成。

    
     
    1. project_home #项目所在目录

    2. |-src #项目源代码

    3. | |-java #Java主程序代码

    4. | |-test #Java测试程序代码

    5. | |-conf

    6. | | mainfest #manifest声明文件

    7. |-lib #库文件目录

    8. |-doc #项目有关说明文档,如果是开源项目,通常该目录下是相应的web content

    9. | |-api #生成项目的Java API文档的地方

    10. |-build #用于创建的临时目录

    11. | |-classes #编译的结果保存在该目录

    12. |-dist #用于发布的临时目录,通常会将build/classes下的文件打包成jar,保存在该目录下

    13. | README #项目的说明文件

    14. | RELEASE #项目的发布文件

    15. | LICENSE #项目的license文件

    •  

    发布项目 
    让我们先看看发布前必须做的一些准备工作: 
    1. 撰写文档。 
    2. 撰写和平台相关的自启动脚本 bootstrap script,批处理文件 batch file,或者程序。 
    3. 撰写安装脚本,使用安装工具。 
    4. 检查版本控制系统中和项目相关的源码,文档,以及其他资料。 
    5. 将版本控制系统中的源码打上标签。 
    6. 运行一次完整的 build。 
    7. 运行一次完整的测试。 
    8. 将软件打包成适当的形式,用于发布和安装。 
    对于打包这个步骤,如下图:

    
     
    1. Data files Java source Documentation

    2. | | |

    3. | _____|_____ |

    4. | | | |

    5. | <javac> <javadoc> |

    6. | | | |

    7. |_____________| |__________________|

    8. | |

    9. jar |

    10. | |

    11. jar file |

    12. |____________________________|

    13. |

    14. |

    15. <zip><gzip><tar>

    16. |

    17. |

    18. Distribution

    19. package

    将源码和数据文件打包成 jar,将文档和生成的文档保存在某个目录,然后将整体打包 zip 或者 tar,为不同的平台提供最终的版本以供下载,这就是打包的过程。

    任何一个复杂的程序除了代码之外还包括了数据,例如初始化数据,配置文件,xml 文件,schema 文件,还有些国际化和本地化文本文件,最理想化的方式是将这些数据打包在 jar 文件里面,然后通过 java 的 getResource 或者 getResourceAsStream 这样的方法来访问这些数据,对于打包在 jar 文件中的文件,java 提供了目录模式 reference pattern 来访问它们,如 org/example/helloworld/helloworld.properties。

    总结

    在本篇文章中我们首先介绍了 Ant 的作用和目录结构,然后介绍了 Ant 在不同操作系统的安装,接着介绍 Ant 的基本使用以及其在IDE中的集成,之后又介绍了部分 Ant 的 Tasks 和 Types,接着给出了一些构建过程,最后介绍了程序目录的组成和发布过程。 
    学习 Ant 不是仅仅学习如何使用 Ant 构建程序,我们从中学习到的更多的是对 Java 程序的构建方式以及构建过程的了解,我们甚至能够知道那些IDE是如何来编译运行程序的(也许它们也是靠着一个 build.xml 文件来相应我们鼠标点下的 compile 和 run 按钮的),此外因为使用 Ant 我们需要创建很多的目录来放置不同类型的文件,我们也就更能了解一个良好程序的目录组织的重要性。

    展开全文
  • 执行ant -version报错: java.lang.NoClassDefFoundError: org/apache/tools/ant/launch/AntMain %ANT_HOME% D:\apache-ant-1.8.4 %CLASSPATH% D:\apache-ant-1.8.4\lib %PATH% C:\Program...
  • android ANT 打包错误

    2015-06-16 05:30:08
    最近做ANT混淆的时候发现编译不过去,找了半天没有明白是什么错误 ,请各位大神帮忙解答一下。 -dex: [dex] input: F:\workspace\yunmaApplication\bin\proguard\obfuscated.jar [dex] Converting compiled files ...
  • 所需文件ant打包apk需要三个目录: build.xml,local.properties,proguard-project.txt生成方式,在项目根目录下执行指令:android update project —path .其中,build.xml文件是进行ant build的主要文件,它...
  • AntAnt标签解释

    千次阅读 2014-10-17 10:46:21
    使用ant命令需要编写ant命令脚本,该脚本由很多Ant标签组成,现在总结一下我所遇到的Ant标签:
  • E:\eclipse1\adt-bundle-windows-x86_64_20140101\adt-bundle-windows-x86_64_20140101\sdk\tools\ant\build.xml:881: The following error occurred while executing this line: E:\eclipse1\adt-bundle-windows-...
  • 在日常的项目开发中,我们可以经常性的需要打包测试,尤其是开发环境是windows,而实际环境则是linux。 这样的话,很多程序员要一会...这个时候我是可以使用ant来打包,去掉项目中的所有的jar文件。然后在项目的tomca
  • ant 内容 <!-- 删除build路径 </target>--> <!-- 建立build/classes路径,并编译class文件到build/classes路径下 depends="clean"--> ${classes}"/> ${classes}" encoding="UTF-8"/> <!-- 打...
  • Ant Design

    千次阅读 2019-05-28 09:04:01
    Ant Design 服务于企业级产品的设计体系,基于确定和自然的设计价值观上的模块化解决方案,让设计者和开发者专注于更好的用户体验。 Ant Design Mobile of React Ant Design Mobile of Angular Ant ...
  • ant 安装

    千次阅读 2012-08-25 11:27:55
    Apache Ant下载页面地址:http://ant.apache.org/bindownload.cgi 这三个随便下载一个,我下载的是.zip后缀的. 下载后解压到你的安装目录:你会看见如下图 现在开始配置环境变量: 我的电脑->属性->高级->...
  • 配置Ant

    千次阅读 2012-01-09 13:52:55
    找到文件%ANT_HOME%\bin\ant.bat,这就是启动Ant的脚本文件,加入以下代码: 在ant.bat文件中的:runAntWithClasspath 后加上了-Xmx1024m, set ANT_OPTS="-Xms128m -Xmx256m"  如果你遇到...
  • 维基百科上对Ant的介绍:Apache Ant,是一个将软件编译、测试、部署等步骤联系在一起加以自动化的一个工具,大多用于Java环境中的软件开发。由Apache软件基金会所提供。默认情况下,它的buildfile(XML文件)名为build....
  • Ant BUILDFILE FAILED D:\Program Files\adt-bundle-windows-x86_64\adt-bundle-windows-x86_64\sdk\tools\ant\build.xml:601: D:\Program Files\adt-bundle-windows-x86_64\adt-bundle-windows-x86_64\sdk\tools\...
  • Ant Design Pro实战入门教程-整合版

    千人学习 2019-12-27 10:54:16
    Ant Design Pro是一个企业级中后台前端/设计解决方案,秉承了 Ant Design 的设计价值观,致力于在设计规范和基础组件的基础上,继续向上构建,提炼出典型模板/业务组件/配套设计资源。随着设计者的不断反馈,Ant ...
  • [extras] $ /Users/lixiuming/Ant/bin/ant -Dtest=Test /Users/lixiuming/Ant/bin/ant: line 28: uname: command not found /Users/lixiuming/Ant/bin/ant: line 29: uname: command not found /Users/lixiuming/Ant...
  • eclipse 导入ant项目之后,右键选择build.xml, run as ant build 为什么浏览器不出现运行界面?就像javaweb项目 run as server之后浏览器就默认运行主页了 。难道run as ant build就是用来编译的,还要手动把项目...
  • Ant—使用Ant构建简单Java项目(一)

    万次阅读 2014-10-16 11:00:34
    Apache Ant主要用于Java项目的构建。为什么要使用Apache Ant来构建项目呢: 1)项目构建不是简单的编译,各种资源需要合理构建,例如有的类需要压缩成jar文件,有的文件需要放在指定位置,有时候需要使用配置文件...
  • Ant Design Vue

    千次阅读 2019-05-28 09:20:14
    Ant Design Vue Ant Design of Vue Following the Ant Design specification, we developed a Vue UI libraryantdthat contains a set of high quality components and demos for building rich, interactive .....
  • ANT DESIGN PRO

    千次阅读 2019-05-28 09:13:17
    ANT DESIGN PRO 开箱即用的中台前端/设计解决方案 相关资源 Ant Design Ant Design Mobile NG-ZORRO-Ant Design of Angular NG-ZORRO-MOBILE Awesome Ant Design Kitchen-Sketch 工具集 Ant Design...
  • ANT安装会出现如下问题: ANT_HOME is set incorrectly or ant could not be located. Please set ANT_HOME.   解决:问题出现是因为该文件夹已经在别的地方运行过,所以,只要重新去官网下载...
  • Ant:给Ant脚本传递参数的最佳实践

    千次阅读 2012-01-05 15:22:30
    Ant是一个Make Tool,主要用于代码的编译,构建。当然,也有很多Ant爱好者开发了很多外部任务扩展了它的功能。它无界面,跨平台的特性,正好适用于软件开发人员。Ant已经成为软件开发人员开发过程中的一道利器。 在...
  • Ant 简易入门

    千次阅读 2012-08-27 17:21:52
    1. 下载 到 http://ant.apache.org/bindownload.cgi 中下载 binary 版的最新的Ant ...如果不配置的话, 在命令行使用ant 时需要使用ant 命令的全路径。 配置的话, 直接使用 ant 就可以了。 新增 ANT_HOME --
  • EMMA ANT使用

    千次阅读 2012-05-15 11:56:45
    http://emma.sourceforge.net/userguide/ar01s03.html ...3. Getting Started (ANT) ...This section introduces EMMA ANT tasks. It starts with an example of how to run an application from ANT
  • Ant学习笔记

    千次阅读 2014-07-11 12:26:02
    1、Ant(another neat tool)是一个基于Java的生成工具,其作用类似于命令的批处理,通过设置一个xml文件后,Ant将会执行xml文件中指定的系列命令。这对于随着应用程序的生成过程变得更加复杂,又需要确保在每次生成...
  • ant学习笔记

    千次阅读 2012-03-19 11:33:33
    1,ant介绍 ant构建工具,我们能用到的多是它的编译,拷贝,复制,运行命令等功能. ant的好处:1,跨平台,因为ant是使用java实现的;2,使用简单;3,语法清晰;4,功能强大. ant做的很多事情,大部分是曾经一个叫make的工具...

空空如也

1 2 3 4 5 ... 20
收藏数 52,141
精华内容 20,856
关键字:

ant