`
阅读更多

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

2 下载、安装Ant
安装Ant
下载.zip文件,解压缩到c:\ant1.3(后面引用为%ANT_HOME%)

2.1 在你运行Ant之前需要做一些配置工作。
? 将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扩展)。而且通过扩展装入的类会有安全方面的限制。
2.2 运行Ant

运行Ant非常简单,当你正确地安装Ant后,只要输入ant就可以了。

n 没有指定任何参数时,Ant会在当前目录下查询build.xml文件。如果找到了就用该文件作为buildfile。如果你用 -find 选项。Ant就会在上级目录中寻找buildfile,直至到达文件系统的根。要想让Ant使用其他的buildfile,可以用参数 -buildfile file,这里file指定了你想使用的buildfile。

n 可以指定执行一个或多个target。当省略target时,Ant使用标签<project>的default属性所指定的target。


命令行选项总结:
ant [options] [target [target2 [target3] ...]]
Options:
-help print this message
-projecthelp print project help information
-version print the version information and exit
-quiet be extra quiet
-verbose be extra verbose
-debug print debugging information
-emacs produce logging information without adornments
-logfile file use given file for log output
-logger classname the class that is to perform logging
-listener classname add an instance of class as a project listener
-buildfile file use specified buildfile
-find file search for buildfile towards the root of the filesystem and use the first one found
-Dproperty=value set property to value
例子
ant
使用当前目录下的build.xml运行Ant,执行缺省的target。
ant -buildfile test.xml
使用当前目录下的test.xml运行Ant,执行缺省的target。
ant -buildfile test.xml dist
使用当前目录下的test.xml运行Ant,执行一个叫做dist的target。
ant -buildfile test.xml -Dbuild=build/classes dist
使用当前目录下的test.xml运行Ant,执行一个叫做dist的target,并设定build属性的值为build/classes。

3 编写build.xml

Ant的buildfile是用XML写的。每个buildfile含有一个project。

buildfile中每个task元素可以有一个id属性,可以用这个id值引用指定的任务。这个值必须是唯一的。(详情请参考下面的Task小节)

3.1 Projects

project有下面的属性:
Attribute Description Required
name 项目名称. No
default 当没有指定target时使用的缺省target Yes
basedir 用于计算所有其他路径的基路径。该属性可以被basedir property覆盖。当覆盖时,该属性被忽略。如果属性和basedir property都没有设定,就使用buildfile文件的父目录。 No
项目的描述以一个顶级的<description>元素的形式出现(参看description小节)。

一个项目可以定义一个或多个target。一个target是一系列你想要执行的。执行Ant时,你可以选择执行那个target。当没有给定target时,使用project的default属性所确定的target。

3.2 Targets

一个target可以依赖于其他的target。例如,你可能会有一个target用于编译程序,一个target用于生成可执行文件。你在生成可执行文件之前必须先编译通过,所以生成可执行文件的target依赖于编译target。Ant会处理这种依赖关系。

然而,应当注意到,Ant的depends属性只指定了target应该被执行的顺序-如果被依赖的target无法运行,这种depends对于指定了依赖关系的target就没有影响。

Ant会依照depends属性中target出现的顺序(从左到右)依次执行每个target。然而,要记住的是只要某个target依赖于一个target,后者就会被先执行。
<target name="A"/>
<target name="B" depends="A"/>
<target name="C" depends="B"/>
<target name="D" depends="C,B,A"/>
假定我们要执行target D。从它的依赖属性来看,你可能认为先执行C,然后B,最后A被执行。错了,C依赖于B,B依赖于A,所以先执行A,然后B,然后C,最后D被执行。

一个target只能被执行一次,即时有多个target依赖于它(看上面的例子)。

如果(或如果不)某些属性被设定,才执行某个target。这样,允许根据系统的状态(java version, OS, 命令行属性定义等等)来更好地控制build的过程。要想让一个target这样做,你就应该在target元素中,加入if(或unless)属性,带 上target因该有所判断的属性。例如:
<target name="build-module-A" if="module-A-present"/>
<target name="build-own-fake-module-A" unless="module-A-present"/>
如果没有if或unless属性,target总会被执行。

可选的description属性可用来提供关于target的一行描述,这些描述可由-projecthelp命令行选项输出。

将你的tstamp task在一个所谓的初始化target是很好的做法,其他的target依赖这个初始化target。要确保初始化target是出现在其他target依赖表中的第一个target。在本手册中大多数的初始化target的名字是"init"。

target有下面的属性:
Attribute Description Required
name target的名字 Yes
depends 用逗号分隔的target的名字列表,也就是依赖表。 No
if 执行target所需要设定的属性名。 No
unless 执行target需要清除设定的属性名。 No
description 关于target功能的简短描述。 No

3.3 Tasks

一个task是一段可执行的代码。

一个task可以有多个属性(如果你愿意的话,可以将其称之为变量)。属性只可能包含对property的引用。这些引用会在task执行前被解析。

下面是Task的一般构造形式:
<name attribute1="value1" attribute2="value2" ... />
这里name是task的名字,attributeN是属性名,valueN是属性值。

有一套内置的(built-in)task,以及一些可选task,但你也可以编写自己的task。

所有的task都有一个task名字属性。Ant用属性值来产生日志信息。

可以给task赋一个id属性:
<taskname id="taskID" ... />
这里taskname是task的名字,而taskID是这个task的唯一标识符。通过这个标识符,你可以在脚本中引用相应的task。例如,在脚本中你可以这样:
<script ... >
task1.setFoo("bar");
</script>
设定某个task实例的foo属性。在另一个task中(用java编写),你可以利用下面的语句存取相应的实例。
project.getReference("task1").
注意1:如果task1还没有运行,就不会被生效(例如:不设定属性),如果你在随后配置它,你所作的一切都会被覆盖。

注意2:未来的Ant版本可能不会兼容这里所提的属性,因为很有可能根本没有task实例,只有proxies。

3.4 Properties

一个project可以有很多的properties。可以在buildfile中用property task来设定,或在Ant之外设定。一个property有一个名字和一个值。property可用于task的属性值。这是通过将属性名放在"${" 和"}"之间并放在属性值的位置来实现的。例如如果有一个property builddir的值是"build",这个property就可用于属性值:${builddir}/classes。这个值就可被解析为 build/classes。

内置属性

如果你使用了<property> task 定义了所有的系统属性,Ant允许你使用这些属性。例如,${os.name}对应操作系统的名字。

要想得到系统属性的列表可参考the Javadoc of System.getProperties。

除了Java的系统属性,Ant还定义了一些自己的内置属性:
basedir project基目录的绝对路径 (与<project>的basedir属性一样)。
ant.file buildfile的绝对路径。
ant.version Ant的版本。
ant.project.name 当前执行的project的名字;由<project>的name属性设定.
ant.java.version Ant检测到的JVM的版本; 目前的值有"1.1", "1.2", "1.3" and "1.4".
???
例子
<project name="MyProject" default="dist" basedir=".">

<!-- set global properties for this build -->
<property name="src" value="."/>
<property name="build" value="build"/>
<property name="dist" value="dist"/>
???
<target name="init">
<!-- Create the time stamp -->
<tstamp/>
<!-- Create the build directory structure used by compile -->
<mkdir dir="${build}"/>
</target>
?
<target name="compile" depends="init">
<!-- Compile the java code from ${src} into ${build} -->
<javac srcdir="${src}" destdir="${build}"/>
</target>

<target name="dist" depends="compile">
<!-- Create the distribution directory -->
<mkdir dir="${dist}/lib"/>
<!-- Put everything in ${build} into the MyProject-${DSTAMP}.jar file -->
<jar jarfile="${dist}/lib/MyProject-${DSTAMP}.jar" basedir="${build}"/>
</target>

<target name="clean">
<!-- Delete the ${build} and ${dist} directory trees -->
<delete dir="${build}"/>
<delete dir="${dist}"/>
</target>

</project>

3.5 Path-like Structures
你可以用":"和";"作为分隔符,指定类似PATH和CLASSPATH的引用。Ant会把分隔符转换为当前系统所用的分隔符。

当需要指定类似路径的值时,可以使用嵌套元素。一般的形式是
<classpath>
<pathelement path="${classpath}"/>
<pathelement location="lib/helper.jar"/>
</classpath>
location属性指定了相对于project基目录的一个文件和目录,而path属性接受逗号或分号分隔的一个位置列表。path属性一般用作预定义的路径--其他情况下,应该用多个location属性。

为简洁起见,classpath标签支持自己的path和location属性。所以:
<classpath>
<pathelement path="${classpath}"/>
</classpath>
可以被简写作:
<classpath path="${classpath}"/>
也可通过<fileset>元素指定路径。构成一个fileset的多个文件加入path-like structure的顺序是未定的。
<classpath>
<pathelement path="${classpath}"/>
<fileset dir="lib">
<include name="**/*.jar"/>
</fileset>
<pathelement location="classes"/>
</classpath>
上面的例子构造了一个路径值包括:${classpath}的路径,跟着lib目录下的所有jar文件,接着是classes目录。

如果你想在多个task中使用相同的path-like structure,你可以用<path>元素定义他们(与target同级),然后通过id属性引用--参考Referencs例子。

path-like structure可能包括对另一个path-like structurede的引用(通过嵌套<path>元素):
<path id="base.path">
<pathelement path="${classpath}"/>
<fileset dir="lib">
<include name="**/*.jar"/>
</fileset>
<pathelement location="classes"/>
</path>
<path id="tests.path">
<path refid="base.path"/>
<pathelement location="testclasses"/>
</path>
前面所提的关于<classpath>的简洁写法对于<path>也是有效的,如:
<path id="tests.path">
? <path refid="base.path"/>
<pathelement location="testclasses"/>
</path>
可写成:
<path id="base.path" path="${classpath}"/>
命令行变量

有些task可接受参数,并将其传递给另一个进程。为了能在变量中包含空格字符,可使用嵌套的arg元素。
Attribute Description Required
value 一个命令行变量;可包含空格字符。 只能用一个
line 空格分隔的命令行变量列表。
file 作为命令行变量的文件名;会被文件的绝对名替代。
path 一个作为单个命令行变量的path-like的字符串;或作为分隔符,Ant会将其转变为特定平台的分隔符。

例子
<arg value="-l -a"/>
是一个含有空格的单个的命令行变量。
<arg line="-l -a"/>
是两个空格分隔的命令行变量。
<arg path="/dir;/dir2:\dir3"/>
是一个命令行变量,其值在DOS系统上为\dir;\dir2;\dir3;在Unix系统上为/dir:/dir2:/dir3 。

References

buildfile元素的id属性可用来引用这些元素。如果你需要一遍遍的复制相同的XML代码块,这一属性就很有用--如多次使用<classpath>结构。

下面的例子:
<project ... >
<target ... >???
<rmic ...>?????
<classpath>???????
<pathelement location="lib/"/>???????
<pathelement path="${java.class.path}/"/>???????
<pathelement path="${additional.path}"/>?????
</classpath>???
</rmic>?
</target>
<target ... >
<javac ...>
<classpath>
<pathelement location="lib/"/>
<pathelement path="${java.class.path}/"/>
<pathelement path="${additional.path}"/>
</classpath>
</javac>
</target>
</project>
可以写成如下形式:
<project ... >
<path id="project.class.path">?
<pathelement location="lib/"/>
<pathelement path="${java.class.path}/"/>??
<pathelement path="${additional.path}"/>
</path>
<target ... >
<rmic ...>
<classpath refid="project.class.path"/>
</rmic>
</target>
<target ... >
<javac ...>
<classpath refid="project.class.path"/>
</javac>
</target>
</project>
所有使用PatternSets, FileSets 或 path-like structures嵌套元素的task也接受这种类型的引用。

4.1 File(Directory)类
4.1.1 Mkdir
n 创建一个目录,如果他的父目录不存在,也会被同时创建。
n 例子:
<mkdir dir="build/classes"/>
n 说明: 如果build不存在,也会被同时创建
4.1.2 Copy
n 拷贝一个(组)文件、目录
n 例子:
1. 拷贝单个的文件:
<copy file="myfile.txt" tofile="mycopy.txt"/>
2. 拷贝单个的文件到指定目录下
<copy file="myfile.txt" todir="../some/other/dir"/>
3. 拷贝一个目录到另外一个目录下
? <copy todir="../new/dir">
??? <fileset dir="src_dir"/>
? </copy>
4. 拷贝一批文件到指定目录下
? <copy todir="../dest/dir">
??? <fileset dir="src_dir">
????? <exclude name="**/*.java"/>
??? </fileset>
? </copy>

? <copy todir="../dest/dir">
??? <fileset dir="src_dir" excludes="**/*.java"/>
? </copy>
5. 拷贝一批文件到指定目录下,将文件名后增加。Bak后缀
? <copy todir="../backup/dir">
??? <fileset dir="src_dir"/>
??? <mapper type="glob" from="*" to="*.bak"/>
? </copy>
6. 拷贝一组文件到指定目录下,替换其中的@标签@内容
? <copy todir="../backup/dir">
??? <fileset dir="src_dir"/>
??? <filterset>
????? <filter token="TITLE" value="Foo Bar"/>
??? </filterset>
? </copy>
4.1.3 Delete
n 删除一个(组)文件或者目录
n 例子
1. 删除一个文件
<delete file="/lib/ant.jar"/>
2. 删除指定目录及其子目录
? <delete dir="lib"/>
3. 删除指定的一组文件
? <delete>
??? <fileset dir="." includes="**/*.bak"/>
? </delete>
4. 删除指定目录及其子目录,包括他自己
? <delete includeEmptyDirs="true">
??? <fileset dir="build"/>
? </delete>
4.1.4 Move
n 移动或重命名一个(组)文件、目录
n 例子:
1. 移动或重命名一个文件
<move file="file.orig" tofile="file.moved"/>
2. 移动或重命名一个文件到另一个文件夹下面
<move file="file.orig" todir="dir/to/move/to"/>
3. 将一个目录移到另外一个目录下
<move todir="new/dir/to/move/to">
<fileset dir="src/dir"/>
</move>
4. 将一组文件移动到另外的目录下
<move todir="some/new/dir">
<fileset dir="my/src/dir">
<include name="**/*.jar"/>
<exclude name="**/ant.jar"/>
</fileset>
</move>
5. 移动文件过程中增加。Bak后缀
<move todir="my/src/dir">
<fileset dir="my/src/dir">
<exclude name="**/*.bak"/>
</fileset>
<mapper type="glob" from="*" to="*.bak"/>
</move>

时间:2007-3-8 10:51:13 | 打开原文
Ant参考教程(一)

ant教程
1,什么是ant
?ant是构建工具
2,什么是构建
?概念到处可查到,形象来说,你要把代码从某个地方拿来,编译,再拷贝到某个地方去等等操作,当然不仅与此,但是主要用来干这个
3,ant的好处
?跨平台? --因为ant是使用java实现的,所以它跨平台
?使用简单--与ant的兄弟make比起来
?语法清晰--同样是和make相比
?功能强大--ant能做的事情很多,可能你用了很久,你仍然不知道它能有多少功能。当你自己开发一些ant插件的时候,你会发现它更多的功能。
4,ant的兄弟make
?ant做的很多事情,大部分是曾经有一个叫make的所做的,不过对象不同,make更多应用于c/c++ ,ant更多应用于Java。当然这不是一定的,但大部分人如此。
一,构建ant环境
要使用ant首先要构建一个ant环境,步骤很简单:
1),安装jdk,设置JAVA_HOME ,PATH ,CLASS_PATH(这些应该是看这篇文章的人应该知道的)
2),下载ant 地址www.apache.org 找一个你喜欢的版本,或者干脆最新的版本
3),解压ant 你得到的是一个压缩包,解压缩它,并把它放在一个尽量简单的目录,例如D:\ant-1.6虽然你不一 定要这么做,但这么做是有好处的。
4),设置ANT_HOME PATH中添加ANT_HOME目录下的bin目录
5),测试一下你的设置,开始-->运行-->cmd进入命令行-->键入 ant 回车,如果看到
Buildfile: build.xml does not exist!
Build failed
那么恭喜你你已经完成ant的设置
二,体验ant
就像每个语言都有HelloWorld一样,一个最简单的应用能让人感受一下Ant
1,首先你要知道你要干什么,我现在想做的事情是:
编写一些程序
编译它们
把它打包成jar包
把他们放在应该放置的地方
运行它们
这里为了简单起见只写一个程序,就是HelloWorld.java程序代码如下:
package test.ant;
public class HelloWorld{
?public static void main(String[] args){
? System.out.println("Hello world1");
?}
};
2,为了达到上边的目的,你可以手动的用javac 、copy 、jar、java来完成,但是考虑一下如果你有成百上千个类,在多次调试,部署的时候,一次次的javac 、copy、jar、
java那将是一份辛苦的工作。现在看看ant怎么优雅的完成它们。
要运行ant需要有一个build.xml虽然不一定要叫这个名字,但是建议你这么做
下边就是一个完整的build.xml,然后我们来详细的解释每一句
<?xml version="1.0" encoding="UTF-8" ?>
<project name="HelloWorld" default="run" basedir=".">
?<property name="src" value="src"/>
?<property name="dest" value="classes"/>
?<property name="hello_jar" value="hello1.jar"/>
?<target name="init">
? <mkdir dir="${dest}"/>
?</target>
?<target name="compile" depends="init">
? <javac srcdir="${src}" destdir="${dest}"/>
?</target>
?<target name="build" depends="compile">
? <jar jarfile="${hello_jar}" basedir="${dest}"/>
?</target>
?<target name="run" depends="build">
? <java classname="test.ant.HelloWorld" classpath="${hello_jar}"/>
?</target>
?<target name="clean">
? <delete dir="${dest}" />
? <delete file="${hello_jar}" />
?</target>
?<target name="rerun" depends="clean,run">
? <ant target="clean" />
? <ant target="run" />
?</target>
</project>
解释:
<?xml version="1.0" encoding="UTF-8" ?>
build.xml中的第一句话,没有实际的意义
<project name="HelloWorld" default="run" basedir=".">
</project>
ant的所有内容必须包含在这个里边,name是你给它取的名字,basedir故名思意就是工作的根目录 .代表当前目录。default代表默认要做的事情。
<property name="src" value="src"/>
类似程序中的变量,为什么这么做想一下变量的作用
<target name="compile" depends="init">
? <javac srcdir="${src}" destdir="${dest}"/>
</target>
把你想做的每一件事情写成一个target ,它有一个名字,depends是它所依赖的target,在执行这个target 例如这里的compile之前ant会先检查init是否曾经被执行过,如果执行
过则直接直接执行compile,如果没有则会先执行它依赖的target例如这里的init,然后在执行这个target
如我们的计划
编译:
<target name="compile" depends="init">
?<javac srcdir="${src}" destdir="${dest}"/>
</target>
做jar包:
<target name="build" depends="compile">
?<jar jarfile="${hello_jar}" basedir="${dest}"/>
</target>
运行:
<target name="run" depends="build">
?<java classname="test.ant.HelloWorld" classpath="${hello_jar}"/>
</target>
为了不用拷贝,我们可以在最开始定义好目标文件夹,这样ant直接把结果就放在目标文件夹中了
新建文件夹:
<target name="init">
?<mkdir dir="${dest}"/>
</target>
为了更多一点的功能体现,又加入了两个target
删除生成的文件
<target name="clean">
?<delete dir="${dest}" />
?<delete file="${hello_jar}" />
</target>
再次运行,这里显示了如何在一个target里边调用其他的target
<target name="rerun" depends="clean,run">
?<ant target="clean" />
?<ant target="run" />
</target>
好了,解释完成了,下边检验一下你的ant吧
新建一个src的文件夹,然后把HelloWorld.java按照包目录放进去
做好build.xml文件
在命令行下键入ant ,你会发现一个个任务都完成了。每次更改完代码只需要再次键入ant
有的时候我们可能并不想运行程序,只想执行这些步骤中的某一两个步骤,例如我只想重新部署而不想运行,键入
ant build
ant中的每一个任务都可以这样调用ant + target name
好了,这样一个简单的ant任务完成了。
?
?
一,什么时候使用ant
也许你听到别人说起ant,一时冲动准备学习一下ant,当你看完了上边的第一个实例,也许你感觉ant真好,也许你感觉ant不过如此,得出这些结论都不能说错,虽然ant很好用,
但并不是在任何情况下都是最好的选择,例如windows上有更多更简单,更容易使用的工具,比如eclipse+myeclipse eclipse+wtp等等,无论是编译,部署,运行使用起来比ant更
容易,方便但有些情况则是ant发挥的好地方:
1,服务器上部署的时候
当你的程序开发完成,部署人员要部署在服务器上的时候,总不能因为因为安装一个程序就配置一个eclipse+myeclipse吧,ant在这个时候是个很好的选择,因为它小巧,容易配
置,你带着你写好的build.xml到任何一台服务器上,只需要做简单的修改(一些设定,例如目录),然后一两个命令完成,这难道不是一件美好的事情吗。
2,linux上,很多时候是这样的,程序开发是在windows下,但是程序要在linux或者unix上运行,在linux或者
在unix(特别是unix上)部署是个麻烦的事情,这个时候ant的特点又出来了,因为ant是跨平台的,你在build.xml可以在大多数操作系统上使用,基本不需要修改。
3,当服务器维护者不懂编程的时候
很多人都有过这样的经历,使用你们程序的人,并不懂得写程序。你得程序因为版本更新,因为修正bug需要一次又一次得重新部署。这个时候你会发现教一个人是如此得困难。但
是有ant后,你只需要告诉他,输入ant xxx等一两个命令,一切ok.
以上是我遇到得一些情况。
看完以上得情况,好好考虑一下,你是否需要使用ant,如果是继续。
?
进一步学习一个稍微复杂一点点的ant
在实际的工作过程中可能会出现以下一些情况,一个项目分成很多个模块,每个小组或者部门负责一个模块,为了测试,他们自己写了一个build.xml,而你负责把这些模块组合到
一起使用,写一个build.xml
这个时候你有两种选择:
1,自己重新写一个build.xml ,这将是一个麻烦的事情
2,尽量利用他们已经写好的build.xml,减少自己的工作
举个例子:
假设你下边有三个小组,每个小组负责一个部分,他们分别有一个src 和一个写好的build.xml
这个时候你拿到他们的src,你需要做的是建立三个文件夹src1 ,src2, src3分别把他们的src和build.xml放进去,然后写一个build.xml
<?xml version="1.0" encoding="UTF-8" ?>
<project name="main" default="build" basedir=".">
?<property name="bin" value="${basedir}\bin" />
?<property name="src1" value="${basedir}\src1" />
?<property name="src2" value="${basedir}\src2" />
?<property name="src3" value="${basedir}\src3" />
?<target name="init">
? <mkdir dir="${bin}" />
?</target>
?<target name="run">
? <ant dir="${src1}" target="run" />
? <ant dir="${src2}" target="run" />
? <ant dir="${src3}" target="run" />
?</target>
?<target name="clean">
? <ant dir="${src1}" target="clean" />
? <ant dir="${src2}" target="clean" />
? <ant dir="${src3}" target="clean" />
?</target>
?<target name="build" depends="init,call">
? <copy todir="${bin}">
?? <fileset dir="${src1}">
??? <include name="*.jar" />
?? </fileset>
?? <fileset dir="${src2}">
??? <include name="*.jar" />
?? </fileset>
?? <fileset dir="${src3}">
??? <include name="*.jar" />
?? </fileset>
? </copy>
?</target>
?<target name="rebuild" depends="build,clean">
? <ant target="clean" />
? <ant target="build" />
?</target>
</project>
ok你的任务完成了。
?
ok,上边你完成了任务,但是你是否有些感触呢,在那些build.xml中,大多数是重复的,而且更改一次目录需要更改不少东西。是否能让工作做的更好一点呢,答案是肯定的。
引入两个东西:
1,propery
2,xml include
这两个东西都有一个功能,就是能把build.xml中<propery />中的内容分离出来,共同使用
除此之外它们各有特点:
propery的特点是维护简单,只需要简单的键值对,因为并不是所有人都喜欢xml的格式
xml include的特点是不单可以提取出属性来,连target也可以。
还是以前的例子:
例如我们想把src1 src2 src3这三个属性从xml中提出来,可以新建一个文件叫all.properties
里边的内容
src1=D:\\study\\ant\\src1
src2=D:\\study\\ant\\src2
src3=D:\\study\\ant\\src3
然后你的build.xml文件可以这样写,别人只需要更改配置文件,而不许要更改你的build.xml文件了
<?xml version="1.0" encoding="UTF-8" ?>
<project name="main" default="build" basedir=".">
?<property file="all.properties" />
?<property name="bin" value="${basedir}\bin" />
?<target name="init">
? <mkdir dir="${bin}" />
?</target>
?<target name="run">
? <ant dir="${src1}" target="run" />
? <ant dir="${src2}" target="run" />
? <ant dir="${src3}" target="run" />
?</target>
?<target name="clean">
? <ant dir="${src1}" target="clean" />
? <ant dir="${src2}" target="clean" />
? <ant dir="${src3}" target="clean" />
?</target>
?<target name="build" depends="init,call">
? <copy todir="${bin}">
?? <fileset dir="${src1}">
??? <include name="*.jar" />
?? </fileset>
?? <fileset dir="${src2}">
??? <include name="*.jar" />
?? </fileset>
?? <fileset dir="${src3}">
??? <include name="*.jar" />
?? </fileset>
? </copy>
?</target>
?<target name="rebuild" depends="build,clean">
? <ant target="clean" />
? <ant target="build" />
?</target>
?<target name="test">
? <ant dir="${src1}" target="test" />
? <ant dir="${src2}" target="test" />
? <ant dir="${src3}" target="test" />
?</target>
</project>
如果你自己看的话你会看到这样一个target
<target name="test">
?<ant dir="${src1}" target="test" />
?<ant dir="${src2}" target="test" />
?<ant dir="${src3}" target="test" />
</target>
有的时候你想给每个小组的build.xml加入几个target,一种做法是每个里边写,然后在这里调用
但是有一种更好的方法。
你可以写一个include.xml文件,内容如下
<?xml version="1.0" encoding="UTF-8" ?>
<property name="src" value="src"/>
<property name="dest" value="classes"/>
<target name="test" >
?<ant target="run" />
</target>
然后更改你三个小组的build.xml文件,每个里边加入如下内容
<!--include a xml file ,it can be common propery ,can be also a target? -->
<!DOCTYPE project [
<!ENTITY share-variable SYSTEM "file:../include.xml">
]>
&share-variable;
变成如下的样子
这个时候,你只要在include.xml添加propery , 添加target,三个build.xml会同时添加这些propery和target
而且不会让三个组的build.xml变得更复杂。
<?xml version="1.0" encoding="UTF-8" ?>
<!--include a xml file ,it can be common propery ,can be also a target? -->
<!DOCTYPE project [
<!ENTITY share-variable SYSTEM "file:../include.xml">
]>
<project name="HelloWorld" default="run" basedir=".">
?<!--use the include? -->
?&share-variable;
?<!--defined the property-->
?<!--via include
?<property name="src" value="src"/>
?<property name="dest" value="classes"/>
?-->
?<property name="hello_jar" value="hello1.jar"/>
?<!--define the op-->
?<target name="init">
? <mkdir dir="${dest}"/>
?</target>
?<target name="compile" depends="init">
? <javac srcdir="${src}" destdir="${dest}"/>
?</target>
?<target name="build" depends="compile">
? <jar jarfile="${hello_jar}" basedir="${dest}"/>
?</target>
?<target name="run" depends="build">
? <java classname="test.ant.HelloWorld" classpath="${hello_jar}"/>
?</target>
?<target name="clean">
? <delete dir="${dest}" />
? <delete file="${hello_jar}" />
?</target>
?<target name="rerun" depends="clean,run">
? <ant target="clean" />
? <ant target="run" />
?</target>
</project>
?
掌握了上边的那些内容之后,你就知道如何去写一个好的ant,但是你会发现当你真的想去做的时候,你不能马上作出好的build.xml,因为你知道太少的ant的默认提供的命令.这
个时候如果你想完成任务,并提高自己,有很多办法:
1,很多开源的程序都带有build.xml,看看它们如何写的
2,ant的document,里边详细列写了ant的各种默认命令,及其丰富
3,google,永远不要忘记它
ok,在这之后随着你写的ant build越来越多,你知道的命令就越多,ant在你的手里也就越来越强大了。
这个是一个慢慢积累的过程。

ant的例子很好找,各种开源框架都会带有一个build.xml仔细看看,会有很大收获
另外一个经常会用到的,但是在开源框架的build.xml一般没有的是cvs
如果使用的是远程的cvs,可以这样使用
<xml version="1.0" encoding="utf-8"?>
<project>
???? <property name="cvsroot" value=":pserver:wang:@192.168.1.2:/cvsroot"/>
???? <property name="basedir" value="/tmp/testant/"/>
???? <property name="cvs.password" value="wang"/>
???? <property name="cvs.passfile" value="${basedir}/ant.cvspass"/>
???? <target name="initpass">
???????????? <cvspass cvsroot="${cvsroot}" password="${cvs.password}" passfile="${cvs.passfile}"/>
???? </target>
???? <target name="checkout" depends="initpass">
???????????? <cvs cvsroot="${cvsroot}" command="checkout" cvsrsh="ssh" package="myproject" dest="${basedir}"
????????????? passfile="${cvs.passfile}"/>
????? </target>
</project>

在eclipse里边先天支持ant,所以你可以在eclipse里边直接写build.xml
因为eclipse提供了提示功能,自动补充功能,它能让你事半功倍。
使用方法,只需要建立一个工程,然后建立一个叫build.xml的文件。然后就可以在里边写你的ant build了
但是时刻记住www.apache.org 永远能找到你需要的东西
?
时间:2007-3-8 10:49:58 | 打开原文
快速搭建自己的CVS

相信有过团队开发经历的人,都用过这样或者那样的版本控制系统。比如,我们就使用CVS(并发版本系统)来管理源代码。它的好处,对于用过的人自然不用多说。
而以前对于CVS的使用也仅限于工作的需要,对于自己的文件和源代码并没有涉及使用, 为此也吃过一些苦头,比如轻易删除的一段代码又要费劲的重写出来。为了避免悲剧重演,我给自己搭建了一套CVS,然后将自己还在更新的文件和源代码放入统 一的目录中打上了CVS的标记。这样只要每天提交更新不误,就不会再出现删除后的抓狂了……
????????? 既然CVS这么有用,你也来为自己的资料加道保险吧。
?
CVS服务器我们选择开源的CVSNT,可以从http://www.cvsnt.org/ 得到。由于个人使用的工作环境一般为Windows,所以我们主要演示Windows平台下的安装配置。对应Windows平台下载得到的是一个安装文件,安装过程没有什么好说的,重启机器后CVSNT就安装完毕了。
CVSNT会在你的机器中启动两个服务:
?

?
?????? 当然现在的CVSNT还不能使用,你还要给CVSNT指定数据仓库的位置。在你准备存放版本控制信息 的目录下,添加作为数据仓库的文件夹,比如我在d盘下创建srcBase作为数据仓库。在“开始”菜单里选择CVSNT的子选项“CVSNT Control Panel”。在弹出的窗口中,选择“Repository configuration”Tab窗口:
?

?
?????? 点击Add按钮,在弹出窗口中,指定好你将作为数据仓库的位置,点击确定完成操作。这样就可以使用CVSNT服务器了。
?????? 另外在第三个Tab窗口“Server settings”中,可以设定使用者的身份、访问端口、temp目录和加密等属性。其中temp目录默认在C盘,你可以指定到其它的地方。
?????? 对于CVS的更多设置,比如远程用户的访问(这是团队开发不可少的配置,而本文假设服务器和客户端存在于一台机器),可以参见安装目录下的帮助文档,或者在链接http://cvsdoc-zh.gro.clinux.org/cvsdoc/zh_CN/html/1_12_13/index.html#toc_Top 中得到中文手册。
??????
?????? 现在你就可以通过命令行的方式来管理你的资料了。但是这样用起来总是不太方便,还要记住不同命令和参数。所以我们需要CVS客户端来简化这个工作。原来我使用的是wincvs ,这是一个不错的软件;但是现在我更喜欢使用TortoiseCVS
Wincvs采用类似于管理器的方式来操作所管理的文件:
?

?
而TortoiseCVS则将所有的操作集成在了右键弹出菜单上了,使用起来更加方便,而且图标醒目易辨别。另外TortoiseCVS提供了很好的中文支持,包括中文的帮助手册:
?

?
两者安装的过程都非常简单,只是使用WinCVS可能需要安装Python工作环境。这里以 TortoiseCVS为例,简单的介绍一下客户端的配置。
选择你要进行版本控制的文件夹,右键选择“CVS—〉创建新模块”。在弹出的窗口中,首先会让你配置CVS服务器,如果是第一次使用,则所有选项都是空的:
?

?
按照图中的配置方式完成对服务器的配置。其中用户可以是任意的系统用户。点击确定以后就可以输入密码完成新模块的创建。然后你将要管理的文件通过“CVS添加”功能打上标示,美好的旅程在更新、提交中就开始了……
?
下面简要的介绍些TortoiseCVS中常用的功能:
右键“CVS—〉选项”或者“开始”菜单“TortoiseCVS—〉Preferences”,打开“参数选择”窗口。在里面可以设置满足自己要求的软件设置。
右键“CVS更新”,将本地指定的文件更新为CVS服务器中最新版本。
右键“CVS提交”,将本地指定的文件提交到CVS服务器中。
右键“CVS添加”,将本地指定的文件最为初始版本提交到CVS服务器中。
右键“CVS”中则集合了各种有用的功能。比如:可以查看某个文件的历史和版本分支图;设置分支等等。
时间:2007-3-7 14:04:51 | 打开原文
Java 5.0的新语言特性

2004 年下半年,Sun公司发布了开发代号为“Tiger”的J2SE 5.0,揭开了Java发展的一个重要里程碑。在过去的Java升级中更多的是进行一些库函数的改进,而这次则直接从语法层面上进行了增强。直接从1.4 跳到5.0(Sun本来是打算用1.5.0这个版本号的),单从版本号的变化上就可以看出这次升级的力度是如此之大。那么,到底有些什么改变呢?下面就请 随我窥视一二(其中所举的代码例子均摘自于《J2SE 5.0 in a Nutshell》):
?
范型(Generics)
在以前,我们需要为不同的数据类型分别建立相对应的方法、类或接口,例如一个加法方法add可能需要分别定义int add(int a, int b),String add(String a, String b),MyClass add(MyClass a, MyClass b)等多个方法,即便这些方法中的处理逻辑完全相同(只是数据类型不同)也是这样。
跟C++中的模板(template)一样,范型使程序员能创建通用的方法、类和接口,这种情况下他们所操作数据的类型是通过参数指定的。通过 使用范型,使得只创建一个类就能自动工作于不同数据类型。因此,范型扩展了程序员复用代码的能力。另外,范型也增加了类型安全。使用范型以后,我们不再需 要显式的强制转换(cast),这样能在编译时就发现类型不符,避免到运行时出现类型转换错误。
下面是使用范型前后的代码对比:
使用范型前:
ArrayList list = new ArrayList();
list.add(0, new Integer(42));
int total = ((Integer)list.get(0)).intValue();
使用范型后(下面还有进一步利用自动装箱/拆箱特性以后更简洁的代码):
ArrayList<Integer> list =? new ArrayList<Integer>();
list.add(0, new Integer(42));
int total = list.get(0).intValue();
顺便提到一点,非常遗憾,运算符重载没有能够跟范型一起被加入进来。如果Java能够支持运算符重载的话,在使用范型的时候感觉就更好了(不过,那样Java就越来越像C++了)。
?
元数据(Metadata)
新的元数据工具更多是为未来考虑而增加的,它让你能够在程序中嵌入注解(annotation),这些注解能够被不同的编程工具处理。例如,工 具可以根据注解(annotation)的要求生成Java源代码,这样只要程序员指定一种动作,然后就可以将实际提供代码的事情留给工具了,从而大大降 低了程序员必须手工输入的重复代码的数量。
下面是使用元数据前后的代码对比:
使用前:
public interface PingIF extends Remote {
????? public void ping() throws RemoteException;
}
public class Ping implements PingIF {
???? public void ping() {
????????? ……
???? }
}
使用后:
public class Ping {
???? public @remote void ping() {
????????? ……
???? }
}
?
自动装箱(Autoboxing)和自动拆箱(Auto-Unboxing)
从Java诞生以来,简单数据类型(int,long,float等)和其对应的包装类型(Integer,Long,Float等)之间一直 不能自动转换,这为我们带来了很多麻烦。现在Java终于添加了自动装箱(Autoboxing)和自动拆箱(Auto-unboxing),为我们解决 了这个问题。自动装箱(Autoboxing)特性让Java自动包装一个简单数据类型(例如int)到对应的包装类型中(例如Integer)中。自动 拆箱(Auto-unboxing)是相反的过程,即将一个包装类型(例如Integer)自动转换为它所对应的简单数据类型(例如int)。举例如下:
以前:
ArrayList<Integer> list = new ArrayList<Integer>();
list.add(0, new Integer(42));
int total = (list.get(0)).intValue();
以后(请对照范型部分使用范型前的例子代码):
ArrayList<Integer> list = new ArrayList<Integer>();
list.add(0, 42);
int total = list.get(0);
?
枚举(Enumeration)
很多编程语言中都是有枚举类型,而在Java诞生的时候, Java的创造者没有把这个东东包含Java中来,这导致我们在程序中写了许多public static final。现在枚举终于被加入到Java中来了。
本质上,一个枚举是一个命名常量的列表。枚举类型通过新的关键字enum来支持。下面是定义一个枚举的例子代码:
public enum StopLight { red, amber, green };
再顺便提到一点,非常遗憾,常量没有能够跟范型一起被加入进来,这意味着使用public static final的命运还没有终结。
?
增强的for循环
Java 5.0中添加了“for-each”形式的循环。这个增强为大量集合、数组等的循环处理提供了便利,并为我们防止数组越界提供有益的帮助,还避免了原来必需的强制类型转换(case),让我们能在编译时就发现类型不符,避免到运行时出现类型转换错误。。
下面是在使用新的for循环前后的代码对比:
使用前:
ArrayList<Integer> list = new ArrayList<Integer>();
for (Iterator i = list.iterator(); i.hasNext();) {
???????? Integer value=(Integer)i.next();
????????????? ……
}
使用后:
ArrayList<Integer> list = new ArrayList<Integer>();
for (Integer i : list) {
?????? ……
}
?
不定参数(Varargs)
在实际开发过程中,有时候会遇到方法参数不固定的情况。在过去,为了解决问题,我们经常采用将参数包装到一个数组或者集合中的方式。现在有 Varargs帮助我们解决这个问题了。Varargs让一个方法可以带有可变数目参数。Varargs的加入使得创建带有可变数目参数的方法变的更加容 易。下面是使用不定参数的例子:
// 方法定义
void argtest(Object ... args) {
????? for (int i=0;i <args.length; i++) {
????? }
}
// 调用方式
argtest("test", "data");
?
静态导入(Static Import)
过去使用静态成员通常我们需要进行这种形式的调用:YourClassName.staticMember,在每次使用静态成员的时候我们都要 把这个静态成员所属类的名字写一遍。现在静态导入可以让我们不必每次都去写类的名字了,可以直接通过静态成员的名字来访问它们。下面是使用静态导入的例 子:
// 静态导入
import static java.awt.BorderLayout.*;
// 调用静态成员
getContentPane().add(new JPanel(), CENTER);
?
其它改变
?????? 上面所列的主要是一些Java 5在语言层面的升级,Java 5在基础类库、用户界面、虚拟机、执行效率等其它方面也进行了大量的升级。例如在基础类库方面,为范型的出现更新了集合框架,为方便多线程开发对线程同步 进行了改进,为方便输入输出增加了新的Formatter和Scanner 类。
对于这些方面我在这里就不再列举了,如果需要你可以查找相应的文档进行学习。
时间:2007-3-7 14:04:10 | 打开原文
第三十七天 用Timer在Web工程中实现类似触发器的机制

用java.util.Timer在Web工程中实现类似触发器的机制
现在正在做的项目要实现一个定时出帐的触发器, 开始打算用Spring整合的Quartz工具来实现(同时Spring也提供了对java.util.Timer的支持),
Spring对Quartz整合的方式,是在配置文件中通过bean的property项设置一个cronTrigger表达式来实现精确的时 点触发,但是由于Spring只有在启动的时候对注入值进行读取,这样的话就很难实现通过运行时读取配置参数,达到不用重启服务即可改变出帐时间的目的, 所以只好自己寻找好一点的解决方案.
在网上找到了一篇文章,看了很受启发,我略做了一些修改,实现了在每个月的某一天的某一个时间进行任务操作的功能.
代码及注释如下:
先要实现一个系统的监听器:
/**
?* <p>Title: </p>
?* <p>Description: </p>
?* <p>Copyright: Copyright (C)Chen Meng 2005</p>
?* <p>Company: 陈盟 </p>
?*
?* @author <a href="mailto:chen_meng@hotmail.com ">陈盟</a>
?* @version 1.0
?* @since 2005-1-13 / 17:26:41
?*/
?
package com.wellsoon.cttbj.vab.background;

import java.util.Date;
import javax.servlet.ServletContextEvent;
import javax.servlet.ServletContextListener;

public class SettleAccountListener implements ServletContextListener {
???
??? private java.util.Timer timer = null;
???
??? /*
???? * @see javax.servlet.ServletContextListener#contextInitialized(javax.servlet.ServletContextEvent)
???? */
??? public void contextInitialized(ServletContextEvent event) {
??????? Date taskRun = null;
???????
??????? // TODO Auto-generated method stub
??????? taskRun = new Date();
??????? timer = new java.util.Timer(true);
??????? event.getServletContext().log("定时器已启动");
/在这里每隔一分钟轮询一次出帐任务,如果任务间隔比较大的话建议把这个值设的大一点,但此设置值将间接影响可设定的触发精度.
??????? timer.schedule(new SettleAccountTask(), 0, 60*1000); /
??????? event.getServletContext().log("已经添加任务调度表");
??? }
??? /*
???? * @see javax.servlet.ServletContextListener#contextDestroyed(javax.servlet.ServletContextEvent)
???? */
??? public void contextDestroyed(ServletContextEvent event) {
??????? // TODO Auto-generated method stub
??????? timer.cancel();
??????? event.getServletContext().log("定时器销毁");
??? }
}
接着来看SettleAccountTask的实现:
/**
?* <p>Title: </p>
?* <p>Description: </p>
?* <p>Copyright: Copyright (C)Chen Meng 2005</p>
?* <p>Company: 陈盟 </p>
?*
?* @author <a href="mailto:chen_meng@hotmail.com ">陈盟</a>
?* @version 1.0
?* @since 2005-1-13 / 17:35:55
?*/
package com.wellsoon.cttbj.vab.background;
import java.util.Calendar;
import java.util.Date;
import java.util.TimerTask;

public class SettleAccountTask extends TimerTask {
??? private static boolean isRunning = false;
??? private static long doTaskMillis = 0l;
??? public void run() {
??????? System.out.println(doTaskMillis);
//下面两个值代表每月的哪一天几点进行实际任务操作.可以通过数据库查询获得
??????? int C_SCHEDULE_DATE = 10;
??????? int C_SCHEDULE_HOUR = 4;
??????? Calendar cal = Calendar.getInstance();
//如果任务量很大,在下次轮询时仍在执行上次轮询的任务,则跳过本次执行,直接错过.
??????? if (!isRunning) {
//如果当前系统时间的DAY_OF_MONTH和HOUR_OF_DAY不满足以下条件,则跳过实际操作.
??????????? if (C_SCHEDULE_DATE == cal.get(Calendar.DAY_OF_MONTH) && C_SCHEDULE_HOUR == cal.get(Calendar.HOUR_OF_DAY)) {
//如果上次执行任务的时间距此次轮询时间间隔太短,则跳过实际操作.
??????????????? if((doTaskMillis + 2*60*60*1000) < cal.getTimeInMillis()) {
//????????????????? 详细任务
??????????????????? isRunning = true;
??????????????????? System.out.println("执行出帐操作");
??????????????????? doTaskMillis = cal.getTimeInMillis();
??????????????????? System.out.println(doTaskMillis);
??????????????????? isRunning = false;
??????????????? }
??????????? }
??????? } else {
??????????? System.out.println("错过");
??????? }
??? }
}
最后,在web.xml中加上
?<listener>
? <listener-class>com.xxx.background.SettleAccountListener</listener-class>
?</listener>
就可以了.
如果有更好的解决方式, 希望您回复.
分享到:
评论

相关推荐

    Ant介绍.doc Ant是什么?

    Ant是什么?如何开始使用Ant?Ant 的基本概念 构建脚本 构建脚本的命名 Ant的路径模式? Ant任务

    ant介绍Ant是什么

    1. Ant是什么?2. 安装Ant3. 运行Ant4. 编写build.xml5. 内置task(internet)6. EAR task(internet)7. WAR task(internet)8. JUnit task(internet)

    ant 学习与总结

    1 Ant是什么? 2下载、安装Ant 3编写build.xml Ant 命令行参考 Apache Ant 是一个基于 Java的生成工具。 生成工具在软件开发中用来将源代码和其他输入文件转换为可执行文件的形式(也有可能转换为可安装的产品映像...

    ant(pdf)

    ant基础教程,主要给初学者提供,Ant是什么?

    ant ant ant ant

    ant ant ant antant ant ant antant ant ant ant

    Ant介绍以及基本使用指南

    Ant是什么?N年前的某个没落软件?错,Ant是辅助开发工具!不多说了,这是个很简短的教程,个人认为挺实用。用得着就下,用不着别下,就这么简单。

    ant ant下载与配置

    ant ant下载 ant配置ant ant下载 ant配置ant ant下载 ant配置

    开发工具 ant-1.9.6

    开发工具 ant-1.9.6开发工具 ant-1.9.6开发工具 ant-1.9.6开发工具 ant-1.9.6开发工具 ant-1.9.6开发工具 ant-1.9.6开发工具 ant-1.9.6开发工具 ant-1.9.6开发工具 ant-1.9.6开发工具 ant-1.9.6开发工具 ant-1.9.6...

    ant的基本配置说明

    为什么需要手工去编写ant脚本呢,很多IDE工具会为我们生成ant脚本阿?有人会这么问。要知道靠IDE自动生成的东西,总是有这样那样的缺点,以及不足,他不能完全满足你的很多需要。如果出现了问题,你不得不手动修改...

    Ant 资源 Ant 资源

    Ant 资源 Ant 资源 Ant 资源 Ant 资源 Ant 资源 Ant 资源 Ant 资源

    Ant工具的使用及Ant介绍

    1,什么是ant ant是构建工具 2,什么是构建 概念到处可查到,形象来说,你要把代码从某个地方拿来,编译,再拷贝到某个地方去等等操作,当然不仅与此,但是主要用来干这个 3,ant的好处 跨平台 --因为ant是使用java实现...

    ant.jar下载

    org.apache.tools.ant.Main org.apache.tools.ant.Task org.apache.tools.bzip2.CRC org.apache.tools.ant.Target org.apache.tools.ant.Project org.apache.tools.zip.ZipFile org.apache.tools.zip.ZipLong ...

    Ant和Maven的作用是什么?两者之间功能、特点有哪些区别?.docx

    Ant和Maven的作用是什么?两者之间功能、特点有哪些区别?.docx

    ant 讲解ant 讲解ant 讲解ant 讲解

    ant 讲解ant 讲解ant 讲解ant 讲解ant 讲解ant 讲解ant 讲解ant 讲解ant 讲解ant 讲解ant 讲解ant 讲解ant 讲解ant 讲解ant 讲解ant 讲解

    ant配置ant配置

    ant配置ant配ant配置ant配置置

    Ant简介(标签)

    可能有些读者并不连接什么是Ant以及入可使用它,但只要使用通过Linux系统得读者,应该知道 make这个命令。当编译Linux内核及一些软件的源程序时,经常要用这个命令。Make命令其实就 是一个项目管理工具,而Ant所...

    ANT文件详解 ant介绍 ANT 命令

    ANT文件详解 ant介绍 ANT 命令

    ANT COLONY ANT COLONY ANT COLONY

    ANT COLONY ANT COLONY ANT COLONY ANT COLONY ANT COLONY ANT COLONY ANT COLONY ANT COLONY ANT COLONY

Global site tag (gtag.js) - Google Analytics