Chinaunix首页 | 论坛 | 博客
  • 博客访问: 313271
  • 博文数量: 54
  • 博客积分: 1400
  • 博客等级: 上尉
  • 技术积分: 606
  • 用 户 组: 普通用户
  • 注册时间: 2006-12-03 22:43
文章分类
文章存档

2011年(3)

2010年(26)

2009年(2)

2008年(23)

我的朋友

分类:

2009-02-21 20:15:11

本文描述了ant的基本语法及其如何应用于项目的管理
-. Ant简介
可 能有许多读者并不了解什么是ant,以及如何使用它。但只要你是用过linux,你应该知道make为何物,当我们编译linux内核及一些软件的源程序 时,我们经常需要在控制台下输入make。Make其实就是一个项目管理工具,而ant所实现的功能与make差不多。Ant是apache软件基金会 jakarta项目中的一个子项目,由于是基于java编写的,因此具有很好的跨平台性。Ant由一些内置任务(task)和可选择的任务组成(当然你还 可以编写自己的任务),使用Make时,你需要写一个Makefile文件,而用ant时则需要写一个build.xml文件。由于采用xml的语法,所 以build.xml文件很容易书写和维护,且结构很清晰,而不像Makefile文件有那么多的限制(例如在tab符号前有一个空格的话,命令就不会执 行)。Ant的优点远不止这些,它还很容易的集成到一些开发环境中(例如visual age,jbuilder,netbeans)。

二.Ant的安装及配置
安装
Ant 目前的版本是1.3,首先到下载ant最新版本1.3,解压到C: /ant(window操作系统) 或者/usr/local/ant(linux操作系统),由于我们要用到xmlc ,而ant1.3中并没有包含它,所以我们需要David.Li为ant写的xmlc任务。具体url为http: //。将下载后的文件中的 ant.jar替换掉ant1.3中ant.jar.这样ant的版本变为1.2.

2.设置路径
(1):windows98操作系统
编辑C:\enhydra\.bashrc,加入下面三行

export ANT_HOME=/ant
export JAVA_HOME=/jdk-1.2.2
export PATH=${PATH}:${ANT_HOME}/bin

(2):Linux操作系统
编辑/etc/profile或者 用户目录下的.bashrc文件,加入下面三行

export ANT_HOME=/usr/local/ant
export JAVA_HOME=/usr/local/jdk-1.2.2
export PATH=${PATH}:${ANT_HOME}/bin

三:用ant管理项目
1:基本的文件目录结构 解压到任意目录,我们可以看到目录树结构如下
├─bin
├─docs
│ ├─ant2
│ ├─api
│ │ └─org
│ │ └─apache
│ │ └─tools
│ │ ├─ant
│ │ │ ├─taskdefs
│ │ │ │ ├─compilers
│ │ │ │ └─optional
│ │ │ │ ├─clearcase
│ │ │ │ ├─depend
│ │ │ │ │ └─constantpool
│ │ │ │ ├─dotnet
│ │ │ │ ├─ejb
│ │ │ │ ├─ide
│ │ │ │ ├─javacc
│ │ │ │ ├─jlink
│ │ │ │ ├─jsp
│ │ │ │ ├─junit
│ │ │ │ ├─metamata
│ │ │ │ ├─net
│ │ │ │ ├─perforce
│ │ │ │ ├─scm
│ │ │ │ ├─sound
│ │ │ │ └─vss
│ │ │ ├─types
│ │ │ └─util
│ │ │ └─regexp
│ │ ├─mail
│ │ └─tar
│ └─manual
│ ├─CoreTasks
│ ├─CoreTypes
│ ├─Integration
│ └─OptionalTasks
└─lib





在这个目录树结构中,与传统的项目不同的是,我们用build.xml取代了Makefile,在讲述这个build.xml文件前,我们先了解一个基本的 build.xml文件的结构。

2:build.xml的基本书写规范
下面我们就来讲述这个文件的书写方法,下面是这个文件的全部内容
1.
2.
3.
4.
5.
6.

7.





为 了方便说明,我们为每一行加了行号,第一行是xml文件的基本要素,第二行说明这是一个项目,第七行说明项目的结束 ,在第二行中,name="MyProject"说明此项目的名称,这个属性可有可无。basedir="."说明基本目录,此属性可有可无。 default="dist"说明项目的缺省目标(target)是什么,这个属性必须有。所谓目标(target)就是一系列任务(task)组成的一 个集合。每个任务(task)的书写方法如下:
<任务名 属性1="属性1的值" 属性2="属性2的值" ....... />




第 三行定义了一些属性(property),以便后面使用,这非常类似于编程中定义的全局变量。从第四行开始定义目标(target),name= "init"指明了此目标的名称,name属性在定义目标时必须有,当然定义目标时还有其他一些属性可选,例如depends,unless,具体请参考 ant的文档。第五行开始定义此目标内的任务,其中mkdir时ant的内部任务名,dir是此任务的属性,其值为${dist}。此任务就是创建一个目 录。其中${dist}是获取dist属性的值(就是我们在第三行定义的)。如上就是一个基本的build.xml文件的写法。你可以在命令行上输入 ant -buildfile build.xml

看一下你的当前目录下是否多了一个dist目录。如果出错,则可能是你没有把ant配置好,参见前面讲的安装及配置,看一下哪儿出了错。

3:build.xml文件
build.xml文件如下,其中有的注释和无关的代码删掉了,且做了一下小小的改动
1:
2:
3:
4:
5:
6:
7:
8:
9:
10:


11:
12:
13:
14:
15:
16:
17:
18:
19:

20:
21:
22:
23:

24:
25:

26:
27:
28:
29:
30:
31:
32:

33:
34:


35:
36:
37:
38:
39:
40:


41:
42:
43:
44:
45:
46:47:sourceout="${build.xmlc.dir}"
48:includes="**/*.html">
49:

50:
51:
52:
53:
54:
55:
56:
57:
58:

59:


60:
61:
62:
63:
64:

65:
66:67:destdir="${build.classes}"
68:classpathref="build.classpath"
69:debug="${build.debug}"/>

70:
71:72:destdir="${build.classes}"
73:classpathref="build.classpath"
74:debug="${build.debug}"
75:includes="${app.name}/**"
76:/>
77:


78:
79:
80:
81:
82:
83:
84:
85:
86:
87:
88:
89:

90:

91:



92:
93:
94:
95:
96:
97:
98:


99:
100:
101:
102:
103:
104:

105:
106:
107:108:tofile="${build.dir}/multiserver.conf"
109:filtering="on"/>

110:
111:
112:
113:


114:





4:build.xml详细说明
下 面我们将详细讲述这个文件,同样为了方便,我加了行号,当然一些基本的东西我就不再重复了。第四行taskdef任务(task)属于ant的内部任务, 它的作用是定义一个任务,其基本属性有name,classname,在定义时这两个属性都必需有。第八行开始定义一个path,它有一个属性id,通过 这个id的值我们可以在后面引用这个path,参见第68行。目标(target)init(从14行到34行)定义了一些基本属性 (property),主要是为了后面的target使用。在第38行,你会看到depends="init",depends是定义一个目标时的可选属 性,它的意思是如果init目标没有执行(出错或其他原因),这个目标也不会被执行。

从第46行开始定义xmlc任务,到第58行结束,中间有很多参数嵌套在其中,srcdir指定源文件目录,sourceout指定输出目录,includes属性将源文件目录中的所有html文件包括进来。*为通配符。

表示取消警告,表示同时产生接口和实现代码,例如:一个welcome.html,它会产生两个文件: WelcomeHTMLImpl.java,WelcomeHTML.java,WelcomeHTML.java中只定义了一个接口 WelcomeHTML,真正的实现在WelcomeHTMLImpl.java中。表示设置编码,由于xmlc将html文件编译为java类,即使你在html文件中已经设置了编码,在 java类中也不会有作用,必须在编译时设置编码。 这两句相当于在命令行上输入-ssi -keep.其中ssi参数是在编译html文件时将定义的ssi文件包括进来,见html目录下的welcome2.html源代码中有一行: Ant简介-jennyljd-ChinaUnix博客
  • 博客访问: 313272
  • 博文数量: 54
  • 博客积分: 1400
  • 博客等级: 上尉
  • 技术积分: 606
  • 用 户 组: 普通用户
  • 注册时间: 2006-12-03 22:43
文章分类
文章存档

2011年(3)

2010年(26)

2009年(2)

2008年(23)

我的朋友

分类:

2009-02-21 20:15:11

本文描述了ant的基本语法及其如何应用于项目的管理
-. Ant简介
可 能有许多读者并不了解什么是ant,以及如何使用它。但只要你是用过linux,你应该知道make为何物,当我们编译linux内核及一些软件的源程序 时,我们经常需要在控制台下输入make。Make其实就是一个项目管理工具,而ant所实现的功能与make差不多。Ant是apache软件基金会 jakarta项目中的一个子项目,由于是基于java编写的,因此具有很好的跨平台性。Ant由一些内置任务(task)和可选择的任务组成(当然你还 可以编写自己的任务),使用Make时,你需要写一个Makefile文件,而用ant时则需要写一个build.xml文件。由于采用xml的语法,所 以build.xml文件很容易书写和维护,且结构很清晰,而不像Makefile文件有那么多的限制(例如在tab符号前有一个空格的话,命令就不会执 行)。Ant的优点远不止这些,它还很容易的集成到一些开发环境中(例如visual age,jbuilder,netbeans)。

二.Ant的安装及配置
安装
Ant 目前的版本是1.3,首先到下载ant最新版本1.3,解压到C: /ant(window操作系统) 或者/usr/local/ant(linux操作系统),由于我们要用到xmlc ,而ant1.3中并没有包含它,所以我们需要David.Li为ant写的xmlc任务。具体url为http: //。将下载后的文件中的 ant.jar替换掉ant1.3中ant.jar.这样ant的版本变为1.2.

2.设置路径
(1):windows98操作系统
编辑C:\enhydra\.bashrc,加入下面三行

export ANT_HOME=/ant
export JAVA_HOME=/jdk-1.2.2
export PATH=${PATH}:${ANT_HOME}/bin

(2):Linux操作系统
编辑/etc/profile或者 用户目录下的.bashrc文件,加入下面三行

export ANT_HOME=/usr/local/ant
export JAVA_HOME=/usr/local/jdk-1.2.2
export PATH=${PATH}:${ANT_HOME}/bin

三:用ant管理项目
1:基本的文件目录结构 解压到任意目录,我们可以看到目录树结构如下
├─bin
├─docs
│ ├─ant2
│ ├─api
│ │ └─org
│ │ └─apache
│ │ └─tools
│ │ ├─ant
│ │ │ ├─taskdefs
│ │ │ │ ├─compilers
│ │ │ │ └─optional
│ │ │ │ ├─clearcase
│ │ │ │ ├─depend
│ │ │ │ │ └─constantpool
│ │ │ │ ├─dotnet
│ │ │ │ ├─ejb
│ │ │ │ ├─ide
│ │ │ │ ├─javacc
│ │ │ │ ├─jlink
│ │ │ │ ├─jsp
│ │ │ │ ├─junit
│ │ │ │ ├─metamata
│ │ │ │ ├─net
│ │ │ │ ├─perforce
│ │ │ │ ├─scm
│ │ │ │ ├─sound
│ │ │ │ └─vss
│ │ │ ├─types
│ │ │ └─util
│ │ │ └─regexp
│ │ ├─mail
│ │ └─tar
│ └─manual
│ ├─CoreTasks
│ ├─CoreTypes
│ ├─Integration
│ └─OptionalTasks
└─lib





在这个目录树结构中,与传统的项目不同的是,我们用build.xml取代了Makefile,在讲述这个build.xml文件前,我们先了解一个基本的 build.xml文件的结构。

2:build.xml的基本书写规范
下面我们就来讲述这个文件的书写方法,下面是这个文件的全部内容
1.
2.
3.
4.
5.
6.

7.





为 了方便说明,我们为每一行加了行号,第一行是xml文件的基本要素,第二行说明这是一个项目,第七行说明项目的结束 ,在第二行中,name="MyProject"说明此项目的名称,这个属性可有可无。basedir="."说明基本目录,此属性可有可无。 default="dist"说明项目的缺省目标(target)是什么,这个属性必须有。所谓目标(target)就是一系列任务(task)组成的一 个集合。每个任务(task)的书写方法如下:
<任务名 属性1="属性1的值" 属性2="属性2的值" ....... />




第 三行定义了一些属性(property),以便后面使用,这非常类似于编程中定义的全局变量。从第四行开始定义目标(target),name= "init"指明了此目标的名称,name属性在定义目标时必须有,当然定义目标时还有其他一些属性可选,例如depends,unless,具体请参考 ant的文档。第五行开始定义此目标内的任务,其中mkdir时ant的内部任务名,dir是此任务的属性,其值为${dist}。此任务就是创建一个目 录。其中${dist}是获取dist属性的值(就是我们在第三行定义的)。如上就是一个基本的build.xml文件的写法。你可以在命令行上输入 ant -buildfile build.xml

看一下你的当前目录下是否多了一个dist目录。如果出错,则可能是你没有把ant配置好,参见前面讲的安装及配置,看一下哪儿出了错。

3:build.xml文件
build.xml文件如下,其中有的注释和无关的代码删掉了,且做了一下小小的改动
1:
2:
3:
4:
5:
6:
7:
8:
9:
10:


11:
12:
13:
14:
15:
16:
17:
18:
19:

20:
21:
22:
23:

24:
25:

26:
27:
28:
29:
30:
31:
32:

33:
34:


35:
36:
37:
38:
39:
40:


41:
42:
43:
44:
45:
46:47:sourceout="${build.xmlc.dir}"
48:includes="**/*.html">
49:

50:
51:
52:
53:
54:
55:
56:
57:
58:

59:


60:
61:
62:
63:
64:

65:
66:67:destdir="${build.classes}"
68:classpathref="build.classpath"
69:debug="${build.debug}"/>

70:
71:72:destdir="${build.classes}"
73:classpathref="build.classpath"
74:debug="${build.debug}"
75:includes="${app.name}/**"
76:/>
77:


78:
79:
80:
81:
82:
83:
84:
85:
86:
87:
88:
89:

90:

91:



92:
93:
94:
95:
96:
97:
98:


99:
100:
101:
102:
103:
104:

105:
106:
107:108:tofile="${build.dir}/multiserver.conf"
109:filtering="on"/>

110:
111:
112:
113:


114:





4:build.xml详细说明
下 面我们将详细讲述这个文件,同样为了方便,我加了行号,当然一些基本的东西我就不再重复了。第四行taskdef任务(task)属于ant的内部任务, 它的作用是定义一个任务,其基本属性有name,classname,在定义时这两个属性都必需有。第八行开始定义一个path,它有一个属性id,通过 这个id的值我们可以在后面引用这个path,参见第68行。目标(target)init(从14行到34行)定义了一些基本属性 (property),主要是为了后面的target使用。在第38行,你会看到depends="init",depends是定义一个目标时的可选属 性,它的意思是如果init目标没有执行(出错或其他原因),这个目标也不会被执行。

从第46行开始定义xmlc任务,到第58行结束,中间有很多参数嵌套在其中,srcdir指定源文件目录,sourceout指定输出目录,includes属性将源文件目录中的所有html文件包括进来。*为通配符。

表示取消警告,表示同时产生接口和实现代码,例如:一个welcome.html,它会产生两个文件: WelcomeHTMLImpl.java,WelcomeHTML.java,WelcomeHTML.java中只定义了一个接口 WelcomeHTML,真正的实现在WelcomeHTMLImpl.java中。表示设置编码,由于xmlc将html文件编译为java类,即使你在html文件中已经设置了编码,在 java类中也不会有作用,必须在编译时设置编码。 这两句相当于在命令行上输入-ssi -keep.其中ssi参数是在编译html文件时将定义的ssi文件包括进来,见html目录下的welcome2.html源代码中有一行: Ant简介-jennyljd-ChinaUnix博客
  • 博客访问: 313273
  • 博文数量: 54
  • 博客积分: 1400
  • 博客等级: 上尉
  • 技术积分: 606
  • 用 户 组: 普通用户
  • 注册时间: 2006-12-03 22:43
文章分类
文章存档

2011年(3)

2010年(26)

2009年(2)

2008年(23)

我的朋友

分类:

2009-02-21 20:15:11

本文描述了ant的基本语法及其如何应用于项目的管理
-. Ant简介
可 能有许多读者并不了解什么是ant,以及如何使用它。但只要你是用过linux,你应该知道make为何物,当我们编译linux内核及一些软件的源程序 时,我们经常需要在控制台下输入make。Make其实就是一个项目管理工具,而ant所实现的功能与make差不多。Ant是apache软件基金会 jakarta项目中的一个子项目,由于是基于java编写的,因此具有很好的跨平台性。Ant由一些内置任务(task)和可选择的任务组成(当然你还 可以编写自己的任务),使用Make时,你需要写一个Makefile文件,而用ant时则需要写一个build.xml文件。由于采用xml的语法,所 以build.xml文件很容易书写和维护,且结构很清晰,而不像Makefile文件有那么多的限制(例如在tab符号前有一个空格的话,命令就不会执 行)。Ant的优点远不止这些,它还很容易的集成到一些开发环境中(例如visual age,jbuilder,netbeans)。

二.Ant的安装及配置
安装
Ant 目前的版本是1.3,首先到下载ant最新版本1.3,解压到C: /ant(window操作系统) 或者/usr/local/ant(linux操作系统),由于我们要用到xmlc ,而ant1.3中并没有包含它,所以我们需要David.Li为ant写的xmlc任务。具体url为http: //。将下载后的文件中的 ant.jar替换掉ant1.3中ant.jar.这样ant的版本变为1.2.

2.设置路径
(1):windows98操作系统
编辑C:\enhydra\.bashrc,加入下面三行

export ANT_HOME=/ant
export JAVA_HOME=/jdk-1.2.2
export PATH=${PATH}:${ANT_HOME}/bin

(2):Linux操作系统
编辑/etc/profile或者 用户目录下的.bashrc文件,加入下面三行

export ANT_HOME=/usr/local/ant
export JAVA_HOME=/usr/local/jdk-1.2.2
export PATH=${PATH}:${ANT_HOME}/bin

三:用ant管理项目
1:基本的文件目录结构 解压到任意目录,我们可以看到目录树结构如下
├─bin
├─docs
│ ├─ant2
│ ├─api
│ │ └─org
│ │ └─apache
│ │ └─tools
│ │ ├─ant
│ │ │ ├─taskdefs
│ │ │ │ ├─compilers
│ │ │ │ └─optional
│ │ │ │ ├─clearcase
│ │ │ │ ├─depend
│ │ │ │ │ └─constantpool
│ │ │ │ ├─dotnet
│ │ │ │ ├─ejb
│ │ │ │ ├─ide
│ │ │ │ ├─javacc
│ │ │ │ ├─jlink
│ │ │ │ ├─jsp
│ │ │ │ ├─junit
│ │ │ │ ├─metamata
│ │ │ │ ├─net
│ │ │ │ ├─perforce
│ │ │ │ ├─scm
│ │ │ │ ├─sound
│ │ │ │ └─vss
│ │ │ ├─types
│ │ │ └─util
│ │ │ └─regexp
│ │ ├─mail
│ │ └─tar
│ └─manual
│ ├─CoreTasks
│ ├─CoreTypes
│ ├─Integration
│ └─OptionalTasks
└─lib





在这个目录树结构中,与传统的项目不同的是,我们用build.xml取代了Makefile,在讲述这个build.xml文件前,我们先了解一个基本的 build.xml文件的结构。

2:build.xml的基本书写规范
下面我们就来讲述这个文件的书写方法,下面是这个文件的全部内容
1.
2.
3.
4.
5.
6.

7.





为 了方便说明,我们为每一行加了行号,第一行是xml文件的基本要素,第二行说明这是一个项目,第七行说明项目的结束 ,在第二行中,name="MyProject"说明此项目的名称,这个属性可有可无。basedir="."说明基本目录,此属性可有可无。 default="dist"说明项目的缺省目标(target)是什么,这个属性必须有。所谓目标(target)就是一系列任务(task)组成的一 个集合。每个任务(task)的书写方法如下:
<任务名 属性1="属性1的值" 属性2="属性2的值" ....... />




第 三行定义了一些属性(property),以便后面使用,这非常类似于编程中定义的全局变量。从第四行开始定义目标(target),name= "init"指明了此目标的名称,name属性在定义目标时必须有,当然定义目标时还有其他一些属性可选,例如depends,unless,具体请参考 ant的文档。第五行开始定义此目标内的任务,其中mkdir时ant的内部任务名,dir是此任务的属性,其值为${dist}。此任务就是创建一个目 录。其中${dist}是获取dist属性的值(就是我们在第三行定义的)。如上就是一个基本的build.xml文件的写法。你可以在命令行上输入 ant -buildfile build.xml

看一下你的当前目录下是否多了一个dist目录。如果出错,则可能是你没有把ant配置好,参见前面讲的安装及配置,看一下哪儿出了错。

3:build.xml文件
build.xml文件如下,其中有的注释和无关的代码删掉了,且做了一下小小的改动
1:
2:
3:
4:
5:
6:
7:
8:
9:
10:


11:
12:
13:
14:
15:
16:
17:
18:
19:

20:
21:
22:
23:

24:
25:

26:
27:
28:
29:
30:
31:
32:

33:
34:


35:
36:
37:
38:
39:
40:


41:
42:
43:
44:
45:
46:47:sourceout="${build.xmlc.dir}"
48:includes="**/*.html">
49:

50:
51:
52:
53:
54:
55:
56:
57:
58:

59:


60:
61:
62:
63:
64:

65:
66:67:destdir="${build.classes}"
68:classpathref="build.classpath"
69:debug="${build.debug}"/>

70:
71:72:destdir="${build.classes}"
73:classpathref="build.classpath"
74:debug="${build.debug}"
75:includes="${app.name}/**"
76:/>
77:


78:
79:
80:
81:
82:
83:
84:
85:
86:
87:
88:
89:

90:

91:



92:
93:
94:
95:
96:
97:
98:


99:
100:
101:
102:
103:
104:

105:
106:
107:108:tofile="${build.dir}/multiserver.conf"
109:filtering="on"/>

110:
111:
112:
113:


114:





4:build.xml详细说明
下 面我们将详细讲述这个文件,同样为了方便,我加了行号,当然一些基本的东西我就不再重复了。第四行taskdef任务(task)属于ant的内部任务, 它的作用是定义一个任务,其基本属性有name,classname,在定义时这两个属性都必需有。第八行开始定义一个path,它有一个属性id,通过 这个id的值我们可以在后面引用这个path,参见第68行。目标(target)init(从14行到34行)定义了一些基本属性 (property),主要是为了后面的target使用。在第38行,你会看到depends="init",depends是定义一个目标时的可选属 性,它的意思是如果init目标没有执行(出错或其他原因),这个目标也不会被执行。

从第46行开始定义xmlc任务,到第58行结束,中间有很多参数嵌套在其中,srcdir指定源文件目录,sourceout指定输出目录,includes属性将源文件目录中的所有html文件包括进来。*为通配符。

表示取消警告,表示同时产生接口和实现代码,例如:一个welcome.html,它会产生两个文件: WelcomeHTMLImpl.java,WelcomeHTML.java,WelcomeHTML.java中只定义了一个接口 WelcomeHTML,真正的实现在WelcomeHTMLImpl.java中。表示设置编码,由于xmlc将html文件编译为java类,即使你在html文件中已经设置了编码,在 java类中也不会有作用,必须在编译时设置编码。 这两句相当于在命令行上输入-ssi -keep.其中ssi参数是在编译html文件时将定义的ssi文件包括进来,见html目录下的welcome2.html源代码中有一行: Ant简介-jennyljd-ChinaUnix博客
  • 博客访问: 313274
  • 博文数量: 54
  • 博客积分: 1400
  • 博客等级: 上尉
  • 技术积分: 606
  • 用 户 组: 普通用户
  • 注册时间: 2006-12-03 22:43
文章分类
文章存档

2011年(3)

2010年(26)

2009年(2)

2008年(23)

我的朋友

分类:

2009-02-21 20:15:11

本文描述了ant的基本语法及其如何应用于项目的管理
-. Ant简介
可 能有许多读者并不了解什么是ant,以及如何使用它。但只要你是用过linux,你应该知道make为何物,当我们编译linux内核及一些软件的源程序 时,我们经常需要在控制台下输入make。Make其实就是一个项目管理工具,而ant所实现的功能与make差不多。Ant是apache软件基金会 jakarta项目中的一个子项目,由于是基于java编写的,因此具有很好的跨平台性。Ant由一些内置任务(task)和可选择的任务组成(当然你还 可以编写自己的任务),使用Make时,你需要写一个Makefile文件,而用ant时则需要写一个build.xml文件。由于采用xml的语法,所 以build.xml文件很容易书写和维护,且结构很清晰,而不像Makefile文件有那么多的限制(例如在tab符号前有一个空格的话,命令就不会执 行)。Ant的优点远不止这些,它还很容易的集成到一些开发环境中(例如visual age,jbuilder,netbeans)。

二.Ant的安装及配置
安装
Ant 目前的版本是1.3,首先到下载ant最新版本1.3,解压到C: /ant(window操作系统) 或者/usr/local/ant(linux操作系统),由于我们要用到xmlc ,而ant1.3中并没有包含它,所以我们需要David.Li为ant写的xmlc任务。具体url为http: //。将下载后的文件中的 ant.jar替换掉ant1.3中ant.jar.这样ant的版本变为1.2.

2.设置路径
(1):windows98操作系统
编辑C:\enhydra\.bashrc,加入下面三行

export ANT_HOME=/ant
export JAVA_HOME=/jdk-1.2.2
export PATH=${PATH}:${ANT_HOME}/bin

(2):Linux操作系统
编辑/etc/profile或者 用户目录下的.bashrc文件,加入下面三行

export ANT_HOME=/usr/local/ant
export JAVA_HOME=/usr/local/jdk-1.2.2
export PATH=${PATH}:${ANT_HOME}/bin

三:用ant管理项目
1:基本的文件目录结构 解压到任意目录,我们可以看到目录树结构如下
├─bin
├─docs
│ ├─ant2
│ ├─api
│ │ └─org
│ │ └─apache
│ │ └─tools
│ │ ├─ant
│ │ │ ├─taskdefs
│ │ │ │ ├─compilers
│ │ │ │ └─optional
│ │ │ │ ├─clearcase
│ │ │ │ ├─depend
│ │ │ │ │ └─constantpool
│ │ │ │ ├─dotnet
│ │ │ │ ├─ejb
│ │ │ │ ├─ide
│ │ │ │ ├─javacc
│ │ │ │ ├─jlink
│ │ │ │ ├─jsp
│ │ │ │ ├─junit
│ │ │ │ ├─metamata
│ │ │ │ ├─net
│ │ │ │ ├─perforce
│ │ │ │ ├─scm
│ │ │ │ ├─sound
│ │ │ │ └─vss
│ │ │ ├─types
│ │ │ └─util
│ │ │ └─regexp
│ │ ├─mail
│ │ └─tar
│ └─manual
│ ├─CoreTasks
│ ├─CoreTypes
│ ├─Integration
│ └─OptionalTasks
└─lib





在这个目录树结构中,与传统的项目不同的是,我们用build.xml取代了Makefile,在讲述这个build.xml文件前,我们先了解一个基本的 build.xml文件的结构。

2:build.xml的基本书写规范
下面我们就来讲述这个文件的书写方法,下面是这个文件的全部内容
1.
2.
3.
4.
5.
6.

7.





为 了方便说明,我们为每一行加了行号,第一行是xml文件的基本要素,第二行说明这是一个项目,第七行说明项目的结束 ,在第二行中,name="MyProject"说明此项目的名称,这个属性可有可无。basedir="."说明基本目录,此属性可有可无。 default="dist"说明项目的缺省目标(target)是什么,这个属性必须有。所谓目标(target)就是一系列任务(task)组成的一 个集合。每个任务(task)的书写方法如下:
<任务名 属性1="属性1的值" 属性2="属性2的值" ....... />




第 三行定义了一些属性(property),以便后面使用,这非常类似于编程中定义的全局变量。从第四行开始定义目标(target),name= "init"指明了此目标的名称,name属性在定义目标时必须有,当然定义目标时还有其他一些属性可选,例如depends,unless,具体请参考 ant的文档。第五行开始定义此目标内的任务,其中mkdir时ant的内部任务名,dir是此任务的属性,其值为${dist}。此任务就是创建一个目 录。其中${dist}是获取dist属性的值(就是我们在第三行定义的)。如上就是一个基本的build.xml文件的写法。你可以在命令行上输入 ant -buildfile build.xml

看一下你的当前目录下是否多了一个dist目录。如果出错,则可能是你没有把ant配置好,参见前面讲的安装及配置,看一下哪儿出了错。

3:build.xml文件
build.xml文件如下,其中有的注释和无关的代码删掉了,且做了一下小小的改动
1:
2:
3:
4:
5:
6:
7:
8:
9:
10:


11:
12:
13:
14:
15:
16:
17:
18:
19:

20:
21:
22:
23:

24:
25:

26:
27:
28:
29:
30:
31:
32:

33:
34:


35:
36:
37:
38:
39:
40:


41:
42:
43:
44:
45:
46:47:sourceout="${build.xmlc.dir}"
48:includes="**/*.html">
49:

50:
51:
52:
53:
54:
55:
56:
57:
58:

59:


60:
61:
62:
63:
64:

65:
66:67:destdir="${build.classes}"
68:classpathref="build.classpath"
69:debug="${build.debug}"/>

70:
71:72:destdir="${build.classes}"
73:classpathref="build.classpath"
74:debug="${build.debug}"
75:includes="${app.name}/**"
76:/>
77:


78:
79:
80:
81:
82:
83:
84:
85:
86:
87:
88:
89:

90:

91:



92:
93:
94:
95:
96:
97:
98:


99:
100:
101:
102:
103:
104:

105:
106:
107:108:tofile="${build.dir}/multiserver.conf"
109:filtering="on"/>

110:
111:
112:
113:


114:





4:build.xml详细说明
下 面我们将详细讲述这个文件,同样为了方便,我加了行号,当然一些基本的东西我就不再重复了。第四行taskdef任务(task)属于ant的内部任务, 它的作用是定义一个任务,其基本属性有name,classname,在定义时这两个属性都必需有。第八行开始定义一个path,它有一个属性id,通过 这个id的值我们可以在后面引用这个path,参见第68行。目标(target)init(从14行到34行)定义了一些基本属性 (property),主要是为了后面的target使用。在第38行,你会看到depends="init",depends是定义一个目标时的可选属 性,它的意思是如果init目标没有执行(出错或其他原因),这个目标也不会被执行。

从第46行开始定义xmlc任务,到第58行结束,中间有很多参数嵌套在其中,srcdir指定源文件目录,sourceout指定输出目录,includes属性将源文件目录中的所有html文件包括进来。*为通配符。

表示取消警告,表示同时产生接口和实现代码,例如:一个welcome.html,它会产生两个文件: WelcomeHTMLImpl.java,WelcomeHTML.java,WelcomeHTML.java中只定义了一个接口 WelcomeHTML,真正的实现在WelcomeHTMLImpl.java中。表示设置编码,由于xmlc将html文件编译为java类,即使你在html文件中已经设置了编码,在 java类中也不会有作用,必须在编译时设置编码。 这两句相当于在命令行上输入-ssi -keep.其中ssi参数是在编译html文件时将定义的ssi文件包括进来,见html目录下的welcome2.html源代码中有一行: Ant简介-jennyljd-ChinaUnix博客
  • 博客访问: 313275
  • 博文数量: 54
  • 博客积分: 1400
  • 博客等级: 上尉
  • 技术积分: 606
  • 用 户 组: 普通用户
  • 注册时间: 2006-12-03 22:43
文章分类
文章存档

2011年(3)

2010年(26)

2009年(2)

2008年(23)

我的朋友

分类:

2009-02-21 20:15:11

本文描述了ant的基本语法及其如何应用于项目的管理
-. Ant简介
可 能有许多读者并不了解什么是ant,以及如何使用它。但只要你是用过linux,你应该知道make为何物,当我们编译linux内核及一些软件的源程序 时,我们经常需要在控制台下输入make。Make其实就是一个项目管理工具,而ant所实现的功能与make差不多。Ant是apache软件基金会 jakarta项目中的一个子项目,由于是基于java编写的,因此具有很好的跨平台性。Ant由一些内置任务(task)和可选择的任务组成(当然你还 可以编写自己的任务),使用Make时,你需要写一个Makefile文件,而用ant时则需要写一个build.xml文件。由于采用xml的语法,所 以build.xml文件很容易书写和维护,且结构很清晰,而不像Makefile文件有那么多的限制(例如在tab符号前有一个空格的话,命令就不会执 行)。Ant的优点远不止这些,它还很容易的集成到一些开发环境中(例如visual age,jbuilder,netbeans)。

二.Ant的安装及配置
安装
Ant 目前的版本是1.3,首先到下载ant最新版本1.3,解压到C: /ant(window操作系统) 或者/usr/local/ant(linux操作系统),由于我们要用到xmlc ,而ant1.3中并没有包含它,所以我们需要David.Li为ant写的xmlc任务。具体url为http: //。将下载后的文件中的 ant.jar替换掉ant1.3中ant.jar.这样ant的版本变为1.2.

2.设置路径
(1):windows98操作系统
编辑C:\enhydra\.bashrc,加入下面三行

export ANT_HOME=/ant
export JAVA_HOME=/jdk-1.2.2
export PATH=${PATH}:${ANT_HOME}/bin

(2):Linux操作系统
编辑/etc/profile或者 用户目录下的.bashrc文件,加入下面三行

export ANT_HOME=/usr/local/ant
export JAVA_HOME=/usr/local/jdk-1.2.2
export PATH=${PATH}:${ANT_HOME}/bin

三:用ant管理项目
1:基本的文件目录结构 解压到任意目录,我们可以看到目录树结构如下
├─bin
├─docs
│ ├─ant2
│ ├─api
│ │ └─org
│ │ └─apache
│ │ └─tools
│ │ ├─ant
│ │ │ ├─taskdefs
│ │ │ │ ├─compilers
│ │ │ │ └─optional
│ │ │ │ ├─clearcase
│ │ │ │ ├─depend
│ │ │ │ │ └─constantpool
│ │ │ │ ├─dotnet
│ │ │ │ ├─ejb
│ │ │ │ ├─ide
│ │ │ │ ├─javacc
│ │ │ │ ├─jlink
│ │ │ │ ├─jsp
│ │ │ │ ├─junit
│ │ │ │ ├─metamata
│ │ │ │ ├─net
│ │ │ │ ├─perforce
│ │ │ │ ├─scm
│ │ │ │ ├─sound
│ │ │ │ └─vss
│ │ │ ├─types
│ │ │ └─util
│ │ │ └─regexp
│ │ ├─mail
│ │ └─tar
│ └─manual
│ ├─CoreTasks
│ ├─CoreTypes
│ ├─Integration
│ └─OptionalTasks
└─lib





在这个目录树结构中,与传统的项目不同的是,我们用build.xml取代了Makefile,在讲述这个build.xml文件前,我们先了解一个基本的 build.xml文件的结构。

2:build.xml的基本书写规范
下面我们就来讲述这个文件的书写方法,下面是这个文件的全部内容
1.
2.
3.
4.
5.
6.

7.





为 了方便说明,我们为每一行加了行号,第一行是xml文件的基本要素,第二行说明这是一个项目,第七行说明项目的结束 ,在第二行中,name="MyProject"说明此项目的名称,这个属性可有可无。basedir="."说明基本目录,此属性可有可无。 default="dist"说明项目的缺省目标(target)是什么,这个属性必须有。所谓目标(target)就是一系列任务(task)组成的一 个集合。每个任务(task)的书写方法如下:
<任务名 属性1="属性1的值" 属性2="属性2的值" ....... />




第 三行定义了一些属性(property),以便后面使用,这非常类似于编程中定义的全局变量。从第四行开始定义目标(target),name= "init"指明了此目标的名称,name属性在定义目标时必须有,当然定义目标时还有其他一些属性可选,例如depends,unless,具体请参考 ant的文档。第五行开始定义此目标内的任务,其中mkdir时ant的内部任务名,dir是此任务的属性,其值为${dist}。此任务就是创建一个目 录。其中${dist}是获取dist属性的值(就是我们在第三行定义的)。如上就是一个基本的build.xml文件的写法。你可以在命令行上输入 ant -buildfile build.xml

看一下你的当前目录下是否多了一个dist目录。如果出错,则可能是你没有把ant配置好,参见前面讲的安装及配置,看一下哪儿出了错。

3:build.xml文件
build.xml文件如下,其中有的注释和无关的代码删掉了,且做了一下小小的改动
1:
2:
3:
4:
5:
6:
7:
8:
9:
10:


11:
12:
13:
14:
15:
16:
17:
18:
19:

20:
21:
22:
23:

24:
25:

26:
27:
28:
29:
30:
31:
32:

33:
34:


35:
36:
37:
38:
39:
40:


41:
42:
43:
44:
45:
46:47:sourceout="${build.xmlc.dir}"
48:includes="**/*.html">
49:

50:
51:
52:
53:
54:
55:
56:
57:
58:

59:


60:
61:
62:
63:
64:

65:
66:67:destdir="${build.classes}"
68:classpathref="build.classpath"
69:debug="${build.debug}"/>

70:
71:72:destdir="${build.classes}"
73:classpathref="build.classpath"
74:debug="${build.debug}"
75:includes="${app.name}/**"
76:/>
77:


78:
79:
80:
81:
82:
83:
84:
85:
86:
87:
88:
89:

90:

91:



92:
93:
94:
95:
96:
97:
98:


99:
100:
101:
102:
103:
104:

105:
106:
107:108:tofile="${build.dir}/multiserver.conf"
109:filtering="on"/>

110:
111:
112:
113:


114:





4:build.xml详细说明
下 面我们将详细讲述这个文件,同样为了方便,我加了行号,当然一些基本的东西我就不再重复了。第四行taskdef任务(task)属于ant的内部任务, 它的作用是定义一个任务,其基本属性有name,classname,在定义时这两个属性都必需有。第八行开始定义一个path,它有一个属性id,通过 这个id的值我们可以在后面引用这个path,参见第68行。目标(target)init(从14行到34行)定义了一些基本属性 (property),主要是为了后面的target使用。在第38行,你会看到depends="init",depends是定义一个目标时的可选属 性,它的意思是如果init目标没有执行(出错或其他原因),这个目标也不会被执行。

从第46行开始定义xmlc任务,到第58行结束,中间有很多参数嵌套在其中,srcdir指定源文件目录,sourceout指定输出目录,includes属性将源文件目录中的所有html文件包括进来。*为通配符。

表示取消警告,表示同时产生接口和实现代码,例如:一个welcome.html,它会产生两个文件: WelcomeHTMLImpl.java,WelcomeHTML.java,WelcomeHTML.java中只定义了一个接口 WelcomeHTML,真正的实现在WelcomeHTMLImpl.java中。表示设置编码,由于xmlc将html文件编译为java类,即使你在html文件中已经设置了编码,在 java类中也不会有作用,必须在编译时设置编码。 这两句相当于在命令行上输入-ssi -keep.其中ssi参数是在编译html文件时将定义的ssi文件包括进来,见html目录下的welcome2.html源代码中有一行: Ant简介-jennyljd-ChinaUnix博客
  • 博客访问: 313276
  • 博文数量: 54
  • 博客积分: 1400
  • 博客等级: 上尉
  • 技术积分: 606
  • 用 户 组: 普通用户
  • 注册时间: 2006-12-03 22:43
文章分类
文章存档

2011年(3)

2010年(26)

2009年(2)

2008年(23)

我的朋友

分类:

2009-02-21 20:15:11

本文描述了ant的基本语法及其如何应用于项目的管理
-. Ant简介
可 能有许多读者并不了解什么是ant,以及如何使用它。但只要你是用过linux,你应该知道make为何物,当我们编译linux内核及一些软件的源程序 时,我们经常需要在控制台下输入make。Make其实就是一个项目管理工具,而ant所实现的功能与make差不多。Ant是apache软件基金会 jakarta项目中的一个子项目,由于是基于java编写的,因此具有很好的跨平台性。Ant由一些内置任务(task)和可选择的任务组成(当然你还 可以编写自己的任务),使用Make时,你需要写一个Makefile文件,而用ant时则需要写一个build.xml文件。由于采用xml的语法,所 以build.xml文件很容易书写和维护,且结构很清晰,而不像Makefile文件有那么多的限制(例如在tab符号前有一个空格的话,命令就不会执 行)。Ant的优点远不止这些,它还很容易的集成到一些开发环境中(例如visual age,jbuilder,netbeans)。

二.Ant的安装及配置
安装
Ant 目前的版本是1.3,首先到下载ant最新版本1.3,解压到C: /ant(window操作系统) 或者/usr/local/ant(linux操作系统),由于我们要用到xmlc ,而ant1.3中并没有包含它,所以我们需要David.Li为ant写的xmlc任务。具体url为http: //。将下载后的文件中的 ant.jar替换掉ant1.3中ant.jar.这样ant的版本变为1.2.

2.设置路径
(1):windows98操作系统
编辑C:\enhydra\.bashrc,加入下面三行

export ANT_HOME=/ant
export JAVA_HOME=/jdk-1.2.2
export PATH=${PATH}:${ANT_HOME}/bin

(2):Linux操作系统
编辑/etc/profile或者 用户目录下的.bashrc文件,加入下面三行

export ANT_HOME=/usr/local/ant
export JAVA_HOME=/usr/local/jdk-1.2.2
export PATH=${PATH}:${ANT_HOME}/bin

三:用ant管理项目
1:基本的文件目录结构 解压到任意目录,我们可以看到目录树结构如下
├─bin
├─docs
│ ├─ant2
│ ├─api
│ │ └─org
│ │ └─apache
│ │ └─tools
│ │ ├─ant
│ │ │ ├─taskdefs
│ │ │ │ ├─compilers
│ │ │ │ └─optional
│ │ │ │ ├─clearcase
│ │ │ │ ├─depend
│ │ │ │ │ └─constantpool
│ │ │ │ ├─dotnet
│ │ │ │ ├─ejb
│ │ │ │ ├─ide
│ │ │ │ ├─javacc
│ │ │ │ ├─jlink
│ │ │ │ ├─jsp
│ │ │ │ ├─junit
│ │ │ │ ├─metamata
│ │ │ │ ├─net
│ │ │ │ ├─perforce
│ │ │ │ ├─scm
│ │ │ │ ├─sound
│ │ │ │ └─vss
│ │ │ ├─types
│ │ │ └─util
│ │ │ └─regexp
│ │ ├─mail
│ │ └─tar
│ └─manual
│ ├─CoreTasks
│ ├─CoreTypes
│ ├─Integration
│ └─OptionalTasks
└─lib





在这个目录树结构中,与传统的项目不同的是,我们用build.xml取代了Makefile,在讲述这个build.xml文件前,我们先了解一个基本的 build.xml文件的结构。

2:build.xml的基本书写规范
下面我们就来讲述这个文件的书写方法,下面是这个文件的全部内容
1.
2.
3.
4.
5.
6.

7.





为 了方便说明,我们为每一行加了行号,第一行是xml文件的基本要素,第二行说明这是一个项目,第七行说明项目的结束 ,在第二行中,name="MyProject"说明此项目的名称,这个属性可有可无。basedir="."说明基本目录,此属性可有可无。 default="dist"说明项目的缺省目标(target)是什么,这个属性必须有。所谓目标(target)就是一系列任务(task)组成的一 个集合。每个任务(task)的书写方法如下:
<任务名 属性1="属性1的值" 属性2="属性2的值" ....... />




第 三行定义了一些属性(property),以便后面使用,这非常类似于编程中定义的全局变量。从第四行开始定义目标(target),name= "init"指明了此目标的名称,name属性在定义目标时必须有,当然定义目标时还有其他一些属性可选,例如depends,unless,具体请参考 ant的文档。第五行开始定义此目标内的任务,其中mkdir时ant的内部任务名,dir是此任务的属性,其值为${dist}。此任务就是创建一个目 录。其中${dist}是获取dist属性的值(就是我们在第三行定义的)。如上就是一个基本的build.xml文件的写法。你可以在命令行上输入 ant -buildfile build.xml

看一下你的当前目录下是否多了一个dist目录。如果出错,则可能是你没有把ant配置好,参见前面讲的安装及配置,看一下哪儿出了错。

3:build.xml文件
build.xml文件如下,其中有的注释和无关的代码删掉了,且做了一下小小的改动
1:
2:
3:
4:
5:
6:
7:
8:
9:
10:


11:
12:
13:
14:
15:
16:
17:
18:
19:

20:
21:
22:
23:

24:
25:

26:
27:
28:
29:
30:
31:
32:

33:
34:


35:
36:
37:
38:
39:
40:


41:
42:
43:
44:
45:
46:47:sourceout="${build.xmlc.dir}"
48:includes="**/*.html">
49:

50:
51:
52:
53:
54:
55:
56:
57:
58:

59:


60:
61:
62:
63:
64:

65:
66:67:destdir="${build.classes}"
68:classpathref="build.classpath"
69:debug="${build.debug}"/>

70:
71:72:destdir="${build.classes}"
73:classpathref="build.classpath"
74:debug="${build.debug}"
75:includes="${app.name}/**"
76:/>
77:


78:
79:
80:
81:
82:
83:
84:
85:
86:
87:
88:
89:

90:

91:



92:
93:
94:
95:
96:
97:
98:


99:
100:
101:
102:
103:
104:

105:
106:
107:108:tofile="${build.dir}/multiserver.conf"
109:filtering="on"/>

110:
111:
112:
113:


114:





4:build.xml详细说明
下 面我们将详细讲述这个文件,同样为了方便,我加了行号,当然一些基本的东西我就不再重复了。第四行taskdef任务(task)属于ant的内部任务, 它的作用是定义一个任务,其基本属性有name,classname,在定义时这两个属性都必需有。第八行开始定义一个path,它有一个属性id,通过 这个id的值我们可以在后面引用这个path,参见第68行。目标(target)init(从14行到34行)定义了一些基本属性 (property),主要是为了后面的target使用。在第38行,你会看到depends="init",depends是定义一个目标时的可选属 性,它的意思是如果init目标没有执行(出错或其他原因),这个目标也不会被执行。

从第46行开始定义xmlc任务,到第58行结束,中间有很多参数嵌套在其中,srcdir指定源文件目录,sourceout指定输出目录,includes属性将源文件目录中的所有html文件包括进来。*为通配符。

表示取消警告,表示同时产生接口和实现代码,例如:一个welcome.html,它会产生两个文件: WelcomeHTMLImpl.java,WelcomeHTML.java,WelcomeHTML.java中只定义了一个接口 WelcomeHTML,真正的实现在WelcomeHTMLImpl.java中。表示设置编码,由于xmlc将html文件编译为java类,即使你在html文件中已经设置了编码,在 java类中也不会有作用,必须在编译时设置编码。 这两句相当于在命令行上输入-ssi -keep.其中ssi参数是在编译html文件时将定义的ssi文件包括进来,见html目录下的welcome2.html源代码中有一行: Ant简介-jennyljd-ChinaUnix博客
  • 博客访问: 313277
  • 博文数量: 54
  • 博客积分: 1400
  • 博客等级: 上尉
  • 技术积分: 606
  • 用 户 组: 普通用户
  • 注册时间: 2006-12-03 22:43
文章分类
文章存档

2011年(3)

2010年(26)

2009年(2)

2008年(23)

我的朋友

分类:

2009-02-21 20:15:11

本文描述了ant的基本语法及其如何应用于项目的管理
-. Ant简介
可 能有许多读者并不了解什么是ant,以及如何使用它。但只要你是用过linux,你应该知道make为何物,当我们编译linux内核及一些软件的源程序 时,我们经常需要在控制台下输入make。Make其实就是一个项目管理工具,而ant所实现的功能与make差不多。Ant是apache软件基金会 jakarta项目中的一个子项目,由于是基于java编写的,因此具有很好的跨平台性。Ant由一些内置任务(task)和可选择的任务组成(当然你还 可以编写自己的任务),使用Make时,你需要写一个Makefile文件,而用ant时则需要写一个build.xml文件。由于采用xml的语法,所 以build.xml文件很容易书写和维护,且结构很清晰,而不像Makefile文件有那么多的限制(例如在tab符号前有一个空格的话,命令就不会执 行)。Ant的优点远不止这些,它还很容易的集成到一些开发环境中(例如visual age,jbuilder,netbeans)。

二.Ant的安装及配置
安装
Ant 目前的版本是1.3,首先到下载ant最新版本1.3,解压到C: /ant(window操作系统) 或者/usr/local/ant(linux操作系统),由于我们要用到xmlc ,而ant1.3中并没有包含它,所以我们需要David.Li为ant写的xmlc任务。具体url为http: //。将下载后的文件中的 ant.jar替换掉ant1.3中ant.jar.这样ant的版本变为1.2.

2.设置路径
(1):windows98操作系统
编辑C:\enhydra\.bashrc,加入下面三行

export ANT_HOME=/ant
export JAVA_HOME=/jdk-1.2.2
export PATH=${PATH}:${ANT_HOME}/bin

(2):Linux操作系统
编辑/etc/profile或者 用户目录下的.bashrc文件,加入下面三行

export ANT_HOME=/usr/local/ant
export JAVA_HOME=/usr/local/jdk-1.2.2
export PATH=${PATH}:${ANT_HOME}/bin

三:用ant管理项目
1:基本的文件目录结构 解压到任意目录,我们可以看到目录树结构如下
├─bin
├─docs
│ ├─ant2
│ ├─api
│ │ └─org
│ │ └─apache
│ │ └─tools
│ │ ├─ant
│ │ │ ├─taskdefs
│ │ │ │ ├─compilers
│ │ │ │ └─optional
│ │ │ │ ├─clearcase
│ │ │ │ ├─depend
│ │ │ │ │ └─constantpool
│ │ │ │ ├─dotnet
│ │ │ │ ├─ejb
│ │ │ │ ├─ide
│ │ │ │ ├─javacc
│ │ │ │ ├─jlink
│ │ │ │ ├─jsp
│ │ │ │ ├─junit
│ │ │ │ ├─metamata
│ │ │ │ ├─net
│ │ │ │ ├─perforce
│ │ │ │ ├─scm
│ │ │ │ ├─sound
│ │ │ │ └─vss
│ │ │ ├─types
│ │ │ └─util
│ │ │ └─regexp
│ │ ├─mail
│ │ └─tar
│ └─manual
│ ├─CoreTasks
│ ├─CoreTypes
│ ├─Integration
│ └─OptionalTasks
└─lib





在这个目录树结构中,与传统的项目不同的是,我们用build.xml取代了Makefile,在讲述这个build.xml文件前,我们先了解一个基本的 build.xml文件的结构。

2:build.xml的基本书写规范
下面我们就来讲述这个文件的书写方法,下面是这个文件的全部内容
1.
2.
3.
4.
5.
6.

7.





为 了方便说明,我们为每一行加了行号,第一行是xml文件的基本要素,第二行说明这是一个项目,第七行说明项目的结束 ,在第二行中,name="MyProject"说明此项目的名称,这个属性可有可无。basedir="."说明基本目录,此属性可有可无。 default="dist"说明项目的缺省目标(target)是什么,这个属性必须有。所谓目标(target)就是一系列任务(task)组成的一 个集合。每个任务(task)的书写方法如下:
<任务名 属性1="属性1的值" 属性2="属性2的值" ....... />




第 三行定义了一些属性(property),以便后面使用,这非常类似于编程中定义的全局变量。从第四行开始定义目标(target),name= "init"指明了此目标的名称,name属性在定义目标时必须有,当然定义目标时还有其他一些属性可选,例如depends,unless,具体请参考 ant的文档。第五行开始定义此目标内的任务,其中mkdir时ant的内部任务名,dir是此任务的属性,其值为${dist}。此任务就是创建一个目 录。其中${dist}是获取dist属性的值(就是我们在第三行定义的)。如上就是一个基本的build.xml文件的写法。你可以在命令行上输入 ant -buildfile build.xml

看一下你的当前目录下是否多了一个dist目录。如果出错,则可能是你没有把ant配置好,参见前面讲的安装及配置,看一下哪儿出了错。

3:build.xml文件
build.xml文件如下,其中有的注释和无关的代码删掉了,且做了一下小小的改动
1:
2:
3:
4:
5:
6:
7:
8:
9:
10:


11:
12:
13:
14:
15:
16:
17:
18:
19:

20:
21:
22:
23:

24:
25:

26:
27:
28:
29:
30:
31:
32:

33:
34:


35:
36:
37:
38:
39:
40:


41:
42:
43:
44:
45:
46:47:sourceout="${build.xmlc.dir}"
48:includes="**/*.html">
49:

50:
51:
52:
53:
54:
55:
56:
57:
58:

59:


60:
61:
62:
63:
64:

65:
66:67:destdir="${build.classes}"
68:classpathref="build.classpath"
69:debug="${build.debug}"/>

70:
71:72:destdir="${build.classes}"
73:classpathref="build.classpath"
74:debug="${build.debug}"
75:includes="${app.name}/**"
76:/>
77:


78:
79:
80:
81:
82:
83:
84:
85:
86:
87:
88:
89:

90:

91:



92:
93:
94:
95:
96:
97:
98:


99:
100:
101:
102:
103:
104:

105:
106:
107:108:tofile="${build.dir}/multiserver.conf"
109:filtering="on"/>

110:
111:
112:
113:


114:





4:build.xml详细说明
下 面我们将详细讲述这个文件,同样为了方便,我加了行号,当然一些基本的东西我就不再重复了。第四行taskdef任务(task)属于ant的内部任务, 它的作用是定义一个任务,其基本属性有name,classname,在定义时这两个属性都必需有。第八行开始定义一个path,它有一个属性id,通过 这个id的值我们可以在后面引用这个path,参见第68行。目标(target)init(从14行到34行)定义了一些基本属性 (property),主要是为了后面的target使用。在第38行,你会看到depends="init",depends是定义一个目标时的可选属 性,它的意思是如果init目标没有执行(出错或其他原因),这个目标也不会被执行。

从第46行开始定义xmlc任务,到第58行结束,中间有很多参数嵌套在其中,srcdir指定源文件目录,sourceout指定输出目录,includes属性将源文件目录中的所有html文件包括进来。*为通配符。

表示取消警告,表示同时产生接口和实现代码,例如:一个welcome.html,它会产生两个文件: WelcomeHTMLImpl.java,WelcomeHTML.java,WelcomeHTML.java中只定义了一个接口 WelcomeHTML,真正的实现在WelcomeHTMLImpl.java中。表示设置编码,由于xmlc将html文件编译为java类,即使你在html文件中已经设置了编码,在 java类中也不会有作用,必须在编译时设置编码。 这两句相当于在命令行上输入-ssi -keep.其中ssi参数是在编译html文件时将定义的ssi文件包括进来,见html目录下的welcome2.html源代码中有一行: Ant简介-jennyljd-ChinaUnix博客
  • 博客访问: 313278
  • 博文数量: 54
  • 博客积分: 1400
  • 博客等级: 上尉
  • 技术积分: 606
  • 用 户 组: 普通用户
  • 注册时间: 2006-12-03 22:43
文章分类
文章存档

2011年(3)

2010年(26)

2009年(2)

2008年(23)

我的朋友

分类:

2009-02-21 20:15:11

本文描述了ant的基本语法及其如何应用于项目的管理
-. Ant简介
可 能有许多读者并不了解什么是ant,以及如何使用它。但只要你是用过linux,你应该知道make为何物,当我们编译linux内核及一些软件的源程序 时,我们经常需要在控制台下输入make。Make其实就是一个项目管理工具,而ant所实现的功能与make差不多。Ant是apache软件基金会 jakarta项目中的一个子项目,由于是基于java编写的,因此具有很好的跨平台性。Ant由一些内置任务(task)和可选择的任务组成(当然你还 可以编写自己的任务),使用Make时,你需要写一个Makefile文件,而用ant时则需要写一个build.xml文件。由于采用xml的语法,所 以build.xml文件很容易书写和维护,且结构很清晰,而不像Makefile文件有那么多的限制(例如在tab符号前有一个空格的话,命令就不会执 行)。Ant的优点远不止这些,它还很容易的集成到一些开发环境中(例如visual age,jbuilder,netbeans)。

二.Ant的安装及配置
安装
Ant 目前的版本是1.3,首先到下载ant最新版本1.3,解压到C: /ant(window操作系统) 或者/usr/local/ant(linux操作系统),由于我们要用到xmlc ,而ant1.3中并没有包含它,所以我们需要David.Li为ant写的xmlc任务。具体url为http: //。将下载后的文件中的 ant.jar替换掉ant1.3中ant.jar.这样ant的版本变为1.2.

2.设置路径
(1):windows98操作系统
编辑C:\enhydra\.bashrc,加入下面三行

export ANT_HOME=/ant
export JAVA_HOME=/jdk-1.2.2
export PATH=${PATH}:${ANT_HOME}/bin

(2):Linux操作系统
编辑/etc/profile或者 用户目录下的.bashrc文件,加入下面三行

export ANT_HOME=/usr/local/ant
export JAVA_HOME=/usr/local/jdk-1.2.2
export PATH=${PATH}:${ANT_HOME}/bin

三:用ant管理项目
1:基本的文件目录结构 解压到任意目录,我们可以看到目录树结构如下
├─bin
├─docs
│ ├─ant2
│ ├─api
│ │ └─org
│ │ └─apache
│ │ └─tools
│ │ ├─ant
│ │ │ ├─taskdefs
│ │ │ │ ├─compilers
│ │ │ │ └─optional
│ │ │ │ ├─clearcase
│ │ │ │ ├─depend
│ │ │ │ │ └─constantpool
│ │ │ │ ├─dotnet
│ │ │ │ ├─ejb
│ │ │ │ ├─ide
│ │ │ │ ├─javacc
│ │ │ │ ├─jlink
│ │ │ │ ├─jsp
│ │ │ │ ├─junit
│ │ │ │ ├─metamata
│ │ │ │ ├─net
│ │ │ │ ├─perforce
│ │ │ │ ├─scm
│ │ │ │ ├─sound
│ │ │ │ └─vss
│ │ │ ├─types
│ │ │ └─util
│ │ │ └─regexp
│ │ ├─mail
│ │ └─tar
│ └─manual
│ ├─CoreTasks
│ ├─CoreTypes
│ ├─Integration
│ └─OptionalTasks
└─lib





在这个目录树结构中,与传统的项目不同的是,我们用build.xml取代了Makefile,在讲述这个build.xml文件前,我们先了解一个基本的 build.xml文件的结构。

2:build.xml的基本书写规范
下面我们就来讲述这个文件的书写方法,下面是这个文件的全部内容
1.
2.
3.
4.
5.
6.

7.





为 了方便说明,我们为每一行加了行号,第一行是xml文件的基本要素,第二行说明这是一个项目,第七行说明项目的结束 ,在第二行中,name="MyProject"说明此项目的名称,这个属性可有可无。basedir="."说明基本目录,此属性可有可无。 default="dist"说明项目的缺省目标(target)是什么,这个属性必须有。所谓目标(target)就是一系列任务(task)组成的一 个集合。每个任务(task)的书写方法如下:
<任务名 属性1="属性1的值" 属性2="属性2的值" ....... />




第 三行定义了一些属性(property),以便后面使用,这非常类似于编程中定义的全局变量。从第四行开始定义目标(target),name= "init"指明了此目标的名称,name属性在定义目标时必须有,当然定义目标时还有其他一些属性可选,例如depends,unless,具体请参考 ant的文档。第五行开始定义此目标内的任务,其中mkdir时ant的内部任务名,dir是此任务的属性,其值为${dist}。此任务就是创建一个目 录。其中${dist}是获取dist属性的值(就是我们在第三行定义的)。如上就是一个基本的build.xml文件的写法。你可以在命令行上输入 ant -buildfile build.xml

看一下你的当前目录下是否多了一个dist目录。如果出错,则可能是你没有把ant配置好,参见前面讲的安装及配置,看一下哪儿出了错。

3:build.xml文件
build.xml文件如下,其中有的注释和无关的代码删掉了,且做了一下小小的改动
1:
2:
3:
4:
5:
6:
7:
8:
9:
10:


11:
12:
13:
14:
15:
16:
17:
18:
19:

20:
21:
22:
23:

24:
25:

26:
27:
28:
29:
30:
31:
32:

33:
34:


35:
36:
37:
38:
39:
40:


41:
42:
43:
44:
45:
46:47:sourceout="${build.xmlc.dir}"
48:includes="**/*.html">
49:

50:
51:
52:
53:
54:
55:
56:
57:
58:

59:


60:
61:
62:
63:
64:

65:
66:67:destdir="${build.classes}"
68:classpathref="build.classpath"
69:debug="${build.debug}"/>

70:
71:72:destdir="${build.classes}"
73:classpathref="build.classpath"
74:debug="${build.debug}"
75:includes="${app.name}/**"
76:/>
77:


78:
79:
80:
81:
82:
83:
84:
85:
86:
87:
88:
89:

90:

91:



92:
93:
94:
95:
96:
97:
98:


99:
100:
101:
102:
103:
104:

105:
106:
107:108:tofile="${build.dir}/multiserver.conf"
109:filtering="on"/>

110:
111:
112:
113:


114:





4:build.xml详细说明
下 面我们将详细讲述这个文件,同样为了方便,我加了行号,当然一些基本的东西我就不再重复了。第四行taskdef任务(task)属于ant的内部任务, 它的作用是定义一个任务,其基本属性有name,classname,在定义时这两个属性都必需有。第八行开始定义一个path,它有一个属性id,通过 这个id的值我们可以在后面引用这个path,参见第68行。目标(target)init(从14行到34行)定义了一些基本属性 (property),主要是为了后面的target使用。在第38行,你会看到depends="init",depends是定义一个目标时的可选属 性,它的意思是如果init目标没有执行(出错或其他原因),这个目标也不会被执行。

从第46行开始定义xmlc任务,到第58行结束,中间有很多参数嵌套在其中,srcdir指定源文件目录,sourceout指定输出目录,includes属性将源文件目录中的所有html文件包括进来。*为通配符。

表示取消警告,表示同时产生接口和实现代码,例如:一个welcome.html,它会产生两个文件: WelcomeHTMLImpl.java,WelcomeHTML.java,WelcomeHTML.java中只定义了一个接口 WelcomeHTML,真正的实现在WelcomeHTMLImpl.java中。表示设置编码,由于xmlc将html文件编译为java类,即使你在html文件中已经设置了编码,在 java类中也不会有作用,必须在编译时设置编码。 这两句相当于在命令行上输入-ssi -keep.其中ssi参数是在编译html文件时将定义的ssi文件包括进来,见html目录下的welcome2.html源代码中有一行: Ant简介-jennyljd-ChinaUnix博客
  • 博客访问: 313279
  • 博文数量: 54
  • 博客积分: 1400
  • 博客等级: 上尉
  • 技术积分: 606
  • 用 户 组: 普通用户
  • 注册时间: 2006-12-03 22:43
文章分类
文章存档

2011年(3)

2010年(26)

2009年(2)

2008年(23)

我的朋友

分类:

2009-02-21 20:15:11

本文描述了ant的基本语法及其如何应用于项目的管理
-. Ant简介
可 能有许多读者并不了解什么是ant,以及如何使用它。但只要你是用过linux,你应该知道make为何物,当我们编译linux内核及一些软件的源程序 时,我们经常需要在控制台下输入make。Make其实就是一个项目管理工具,而ant所实现的功能与make差不多。Ant是apache软件基金会 jakarta项目中的一个子项目,由于是基于java编写的,因此具有很好的跨平台性。Ant由一些内置任务(task)和可选择的任务组成(当然你还 可以编写自己的任务),使用Make时,你需要写一个Makefile文件,而用ant时则需要写一个build.xml文件。由于采用xml的语法,所 以build.xml文件很容易书写和维护,且结构很清晰,而不像Makefile文件有那么多的限制(例如在tab符号前有一个空格的话,命令就不会执 行)。Ant的优点远不止这些,它还很容易的集成到一些开发环境中(例如visual age,jbuilder,netbeans)。

二.Ant的安装及配置
安装
Ant 目前的版本是1.3,首先到下载ant最新版本1.3,解压到C: /ant(window操作系统) 或者/usr/local/ant(linux操作系统),由于我们要用到xmlc ,而ant1.3中并没有包含它,所以我们需要David.Li为ant写的xmlc任务。具体url为http: //。将下载后的文件中的 ant.jar替换掉ant1.3中ant.jar.这样ant的版本变为1.2.

2.设置路径
(1):windows98操作系统
编辑C:\enhydra\.bashrc,加入下面三行

export ANT_HOME=/ant
export JAVA_HOME=/jdk-1.2.2
export PATH=${PATH}:${ANT_HOME}/bin

(2):Linux操作系统
编辑/etc/profile或者 用户目录下的.bashrc文件,加入下面三行

export ANT_HOME=/usr/local/ant
export JAVA_HOME=/usr/local/jdk-1.2.2
export PATH=${PATH}:${ANT_HOME}/bin

三:用ant管理项目
1:基本的文件目录结构 解压到任意目录,我们可以看到目录树结构如下
├─bin
├─docs
│ ├─ant2
│ ├─api
│ │ └─org
│ │ └─apache
│ │ └─tools
│ │ ├─ant
│ │ │ ├─taskdefs
│ │ │ │ ├─compilers
│ │ │ │ └─optional
│ │ │ │ ├─clearcase
│ │ │ │ ├─depend
│ │ │ │ │ └─constantpool
│ │ │ │ ├─dotnet
│ │ │ │ ├─ejb
│ │ │ │ ├─ide
│ │ │ │ ├─javacc
│ │ │ │ ├─jlink
│ │ │ │ ├─jsp
│ │ │ │ ├─junit
│ │ │ │ ├─metamata
│ │ │ │ ├─net
│ │ │ │ ├─perforce
│ │ │ │ ├─scm
│ │ │ │ ├─sound
│ │ │ │ └─vss
│ │ │ ├─types
│ │ │ └─util
│ │ │ └─regexp
│ │ ├─mail
│ │ └─tar
│ └─manual
│ ├─CoreTasks
│ ├─CoreTypes
│ ├─Integration
│ └─OptionalTasks
└─lib





在这个目录树结构中,与传统的项目不同的是,我们用build.xml取代了Makefile,在讲述这个build.xml文件前,我们先了解一个基本的 build.xml文件的结构。

2:build.xml的基本书写规范
下面我们就来讲述这个文件的书写方法,下面是这个文件的全部内容
1.
2.
3.
4.
5.
6.

7.





为 了方便说明,我们为每一行加了行号,第一行是xml文件的基本要素,第二行说明这是一个项目,第七行说明项目的结束 ,在第二行中,name="MyProject"说明此项目的名称,这个属性可有可无。basedir="."说明基本目录,此属性可有可无。 default="dist"说明项目的缺省目标(target)是什么,这个属性必须有。所谓目标(target)就是一系列任务(task)组成的一 个集合。每个任务(task)的书写方法如下:
<任务名 属性1="属性1的值" 属性2="属性2的值" ....... />




第 三行定义了一些属性(property),以便后面使用,这非常类似于编程中定义的全局变量。从第四行开始定义目标(target),name= "init"指明了此目标的名称,name属性在定义目标时必须有,当然定义目标时还有其他一些属性可选,例如depends,unless,具体请参考 ant的文档。第五行开始定义此目标内的任务,其中mkdir时ant的内部任务名,dir是此任务的属性,其值为${dist}。此任务就是创建一个目 录。其中${dist}是获取dist属性的值(就是我们在第三行定义的)。如上就是一个基本的build.xml文件的写法。你可以在命令行上输入 ant -buildfile build.xml

看一下你的当前目录下是否多了一个dist目录。如果出错,则可能是你没有把ant配置好,参见前面讲的安装及配置,看一下哪儿出了错。

3:build.xml文件
build.xml文件如下,其中有的注释和无关的代码删掉了,且做了一下小小的改动
1:
2:
3:
4:
5:
6:
7:
8:
9:
10:


11:
12:
13:
14:
15:
16:
17:
18:
19:

20:
21:
22:
23:

24:
25:

26:
27:
28:
29:
30:
31:
32:

33:
34:


35:
36:
37:
38:
39:
40:


41:
42:
43:
44:
45:
46:47:sourceout="${build.xmlc.dir}"
48:includes="**/*.html">
49:

50:
51:
52:
53:
54:
55:
56:
57:
58:

59:


60:
61:
62:
63:
64:

65:
66:67:destdir="${build.classes}"
68:classpathref="build.classpath"
69:debug="${build.debug}"/>

70:
71:72:destdir="${build.classes}"
73:classpathref="build.classpath"
74:debug="${build.debug}"
75:includes="${app.name}/**"
76:/>
77:


78:
79:
80:
81:
82:
83:
84:
85:
86:
87:
88:
89:

90:

91:



92:
93:
94:
95:
96:
97:
98:


99:
100:
101:
102:
103:
104:

105:
106:
107:108:tofile="${build.dir}/multiserver.conf"
109:filtering="on"/>

110:
111:
112:
113:


114:





4:build.xml详细说明
下 面我们将详细讲述这个文件,同样为了方便,我加了行号,当然一些基本的东西我就不再重复了。第四行taskdef任务(task)属于ant的内部任务, 它的作用是定义一个任务,其基本属性有name,classname,在定义时这两个属性都必需有。第八行开始定义一个path,它有一个属性id,通过 这个id的值我们可以在后面引用这个path,参见第68行。目标(target)init(从14行到34行)定义了一些基本属性 (property),主要是为了后面的target使用。在第38行,你会看到depends="init",depends是定义一个目标时的可选属 性,它的意思是如果init目标没有执行(出错或其他原因),这个目标也不会被执行。

从第46行开始定义xmlc任务,到第58行结束,中间有很多参数嵌套在其中,srcdir指定源文件目录,sourceout指定输出目录,includes属性将源文件目录中的所有html文件包括进来。*为通配符。

表示取消警告,表示同时产生接口和实现代码,例如:一个welcome.html,它会产生两个文件: WelcomeHTMLImpl.java,WelcomeHTML.java,WelcomeHTML.java中只定义了一个接口 WelcomeHTML,真正的实现在WelcomeHTMLImpl.java中。表示设置编码,由于xmlc将html文件编译为java类,即使你在html文件中已经设置了编码,在 java类中也不会有作用,必须在编译时设置编码。 这两句相当于在命令行上输入-ssi -keep.其中ssi参数是在编译html文件时将定义的ssi文件包括进来,见html目录下的welcome2.html源代码中有一行: Ant简介-jennyljd-ChinaUnix博客
  • 博客访问: 313280
  • 博文数量: 54
  • 博客积分: 1400
  • 博客等级: 上尉
  • 技术积分: 606
  • 用 户 组: 普通用户
  • 注册时间: 2006-12-03 22:43
文章分类
文章存档

2011年(3)

2010年(26)

2009年(2)

2008年(23)

我的朋友

分类:

2009-02-21 20:15:11

本文描述了ant的基本语法及其如何应用于项目的管理
-. Ant简介
可 能有许多读者并不了解什么是ant,以及如何使用它。但只要你是用过linux,你应该知道make为何物,当我们编译linux内核及一些软件的源程序 时,我们经常需要在控制台下输入make。Make其实就是一个项目管理工具,而ant所实现的功能与make差不多。Ant是apache软件基金会 jakarta项目中的一个子项目,由于是基于java编写的,因此具有很好的跨平台性。Ant由一些内置任务(task)和可选择的任务组成(当然你还 可以编写自己的任务),使用Make时,你需要写一个Makefile文件,而用ant时则需要写一个build.xml文件。由于采用xml的语法,所 以build.xml文件很容易书写和维护,且结构很清晰,而不像Makefile文件有那么多的限制(例如在tab符号前有一个空格的话,命令就不会执 行)。Ant的优点远不止这些,它还很容易的集成到一些开发环境中(例如visual age,jbuilder,netbeans)。

二.Ant的安装及配置
安装
Ant 目前的版本是1.3,首先到下载ant最新版本1.3,解压到C: /ant(window操作系统) 或者/usr/local/ant(linux操作系统),由于我们要用到xmlc ,而ant1.3中并没有包含它,所以我们需要David.Li为ant写的xmlc任务。具体url为http: //。将下载后的文件中的 ant.jar替换掉ant1.3中ant.jar.这样ant的版本变为1.2.

2.设置路径
(1):windows98操作系统
编辑C:\enhydra\.bashrc,加入下面三行

export ANT_HOME=/ant
export JAVA_HOME=/jdk-1.2.2
export PATH=${PATH}:${ANT_HOME}/bin

(2):Linux操作系统
编辑/etc/profile或者 用户目录下的.bashrc文件,加入下面三行

export ANT_HOME=/usr/local/ant
export JAVA_HOME=/usr/local/jdk-1.2.2
export PATH=${PATH}:${ANT_HOME}/bin

三:用ant管理项目
1:基本的文件目录结构 解压到任意目录,我们可以看到目录树结构如下
├─bin
├─docs
│ ├─ant2
│ ├─api
│ │ └─org
│ │ └─apache
│ │ └─tools
│ │ ├─ant
│ │ │ ├─taskdefs
│ │ │ │ ├─compilers
│ │ │ │ └─optional
│ │ │ │ ├─clearcase
│ │ │ │ ├─depend
│ │ │ │ │ └─constantpool
│ │ │ │ ├─dotnet
│ │ │ │ ├─ejb
│ │ │ │ ├─ide
│ │ │ │ ├─javacc
│ │ │ │ ├─jlink
│ │ │ │ ├─jsp
│ │ │ │ ├─junit
│ │ │ │ ├─metamata
│ │ │ │ ├─net
│ │ │ │ ├─perforce
│ │ │ │ ├─scm
│ │ │ │ ├─sound
│ │ │ │ └─vss
│ │ │ ├─types
│ │ │ └─util
│ │ │ └─regexp
│ │ ├─mail
│ │ └─tar
│ └─manual
│ ├─CoreTasks
│ ├─CoreTypes
│ ├─Integration
│ └─OptionalTasks
└─lib





在这个目录树结构中,与传统的项目不同的是,我们用build.xml取代了Makefile,在讲述这个build.xml文件前,我们先了解一个基本的 build.xml文件的结构。

2:build.xml的基本书写规范
下面我们就来讲述这个文件的书写方法,下面是这个文件的全部内容
1.
2.
3.
4.
5.
6.

7.





为 了方便说明,我们为每一行加了行号,第一行是xml文件的基本要素,第二行说明这是一个项目,第七行说明项目的结束 ,在第二行中,name="MyProject"说明此项目的名称,这个属性可有可无。basedir="."说明基本目录,此属性可有可无。 default="dist"说明项目的缺省目标(target)是什么,这个属性必须有。所谓目标(target)就是一系列任务(task)组成的一 个集合。每个任务(task)的书写方法如下:
<任务名 属性1="属性1的值" 属性2="属性2的值" ....... />




第 三行定义了一些属性(property),以便后面使用,这非常类似于编程中定义的全局变量。从第四行开始定义目标(target),name= "init"指明了此目标的名称,name属性在定义目标时必须有,当然定义目标时还有其他一些属性可选,例如depends,unless,具体请参考 ant的文档。第五行开始定义此目标内的任务,其中mkdir时ant的内部任务名,dir是此任务的属性,其值为${dist}。此任务就是创建一个目 录。其中${dist}是获取dist属性的值(就是我们在第三行定义的)。如上就是一个基本的build.xml文件的写法。你可以在命令行上输入 ant -buildfile build.xml

看一下你的当前目录下是否多了一个dist目录。如果出错,则可能是你没有把ant配置好,参见前面讲的安装及配置,看一下哪儿出了错。

3:build.xml文件
build.xml文件如下,其中有的注释和无关的代码删掉了,且做了一下小小的改动
1:
2:
3:
4:
5:
6:
7:
8:
9:
10:


11:
12:
13:
14:
15:
16:
17:
18:
19:

20:
21:
22:
23:

24:
25:

26:
27:
28:
29:
30:
31:
32:

33:
34:


35:
36:
37:
38:
39:
40:


41:
42:
43:
44:
45:
46:47:sourceout="${build.xmlc.dir}"
48:includes="**/*.html">
49:

50:
51:
52:
53:
54:
55:
56:
57:
58:

59:


60:
61:
62:
63:
64:

65:
66:67:destdir="${build.classes}"
68:classpathref="build.classpath"
69:debug="${build.debug}"/>

70:
71:72:destdir="${build.classes}"
73:classpathref="build.classpath"
74:debug="${build.debug}"
75:includes="${app.name}/**"
76:/>
77:


78:
79:
80:
81:
82:
83:
84:
85:
86:
87:
88:
89:

90:

91:



92:
93:
94:
95:
96:
97:
98:


99:
100:
101:
102:
103:
104:

105:
106:
107:108:tofile="${build.dir}/multiserver.conf"
109:filtering="on"/>

110:
111:
112:
113:


114:





4:build.xml详细说明
下 面我们将详细讲述这个文件,同样为了方便,我加了行号,当然一些基本的东西我就不再重复了。第四行taskdef任务(task)属于ant的内部任务, 它的作用是定义一个任务,其基本属性有name,classname,在定义时这两个属性都必需有。第八行开始定义一个path,它有一个属性id,通过 这个id的值我们可以在后面引用这个path,参见第68行。目标(target)init(从14行到34行)定义了一些基本属性 (property),主要是为了后面的target使用。在第38行,你会看到depends="init",depends是定义一个目标时的可选属 性,它的意思是如果init目标没有执行(出错或其他原因),这个目标也不会被执行。

从第46行开始定义xmlc任务,到第58行结束,中间有很多参数嵌套在其中,srcdir指定源文件目录,sourceout指定输出目录,includes属性将源文件目录中的所有html文件包括进来。*为通配符。

表示取消警告,表示同时产生接口和实现代码,例如:一个welcome.html,它会产生两个文件: WelcomeHTMLImpl.java,WelcomeHTML.java,WelcomeHTML.java中只定义了一个接口 WelcomeHTML,真正的实现在WelcomeHTMLImpl.java中。表示设置编码,由于xmlc将html文件编译为java类,即使你在html文件中已经设置了编码,在 java类中也不会有作用,必须在编译时设置编码。 这两句相当于在命令行上输入-ssi -keep.其中ssi参数是在编译html文件时将定义的ssi文件包括进来,见html目录下的welcome2.html源代码中有一行: Ant简介-jennyljd-ChinaUnix博客
  • 博客访问: 313281
  • 博文数量: 54
  • 博客积分: 1400
  • 博客等级: 上尉
  • 技术积分: 606
  • 用 户 组: 普通用户
  • 注册时间: 2006-12-03 22:43
文章分类
文章存档

2011年(3)

2010年(26)

2009年(2)

2008年(23)

我的朋友

分类:

2009-02-21 20:15:11

本文描述了ant的基本语法及其如何应用于项目的管理
-. Ant简介
可 能有许多读者并不了解什么是ant,以及如何使用它。但只要你是用过linux,你应该知道make为何物,当我们编译linux内核及一些软件的源程序 时,我们经常需要在控制台下输入make。Make其实就是一个项目管理工具,而ant所实现的功能与make差不多。Ant是apache软件基金会 jakarta项目中的一个子项目,由于是基于java编写的,因此具有很好的跨平台性。Ant由一些内置任务(task)和可选择的任务组成(当然你还 可以编写自己的任务),使用Make时,你需要写一个Makefile文件,而用ant时则需要写一个build.xml文件。由于采用xml的语法,所 以build.xml文件很容易书写和维护,且结构很清晰,而不像Makefile文件有那么多的限制(例如在tab符号前有一个空格的话,命令就不会执 行)。Ant的优点远不止这些,它还很容易的集成到一些开发环境中(例如visual age,jbuilder,netbeans)。

二.Ant的安装及配置
安装
Ant 目前的版本是1.3,首先到下载ant最新版本1.3,解压到C: /ant(window操作系统) 或者/usr/local/ant(linux操作系统),由于我们要用到xmlc ,而ant1.3中并没有包含它,所以我们需要David.Li为ant写的xmlc任务。具体url为http: //。将下载后的文件中的 ant.jar替换掉ant1.3中ant.jar.这样ant的版本变为1.2.

2.设置路径
(1):windows98操作系统
编辑C:\enhydra\.bashrc,加入下面三行

export ANT_HOME=/ant
export JAVA_HOME=/jdk-1.2.2
export PATH=${PATH}:${ANT_HOME}/bin

(2):Linux操作系统
编辑/etc/profile或者 用户目录下的.bashrc文件,加入下面三行

export ANT_HOME=/usr/local/ant
export JAVA_HOME=/usr/local/jdk-1.2.2
export PATH=${PATH}:${ANT_HOME}/bin

三:用ant管理项目
1:基本的文件目录结构 解压到任意目录,我们可以看到目录树结构如下
├─bin
├─docs
│ ├─ant2
│ ├─api
│ │ └─org
│ │ └─apache
│ │ └─tools
│ │ ├─ant
│ │ │ ├─taskdefs
│ │ │ │ ├─compilers
│ │ │ │ └─optional
│ │ │ │ ├─clearcase
│ │ │ │ ├─depend
│ │ │ │ │ └─constantpool
│ │ │ │ ├─dotnet
│ │ │ │ ├─ejb
│ │ │ │ ├─ide
│ │ │ │ ├─javacc
│ │ │ │ ├─jlink
│ │ │ │ ├─jsp
│ │ │ │ ├─junit
│ │ │ │ ├─metamata
│ │ │ │ ├─net
│ │ │ │ ├─perforce
│ │ │ │ ├─scm
│ │ │ │ ├─sound
│ │ │ │ └─vss
│ │ │ ├─types
│ │ │ └─util
│ │ │ └─regexp
│ │ ├─mail
│ │ └─tar
│ └─manual
│ ├─CoreTasks
│ ├─CoreTypes
│ ├─Integration
│ └─OptionalTasks
└─lib





在这个目录树结构中,与传统的项目不同的是,我们用build.xml取代了Makefile,在讲述这个build.xml文件前,我们先了解一个基本的 build.xml文件的结构。

2:build.xml的基本书写规范
下面我们就来讲述这个文件的书写方法,下面是这个文件的全部内容
1.
2.
3.
4.
5.
6.

7.





为 了方便说明,我们为每一行加了行号,第一行是xml文件的基本要素,第二行说明这是一个项目,第七行说明项目的结束 ,在第二行中,name="MyProject"说明此项目的名称,这个属性可有可无。basedir="."说明基本目录,此属性可有可无。 default="dist"说明项目的缺省目标(target)是什么,这个属性必须有。所谓目标(target)就是一系列任务(task)组成的一 个集合。每个任务(task)的书写方法如下:
<任务名 属性1="属性1的值" 属性2="属性2的值" ....... />




第 三行定义了一些属性(property),以便后面使用,这非常类似于编程中定义的全局变量。从第四行开始定义目标(target),name= "init"指明了此目标的名称,name属性在定义目标时必须有,当然定义目标时还有其他一些属性可选,例如depends,unless,具体请参考 ant的文档。第五行开始定义此目标内的任务,其中mkdir时ant的内部任务名,dir是此任务的属性,其值为${dist}。此任务就是创建一个目 录。其中${dist}是获取dist属性的值(就是我们在第三行定义的)。如上就是一个基本的build.xml文件的写法。你可以在命令行上输入 ant -buildfile build.xml

看一下你的当前目录下是否多了一个dist目录。如果出错,则可能是你没有把ant配置好,参见前面讲的安装及配置,看一下哪儿出了错。

3:build.xml文件
build.xml文件如下,其中有的注释和无关的代码删掉了,且做了一下小小的改动
1:
2:
3:
4:
5:
6:
7:
8:
9:
10:


11:
12:
13:
14:
15:
16:
17:
18:
19:

20:
21:
22:
23:

24:
25:

26:
27:
28:
29:
30:
31:
32:

33:
34:


35:
36:
37:
38:
39:
40:


41:
42:
43:
44:
45:
46:47:sourceout="${build.xmlc.dir}"
48:includes="**/*.html">
49:

50:
51:
52:
53:
54:
55:
56:
57:
58:

59:


60:
61:
62:
63:
64:

65:
66:67:destdir="${build.classes}"
68:classpathref="build.classpath"
69:debug="${build.debug}"/>

70:
71:72:destdir="${build.classes}"
73:classpathref="build.classpath"
74:debug="${build.debug}"
75:includes="${app.name}/**"
76:/>
77:


78:
79:
80:
81:
82:
83:
84:
85:
86:
87:
88:
89:

90:

91:



92:
93:
94:
95:
96:
97:
98:


99:
100:
101:
102:
103:
104:

105:
106:
107:108:tofile="${build.dir}/multiserver.conf"
109:filtering="on"/>

110:
111:
112:
113:


114:





4:build.xml详细说明
下 面我们将详细讲述这个文件,同样为了方便,我加了行号,当然一些基本的东西我就不再重复了。第四行taskdef任务(task)属于ant的内部任务, 它的作用是定义一个任务,其基本属性有name,classname,在定义时这两个属性都必需有。第八行开始定义一个path,它有一个属性id,通过 这个id的值我们可以在后面引用这个path,参见第68行。目标(target)init(从14行到34行)定义了一些基本属性 (property),主要是为了后面的target使用。在第38行,你会看到depends="init",depends是定义一个目标时的可选属 性,它的意思是如果init目标没有执行(出错或其他原因),这个目标也不会被执行。

从第46行开始定义xmlc任务,到第58行结束,中间有很多参数嵌套在其中,srcdir指定源文件目录,sourceout指定输出目录,includes属性将源文件目录中的所有html文件包括进来。*为通配符。

表示取消警告,表示同时产生接口和实现代码,例如:一个welcome.html,它会产生两个文件: WelcomeHTMLImpl.java,WelcomeHTML.java,WelcomeHTML.java中只定义了一个接口 WelcomeHTML,真正的实现在WelcomeHTMLImpl.java中。表示设置编码,由于xmlc将html文件编译为java类,即使你在html文件中已经设置了编码,在 java类中也不会有作用,必须在编译时设置编码。 这两句相当于在命令行上输入-ssi -keep.其中ssi参数是在编译html文件时将定义的ssi文件包括进来,见html目录下的welcome2.html源代码中有一行: Ant简介-jennyljd-ChinaUnix博客
  • 博客访问: 313282
  • 博文数量: 54
  • 博客积分: 1400
  • 博客等级: 上尉
  • 技术积分: 606
  • 用 户 组: 普通用户
  • 注册时间: 2006-12-03 22:43
文章分类
文章存档

2011年(3)

2010年(26)

2009年(2)

2008年(23)

我的朋友

分类:

2009-02-21 20:15:11

本文描述了ant的基本语法及其如何应用于项目的管理
-. Ant简介
可 能有许多读者并不了解什么是ant,以及如何使用它。但只要你是用过linux,你应该知道make为何物,当我们编译linux内核及一些软件的源程序 时,我们经常需要在控制台下输入make。Make其实就是一个项目管理工具,而ant所实现的功能与make差不多。Ant是apache软件基金会 jakarta项目中的一个子项目,由于是基于java编写的,因此具有很好的跨平台性。Ant由一些内置任务(task)和可选择的任务组成(当然你还 可以编写自己的任务),使用Make时,你需要写一个Makefile文件,而用ant时则需要写一个build.xml文件。由于采用xml的语法,所 以build.xml文件很容易书写和维护,且结构很清晰,而不像Makefile文件有那么多的限制(例如在tab符号前有一个空格的话,命令就不会执 行)。Ant的优点远不止这些,它还很容易的集成到一些开发环境中(例如visual age,jbuilder,netbeans)。

二.Ant的安装及配置
安装
Ant 目前的版本是1.3,首先到下载ant最新版本1.3,解压到C: /ant(window操作系统) 或者/usr/local/ant(linux操作系统),由于我们要用到xmlc ,而ant1.3中并没有包含它,所以我们需要David.Li为ant写的xmlc任务。具体url为http: //。将下载后的文件中的 ant.jar替换掉ant1.3中ant.jar.这样ant的版本变为1.2.

2.设置路径
(1):windows98操作系统
编辑C:\enhydra\.bashrc,加入下面三行

export ANT_HOME=/ant
export JAVA_HOME=/jdk-1.2.2
export PATH=${PATH}:${ANT_HOME}/bin

(2):Linux操作系统
编辑/etc/profile或者 用户目录下的.bashrc文件,加入下面三行

export ANT_HOME=/usr/local/ant
export JAVA_HOME=/usr/local/jdk-1.2.2
export PATH=${PATH}:${ANT_HOME}/bin

三:用ant管理项目
1:基本的文件目录结构 解压到任意目录,我们可以看到目录树结构如下
├─bin
├─docs
│ ├─ant2
│ ├─api
│ │ └─org
│ │ └─apache
│ │ └─tools
│ │ ├─ant
│ │ │ ├─taskdefs
│ │ │ │ ├─compilers
│ │ │ │ └─optional
│ │ │ │ ├─clearcase
│ │ │ │ ├─depend
│ │ │ │ │ └─constantpool
│ │ │ │ ├─dotnet
│ │ │ │ ├─ejb
│ │ │ │ ├─ide
│ │ │ │ ├─javacc
│ │ │ │ ├─jlink
│ │ │ │ ├─jsp
│ │ │ │ ├─junit
│ │ │ │ ├─metamata
│ │ │ │ ├─net
│ │ │ │ ├─perforce
│ │ │ │ ├─scm
│ │ │ │ ├─sound
│ │ │ │ └─vss
│ │ │ ├─types
│ │ │ └─util
│ │ │ └─regexp
│ │ ├─mail
│ │ └─tar
│ └─manual
│ ├─CoreTasks
│ ├─CoreTypes
│ ├─Integration
│ └─OptionalTasks
└─lib





在这个目录树结构中,与传统的项目不同的是,我们用build.xml取代了Makefile,在讲述这个build.xml文件前,我们先了解一个基本的 build.xml文件的结构。

2:build.xml的基本书写规范
下面我们就来讲述这个文件的书写方法,下面是这个文件的全部内容
1.
2.
3.
4.
5.
6.

7.





为 了方便说明,我们为每一行加了行号,第一行是xml文件的基本要素,第二行说明这是一个项目,第七行说明项目的结束 ,在第二行中,name="MyProject"说明此项目的名称,这个属性可有可无。basedir="."说明基本目录,此属性可有可无。 default="dist"说明项目的缺省目标(target)是什么,这个属性必须有。所谓目标(target)就是一系列任务(task)组成的一 个集合。每个任务(task)的书写方法如下:
<任务名 属性1="属性1的值" 属性2="属性2的值" ....... />




第 三行定义了一些属性(property),以便后面使用,这非常类似于编程中定义的全局变量。从第四行开始定义目标(target),name= "init"指明了此目标的名称,name属性在定义目标时必须有,当然定义目标时还有其他一些属性可选,例如depends,unless,具体请参考 ant的文档。第五行开始定义此目标内的任务,其中mkdir时ant的内部任务名,dir是此任务的属性,其值为${dist}。此任务就是创建一个目 录。其中${dist}是获取dist属性的值(就是我们在第三行定义的)。如上就是一个基本的build.xml文件的写法。你可以在命令行上输入 ant -buildfile build.xml

看一下你的当前目录下是否多了一个dist目录。如果出错,则可能是你没有把ant配置好,参见前面讲的安装及配置,看一下哪儿出了错。

3:build.xml文件
build.xml文件如下,其中有的注释和无关的代码删掉了,且做了一下小小的改动
1:
2:
3:
4:
5:
6:
7:
8:
9:
10:


11:
12:
13:
14:
15:
16:
17:
18:
19:

20:
21:
22:
23:

24:
25:

26:
27:
28:
29:
30:
31:
32:

33:
34:


35:
36:
37:
38:
39:
40:


41:
42:
43:
44:
45:
46:47:sourceout="${build.xmlc.dir}"
48:includes="**/*.html">
49:

50:
51:
52:
53:
54:
55:
56:
57:
58:

59:


60:
61:
62:
63:
64:

65:
66:67:destdir="${build.classes}"
68:classpathref="build.classpath"
69:debug="${build.debug}"/>

70:
71:72:destdir="${build.classes}"
73:classpathref="build.classpath"
74:debug="${build.debug}"
75:includes="${app.name}/**"
76:/>
77:


78:
79:
80:
81:
82:
83:
84:
85:
86:
87:
88:
89:

90:

91:



92:
93:
94:
95:
96:
97:
98:


99:
100:
101:
102:
103:
104:

105:
106:
107:108:tofile="${build.dir}/multiserver.conf"
109:filtering="on"/>

110:
111:
112:
113:


114:





4:build.xml详细说明
下 面我们将详细讲述这个文件,同样为了方便,我加了行号,当然一些基本的东西我就不再重复了。第四行taskdef任务(task)属于ant的内部任务, 它的作用是定义一个任务,其基本属性有name,classname,在定义时这两个属性都必需有。第八行开始定义一个path,它有一个属性id,通过 这个id的值我们可以在后面引用这个path,参见第68行。目标(target)init(从14行到34行)定义了一些基本属性 (property),主要是为了后面的target使用。在第38行,你会看到depends="init",depends是定义一个目标时的可选属 性,它的意思是如果init目标没有执行(出错或其他原因),这个目标也不会被执行。

从第46行开始定义xmlc任务,到第58行结束,中间有很多参数嵌套在其中,srcdir指定源文件目录,sourceout指定输出目录,includes属性将源文件目录中的所有html文件包括进来。*为通配符。

表示取消警告,表示同时产生接口和实现代码,例如:一个welcome.html,它会产生两个文件: WelcomeHTMLImpl.java,WelcomeHTML.java,WelcomeHTML.java中只定义了一个接口 WelcomeHTML,真正的实现在WelcomeHTMLImpl.java中。表示设置编码,由于xmlc将html文件编译为java类,即使你在html文件中已经设置了编码,在 java类中也不会有作用,必须在编译时设置编码。 这两句相当于在命令行上输入-ssi -keep.其中ssi参数是在编译html文件时将定义的ssi文件包括进来,见html目录下的welcome2.html源代码中有一行: Ant简介-jennyljd-ChinaUnix博客
  • 博客访问: 313283
  • 博文数量: 54
  • 博客积分: 1400
  • 博客等级: 上尉
  • 技术积分: 606
  • 用 户 组: 普通用户
  • 注册时间: 2006-12-03 22:43
文章分类
文章存档

2011年(3)

2010年(26)

2009年(2)

2008年(23)

我的朋友

分类:

2009-02-21 20:15:11

本文描述了ant的基本语法及其如何应用于项目的管理
-. Ant简介
可 能有许多读者并不了解什么是ant,以及如何使用它。但只要你是用过linux,你应该知道make为何物,当我们编译linux内核及一些软件的源程序 时,我们经常需要在控制台下输入make。Make其实就是一个项目管理工具,而ant所实现的功能与make差不多。Ant是apache软件基金会 jakarta项目中的一个子项目,由于是基于java编写的,因此具有很好的跨平台性。Ant由一些内置任务(task)和可选择的任务组成(当然你还 可以编写自己的任务),使用Make时,你需要写一个Makefile文件,而用ant时则需要写一个build.xml文件。由于采用xml的语法,所 以build.xml文件很容易书写和维护,且结构很清晰,而不像Makefile文件有那么多的限制(例如在tab符号前有一个空格的话,命令就不会执 行)。Ant的优点远不止这些,它还很容易的集成到一些开发环境中(例如visual age,jbuilder,netbeans)。

二.Ant的安装及配置
安装
Ant 目前的版本是1.3,首先到下载ant最新版本1.3,解压到C: /ant(window操作系统) 或者/usr/local/ant(linux操作系统),由于我们要用到xmlc ,而ant1.3中并没有包含它,所以我们需要David.Li为ant写的xmlc任务。具体url为http: //。将下载后的文件中的 ant.jar替换掉ant1.3中ant.jar.这样ant的版本变为1.2.

2.设置路径
(1):windows98操作系统
编辑C:\enhydra\.bashrc,加入下面三行

export ANT_HOME=/ant
export JAVA_HOME=/jdk-1.2.2
export PATH=${PATH}:${ANT_HOME}/bin

(2):Linux操作系统
编辑/etc/profile或者 用户目录下的.bashrc文件,加入下面三行

export ANT_HOME=/usr/local/ant
export JAVA_HOME=/usr/local/jdk-1.2.2
export PATH=${PATH}:${ANT_HOME}/bin

三:用ant管理项目
1:基本的文件目录结构 解压到任意目录,我们可以看到目录树结构如下
├─bin
├─docs
│ ├─ant2
│ ├─api
│ │ └─org
│ │ └─apache
│ │ └─tools
│ │ ├─ant
│ │ │ ├─taskdefs
│ │ │ │ ├─compilers
│ │ │ │ └─optional
│ │ │ │ ├─clearcase
│ │ │ │ ├─depend
│ │ │ │ │ └─constantpool
│ │ │ │ ├─dotnet
│ │ │ │ ├─ejb
│ │ │ │ ├─ide
│ │ │ │ ├─javacc
│ │ │ │ ├─jlink
│ │ │ │ ├─jsp
│ │ │ │ ├─junit
│ │ │ │ ├─metamata
│ │ │ │ ├─net
│ │ │ │ ├─perforce
│ │ │ │ ├─scm
│ │ │ │ ├─sound
│ │ │ │ └─vss
│ │ │ ├─types
│ │ │ └─util
│ │ │ └─regexp
│ │ ├─mail
│ │ └─tar
│ └─manual
│ ├─CoreTasks
│ ├─CoreTypes
│ ├─Integration
│ └─OptionalTasks
└─lib





在这个目录树结构中,与传统的项目不同的是,我们用build.xml取代了Makefile,在讲述这个build.xml文件前,我们先了解一个基本的 build.xml文件的结构。

2:build.xml的基本书写规范
下面我们就来讲述这个文件的书写方法,下面是这个文件的全部内容
1.
2.
3.
4.
5.
6.

7.





为 了方便说明,我们为每一行加了行号,第一行是xml文件的基本要素,第二行说明这是一个项目,第七行说明项目的结束 ,在第二行中,name="MyProject"说明此项目的名称,这个属性可有可无。basedir="."说明基本目录,此属性可有可无。 default="dist"说明项目的缺省目标(target)是什么,这个属性必须有。所谓目标(target)就是一系列任务(task)组成的一 个集合。每个任务(task)的书写方法如下:
<任务名 属性1="属性1的值" 属性2="属性2的值" ....... />




第 三行定义了一些属性(property),以便后面使用,这非常类似于编程中定义的全局变量。从第四行开始定义目标(target),name= "init"指明了此目标的名称,name属性在定义目标时必须有,当然定义目标时还有其他一些属性可选,例如depends,unless,具体请参考 ant的文档。第五行开始定义此目标内的任务,其中mkdir时ant的内部任务名,dir是此任务的属性,其值为${dist}。此任务就是创建一个目 录。其中${dist}是获取dist属性的值(就是我们在第三行定义的)。如上就是一个基本的build.xml文件的写法。你可以在命令行上输入 ant -buildfile build.xml

看一下你的当前目录下是否多了一个dist目录。如果出错,则可能是你没有把ant配置好,参见前面讲的安装及配置,看一下哪儿出了错。

3:build.xml文件
build.xml文件如下,其中有的注释和无关的代码删掉了,且做了一下小小的改动
1:
2:
3:
4:
5:
6:
7:
8:
9:
10:


11:
12:
13:
14:
15:
16:
17:
18:
19:

20:
21:
22:
23:

24:
25:

26:
27:
28:
29:
30:
31:
32:

33:
34:


35:
36:
37:
38:
39:
40:


41:
42:
43:
44:
45:
46:47:sourceout="${build.xmlc.dir}"
48:includes="**/*.html">
49:

50:
51:
52:
53:
54:
55:
56:
57:
58:

59:


60:
61:
62:
63:
64:

65:
66:67:destdir="${build.classes}"
68:classpathref="build.classpath"
69:debug="${build.debug}"/>

70:
71:72:destdir="${build.classes}"
73:classpathref="build.classpath"
74:debug="${build.debug}"
75:includes="${app.name}/**"
76:/>
77:


78:
79:
80:
81:
82:
83:
84:
85:
86:
87:
88:
89:

90:

91:



92:
93:
94:
95:
96:
97:
98:


99:
100:
101:
102:
103:
104:

105:
106:
107:108:tofile="${build.dir}/multiserver.conf"
109:filtering="on"/>

110:
111:
112:
113:


114:





4:build.xml详细说明
下 面我们将详细讲述这个文件,同样为了方便,我加了行号,当然一些基本的东西我就不再重复了。第四行taskdef任务(task)属于ant的内部任务, 它的作用是定义一个任务,其基本属性有name,classname,在定义时这两个属性都必需有。第八行开始定义一个path,它有一个属性id,通过 这个id的值我们可以在后面引用这个path,参见第68行。目标(target)init(从14行到34行)定义了一些基本属性 (property),主要是为了后面的target使用。在第38行,你会看到depends="init",depends是定义一个目标时的可选属 性,它的意思是如果init目标没有执行(出错或其他原因),这个目标也不会被执行。

从第46行开始定义xmlc任务,到第58行结束,中间有很多参数嵌套在其中,srcdir指定源文件目录,sourceout指定输出目录,includes属性将源文件目录中的所有html文件包括进来。*为通配符。

表示取消警告,表示同时产生接口和实现代码,例如:一个welcome.html,它会产生两个文件: WelcomeHTMLImpl.java,WelcomeHTML.java,WelcomeHTML.java中只定义了一个接口 WelcomeHTML,真正的实现在WelcomeHTMLImpl.java中。表示设置编码,由于xmlc将html文件编译为java类,即使你在html文件中已经设置了编码,在 java类中也不会有作用,必须在编译时设置编码。 这两句相当于在命令行上输入-ssi -keep.其中ssi参数是在编译html文件时将定义的ssi文件包括进来,见html目录下的welcome2.html源代码中有一行: Ant简介-jennyljd-ChinaUnix博客
  • 博客访问: 313274
  • 博文数量: 54
  • 博客积分: 1400
  • 博客等级: 上尉
  • 技术积分: 606
  • 用 户 组: 普通用户
  • 注册时间: 2006-12-03 22:43
文章分类
文章存档

2011年(3)

2010年(26)

2009年(2)

2008年(23)

我的朋友

分类:

2009-02-21 20:15:11

本文描述了ant的基本语法及其如何应用于项目的管理
-. Ant简介
可 能有许多读者并不了解什么是ant,以及如何使用它。但只要你是用过linux,你应该知道make为何物,当我们编译linux内核及一些软件的源程序 时,我们经常需要在控制台下输入make。Make其实就是一个项目管理工具,而ant所实现的功能与make差不多。Ant是apache软件基金会 jakarta项目中的一个子项目,由于是基于java编写的,因此具有很好的跨平台性。Ant由一些内置任务(task)和可选择的任务组成(当然你还 可以编写自己的任务),使用Make时,你需要写一个Makefile文件,而用ant时则需要写一个build.xml文件。由于采用xml的语法,所 以build.xml文件很容易书写和维护,且结构很清晰,而不像Makefile文件有那么多的限制(例如在tab符号前有一个空格的话,命令就不会执 行)。Ant的优点远不止这些,它还很容易的集成到一些开发环境中(例如visual age,jbuilder,netbeans)。

二.Ant的安装及配置
安装
Ant 目前的版本是1.3,首先到下载ant最新版本1.3,解压到C: /ant(window操作系统) 或者/usr/local/ant(linux操作系统),由于我们要用到xmlc ,而ant1.3中并没有包含它,所以我们需要David.Li为ant写的xmlc任务。具体url为http: //。将下载后的文件中的 ant.jar替换掉ant1.3中ant.jar.这样ant的版本变为1.2.

2.设置路径
(1):windows98操作系统
编辑C:\enhydra\.bashrc,加入下面三行

export ANT_HOME=/ant
export JAVA_HOME=/jdk-1.2.2
export PATH=${PATH}:${ANT_HOME}/bin

(2):Linux操作系统
编辑/etc/profile或者 用户目录下的.bashrc文件,加入下面三行

export ANT_HOME=/usr/local/ant
export JAVA_HOME=/usr/local/jdk-1.2.2
export PATH=${PATH}:${ANT_HOME}/bin

三:用ant管理项目
1:基本的文件目录结构 解压到任意目录,我们可以看到目录树结构如下
├─bin
├─docs
│ ├─ant2
│ ├─api
│ │ └─org
│ │ └─apache
│ │ └─tools
│ │ ├─ant
│ │ │ ├─taskdefs
│ │ │ │ ├─compilers
│ │ │ │ └─optional
│ │ │ │ ├─clearcase
│ │ │ │ ├─depend
│ │ │ │ │ └─constantpool
│ │ │ │ ├─dotnet
│ │ │ │ ├─ejb
│ │ │ │ ├─ide
│ │ │ │ ├─javacc
│ │ │ │ ├─jlink
│ │ │ │ ├─jsp
│ │ │ │ ├─junit
│ │ │ │ ├─metamata
│ │ │ │ ├─net
│ │ │ │ ├─perforce
│ │ │ │ ├─scm
│ │ │ │ ├─sound
│ │ │ │ └─vss
│ │ │ ├─types
│ │ │ └─util
│ │ │ └─regexp
│ │ ├─mail
│ │ └─tar
│ └─manual
│ ├─CoreTasks
│ ├─CoreTypes
│ ├─Integration
│ └─OptionalTasks
└─lib





在这个目录树结构中,与传统的项目不同的是,我们用build.xml取代了Makefile,在讲述这个build.xml文件前,我们先了解一个基本的 build.xml文件的结构。

2:build.xml的基本书写规范
下面我们就来讲述这个文件的书写方法,下面是这个文件的全部内容
1.
2.
3.
4.
5.
6.

7.





为 了方便说明,我们为每一行加了行号,第一行是xml文件的基本要素,第二行说明这是一个项目,第七行说明项目的结束 ,在第二行中,name="MyProject"说明此项目的名称,这个属性可有可无。basedir="."说明基本目录,此属性可有可无。 default="dist"说明项目的缺省目标(target)是什么,这个属性必须有。所谓目标(target)就是一系列任务(task)组成的一 个集合。每个任务(task)的书写方法如下:
<任务名 属性1="属性1的值" 属性2="属性2的值" ....... />




第 三行定义了一些属性(property),以便后面使用,这非常类似于编程中定义的全局变量。从第四行开始定义目标(target),name= "init"指明了此目标的名称,name属性在定义目标时必须有,当然定义目标时还有其他一些属性可选,例如depends,unless,具体请参考 ant的文档。第五行开始定义此目标内的任务,其中mkdir时ant的内部任务名,dir是此任务的属性,其值为${dist}。此任务就是创建一个目 录。其中${dist}是获取dist属性的值(就是我们在第三行定义的)。如上就是一个基本的build.xml文件的写法。你可以在命令行上输入 ant -buildfile build.xml

看一下你的当前目录下是否多了一个dist目录。如果出错,则可能是你没有把ant配置好,参见前面讲的安装及配置,看一下哪儿出了错。

3:build.xml文件
build.xml文件如下,其中有的注释和无关的代码删掉了,且做了一下小小的改动
1:
2:
3:
4:
5:
6:
7:
8:
9:
10:


11:
12:
13:
14:
15:
16:
17:
18:
19:

20:
21:
22:
23:

24:
25:

26:
27:
28:
29:
30:
31:
32:

33:
34:


35:
36:
37:
38:
39:
40:


41:
42:
43:
44:
45:
46:47:sourceout="${build.xmlc.dir}"
48:includes="**/*.html">
49:

50:
51:
52:
53:
54:
55:
56:
57:
58:

59:


60:
61:
62:
63:
64:

65:
66:67:destdir="${build.classes}"
68:classpathref="build.classpath"
69:debug="${build.debug}"/>

70:
71:72:destdir="${build.classes}"
73:classpathref="build.classpath"
74:debug="${build.debug}"
75:includes="${app.name}/**"
76:/>
77:


78:
79:
80:
81:
82:
83:
84:
85:
86:
87:
88:
89:

90:

91:



92:
93:
94:
95:
96:
97:
98:


99:
100:
101:
102:
103:
104:

105:
106:
107:108:tofile="${build.dir}/multiserver.conf"
109:filtering="on"/>

110:
111:
112:
113:


114:





4:build.xml详细说明
下 面我们将详细讲述这个文件,同样为了方便,我加了行号,当然一些基本的东西我就不再重复了。第四行taskdef任务(task)属于ant的内部任务, 它的作用是定义一个任务,其基本属性有name,classname,在定义时这两个属性都必需有。第八行开始定义一个path,它有一个属性id,通过 这个id的值我们可以在后面引用这个path,参见第68行。目标(target)init(从14行到34行)定义了一些基本属性 (property),主要是为了后面的target使用。在第38行,你会看到depends="init",depends是定义一个目标时的可选属 性,它的意思是如果init目标没有执行(出错或其他原因),这个目标也不会被执行。

从第46行开始定义xmlc任务,到第58行结束,中间有很多参数嵌套在其中,srcdir指定源文件目录,sourceout指定输出目录,includes属性将源文件目录中的所有html文件包括进来。*为通配符。

表示取消警告,表示同时产生接口和实现代码,例如:一个welcome.html,它会产生两个文件: WelcomeHTMLImpl.java,WelcomeHTML.java,WelcomeHTML.java中只定义了一个接口 WelcomeHTML,真正的实现在WelcomeHTMLImpl.java中。表示设置编码,由于xmlc将html文件编译为java类,即使你在html文件中已经设置了编码,在 java类中也不会有作用,必须在编译时设置编码。 这两句相当于在命令行上输入-ssi -keep.其中ssi参数是在编译html文件时将定义的ssi文件包括进来,见html目录下的welcome2.html源代码中有一行: Ant简介-jennyljd-ChinaUnix博客
  • 博客访问: 313285
  • 博文数量: 54
  • 博客积分: 1400
  • 博客等级: 上尉
  • 技术积分: 606
  • 用 户 组: 普通用户
  • 注册时间: 2006-12-03 22:43
文章分类
文章存档

2011年(3)

2010年(26)

2009年(2)

2008年(23)

我的朋友

分类:

2009-02-21 20:15:11

本文描述了ant的基本语法及其如何应用于项目的管理
-. Ant简介
可 能有许多读者并不了解什么是ant,以及如何使用它。但只要你是用过linux,你应该知道make为何物,当我们编译linux内核及一些软件的源程序 时,我们经常需要在控制台下输入make。Make其实就是一个项目管理工具,而ant所实现的功能与make差不多。Ant是apache软件基金会 jakarta项目中的一个子项目,由于是基于java编写的,因此具有很好的跨平台性。Ant由一些内置任务(task)和可选择的任务组成(当然你还 可以编写自己的任务),使用Make时,你需要写一个Makefile文件,而用ant时则需要写一个build.xml文件。由于采用xml的语法,所 以build.xml文件很容易书写和维护,且结构很清晰,而不像Makefile文件有那么多的限制(例如在tab符号前有一个空格的话,命令就不会执 行)。Ant的优点远不止这些,它还很容易的集成到一些开发环境中(例如visual age,jbuilder,netbeans)。

二.Ant的安装及配置
安装
Ant 目前的版本是1.3,首先到下载ant最新版本1.3,解压到C: /ant(window操作系统) 或者/usr/local/ant(linux操作系统),由于我们要用到xmlc ,而ant1.3中并没有包含它,所以我们需要David.Li为ant写的xmlc任务。具体url为http: //。将下载后的文件中的 ant.jar替换掉ant1.3中ant.jar.这样ant的版本变为1.2.

2.设置路径
(1):windows98操作系统
编辑C:\enhydra\.bashrc,加入下面三行

export ANT_HOME=/ant
export JAVA_HOME=/jdk-1.2.2
export PATH=${PATH}:${ANT_HOME}/bin

(2):Linux操作系统
编辑/etc/profile或者 用户目录下的.bashrc文件,加入下面三行

export ANT_HOME=/usr/local/ant
export JAVA_HOME=/usr/local/jdk-1.2.2
export PATH=${PATH}:${ANT_HOME}/bin

三:用ant管理项目
1:基本的文件目录结构 解压到任意目录,我们可以看到目录树结构如下
├─bin
├─docs
│ ├─ant2
│ ├─api
│ │ └─org
│ │ └─apache
│ │ └─tools
│ │ ├─ant
│ │ │ ├─taskdefs
│ │ │ │ ├─compilers
│ │ │ │ └─optional
│ │ │ │ ├─clearcase
│ │ │ │ ├─depend
│ │ │ │ │ └─constantpool
│ │ │ │ ├─dotnet
│ │ │ │ ├─ejb
│ │ │ │ ├─ide
│ │ │ │ ├─javacc
│ │ │ │ ├─jlink
│ │ │ │ ├─jsp
│ │ │ │ ├─junit
│ │ │ │ ├─metamata
│ │ │ │ ├─net
│ │ │ │ ├─perforce
│ │ │ │ ├─scm
│ │ │ │ ├─sound
│ │ │ │ └─vss
│ │ │ ├─types
│ │ │ └─util
│ │ │ └─regexp
│ │ ├─mail
│ │ └─tar
│ └─manual
│ ├─CoreTasks
│ ├─CoreTypes
│ ├─Integration
│ └─OptionalTasks
└─lib





在这个目录树结构中,与传统的项目不同的是,我们用build.xml取代了Makefile,在讲述这个build.xml文件前,我们先了解一个基本的 build.xml文件的结构。

2:build.xml的基本书写规范
下面我们就来讲述这个文件的书写方法,下面是这个文件的全部内容
1.
2.
3.
4.
5.
6.

7.





为 了方便说明,我们为每一行加了行号,第一行是xml文件的基本要素,第二行说明这是一个项目,第七行说明项目的结束 ,在第二行中,name="MyProject"说明此项目的名称,这个属性可有可无。basedir="."说明基本目录,此属性可有可无。 default="dist"说明项目的缺省目标(target)是什么,这个属性必须有。所谓目标(target)就是一系列任务(task)组成的一 个集合。每个任务(task)的书写方法如下:
<任务名 属性1="属性1的值" 属性2="属性2的值" ....... />




第 三行定义了一些属性(property),以便后面使用,这非常类似于编程中定义的全局变量。从第四行开始定义目标(target),name= "init"指明了此目标的名称,name属性在定义目标时必须有,当然定义目标时还有其他一些属性可选,例如depends,unless,具体请参考 ant的文档。第五行开始定义此目标内的任务,其中mkdir时ant的内部任务名,dir是此任务的属性,其值为${dist}。此任务就是创建一个目 录。其中${dist}是获取dist属性的值(就是我们在第三行定义的)。如上就是一个基本的build.xml文件的写法。你可以在命令行上输入 ant -buildfile build.xml

看一下你的当前目录下是否多了一个dist目录。如果出错,则可能是你没有把ant配置好,参见前面讲的安装及配置,看一下哪儿出了错。

3:build.xml文件
build.xml文件如下,其中有的注释和无关的代码删掉了,且做了一下小小的改动
1:
2:
3:
4:
5:
6:
7:
8:
9:
10:


11:
12:
13:
14:
15:
16:
17:
18:
19:

20:
21:
22:
23:

24:
25:

26:
27:
28:
29:
30:
31:
32:

33:
34:


35:
36:
37:
38:
39:
40:


41:
42:
43:
44:
45:
46:47:sourceout="${build.xmlc.dir}"
48:includes="**/*.html">
49:

50:
51:
52:
53:
54:
55:
56:
57:
58:

59:


60:
61:
62:
63:
64:

65:
66:67:destdir="${build.classes}"
68:classpathref="build.classpath"
69:debug="${build.debug}"/>

70:
71:72:destdir="${build.classes}"
73:classpathref="build.classpath"
74:debug="${build.debug}"
75:includes="${app.name}/**"
76:/>
77:


78:
79:
80:
81:
82:
83:
84:
85:
86:
87:
88:
89:

90:

91:



92:
93:
94:
95:
96:
97:
98:


99:
100:
101:
102:
103:
104:

105:
106:
107:108:tofile="${build.dir}/multiserver.conf"
109:filtering="on"/>

110:
111:
112:
113:


114:





4:build.xml详细说明
下 面我们将详细讲述这个文件,同样为了方便,我加了行号,当然一些基本的东西我就不再重复了。第四行taskdef任务(task)属于ant的内部任务, 它的作用是定义一个任务,其基本属性有name,classname,在定义时这两个属性都必需有。第八行开始定义一个path,它有一个属性id,通过 这个id的值我们可以在后面引用这个path,参见第68行。目标(target)init(从14行到34行)定义了一些基本属性 (property),主要是为了后面的target使用。在第38行,你会看到depends="init",depends是定义一个目标时的可选属 性,它的意思是如果init目标没有执行(出错或其他原因),这个目标也不会被执行。

从第46行开始定义xmlc任务,到第58行结束,中间有很多参数嵌套在其中,srcdir指定源文件目录,sourceout指定输出目录,includes属性将源文件目录中的所有html文件包括进来。*为通配符。

表示取消警告,表示同时产生接口和实现代码,例如:一个welcome.html,它会产生两个文件: WelcomeHTMLImpl.java,WelcomeHTML.java,WelcomeHTML.java中只定义了一个接口 WelcomeHTML,真正的实现在WelcomeHTMLImpl.java中。表示设置编码,由于xmlc将html文件编译为java类,即使你在html文件中已经设置了编码,在 java类中也不会有作用,必须在编译时设置编码。 这两句相当于在命令行上输入-ssi -keep.其中ssi参数是在编译html文件时将定义的ssi文件包括进来,见html目录下的welcome2.html源代码中有一行: Ant简介-jennyljd-ChinaUnix博客
  • 博客访问: 313286
  • 博文数量: 54
  • 博客积分: 1400
  • 博客等级: 上尉
  • 技术积分: 606
  • 用 户 组: 普通用户
  • 注册时间: 2006-12-03 22:43
文章分类
文章存档

2011年(3)

2010年(26)

2009年(2)

2008年(23)

我的朋友

分类:

2009-02-21 20:15:11

本文描述了ant的基本语法及其如何应用于项目的管理
-. Ant简介
可 能有许多读者并不了解什么是ant,以及如何使用它。但只要你是用过linux,你应该知道make为何物,当我们编译linux内核及一些软件的源程序 时,我们经常需要在控制台下输入make。Make其实就是一个项目管理工具,而ant所实现的功能与make差不多。Ant是apache软件基金会 jakarta项目中的一个子项目,由于是基于java编写的,因此具有很好的跨平台性。Ant由一些内置任务(task)和可选择的任务组成(当然你还 可以编写自己的任务),使用Make时,你需要写一个Makefile文件,而用ant时则需要写一个build.xml文件。由于采用xml的语法,所 以build.xml文件很容易书写和维护,且结构很清晰,而不像Makefile文件有那么多的限制(例如在tab符号前有一个空格的话,命令就不会执 行)。Ant的优点远不止这些,它还很容易的集成到一些开发环境中(例如visual age,jbuilder,netbeans)。

二.Ant的安装及配置
安装
Ant 目前的版本是1.3,首先到下载ant最新版本1.3,解压到C: /ant(window操作系统) 或者/usr/local/ant(linux操作系统),由于我们要用到xmlc ,而ant1.3中并没有包含它,所以我们需要David.Li为ant写的xmlc任务。具体url为http: //。将下载后的文件中的 ant.jar替换掉ant1.3中ant.jar.这样ant的版本变为1.2.

2.设置路径
(1):windows98操作系统
编辑C:\enhydra\.bashrc,加入下面三行

export ANT_HOME=/ant
export JAVA_HOME=/jdk-1.2.2
export PATH=${PATH}:${ANT_HOME}/bin

(2):Linux操作系统
编辑/etc/profile或者 用户目录下的.bashrc文件,加入下面三行

export ANT_HOME=/usr/local/ant
export JAVA_HOME=/usr/local/jdk-1.2.2
export PATH=${PATH}:${ANT_HOME}/bin

三:用ant管理项目
1:基本的文件目录结构 解压到任意目录,我们可以看到目录树结构如下
├─bin
├─docs
│ ├─ant2
│ ├─api
│ │ └─org
│ │ └─apache
│ │ └─tools
│ │ ├─ant
│ │ │ ├─taskdefs
│ │ │ │ ├─compilers
│ │ │ │ └─optional
│ │ │ │ ├─clearcase
│ │ │ │ ├─depend
│ │ │ │ │ └─constantpool
│ │ │ │ ├─dotnet
│ │ │ │ ├─ejb
│ │ │ │ ├─ide
│ │ │ │ ├─javacc
│ │ │ │ ├─jlink
│ │ │ │ ├─jsp
│ │ │ │ ├─junit
│ │ │ │ ├─metamata
│ │ │ │ ├─net
│ │ │ │ ├─perforce
│ │ │ │ ├─scm
│ │ │ │ ├─sound
│ │ │ │ └─vss
│ │ │ ├─types
│ │ │ └─util
│ │ │ └─regexp
│ │ ├─mail
│ │ └─tar
│ └─manual
│ ├─CoreTasks
│ ├─CoreTypes
│ ├─Integration
│ └─OptionalTasks
└─lib





在这个目录树结构中,与传统的项目不同的是,我们用build.xml取代了Makefile,在讲述这个build.xml文件前,我们先了解一个基本的 build.xml文件的结构。

2:build.xml的基本书写规范
下面我们就来讲述这个文件的书写方法,下面是这个文件的全部内容
1.
2.
3.
4.
5.
6.

7.





为 了方便说明,我们为每一行加了行号,第一行是xml文件的基本要素,第二行说明这是一个项目,第七行说明项目的结束 ,在第二行中,name="MyProject"说明此项目的名称,这个属性可有可无。basedir="."说明基本目录,此属性可有可无。 default="dist"说明项目的缺省目标(target)是什么,这个属性必须有。所谓目标(target)就是一系列任务(task)组成的一 个集合。每个任务(task)的书写方法如下:
<任务名 属性1="属性1的值" 属性2="属性2的值" ....... />




第 三行定义了一些属性(property),以便后面使用,这非常类似于编程中定义的全局变量。从第四行开始定义目标(target),name= "init"指明了此目标的名称,name属性在定义目标时必须有,当然定义目标时还有其他一些属性可选,例如depends,unless,具体请参考 ant的文档。第五行开始定义此目标内的任务,其中mkdir时ant的内部任务名,dir是此任务的属性,其值为${dist}。此任务就是创建一个目 录。其中${dist}是获取dist属性的值(就是我们在第三行定义的)。如上就是一个基本的build.xml文件的写法。你可以在命令行上输入 ant -buildfile build.xml

看一下你的当前目录下是否多了一个dist目录。如果出错,则可能是你没有把ant配置好,参见前面讲的安装及配置,看一下哪儿出了错。

3:build.xml文件
build.xml文件如下,其中有的注释和无关的代码删掉了,且做了一下小小的改动
1:
2:
3:
4:
5:
6:
7:
8:
9:
10:


11:
12:
13:
14:
15:
16:
17:
18:
19:

20:
21:
22:
23:

24:
25:

26:
27:
28:
29:
30:
31:
32:

33:
34:


35:
36:
37:
38:
39:
40:


41:
42:
43:
44:
45:
46:47:sourceout="${build.xmlc.dir}"
48:includes="**/*.html">
49:

50:
51:
52:
53:
54:
55:
56:
57:
58:

59:


60:
61:
62:
63:
64:

65:
66:67:destdir="${build.classes}"
68:classpathref="build.classpath"
69:debug="${build.debug}"/>

70:
71:72:destdir="${build.classes}"
73:classpathref="build.classpath"
74:debug="${build.debug}"
75:includes="${app.name}/**"
76:/>
77:


78:
79:
80:
81:
82:
83:
84:
85:
86:
87:
88:
89:

90:

91:



92:
93:
94:
95:
96:
97:
98:


99:
100:
101:
102:
103:
104:

105:
106:
107:108:tofile="${build.dir}/multiserver.conf"
109:filtering="on"/>

110:
111:
112:
113:


114:





4:build.xml详细说明
下 面我们将详细讲述这个文件,同样为了方便,我加了行号,当然一些基本的东西我就不再重复了。第四行taskdef任务(task)属于ant的内部任务, 它的作用是定义一个任务,其基本属性有name,classname,在定义时这两个属性都必需有。第八行开始定义一个path,它有一个属性id,通过 这个id的值我们可以在后面引用这个path,参见第68行。目标(target)init(从14行到34行)定义了一些基本属性 (property),主要是为了后面的target使用。在第38行,你会看到depends="init",depends是定义一个目标时的可选属 性,它的意思是如果init目标没有执行(出错或其他原因),这个目标也不会被执行。

从第46行开始定义xmlc任务,到第58行结束,中间有很多参数嵌套在其中,srcdir指定源文件目录,sourceout指定输出目录,includes属性将源文件目录中的所有html文件包括进来。*为通配符。

表示取消警告,表示同时产生接口和实现代码,例如:一个welcome.html,它会产生两个文件: WelcomeHTMLImpl.java,WelcomeHTML.java,WelcomeHTML.java中只定义了一个接口 WelcomeHTML,真正的实现在WelcomeHTMLImpl.java中。表示设置编码,由于xmlc将html文件编译为java类,即使你在html文件中已经设置了编码,在 java类中也不会有作用,必须在编译时设置编码。 这两句相当于在命令行上输入-ssi -keep.其中ssi参数是在编译html文件时将定义的ssi文件包括进来,见html目录下的welcome2.html源代码中有一行: Ant简介-jennyljd-ChinaUnix博客
  • 博客访问: 313287
  • 博文数量: 54
  • 博客积分: 1400
  • 博客等级: 上尉
  • 技术积分: 606
  • 用 户 组: 普通用户
  • 注册时间: 2006-12-03 22:43
文章分类
文章存档

2011年(3)

2010年(26)

2009年(2)

2008年(23)

我的朋友

分类:

2009-02-21 20:15:11

本文描述了ant的基本语法及其如何应用于项目的管理
-. Ant简介
可 能有许多读者并不了解什么是ant,以及如何使用它。但只要你是用过linux,你应该知道make为何物,当我们编译linux内核及一些软件的源程序 时,我们经常需要在控制台下输入make。Make其实就是一个项目管理工具,而ant所实现的功能与make差不多。Ant是apache软件基金会 jakarta项目中的一个子项目,由于是基于java编写的,因此具有很好的跨平台性。Ant由一些内置任务(task)和可选择的任务组成(当然你还 可以编写自己的任务),使用Make时,你需要写一个Makefile文件,而用ant时则需要写一个build.xml文件。由于采用xml的语法,所 以build.xml文件很容易书写和维护,且结构很清晰,而不像Makefile文件有那么多的限制(例如在tab符号前有一个空格的话,命令就不会执 行)。Ant的优点远不止这些,它还很容易的集成到一些开发环境中(例如visual age,jbuilder,netbeans)。

二.Ant的安装及配置
安装
Ant 目前的版本是1.3,首先到下载ant最新版本1.3,解压到C: /ant(window操作系统) 或者/usr/local/ant(linux操作系统),由于我们要用到xmlc ,而ant1.3中并没有包含它,所以我们需要David.Li为ant写的xmlc任务。具体url为http: //。将下载后的文件中的 ant.jar替换掉ant1.3中ant.jar.这样ant的版本变为1.2.

2.设置路径
(1):windows98操作系统
编辑C:\enhydra\.bashrc,加入下面三行

export ANT_HOME=/ant
export JAVA_HOME=/jdk-1.2.2
export PATH=${PATH}:${ANT_HOME}/bin

(2):Linux操作系统
编辑/etc/profile或者 用户目录下的.bashrc文件,加入下面三行

export ANT_HOME=/usr/local/ant
export JAVA_HOME=/usr/local/jdk-1.2.2
export PATH=${PATH}:${ANT_HOME}/bin

三:用ant管理项目
1:基本的文件目录结构 解压到任意目录,我们可以看到目录树结构如下
├─bin
├─docs
│ ├─ant2
│ ├─api
│ │ └─org
│ │ └─apache
│ │ └─tools
│ │ ├─ant
│ │ │ ├─taskdefs
│ │ │ │ ├─compilers
│ │ │ │ └─optional
│ │ │ │ ├─clearcase
│ │ │ │ ├─depend
│ │ │ │ │ └─constantpool
│ │ │ │ ├─dotnet
│ │ │ │ ├─ejb
│ │ │ │ ├─ide
│ │ │ │ ├─javacc
│ │ │ │ ├─jlink
│ │ │ │ ├─jsp
│ │ │ │ ├─junit
│ │ │ │ ├─metamata
│ │ │ │ ├─net
│ │ │ │ ├─perforce
│ │ │ │ ├─scm
│ │ │ │ ├─sound
│ │ │ │ └─vss
│ │ │ ├─types
│ │ │ └─util
│ │ │ └─regexp
│ │ ├─mail
│ │ └─tar
│ └─manual
│ ├─CoreTasks
│ ├─CoreTypes
│ ├─Integration
│ └─OptionalTasks
└─lib





在这个目录树结构中,与传统的项目不同的是,我们用build.xml取代了Makefile,在讲述这个build.xml文件前,我们先了解一个基本的 build.xml文件的结构。

2:build.xml的基本书写规范
下面我们就来讲述这个文件的书写方法,下面是这个文件的全部内容
1.
2.
3.
4.
5.
6.

7.





为 了方便说明,我们为每一行加了行号,第一行是xml文件的基本要素,第二行说明这是一个项目,第七行说明项目的结束 ,在第二行中,name="MyProject"说明此项目的名称,这个属性可有可无。basedir="."说明基本目录,此属性可有可无。 default="dist"说明项目的缺省目标(target)是什么,这个属性必须有。所谓目标(target)就是一系列任务(task)组成的一 个集合。每个任务(task)的书写方法如下:
<任务名 属性1="属性1的值" 属性2="属性2的值" ....... />




第 三行定义了一些属性(property),以便后面使用,这非常类似于编程中定义的全局变量。从第四行开始定义目标(target),name= "init"指明了此目标的名称,name属性在定义目标时必须有,当然定义目标时还有其他一些属性可选,例如depends,unless,具体请参考 ant的文档。第五行开始定义此目标内的任务,其中mkdir时ant的内部任务名,dir是此任务的属性,其值为${dist}。此任务就是创建一个目 录。其中${dist}是获取dist属性的值(就是我们在第三行定义的)。如上就是一个基本的build.xml文件的写法。你可以在命令行上输入 ant -buildfile build.xml

看一下你的当前目录下是否多了一个dist目录。如果出错,则可能是你没有把ant配置好,参见前面讲的安装及配置,看一下哪儿出了错。

3:build.xml文件
build.xml文件如下,其中有的注释和无关的代码删掉了,且做了一下小小的改动
1:
2:
3:
4:
5:
6:
7:
8:
9:
10:


11:
12:
13:
14:
15:
16:
17:
18:
19:

20:
21:
22:
23:

24:
25:

26:
27:
28:
29:
30:
31:
32:

33:
34:


35:
36:
37:
38:
39:
40:


41:
42:
43:
44:
45:
46:47:sourceout="${build.xmlc.dir}"
48:includes="**/*.html">
49:

50:
51:
52:
53:
54:
55:
56:
57:
58:

59:


60:
61:
62:
63:
64:

65:
66:67:destdir="${build.classes}"
68:classpathref="build.classpath"
69:debug="${build.debug}"/>

70:
71:72:destdir="${build.classes}"
73:classpathref="build.classpath"
74:debug="${build.debug}"
75:includes="${app.name}/**"
76:/>
77:


78:
79:
80:
81:
82:
83:
84:
85:
86:
87:
88:
89:

90:

91:



92:
93:
94:
95:
96:
97:
98:


99:
100:
101:
102:
103:
104:

105:
106:
107:108:tofile="${build.dir}/multiserver.conf"
109:filtering="on"/>

110:
111:
112:
113:


114:





4:build.xml详细说明
下 面我们将详细讲述这个文件,同样为了方便,我加了行号,当然一些基本的东西我就不再重复了。第四行taskdef任务(task)属于ant的内部任务, 它的作用是定义一个任务,其基本属性有name,classname,在定义时这两个属性都必需有。第八行开始定义一个path,它有一个属性id,通过 这个id的值我们可以在后面引用这个path,参见第68行。目标(target)init(从14行到34行)定义了一些基本属性 (property),主要是为了后面的target使用。在第38行,你会看到depends="init",depends是定义一个目标时的可选属 性,它的意思是如果init目标没有执行(出错或其他原因),这个目标也不会被执行。

从第46行开始定义xmlc任务,到第58行结束,中间有很多参数嵌套在其中,srcdir指定源文件目录,sourceout指定输出目录,includes属性将源文件目录中的所有html文件包括进来。*为通配符。

表示取消警告,表示同时产生接口和实现代码,例如:一个welcome.html,它会产生两个文件: WelcomeHTMLImpl.java,WelcomeHTML.java,WelcomeHTML.java中只定义了一个接口 WelcomeHTML,真正的实现在WelcomeHTMLImpl.java中。表示设置编码,由于xmlc将html文件编译为java类,即使你在html文件中已经设置了编码,在 java类中也不会有作用,必须在编译时设置编码。 这两句相当于在命令行上输入-ssi -keep.其中ssi参数是在编译html文件时将定义的ssi文件包括进来,见html目录下的welcome2.html源代码中有一行: Ant简介-jennyljd-ChinaUnix博客
  • 博客访问: 313288
  • 博文数量: 54
  • 博客积分: 1400
  • 博客等级: 上尉
  • 技术积分: 606
  • 用 户 组: 普通用户
  • 注册时间: 2006-12-03 22:43
文章分类
文章存档

2011年(3)

2010年(26)

2009年(2)

2008年(23)

我的朋友

分类:

2009-02-21 20:15:11

本文描述了ant的基本语法及其如何应用于项目的管理
-. Ant简介
可 能有许多读者并不了解什么是ant,以及如何使用它。但只要你是用过linux,你应该知道make为何物,当我们编译linux内核及一些软件的源程序 时,我们经常需要在控制台下输入make。Make其实就是一个项目管理工具,而ant所实现的功能与make差不多。Ant是apache软件基金会 jakarta项目中的一个子项目,由于是基于java编写的,因此具有很好的跨平台性。Ant由一些内置任务(task)和可选择的任务组成(当然你还 可以编写自己的任务),使用Make时,你需要写一个Makefile文件,而用ant时则需要写一个build.xml文件。由于采用xml的语法,所 以build.xml文件很容易书写和维护,且结构很清晰,而不像Makefile文件有那么多的限制(例如在tab符号前有一个空格的话,命令就不会执 行)。Ant的优点远不止这些,它还很容易的集成到一些开发环境中(例如visual age,jbuilder,netbeans)。

二.Ant的安装及配置
安装
Ant 目前的版本是1.3,首先到下载ant最新版本1.3,解压到C: /ant(window操作系统) 或者/usr/local/ant(linux操作系统),由于我们要用到xmlc ,而ant1.3中并没有包含它,所以我们需要David.Li为ant写的xmlc任务。具体url为http: //。将下载后的文件中的 ant.jar替换掉ant1.3中ant.jar.这样ant的版本变为1.2.

2.设置路径
(1):windows98操作系统
编辑C:\enhydra\.bashrc,加入下面三行

export ANT_HOME=/ant
export JAVA_HOME=/jdk-1.2.2
export PATH=${PATH}:${ANT_HOME}/bin

(2):Linux操作系统
编辑/etc/profile或者 用户目录下的.bashrc文件,加入下面三行

export ANT_HOME=/usr/local/ant
export JAVA_HOME=/usr/local/jdk-1.2.2
export PATH=${PATH}:${ANT_HOME}/bin

三:用ant管理项目
1:基本的文件目录结构 解压到任意目录,我们可以看到目录树结构如下
├─bin
├─docs
│ ├─ant2
│ ├─api
│ │ └─org
│ │ └─apache
│ │ └─tools
│ │ ├─ant
│ │ │ ├─taskdefs
│ │ │ │ ├─compilers
│ │ │ │ └─optional
│ │ │ │ ├─clearcase
│ │ │ │ ├─depend
│ │ │ │ │ └─constantpool
│ │ │ │ ├─dotnet
│ │ │ │ ├─ejb
│ │ │ │ ├─ide
│ │ │ │ ├─javacc
│ │ │ │ ├─jlink
│ │ │ │ ├─jsp
│ │ │ │ ├─junit
│ │ │ │ ├─metamata
│ │ │ │ ├─net
│ │ │ │ ├─perforce
│ │ │ │ ├─scm
│ │ │ │ ├─sound
│ │ │ │ └─vss
│ │ │ ├─types
│ │ │ └─util
│ │ │ └─regexp
│ │ ├─mail
│ │ └─tar
│ └─manual
│ ├─CoreTasks
│ ├─CoreTypes
│ ├─Integration
│ └─OptionalTasks
└─lib





在这个目录树结构中,与传统的项目不同的是,我们用build.xml取代了Makefile,在讲述这个build.xml文件前,我们先了解一个基本的 build.xml文件的结构。

2:build.xml的基本书写规范
下面我们就来讲述这个文件的书写方法,下面是这个文件的全部内容
1.
2.
3.
4.
5.
6.

7.





为 了方便说明,我们为每一行加了行号,第一行是xml文件的基本要素,第二行说明这是一个项目,第七行说明项目的结束 ,在第二行中,name="MyProject"说明此项目的名称,这个属性可有可无。basedir="."说明基本目录,此属性可有可无。 default="dist"说明项目的缺省目标(target)是什么,这个属性必须有。所谓目标(target)就是一系列任务(task)组成的一 个集合。每个任务(task)的书写方法如下:
<任务名 属性1="属性1的值" 属性2="属性2的值" ....... />




第 三行定义了一些属性(property),以便后面使用,这非常类似于编程中定义的全局变量。从第四行开始定义目标(target),name= "init"指明了此目标的名称,name属性在定义目标时必须有,当然定义目标时还有其他一些属性可选,例如depends,unless,具体请参考 ant的文档。第五行开始定义此目标内的任务,其中mkdir时ant的内部任务名,dir是此任务的属性,其值为${dist}。此任务就是创建一个目 录。其中${dist}是获取dist属性的值(就是我们在第三行定义的)。如上就是一个基本的build.xml文件的写法。你可以在命令行上输入 ant -buildfile build.xml

看一下你的当前目录下是否多了一个dist目录。如果出错,则可能是你没有把ant配置好,参见前面讲的安装及配置,看一下哪儿出了错。

3:build.xml文件
build.xml文件如下,其中有的注释和无关的代码删掉了,且做了一下小小的改动
1:
2:
3:
4:
5:
6:
7:
8:
9:
10:


11:
12:
13:
14:
15:
16:
17:
18:
19:

20:
21:
22:
23:

24:
25:

26:
27:
28:
29:
30:
31:
32:

33:
34:


35:
36:
37:
38:
39:
40:


41:
42:
43:
44:
45:
46:47:sourceout="${build.xmlc.dir}"
48:includes="**/*.html">
49:

50:
51:
52:
53:
54:
55:
56:
57:
58:

59:


60:
61:
62:
63:
64:

65:
66:67:destdir="${build.classes}"
68:classpathref="build.classpath"
69:debug="${build.debug}"/>

70:
71:72:destdir="${build.classes}"
73:classpathref="build.classpath"
74:debug="${build.debug}"
75:includes="${app.name}/**"
76:/>
77:


78:
79:
80:
81:
82:
83:
84:
85:
86:
87:
88:
89:

90:

91:



92:
93:
94:
95:
96:
97:
98:


99:
100:
101:
102:
103:
104:

105:
106:
107:108:tofile="${build.dir}/multiserver.conf"
109:filtering="on"/>

110:
111:
112:
113:


114:





4:build.xml详细说明
下 面我们将详细讲述这个文件,同样为了方便,我加了行号,当然一些基本的东西我就不再重复了。第四行taskdef任务(task)属于ant的内部任务, 它的作用是定义一个任务,其基本属性有name,classname,在定义时这两个属性都必需有。第八行开始定义一个path,它有一个属性id,通过 这个id的值我们可以在后面引用这个path,参见第68行。目标(target)init(从14行到34行)定义了一些基本属性 (property),主要是为了后面的target使用。在第38行,你会看到depends="init",depends是定义一个目标时的可选属 性,它的意思是如果init目标没有执行(出错或其他原因),这个目标也不会被执行。

从第46行开始定义xmlc任务,到第58行结束,中间有很多参数嵌套在其中,srcdir指定源文件目录,sourceout指定输出目录,includes属性将源文件目录中的所有html文件包括进来。*为通配符。

表示取消警告,表示同时产生接口和实现代码,例如:一个welcome.html,它会产生两个文件: WelcomeHTMLImpl.java,WelcomeHTML.java,WelcomeHTML.java中只定义了一个接口 WelcomeHTML,真正的实现在WelcomeHTMLImpl.java中。表示设置编码,由于xmlc将html文件编译为java类,即使你在html文件中已经设置了编码,在 java类中也不会有作用,必须在编译时设置编码。 这两句相当于在命令行上输入-ssi -keep.其中ssi参数是在编译html文件时将定义的ssi文件包括进来,见html目录下的welcome2.html源代码中有一行: Ant简介-jennyljd-ChinaUnix博客
  • 博客访问: 313289
  • 博文数量: 54
  • 博客积分: 1400
  • 博客等级: 上尉
  • 技术积分: 606
  • 用 户 组: 普通用户
  • 注册时间: 2006-12-03 22:43
文章分类
文章存档

2011年(3)

2010年(26)

2009年(2)

2008年(23)

我的朋友

分类:

2009-02-21 20:15:11

本文描述了ant的基本语法及其如何应用于项目的管理
-. Ant简介
可 能有许多读者并不了解什么是ant,以及如何使用它。但只要你是用过linux,你应该知道make为何物,当我们编译linux内核及一些软件的源程序 时,我们经常需要在控制台下输入make。Make其实就是一个项目管理工具,而ant所实现的功能与make差不多。Ant是apache软件基金会 jakarta项目中的一个子项目,由于是基于java编写的,因此具有很好的跨平台性。Ant由一些内置任务(task)和可选择的任务组成(当然你还 可以编写自己的任务),使用Make时,你需要写一个Makefile文件,而用ant时则需要写一个build.xml文件。由于采用xml的语法,所 以build.xml文件很容易书写和维护,且结构很清晰,而不像Makefile文件有那么多的限制(例如在tab符号前有一个空格的话,命令就不会执 行)。Ant的优点远不止这些,它还很容易的集成到一些开发环境中(例如visual age,jbuilder,netbeans)。

二.Ant的安装及配置
安装
Ant 目前的版本是1.3,首先到下载ant最新版本1.3,解压到C: /ant(window操作系统) 或者/usr/local/ant(linux操作系统),由于我们要用到xmlc ,而ant1.3中并没有包含它,所以我们需要David.Li为ant写的xmlc任务。具体url为http: //。将下载后的文件中的 ant.jar替换掉ant1.3中ant.jar.这样ant的版本变为1.2.

2.设置路径
(1):windows98操作系统
编辑C:\enhydra\.bashrc,加入下面三行

export ANT_HOME=/ant
export JAVA_HOME=/jdk-1.2.2
export PATH=${PATH}:${ANT_HOME}/bin

(2):Linux操作系统
编辑/etc/profile或者 用户目录下的.bashrc文件,加入下面三行

export ANT_HOME=/usr/local/ant
export JAVA_HOME=/usr/local/jdk-1.2.2
export PATH=${PATH}:${ANT_HOME}/bin

三:用ant管理项目
1:基本的文件目录结构 解压到任意目录,我们可以看到目录树结构如下
├─bin
├─docs
│ ├─ant2
│ ├─api
│ │ └─org
│ │ └─apache
│ │ └─tools
│ │ ├─ant
│ │ │ ├─taskdefs
│ │ │ │ ├─compilers
│ │ │ │ └─optional
│ │ │ │ ├─clearcase
│ │ │ │ ├─depend
│ │ │ │ │ └─constantpool
│ │ │ │ ├─dotnet
│ │ │ │ ├─ejb
│ │ │ │ ├─ide
│ │ │ │ ├─javacc
│ │ │ │ ├─jlink
│ │ │ │ ├─jsp
│ │ │ │ ├─junit
│ │ │ │ ├─metamata
│ │ │ │ ├─net
│ │ │ │ ├─perforce
│ │ │ │ ├─scm
│ │ │ │ ├─sound
│ │ │ │ └─vss
│ │ │ ├─types
│ │ │ └─util
│ │ │ └─regexp
│ │ ├─mail
│ │ └─tar
│ └─manual
│ ├─CoreTasks
│ ├─CoreTypes
│ ├─Integration
│ └─OptionalTasks
└─lib





在这个目录树结构中,与传统的项目不同的是,我们用build.xml取代了Makefile,在讲述这个build.xml文件前,我们先了解一个基本的 build.xml文件的结构。

2:build.xml的基本书写规范
下面我们就来讲述这个文件的书写方法,下面是这个文件的全部内容
1.
2.
3.
4.
5.
6.

7.





为 了方便说明,我们为每一行加了行号,第一行是xml文件的基本要素,第二行说明这是一个项目,第七行说明项目的结束 ,在第二行中,name="MyProject"说明此项目的名称,这个属性可有可无。basedir="."说明基本目录,此属性可有可无。 default="dist"说明项目的缺省目标(target)是什么,这个属性必须有。所谓目标(target)就是一系列任务(task)组成的一 个集合。每个任务(task)的书写方法如下:
<任务名 属性1="属性1的值" 属性2="属性2的值" ....... />




第 三行定义了一些属性(property),以便后面使用,这非常类似于编程中定义的全局变量。从第四行开始定义目标(target),name= "init"指明了此目标的名称,name属性在定义目标时必须有,当然定义目标时还有其他一些属性可选,例如depends,unless,具体请参考 ant的文档。第五行开始定义此目标内的任务,其中mkdir时ant的内部任务名,dir是此任务的属性,其值为${dist}。此任务就是创建一个目 录。其中${dist}是获取dist属性的值(就是我们在第三行定义的)。如上就是一个基本的build.xml文件的写法。你可以在命令行上输入 ant -buildfile build.xml

看一下你的当前目录下是否多了一个dist目录。如果出错,则可能是你没有把ant配置好,参见前面讲的安装及配置,看一下哪儿出了错。

3:build.xml文件
build.xml文件如下,其中有的注释和无关的代码删掉了,且做了一下小小的改动
1:
2:
3:
4:
5:
6:
7:
8:
9:
10:


11:
12:
13:
14:
15:
16:
17:
18:
19:

20:
21:
22:
23:

24:
25:

26:
27:
28:
29:
30:
31:
32:

33:
34:


35:
36:
37:
38:
39:
40:


41:
42:
43:
44:
45:
46:47:sourceout="${build.xmlc.dir}"
48:includes="**/*.html">
49:

50:
51:
52:
53:
54:
55:
56:
57:
58:

59:


60:
61:
62:
63:
64:

65:
66:67:destdir="${build.classes}"
68:classpathref="build.classpath"
69:debug="${build.debug}"/>

70:
71:72:destdir="${build.classes}"
73:classpathref="build.classpath"
74:debug="${build.debug}"
75:includes="${app.name}/**"
76:/>
77:


78:
79:
80:
81:
82:
83:
84:
85:
86:
87:
88:
89:

90:

91:



92:
93:
94:
95:
96:
97:
98:


99:
100:
101:
102:
103:
104:

105:
106:
107:108:tofile="${build.dir}/multiserver.conf"
109:filtering="on"/>

110:
111:
112:
113:


114:





4:build.xml详细说明
下 面我们将详细讲述这个文件,同样为了方便,我加了行号,当然一些基本的东西我就不再重复了。第四行taskdef任务(task)属于ant的内部任务, 它的作用是定义一个任务,其基本属性有name,classname,在定义时这两个属性都必需有。第八行开始定义一个path,它有一个属性id,通过 这个id的值我们可以在后面引用这个path,参见第68行。目标(target)init(从14行到34行)定义了一些基本属性 (property),主要是为了后面的target使用。在第38行,你会看到depends="init",depends是定义一个目标时的可选属 性,它的意思是如果init目标没有执行(出错或其他原因),这个目标也不会被执行。

从第46行开始定义xmlc任务,到第58行结束,中间有很多参数嵌套在其中,srcdir指定源文件目录,sourceout指定输出目录,includes属性将源文件目录中的所有html文件包括进来。*为通配符。

表示取消警告,表示同时产生接口和实现代码,例如:一个welcome.html,它会产生两个文件: WelcomeHTMLImpl.java,WelcomeHTML.java,WelcomeHTML.java中只定义了一个接口 WelcomeHTML,真正的实现在WelcomeHTMLImpl.java中。表示设置编码,由于xmlc将html文件编译为java类,即使你在html文件中已经设置了编码,在 java类中也不会有作用,必须在编译时设置编码。 这两句相当于在命令行上输入-ssi -keep.其中ssi参数是在编译html文件时将定义的ssi文件包括进来,见html目录下的welcome2.html源代码中有一行: Ant简介-jennyljd-ChinaUnix博客
  • 博客访问: 313290
  • 博文数量: 54
  • 博客积分: 1400
  • 博客等级: 上尉
  • 技术积分: 606
  • 用 户 组: 普通用户
  • 注册时间: 2006-12-03 22:43
文章分类
文章存档

2011年(3)

2010年(26)

2009年(2)

2008年(23)

我的朋友

分类:

2009-02-21 20:15:11

本文描述了ant的基本语法及其如何应用于项目的管理
-. Ant简介
可 能有许多读者并不了解什么是ant,以及如何使用它。但只要你是用过linux,你应该知道make为何物,当我们编译linux内核及一些软件的源程序 时,我们经常需要在控制台下输入make。Make其实就是一个项目管理工具,而ant所实现的功能与make差不多。Ant是apache软件基金会 jakarta项目中的一个子项目,由于是基于java编写的,因此具有很好的跨平台性。Ant由一些内置任务(task)和可选择的任务组成(当然你还 可以编写自己的任务),使用Make时,你需要写一个Makefile文件,而用ant时则需要写一个build.xml文件。由于采用xml的语法,所 以build.xml文件很容易书写和维护,且结构很清晰,而不像Makefile文件有那么多的限制(例如在tab符号前有一个空格的话,命令就不会执 行)。Ant的优点远不止这些,它还很容易的集成到一些开发环境中(例如visual age,jbuilder,netbeans)。

二.Ant的安装及配置
安装
Ant 目前的版本是1.3,首先到下载ant最新版本1.3,解压到C: /ant(window操作系统) 或者/usr/local/ant(linux操作系统),由于我们要用到xmlc ,而ant1.3中并没有包含它,所以我们需要David.Li为ant写的xmlc任务。具体url为http: //。将下载后的文件中的 ant.jar替换掉ant1.3中ant.jar.这样ant的版本变为1.2.

2.设置路径
(1):windows98操作系统
编辑C:\enhydra\.bashrc,加入下面三行

export ANT_HOME=/ant
export JAVA_HOME=/jdk-1.2.2
export PATH=${PATH}:${ANT_HOME}/bin

(2):Linux操作系统
编辑/etc/profile或者 用户目录下的.bashrc文件,加入下面三行

export ANT_HOME=/usr/local/ant
export JAVA_HOME=/usr/local/jdk-1.2.2
export PATH=${PATH}:${ANT_HOME}/bin

三:用ant管理项目
1:基本的文件目录结构 解压到任意目录,我们可以看到目录树结构如下
├─bin
├─docs
│ ├─ant2
│ ├─api
│ │ └─org
│ │ └─apache
│ │ └─tools
│ │ ├─ant
│ │ │ ├─taskdefs
│ │ │ │ ├─compilers
│ │ │ │ └─optional
│ │ │ │ ├─clearcase
│ │ │ │ ├─depend
│ │ │ │ │ └─constantpool
│ │ │ │ ├─dotnet
│ │ │ │ ├─ejb
│ │ │ │ ├─ide
│ │ │ │ ├─javacc
│ │ │ │ ├─jlink
│ │ │ │ ├─jsp
│ │ │ │ ├─junit
│ │ │ │ ├─metamata
│ │ │ │ ├─net
│ │ │ │ ├─perforce
│ │ │ │ ├─scm
│ │ │ │ ├─sound
│ │ │ │ └─vss
│ │ │ ├─types
│ │ │ └─util
│ │ │ └─regexp
│ │ ├─mail
│ │ └─tar
│ └─manual
│ ├─CoreTasks
│ ├─CoreTypes
│ ├─Integration
│ └─OptionalTasks
└─lib





在这个目录树结构中,与传统的项目不同的是,我们用build.xml取代了Makefile,在讲述这个build.xml文件前,我们先了解一个基本的 build.xml文件的结构。

2:build.xml的基本书写规范
下面我们就来讲述这个文件的书写方法,下面是这个文件的全部内容
1.
2.
3.
4.
5.
6.

7.





为 了方便说明,我们为每一行加了行号,第一行是xml文件的基本要素,第二行说明这是一个项目,第七行说明项目的结束 ,在第二行中,name="MyProject"说明此项目的名称,这个属性可有可无。basedir="."说明基本目录,此属性可有可无。 default="dist"说明项目的缺省目标(target)是什么,这个属性必须有。所谓目标(target)就是一系列任务(task)组成的一 个集合。每个任务(task)的书写方法如下:
<任务名 属性1="属性1的值" 属性2="属性2的值" ....... />




第 三行定义了一些属性(property),以便后面使用,这非常类似于编程中定义的全局变量。从第四行开始定义目标(target),name= "init"指明了此目标的名称,name属性在定义目标时必须有,当然定义目标时还有其他一些属性可选,例如depends,unless,具体请参考 ant的文档。第五行开始定义此目标内的任务,其中mkdir时ant的内部任务名,dir是此任务的属性,其值为${dist}。此任务就是创建一个目 录。其中${dist}是获取dist属性的值(就是我们在第三行定义的)。如上就是一个基本的build.xml文件的写法。你可以在命令行上输入 ant -buildfile build.xml

看一下你的当前目录下是否多了一个dist目录。如果出错,则可能是你没有把ant配置好,参见前面讲的安装及配置,看一下哪儿出了错。

3:build.xml文件
build.xml文件如下,其中有的注释和无关的代码删掉了,且做了一下小小的改动
1:
2:
3:
4:
5:
6:
7:
8:
9:
10:


11:
12:
13:
14:
15:
16:
17:
18:
19:

20:
21:
22:
23:

24:
25:

26:
27:
28:
29:
30:
31:
32:

33:
34:


35:
36:
37:
38:
39:
40:


41:
42:
43:
44:
45:
46:47:sourceout="${build.xmlc.dir}"
48:includes="**/*.html">
49:

50:
51:
52:
53:
54:
55:
56:
57:
58:

59:


60:
61:
62:
63:
64:

65:
66:67:destdir="${build.classes}"
68:classpathref="build.classpath"
69:debug="${build.debug}"/>

70:
71:72:destdir="${build.classes}"
73:classpathref="build.classpath"
74:debug="${build.debug}"
75:includes="${app.name}/**"
76:/>
77:


78:
79:
80:
81:
82:
83:
84:
85:
86:
87:
88:
89:

90:

91:



92:
93:
94:
95:
96:
97:
98:


99:
100:
101:
102:
103:
104:

105:
106:
107:108:tofile="${build.dir}/multiserver.conf"
109:filtering="on"/>

110:
111:
112:
113:


114:





4:build.xml详细说明
下 面我们将详细讲述这个文件,同样为了方便,我加了行号,当然一些基本的东西我就不再重复了。第四行taskdef任务(task)属于ant的内部任务, 它的作用是定义一个任务,其基本属性有name,classname,在定义时这两个属性都必需有。第八行开始定义一个path,它有一个属性id,通过 这个id的值我们可以在后面引用这个path,参见第68行。目标(target)init(从14行到34行)定义了一些基本属性 (property),主要是为了后面的target使用。在第38行,你会看到depends="init",depends是定义一个目标时的可选属 性,它的意思是如果init目标没有执行(出错或其他原因),这个目标也不会被执行。

从第46行开始定义xmlc任务,到第58行结束,中间有很多参数嵌套在其中,srcdir指定源文件目录,sourceout指定输出目录,includes属性将源文件目录中的所有html文件包括进来。*为通配符。

表示取消警告,表示同时产生接口和实现代码,例如:一个welcome.html,它会产生两个文件: WelcomeHTMLImpl.java,WelcomeHTML.java,WelcomeHTML.java中只定义了一个接口 WelcomeHTML,真正的实现在WelcomeHTMLImpl.java中。表示设置编码,由于xmlc将html文件编译为java类,即使你在html文件中已经设置了编码,在 java类中也不会有作用,必须在编译时设置编码。 这两句相当于在命令行上输入-ssi -keep.其中ssi参数是在编译html文件时将定义的ssi文件包括进来,见html目录下的welcome2.html源代码中有一行: Ant简介-jennyljd-ChinaUnix博客
  • 博客访问: 313291
  • 博文数量: 54
  • 博客积分: 1400
  • 博客等级: 上尉
  • 技术积分: 606
  • 用 户 组: 普通用户
  • 注册时间: 2006-12-03 22:43
文章分类
文章存档

2011年(3)

2010年(26)

2009年(2)

2008年(23)

我的朋友

分类:

2009-02-21 20:15:11

本文描述了ant的基本语法及其如何应用于项目的管理
-. Ant简介
可 能有许多读者并不了解什么是ant,以及如何使用它。但只要你是用过linux,你应该知道make为何物,当我们编译linux内核及一些软件的源程序 时,我们经常需要在控制台下输入make。Make其实就是一个项目管理工具,而ant所实现的功能与make差不多。Ant是apache软件基金会 jakarta项目中的一个子项目,由于是基于java编写的,因此具有很好的跨平台性。Ant由一些内置任务(task)和可选择的任务组成(当然你还 可以编写自己的任务),使用Make时,你需要写一个Makefile文件,而用ant时则需要写一个build.xml文件。由于采用xml的语法,所 以build.xml文件很容易书写和维护,且结构很清晰,而不像Makefile文件有那么多的限制(例如在tab符号前有一个空格的话,命令就不会执 行)。Ant的优点远不止这些,它还很容易的集成到一些开发环境中(例如visual age,jbuilder,netbeans)。

二.Ant的安装及配置
安装
Ant 目前的版本是1.3,首先到下载ant最新版本1.3,解压到C: /ant(window操作系统) 或者/usr/local/ant(linux操作系统),由于我们要用到xmlc ,而ant1.3中并没有包含它,所以我们需要David.Li为ant写的xmlc任务。具体url为http: //。将下载后的文件中的 ant.jar替换掉ant1.3中ant.jar.这样ant的版本变为1.2.

2.设置路径
(1):windows98操作系统
编辑C:\enhydra\.bashrc,加入下面三行

export ANT_HOME=/ant
export JAVA_HOME=/jdk-1.2.2
export PATH=${PATH}:${ANT_HOME}/bin

(2):Linux操作系统
编辑/etc/profile或者 用户目录下的.bashrc文件,加入下面三行

export ANT_HOME=/usr/local/ant
export JAVA_HOME=/usr/local/jdk-1.2.2
export PATH=${PATH}:${ANT_HOME}/bin

三:用ant管理项目
1:基本的文件目录结构 解压到任意目录,我们可以看到目录树结构如下
├─bin
├─docs
│ ├─ant2
│ ├─api
│ │ └─org
│ │ └─apache
│ │ └─tools
│ │ ├─ant
│ │ │ ├─taskdefs
│ │ │ │ ├─compilers
│ │ │ │ └─optional
│ │ │ │ ├─clearcase
│ │ │ │ ├─depend
│ │ │ │ │ └─constantpool
│ │ │ │ ├─dotnet
│ │ │ │ ├─ejb
│ │ │ │ ├─ide
│ │ │ │ ├─javacc
│ │ │ │ ├─jlink
│ │ │ │ ├─jsp
│ │ │ │ ├─junit
│ │ │ │ ├─metamata
│ │ │ │ ├─net
│ │ │ │ ├─perforce
│ │ │ │ ├─scm
│ │ │ │ ├─sound
│ │ │ │ └─vss
│ │ │ ├─types
│ │ │ └─util
│ │ │ └─regexp
│ │ ├─mail
│ │ └─tar
│ └─manual
│ ├─CoreTasks
│ ├─CoreTypes
│ ├─Integration
│ └─OptionalTasks
└─lib





在这个目录树结构中,与传统的项目不同的是,我们用build.xml取代了Makefile,在讲述这个build.xml文件前,我们先了解一个基本的 build.xml文件的结构。

2:build.xml的基本书写规范
下面我们就来讲述这个文件的书写方法,下面是这个文件的全部内容
1.
2.
3.
4.
5.
6.

7.





为 了方便说明,我们为每一行加了行号,第一行是xml文件的基本要素,第二行说明这是一个项目,第七行说明项目的结束 ,在第二行中,name="MyProject"说明此项目的名称,这个属性可有可无。basedir="."说明基本目录,此属性可有可无。 default="dist"说明项目的缺省目标(target)是什么,这个属性必须有。所谓目标(target)就是一系列任务(task)组成的一 个集合。每个任务(task)的书写方法如下:
<任务名 属性1="属性1的值" 属性2="属性2的值" ....... />




第 三行定义了一些属性(property),以便后面使用,这非常类似于编程中定义的全局变量。从第四行开始定义目标(target),name= "init"指明了此目标的名称,name属性在定义目标时必须有,当然定义目标时还有其他一些属性可选,例如depends,unless,具体请参考 ant的文档。第五行开始定义此目标内的任务,其中mkdir时ant的内部任务名,dir是此任务的属性,其值为${dist}。此任务就是创建一个目 录。其中${dist}是获取dist属性的值(就是我们在第三行定义的)。如上就是一个基本的build.xml文件的写法。你可以在命令行上输入 ant -buildfile build.xml

看一下你的当前目录下是否多了一个dist目录。如果出错,则可能是你没有把ant配置好,参见前面讲的安装及配置,看一下哪儿出了错。

3:build.xml文件
build.xml文件如下,其中有的注释和无关的代码删掉了,且做了一下小小的改动
1:
2:
3:
4:
5:
6:
7:
8:
9:
10:


11:
12:
13:
14:
15:
16:
17:
18:
19:

20:
21:
22:
23:

24:
25:

26:
27:
28:
29:
30:
31:
32:

33:
34:


35:
36:
37:
38:
39:
40:


41:
42:
43:
44:
45:
46:47:sourceout="${build.xmlc.dir}"
48:includes="**/*.html">
49:

50:
51:
52:
53:
54:
55:
56:
57:
58:

59:


60:
61:
62:
63:
64:

65:
66:67:destdir="${build.classes}"
68:classpathref="build.classpath"
69:debug="${build.debug}"/>

70:
71:72:destdir="${build.classes}"
73:classpathref="build.classpath"
74:debug="${build.debug}"
75:includes="${app.name}/**"
76:/>
77:


78:
79:
80:
81:
82:
83:
84:
85:
86:
87:
88:
89:

90:

91:



92:
93:
94:
95:
96:
97:
98:


99:
100:
101:
102:
103:
104:

105:
106:
107:108:tofile="${build.dir}/multiserver.conf"
109:filtering="on"/>

110:
111:
112:
113:


114:





4:build.xml详细说明
下 面我们将详细讲述这个文件,同样为了方便,我加了行号,当然一些基本的东西我就不再重复了。第四行taskdef任务(task)属于ant的内部任务, 它的作用是定义一个任务,其基本属性有name,classname,在定义时这两个属性都必需有。第八行开始定义一个path,它有一个属性id,通过 这个id的值我们可以在后面引用这个path,参见第68行。目标(target)init(从14行到34行)定义了一些基本属性 (property),主要是为了后面的target使用。在第38行,你会看到depends="init",depends是定义一个目标时的可选属 性,它的意思是如果init目标没有执行(出错或其他原因),这个目标也不会被执行。

从第46行开始定义xmlc任务,到第58行结束,中间有很多参数嵌套在其中,srcdir指定源文件目录,sourceout指定输出目录,includes属性将源文件目录中的所有html文件包括进来。*为通配符。

表示取消警告,表示同时产生接口和实现代码,例如:一个welcome.html,它会产生两个文件: WelcomeHTMLImpl.java,WelcomeHTML.java,WelcomeHTML.java中只定义了一个接口 WelcomeHTML,真正的实现在WelcomeHTMLImpl.java中。表示设置编码,由于xmlc将html文件编译为java类,即使你在html文件中已经设置了编码,在 java类中也不会有作用,必须在编译时设置编码。 这两句相当于在命令行上输入-ssi -keep.其中ssi参数是在编译html文件时将定义的ssi文件包括进来,见html目录下的welcome2.html源代码中有一行: Ant简介-jennyljd-ChinaUnix博客
  • 博客访问: 313292
  • 博文数量: 54
  • 博客积分: 1400
  • 博客等级: 上尉
  • 技术积分: 606
  • 用 户 组: 普通用户
  • 注册时间: 2006-12-03 22:43
文章分类
文章存档

2011年(3)

2010年(26)

2009年(2)

2008年(23)

我的朋友

分类:

2009-02-21 20:15:11

本文描述了ant的基本语法及其如何应用于项目的管理
-. Ant简介
可 能有许多读者并不了解什么是ant,以及如何使用它。但只要你是用过linux,你应该知道make为何物,当我们编译linux内核及一些软件的源程序 时,我们经常需要在控制台下输入make。Make其实就是一个项目管理工具,而ant所实现的功能与make差不多。Ant是apache软件基金会 jakarta项目中的一个子项目,由于是基于java编写的,因此具有很好的跨平台性。Ant由一些内置任务(task)和可选择的任务组成(当然你还 可以编写自己的任务),使用Make时,你需要写一个Makefile文件,而用ant时则需要写一个build.xml文件。由于采用xml的语法,所 以build.xml文件很容易书写和维护,且结构很清晰,而不像Makefile文件有那么多的限制(例如在tab符号前有一个空格的话,命令就不会执 行)。Ant的优点远不止这些,它还很容易的集成到一些开发环境中(例如visual age,jbuilder,netbeans)。

二.Ant的安装及配置
安装
Ant 目前的版本是1.3,首先到下载ant最新版本1.3,解压到C: /ant(window操作系统) 或者/usr/local/ant(linux操作系统),由于我们要用到xmlc ,而ant1.3中并没有包含它,所以我们需要David.Li为ant写的xmlc任务。具体url为http: //。将下载后的文件中的 ant.jar替换掉ant1.3中ant.jar.这样ant的版本变为1.2.

2.设置路径
(1):windows98操作系统
编辑C:\enhydra\.bashrc,加入下面三行

export ANT_HOME=/ant
export JAVA_HOME=/jdk-1.2.2
export PATH=${PATH}:${ANT_HOME}/bin

(2):Linux操作系统
编辑/etc/profile或者 用户目录下的.bashrc文件,加入下面三行

export ANT_HOME=/usr/local/ant
export JAVA_HOME=/usr/local/jdk-1.2.2
export PATH=${PATH}:${ANT_HOME}/bin

三:用ant管理项目
1:基本的文件目录结构 解压到任意目录,我们可以看到目录树结构如下
├─bin
├─docs
│ ├─ant2
│ ├─api
│ │ └─org
│ │ └─apache
│ │ └─tools
│ │ ├─ant
│ │ │ ├─taskdefs
│ │ │ │ ├─compilers
│ │ │ │ └─optional
│ │ │ │ ├─clearcase
│ │ │ │ ├─depend
│ │ │ │ │ └─constantpool
│ │ │ │ ├─dotnet
│ │ │ │ ├─ejb
│ │ │ │ ├─ide
│ │ │ │ ├─javacc
│ │ │ │ ├─jlink
│ │ │ │ ├─jsp
│ │ │ │ ├─junit
│ │ │ │ ├─metamata
│ │ │ │ ├─net
│ │ │ │ ├─perforce
│ │ │ │ ├─scm
│ │ │ │ ├─sound
│ │ │ │ └─vss
│ │ │ ├─types
│ │ │ └─util
│ │ │ └─regexp
│ │ ├─mail
│ │ └─tar
│ └─manual
│ ├─CoreTasks
│ ├─CoreTypes
│ ├─Integration
│ └─OptionalTasks
└─lib





在这个目录树结构中,与传统的项目不同的是,我们用build.xml取代了Makefile,在讲述这个build.xml文件前,我们先了解一个基本的 build.xml文件的结构。

2:build.xml的基本书写规范
下面我们就来讲述这个文件的书写方法,下面是这个文件的全部内容
1.
2.
3.
4.
5.
6.

7.





为 了方便说明,我们为每一行加了行号,第一行是xml文件的基本要素,第二行说明这是一个项目,第七行说明项目的结束 ,在第二行中,name="MyProject"说明此项目的名称,这个属性可有可无。basedir="."说明基本目录,此属性可有可无。 default="dist"说明项目的缺省目标(target)是什么,这个属性必须有。所谓目标(target)就是一系列任务(task)组成的一 个集合。每个任务(task)的书写方法如下:
<任务名 属性1="属性1的值" 属性2="属性2的值" ....... />




第 三行定义了一些属性(property),以便后面使用,这非常类似于编程中定义的全局变量。从第四行开始定义目标(target),name= "init"指明了此目标的名称,name属性在定义目标时必须有,当然定义目标时还有其他一些属性可选,例如depends,unless,具体请参考 ant的文档。第五行开始定义此目标内的任务,其中mkdir时ant的内部任务名,dir是此任务的属性,其值为${dist}。此任务就是创建一个目 录。其中${dist}是获取dist属性的值(就是我们在第三行定义的)。如上就是一个基本的build.xml文件的写法。你可以在命令行上输入 ant -buildfile build.xml

看一下你的当前目录下是否多了一个dist目录。如果出错,则可能是你没有把ant配置好,参见前面讲的安装及配置,看一下哪儿出了错。

3:build.xml文件
build.xml文件如下,其中有的注释和无关的代码删掉了,且做了一下小小的改动
1:
2:
3:
4:
5:
6:
7:
8:
9:
10:


11:
12:
13:
14:
15:
16:
17:
18:
19:

20:
21:
22:
23:

24:
25:

26:
27:
28:
29:
30:
31:
32:

33:
34:


35:
36:
37:
38:
39:
40:


41:
42:
43:
44:
45:
46:47:sourceout="${build.xmlc.dir}"
48:includes="**/*.html">
49:

50:
51:
52:
53:
54:
55:
56:
57:
58:

59:


60:
61:
62:
63:
64:

65:
66:67:destdir="${build.classes}"
68:classpathref="build.classpath"
69:debug="${build.debug}"/>

70:
71:72:destdir="${build.classes}"
73:classpathref="build.classpath"
74:debug="${build.debug}"
75:includes="${app.name}/**"
76:/>
77:


78:
79:
80:
81:
82:
83:
84:
85:
86:
87:
88:
89:

90:

91:



92:
93:
94:
95:
96:
97:
98:


99:
100:
101:
102:
103:
104:

105:
106:
107:108:tofile="${build.dir}/multiserver.conf"
109:filtering="on"/>

110:
111:
112:
113:


114:





4:build.xml详细说明
下 面我们将详细讲述这个文件,同样为了方便,我加了行号,当然一些基本的东西我就不再重复了。第四行taskdef任务(task)属于ant的内部任务, 它的作用是定义一个任务,其基本属性有name,classname,在定义时这两个属性都必需有。第八行开始定义一个path,它有一个属性id,通过 这个id的值我们可以在后面引用这个path,参见第68行。目标(target)init(从14行到34行)定义了一些基本属性 (property),主要是为了后面的target使用。在第38行,你会看到depends="init",depends是定义一个目标时的可选属 性,它的意思是如果init目标没有执行(出错或其他原因),这个目标也不会被执行。

从第46行开始定义xmlc任务,到第58行结束,中间有很多参数嵌套在其中,srcdir指定源文件目录,sourceout指定输出目录,includes属性将源文件目录中的所有html文件包括进来。*为通配符。

表示取消警告,表示同时产生接口和实现代码,例如:一个welcome.html,它会产生两个文件: WelcomeHTMLImpl.java,WelcomeHTML.java,WelcomeHTML.java中只定义了一个接口 WelcomeHTML,真正的实现在WelcomeHTMLImpl.java中。表示设置编码,由于xmlc将html文件编译为java类,即使你在html文件中已经设置了编码,在 java类中也不会有作用,必须在编译时设置编码。 这两句相当于在命令行上输入-ssi -keep.其中ssi参数是在编译html文件时将定义的ssi文件包括进来,见html目录下的welcome2.html源代码中有一行: Ant简介-jennyljd-ChinaUnix博客
  • 博客访问: 313293
  • 博文数量: 54
  • 博客积分: 1400
  • 博客等级: 上尉
  • 技术积分: 606
  • 用 户 组: 普通用户
  • 注册时间: 2006-12-03 22:43
文章分类
文章存档

2011年(3)

2010年(26)

2009年(2)

2008年(23)

我的朋友

分类:

2009-02-21 20:15:11

本文描述了ant的基本语法及其如何应用于项目的管理
-. Ant简介
可 能有许多读者并不了解什么是ant,以及如何使用它。但只要你是用过linux,你应该知道make为何物,当我们编译linux内核及一些软件的源程序 时,我们经常需要在控制台下输入make。Make其实就是一个项目管理工具,而ant所实现的功能与make差不多。Ant是apache软件基金会 jakarta项目中的一个子项目,由于是基于java编写的,因此具有很好的跨平台性。Ant由一些内置任务(task)和可选择的任务组成(当然你还 可以编写自己的任务),使用Make时,你需要写一个Makefile文件,而用ant时则需要写一个build.xml文件。由于采用xml的语法,所 以build.xml文件很容易书写和维护,且结构很清晰,而不像Makefile文件有那么多的限制(例如在tab符号前有一个空格的话,命令就不会执 行)。Ant的优点远不止这些,它还很容易的集成到一些开发环境中(例如visual age,jbuilder,netbeans)。

二.Ant的安装及配置
安装
Ant 目前的版本是1.3,首先到下载ant最新版本1.3,解压到C: /ant(window操作系统) 或者/usr/local/ant(linux操作系统),由于我们要用到xmlc ,而ant1.3中并没有包含它,所以我们需要David.Li为ant写的xmlc任务。具体url为http: //。将下载后的文件中的 ant.jar替换掉ant1.3中ant.jar.这样ant的版本变为1.2.

2.设置路径
(1):windows98操作系统
编辑C:\enhydra\.bashrc,加入下面三行

export ANT_HOME=/ant
export JAVA_HOME=/jdk-1.2.2
export PATH=${PATH}:${ANT_HOME}/bin

(2):Linux操作系统
编辑/etc/profile或者 用户目录下的.bashrc文件,加入下面三行

export ANT_HOME=/usr/local/ant
export JAVA_HOME=/usr/local/jdk-1.2.2
export PATH=${PATH}:${ANT_HOME}/bin

三:用ant管理项目
1:基本的文件目录结构 解压到任意目录,我们可以看到目录树结构如下
├─bin
├─docs
│ ├─ant2
│ ├─api
│ │ └─org
│ │ └─apache
│ │ └─tools
│ │ ├─ant
│ │ │ ├─taskdefs
│ │ │ │ ├─compilers
│ │ │ │ └─optional
│ │ │ │ ├─clearcase
│ │ │ │ ├─depend
│ │ │ │ │ └─constantpool
│ │ │ │ ├─dotnet
│ │ │ │ ├─ejb
│ │ │ │ ├─ide
│ │ │ │ ├─javacc
│ │ │ │ ├─jlink
│ │ │ │ ├─jsp
│ │ │ │ ├─junit
│ │ │ │ ├─metamata
│ │ │ │ ├─net
│ │ │ │ ├─perforce
│ │ │ │ ├─scm
│ │ │ │ ├─sound
│ │ │ │ └─vss
│ │ │ ├─types
│ │ │ └─util
│ │ │ └─regexp
│ │ ├─mail
│ │ └─tar
│ └─manual
│ ├─CoreTasks
│ ├─CoreTypes
│ ├─Integration
│ └─OptionalTasks
└─lib





在这个目录树结构中,与传统的项目不同的是,我们用build.xml取代了Makefile,在讲述这个build.xml文件前,我们先了解一个基本的 build.xml文件的结构。

2:build.xml的基本书写规范
下面我们就来讲述这个文件的书写方法,下面是这个文件的全部内容
1.
2.
3.
4.
5.
6.

7.





为 了方便说明,我们为每一行加了行号,第一行是xml文件的基本要素,第二行说明这是一个项目,第七行说明项目的结束 ,在第二行中,name="MyProject"说明此项目的名称,这个属性可有可无。basedir="."说明基本目录,此属性可有可无。 default="dist"说明项目的缺省目标(target)是什么,这个属性必须有。所谓目标(target)就是一系列任务(task)组成的一 个集合。每个任务(task)的书写方法如下:
<任务名 属性1="属性1的值" 属性2="属性2的值" ....... />




第 三行定义了一些属性(property),以便后面使用,这非常类似于编程中定义的全局变量。从第四行开始定义目标(target),name= "init"指明了此目标的名称,name属性在定义目标时必须有,当然定义目标时还有其他一些属性可选,例如depends,unless,具体请参考 ant的文档。第五行开始定义此目标内的任务,其中mkdir时ant的内部任务名,dir是此任务的属性,其值为${dist}。此任务就是创建一个目 录。其中${dist}是获取dist属性的值(就是我们在第三行定义的)。如上就是一个基本的build.xml文件的写法。你可以在命令行上输入 ant -buildfile build.xml

看一下你的当前目录下是否多了一个dist目录。如果出错,则可能是你没有把ant配置好,参见前面讲的安装及配置,看一下哪儿出了错。

3:build.xml文件
build.xml文件如下,其中有的注释和无关的代码删掉了,且做了一下小小的改动
1:
2:
3:
4:
5:
6:
7:
8:
9:
10:


11:
12:
13:
14:
15:
16:
17:
18:
19:

20:
21:
22:
23:

24:
25:

26:
27:
28:
29:
30:
31:
32:

33:
34:


35:
36:
37:
38:
39:
40:


41:
42:
43:
44:
45:
46:47:sourceout="${build.xmlc.dir}"
48:includes="**/*.html">
49:

50:
51:
52:
53:
54:
55:
56:
57:
58:

59:


60:
61:
62:
63:
64:

65:
66:67:destdir="${build.classes}"
68:classpathref="build.classpath"
69:debug="${build.debug}"/>

70:
71:72:destdir="${build.classes}"
73:classpathref="build.classpath"
74:debug="${build.debug}"
75:includes="${app.name}/**"
76:/>
77:


78:
79:
80:
81:
82:
83:
84:
85:
86:
87:
88:
89:

90:

91:



92:
93:
94:
95:
96:
97:
98:


99:
100:
101:
102:
103:
104:

105:
106:
107:108:tofile="${build.dir}/multiserver.conf"
109:filtering="on"/>

110:
111:
112:
113:


114:





4:build.xml详细说明
下 面我们将详细讲述这个文件,同样为了方便,我加了行号,当然一些基本的东西我就不再重复了。第四行taskdef任务(task)属于ant的内部任务, 它的作用是定义一个任务,其基本属性有name,classname,在定义时这两个属性都必需有。第八行开始定义一个path,它有一个属性id,通过 这个id的值我们可以在后面引用这个path,参见第68行。目标(target)init(从14行到34行)定义了一些基本属性 (property),主要是为了后面的target使用。在第38行,你会看到depends="init",depends是定义一个目标时的可选属 性,它的意思是如果init目标没有执行(出错或其他原因),这个目标也不会被执行。

从第46行开始定义xmlc任务,到第58行结束,中间有很多参数嵌套在其中,srcdir指定源文件目录,sourceout指定输出目录,includes属性将源文件目录中的所有html文件包括进来。*为通配符。

表示取消警告,表示同时产生接口和实现代码,例如:一个welcome.html,它会产生两个文件: WelcomeHTMLImpl.java,WelcomeHTML.java,WelcomeHTML.java中只定义了一个接口 WelcomeHTML,真正的实现在WelcomeHTMLImpl.java中。表示设置编码,由于xmlc将html文件编译为java类,即使你在html文件中已经设置了编码,在 java类中也不会有作用,必须在编译时设置编码。 这两句相当于在命令行上输入-ssi -keep.其中ssi参数是在编译html文件时将定义的ssi文件包括进来,见html目录下的welcome2.html源代码中有一行: Ant简介-jennyljd-ChinaUnix博客
  • 博客访问: 313294
  • 博文数量: 54
  • 博客积分: 1400
  • 博客等级: 上尉
  • 技术积分: 606
  • 用 户 组: 普通用户
  • 注册时间: 2006-12-03 22:43
文章分类
文章存档

2011年(3)

2010年(26)

2009年(2)

2008年(23)

我的朋友

分类:

2009-02-21 20:15:11

本文描述了ant的基本语法及其如何应用于项目的管理
-. Ant简介
可 能有许多读者并不了解什么是ant,以及如何使用它。但只要你是用过linux,你应该知道make为何物,当我们编译linux内核及一些软件的源程序 时,我们经常需要在控制台下输入make。Make其实就是一个项目管理工具,而ant所实现的功能与make差不多。Ant是apache软件基金会 jakarta项目中的一个子项目,由于是基于java编写的,因此具有很好的跨平台性。Ant由一些内置任务(task)和可选择的任务组成(当然你还 可以编写自己的任务),使用Make时,你需要写一个Makefile文件,而用ant时则需要写一个build.xml文件。由于采用xml的语法,所 以build.xml文件很容易书写和维护,且结构很清晰,而不像Makefile文件有那么多的限制(例如在tab符号前有一个空格的话,命令就不会执 行)。Ant的优点远不止这些,它还很容易的集成到一些开发环境中(例如visual age,jbuilder,netbeans)。

二.Ant的安装及配置
安装
Ant 目前的版本是1.3,首先到下载ant最新版本1.3,解压到C: /ant(window操作系统) 或者/usr/local/ant(linux操作系统),由于我们要用到xmlc ,而ant1.3中并没有包含它,所以我们需要David.Li为ant写的xmlc任务。具体url为http: //。将下载后的文件中的 ant.jar替换掉ant1.3中ant.jar.这样ant的版本变为1.2.

2.设置路径
(1):windows98操作系统
编辑C:\enhydra\.bashrc,加入下面三行

export ANT_HOME=/ant
export JAVA_HOME=/jdk-1.2.2
export PATH=${PATH}:${ANT_HOME}/bin

(2):Linux操作系统
编辑/etc/profile或者 用户目录下的.bashrc文件,加入下面三行

export ANT_HOME=/usr/local/ant
export JAVA_HOME=/usr/local/jdk-1.2.2
export PATH=${PATH}:${ANT_HOME}/bin

三:用ant管理项目
1:基本的文件目录结构 解压到任意目录,我们可以看到目录树结构如下
├─bin
├─docs
│ ├─ant2
│ ├─api
│ │ └─org
│ │ └─apache
│ │ └─tools
│ │ ├─ant
│ │ │ ├─taskdefs
│ │ │ │ ├─compilers
│ │ │ │ └─optional
│ │ │ │ ├─clearcase
│ │ │ │ ├─depend
│ │ │ │ │ └─constantpool
│ │ │ │ ├─dotnet
│ │ │ │ ├─ejb
│ │ │ │ ├─ide
│ │ │ │ ├─javacc
│ │ │ │ ├─jlink
│ │ │ │ ├─jsp
│ │ │ │ ├─junit
│ │ │ │ ├─metamata
│ │ │ │ ├─net
│ │ │ │ ├─perforce
│ │ │ │ ├─scm
│ │ │ │ ├─sound
│ │ │ │ └─vss
│ │ │ ├─types
│ │ │ └─util
│ │ │ └─regexp
│ │ ├─mail
│ │ └─tar
│ └─manual
│ ├─CoreTasks
│ ├─CoreTypes
│ ├─Integration
│ └─OptionalTasks
└─lib





在这个目录树结构中,与传统的项目不同的是,我们用build.xml取代了Makefile,在讲述这个build.xml文件前,我们先了解一个基本的 build.xml文件的结构。

2:build.xml的基本书写规范
下面我们就来讲述这个文件的书写方法,下面是这个文件的全部内容
1.
2.
3.
4.
5.
6.

7.





为 了方便说明,我们为每一行加了行号,第一行是xml文件的基本要素,第二行说明这是一个项目,第七行说明项目的结束 ,在第二行中,name="MyProject"说明此项目的名称,这个属性可有可无。basedir="."说明基本目录,此属性可有可无。 default="dist"说明项目的缺省目标(target)是什么,这个属性必须有。所谓目标(target)就是一系列任务(task)组成的一 个集合。每个任务(task)的书写方法如下:
<任务名 属性1="属性1的值" 属性2="属性2的值" ....... />




第 三行定义了一些属性(property),以便后面使用,这非常类似于编程中定义的全局变量。从第四行开始定义目标(target),name= "init"指明了此目标的名称,name属性在定义目标时必须有,当然定义目标时还有其他一些属性可选,例如depends,unless,具体请参考 ant的文档。第五行开始定义此目标内的任务,其中mkdir时ant的内部任务名,dir是此任务的属性,其值为${dist}。此任务就是创建一个目 录。其中${dist}是获取dist属性的值(就是我们在第三行定义的)。如上就是一个基本的build.xml文件的写法。你可以在命令行上输入 ant -buildfile build.xml

看一下你的当前目录下是否多了一个dist目录。如果出错,则可能是你没有把ant配置好,参见前面讲的安装及配置,看一下哪儿出了错。

3:build.xml文件
build.xml文件如下,其中有的注释和无关的代码删掉了,且做了一下小小的改动
1:
2:
3:
4:
5:
6:
7:
8:
9:
10:


11:
12:
13:
14:
15:
16:
17:
18:
19:

20:
21:
22:
23:

24:
25:

26:
27:
28:
29:
30:
31:
32:

33:
34:


35:
36:
37:
38:
39:
40:


41:
42:
43:
44:
45:
46:47:sourceout="${build.xmlc.dir}"
48:includes="**/*.html">
49:

50:
51:
52:
53:
54:
55:
56:
57:
58:

59:


60:
61:
62:
63:
64:

65:
66:67:destdir="${build.classes}"
68:classpathref="build.classpath"
69:debug="${build.debug}"/>

70:
71:72:destdir="${build.classes}"
73:classpathref="build.classpath"
74:debug="${build.debug}"
75:includes="${app.name}/**"
76:/>
77:


78:
79:
80:
81:
82:
83:
84:
85:
86:
87:
88:
89:

90:

91:



92:
93:
94:
95:
96:
97:
98:


99:
100:
101:
102:
103:
104:

105:
106:
107:108:tofile="${build.dir}/multiserver.conf"
109:filtering="on"/>

110:
111:
112:
113:


114:





4:build.xml详细说明
下 面我们将详细讲述这个文件,同样为了方便,我加了行号,当然一些基本的东西我就不再重复了。第四行taskdef任务(task)属于ant的内部任务, 它的作用是定义一个任务,其基本属性有name,classname,在定义时这两个属性都必需有。第八行开始定义一个path,它有一个属性id,通过 这个id的值我们可以在后面引用这个path,参见第68行。目标(target)init(从14行到34行)定义了一些基本属性 (property),主要是为了后面的target使用。在第38行,你会看到depends="init",depends是定义一个目标时的可选属 性,它的意思是如果init目标没有执行(出错或其他原因),这个目标也不会被执行。

从第46行开始定义xmlc任务,到第58行结束,中间有很多参数嵌套在其中,srcdir指定源文件目录,sourceout指定输出目录,includes属性将源文件目录中的所有html文件包括进来。*为通配符。

表示取消警告,表示同时产生接口和实现代码,例如:一个welcome.html,它会产生两个文件: WelcomeHTMLImpl.java,WelcomeHTML.java,WelcomeHTML.java中只定义了一个接口 WelcomeHTML,真正的实现在WelcomeHTMLImpl.java中。表示设置编码,由于xmlc将html文件编译为java类,即使你在html文件中已经设置了编码,在 java类中也不会有作用,必须在编译时设置编码。 这两句相当于在命令行上输入-ssi -keep.其中ssi参数是在编译html文件时将定义的ssi文件包括进来,见html目录下的welcome2.html源代码中有一行: Ant简介-jennyljd-ChinaUnix博客
  • 博客访问: 313295
  • 博文数量: 54
  • 博客积分: 1400
  • 博客等级: 上尉
  • 技术积分: 606
  • 用 户 组: 普通用户
  • 注册时间: 2006-12-03 22:43
文章分类
文章存档

2011年(3)

2010年(26)

2009年(2)

2008年(23)

我的朋友

分类:

2009-02-21 20:15:11

本文描述了ant的基本语法及其如何应用于项目的管理
-. Ant简介
可 能有许多读者并不了解什么是ant,以及如何使用它。但只要你是用过linux,你应该知道make为何物,当我们编译linux内核及一些软件的源程序 时,我们经常需要在控制台下输入make。Make其实就是一个项目管理工具,而ant所实现的功能与make差不多。Ant是apache软件基金会 jakarta项目中的一个子项目,由于是基于java编写的,因此具有很好的跨平台性。Ant由一些内置任务(task)和可选择的任务组成(当然你还 可以编写自己的任务),使用Make时,你需要写一个Makefile文件,而用ant时则需要写一个build.xml文件。由于采用xml的语法,所 以build.xml文件很容易书写和维护,且结构很清晰,而不像Makefile文件有那么多的限制(例如在tab符号前有一个空格的话,命令就不会执 行)。Ant的优点远不止这些,它还很容易的集成到一些开发环境中(例如visual age,jbuilder,netbeans)。

二.Ant的安装及配置
安装
Ant 目前的版本是1.3,首先到下载ant最新版本1.3,解压到C: /ant(window操作系统) 或者/usr/local/ant(linux操作系统),由于我们要用到xmlc ,而ant1.3中并没有包含它,所以我们需要David.Li为ant写的xmlc任务。具体url为http: //。将下载后的文件中的 ant.jar替换掉ant1.3中ant.jar.这样ant的版本变为1.2.

2.设置路径
(1):windows98操作系统
编辑C:\enhydra\.bashrc,加入下面三行

export ANT_HOME=/ant
export JAVA_HOME=/jdk-1.2.2
export PATH=${PATH}:${ANT_HOME}/bin

(2):Linux操作系统
编辑/etc/profile或者 用户目录下的.bashrc文件,加入下面三行

export ANT_HOME=/usr/local/ant
export JAVA_HOME=/usr/local/jdk-1.2.2
export PATH=${PATH}:${ANT_HOME}/bin

三:用ant管理项目
1:基本的文件目录结构 解压到任意目录,我们可以看到目录树结构如下
├─bin
├─docs
│ ├─ant2
│ ├─api
│ │ └─org
│ │ └─apache
│ │ └─tools
│ │ ├─ant
│ │ │ ├─taskdefs
│ │ │ │ ├─compilers
│ │ │ │ └─optional
│ │ │ │ ├─clearcase
│ │ │ │ ├─depend
│ │ │ │ │ └─constantpool
│ │ │ │ ├─dotnet
│ │ │ │ ├─ejb
│ │ │ │ ├─ide
│ │ │ │ ├─javacc
│ │ │ │ ├─jlink
│ │ │ │ ├─jsp
│ │ │ │ ├─junit
│ │ │ │ ├─metamata
│ │ │ │ ├─net
│ │ │ │ ├─perforce
│ │ │ │ ├─scm
│ │ │ │ ├─sound
│ │ │ │ └─vss
│ │ │ ├─types
│ │ │ └─util
│ │ │ └─regexp
│ │ ├─mail
│ │ └─tar
│ └─manual
│ ├─CoreTasks
│ ├─CoreTypes
│ ├─Integration
│ └─OptionalTasks
└─lib





在这个目录树结构中,与传统的项目不同的是,我们用build.xml取代了Makefile,在讲述这个build.xml文件前,我们先了解一个基本的 build.xml文件的结构。

2:build.xml的基本书写规范
下面我们就来讲述这个文件的书写方法,下面是这个文件的全部内容
1.
2.
3.
4.
5.
6.

7.





为 了方便说明,我们为每一行加了行号,第一行是xml文件的基本要素,第二行说明这是一个项目,第七行说明项目的结束 ,在第二行中,name="MyProject"说明此项目的名称,这个属性可有可无。basedir="."说明基本目录,此属性可有可无。 default="dist"说明项目的缺省目标(target)是什么,这个属性必须有。所谓目标(target)就是一系列任务(task)组成的一 个集合。每个任务(task)的书写方法如下:
<任务名 属性1="属性1的值" 属性2="属性2的值" ....... />




第 三行定义了一些属性(property),以便后面使用,这非常类似于编程中定义的全局变量。从第四行开始定义目标(target),name= "init"指明了此目标的名称,name属性在定义目标时必须有,当然定义目标时还有其他一些属性可选,例如depends,unless,具体请参考 ant的文档。第五行开始定义此目标内的任务,其中mkdir时ant的内部任务名,dir是此任务的属性,其值为${dist}。此任务就是创建一个目 录。其中${dist}是获取dist属性的值(就是我们在第三行定义的)。如上就是一个基本的build.xml文件的写法。你可以在命令行上输入 ant -buildfile build.xml

看一下你的当前目录下是否多了一个dist目录。如果出错,则可能是你没有把ant配置好,参见前面讲的安装及配置,看一下哪儿出了错。

3:build.xml文件
build.xml文件如下,其中有的注释和无关的代码删掉了,且做了一下小小的改动
1:
2:
3:
4:
5:
6:
7:
8:
9:
10:


11:
12:
13:
14:
15:
16:
17:
18:
19:

20:
21:
22:
23:

24:
25:

26:
27:
28:
29:
30:
31:
32:

33:
34:


35:
36:
37:
38:
39:
40:


41:
42:
43:
44:
45:
46:47:sourceout="${build.xmlc.dir}"
48:includes="**/*.html">
49:

50:
51:
52:
53:
54:
55:
56:
57:
58:

59:


60:
61:
62:
63:
64:

65:
66:67:destdir="${build.classes}"
68:classpathref="build.classpath"
69:debug="${build.debug}"/>

70:
71:72:destdir="${build.classes}"
73:classpathref="build.classpath"
74:debug="${build.debug}"
75:includes="${app.name}/**"
76:/>
77:


78:
79:
80:
81:
82:
83:
84:
85:
86:
87:
88:
89:

90:

91:



92:
93:
94:
95:
96:
97:
98:


99:
100:
101:
102:
103:
104:

105:
106:
107:108:tofile="${build.dir}/multiserver.conf"
109:filtering="on"/>

110:
111:
112:
113:


114:





4:build.xml详细说明
下 面我们将详细讲述这个文件,同样为了方便,我加了行号,当然一些基本的东西我就不再重复了。第四行taskdef任务(task)属于ant的内部任务, 它的作用是定义一个任务,其基本属性有name,classname,在定义时这两个属性都必需有。第八行开始定义一个path,它有一个属性id,通过 这个id的值我们可以在后面引用这个path,参见第68行。目标(target)init(从14行到34行)定义了一些基本属性 (property),主要是为了后面的target使用。在第38行,你会看到depends="init",depends是定义一个目标时的可选属 性,它的意思是如果init目标没有执行(出错或其他原因),这个目标也不会被执行。

从第46行开始定义xmlc任务,到第58行结束,中间有很多参数嵌套在其中,srcdir指定源文件目录,sourceout指定输出目录,includes属性将源文件目录中的所有html文件包括进来。*为通配符。

表示取消警告,表示同时产生接口和实现代码,例如:一个welcome.html,它会产生两个文件: WelcomeHTMLImpl.java,WelcomeHTML.java,WelcomeHTML.java中只定义了一个接口 WelcomeHTML,真正的实现在WelcomeHTMLImpl.java中。表示设置编码,由于xmlc将html文件编译为java类,即使你在html文件中已经设置了编码,在 java类中也不会有作用,必须在编译时设置编码。 这两句相当于在命令行上输入-ssi -keep.其中ssi参数是在编译html文件时将定义的ssi文件包括进来,见html目录下的welcome2.html源代码中有一行: Ant简介-jennyljd-ChinaUnix博客
  • 博客访问: 313296
  • 博文数量: 54
  • 博客积分: 1400
  • 博客等级: 上尉
  • 技术积分: 606
  • 用 户 组: 普通用户
  • 注册时间: 2006-12-03 22:43
文章分类
文章存档

2011年(3)

2010年(26)

2009年(2)

2008年(23)

我的朋友

分类:

2009-02-21 20:15:11

本文描述了ant的基本语法及其如何应用于项目的管理
-. Ant简介
可 能有许多读者并不了解什么是ant,以及如何使用它。但只要你是用过linux,你应该知道make为何物,当我们编译linux内核及一些软件的源程序 时,我们经常需要在控制台下输入make。Make其实就是一个项目管理工具,而ant所实现的功能与make差不多。Ant是apache软件基金会 jakarta项目中的一个子项目,由于是基于java编写的,因此具有很好的跨平台性。Ant由一些内置任务(task)和可选择的任务组成(当然你还 可以编写自己的任务),使用Make时,你需要写一个Makefile文件,而用ant时则需要写一个build.xml文件。由于采用xml的语法,所 以build.xml文件很容易书写和维护,且结构很清晰,而不像Makefile文件有那么多的限制(例如在tab符号前有一个空格的话,命令就不会执 行)。Ant的优点远不止这些,它还很容易的集成到一些开发环境中(例如visual age,jbuilder,netbeans)。

二.Ant的安装及配置
安装
Ant 目前的版本是1.3,首先到下载ant最新版本1.3,解压到C: /ant(window操作系统) 或者/usr/local/ant(linux操作系统),由于我们要用到xmlc ,而ant1.3中并没有包含它,所以我们需要David.Li为ant写的xmlc任务。具体url为http: //。将下载后的文件中的 ant.jar替换掉ant1.3中ant.jar.这样ant的版本变为1.2.

2.设置路径
(1):windows98操作系统
编辑C:\enhydra\.bashrc,加入下面三行

export ANT_HOME=/ant
export JAVA_HOME=/jdk-1.2.2
export PATH=${PATH}:${ANT_HOME}/bin

(2):Linux操作系统
编辑/etc/profile或者 用户目录下的.bashrc文件,加入下面三行

export ANT_HOME=/usr/local/ant
export JAVA_HOME=/usr/local/jdk-1.2.2
export PATH=${PATH}:${ANT_HOME}/bin

三:用ant管理项目
1:基本的文件目录结构 解压到任意目录,我们可以看到目录树结构如下
├─bin
├─docs
│ ├─ant2
│ ├─api
│ │ └─org
│ │ └─apache
│ │ └─tools
│ │ ├─ant
│ │ │ ├─taskdefs
│ │ │ │ ├─compilers
│ │ │ │ └─optional
│ │ │ │ ├─clearcase
│ │ │ │ ├─depend
│ │ │ │ │ └─constantpool
│ │ │ │ ├─dotnet
│ │ │ │ ├─ejb
│ │ │ │ ├─ide
│ │ │ │ ├─javacc
│ │ │ │ ├─jlink
│ │ │ │ ├─jsp
│ │ │ │ ├─junit
│ │ │ │ ├─metamata
│ │ │ │ ├─net
│ │ │ │ ├─perforce
│ │ │ │ ├─scm
│ │ │ │ ├─sound
│ │ │ │ └─vss
│ │ │ ├─types
│ │ │ └─util
│ │ │ └─regexp
│ │ ├─mail
│ │ └─tar
│ └─manual
│ ├─CoreTasks
│ ├─CoreTypes
│ ├─Integration
│ └─OptionalTasks
└─lib





在这个目录树结构中,与传统的项目不同的是,我们用build.xml取代了Makefile,在讲述这个build.xml文件前,我们先了解一个基本的 build.xml文件的结构。

2:build.xml的基本书写规范
下面我们就来讲述这个文件的书写方法,下面是这个文件的全部内容
1.
2.
3.
4.
5.
6.

7.





为 了方便说明,我们为每一行加了行号,第一行是xml文件的基本要素,第二行说明这是一个项目,第七行说明项目的结束 ,在第二行中,name="MyProject"说明此项目的名称,这个属性可有可无。basedir="."说明基本目录,此属性可有可无。 default="dist"说明项目的缺省目标(target)是什么,这个属性必须有。所谓目标(target)就是一系列任务(task)组成的一 个集合。每个任务(task)的书写方法如下:
<任务名 属性1="属性1的值" 属性2="属性2的值" ....... />




第 三行定义了一些属性(property),以便后面使用,这非常类似于编程中定义的全局变量。从第四行开始定义目标(target),name= "init"指明了此目标的名称,name属性在定义目标时必须有,当然定义目标时还有其他一些属性可选,例如depends,unless,具体请参考 ant的文档。第五行开始定义此目标内的任务,其中mkdir时ant的内部任务名,dir是此任务的属性,其值为${dist}。此任务就是创建一个目 录。其中${dist}是获取dist属性的值(就是我们在第三行定义的)。如上就是一个基本的build.xml文件的写法。你可以在命令行上输入 ant -buildfile build.xml

看一下你的当前目录下是否多了一个dist目录。如果出错,则可能是你没有把ant配置好,参见前面讲的安装及配置,看一下哪儿出了错。

3:build.xml文件
build.xml文件如下,其中有的注释和无关的代码删掉了,且做了一下小小的改动
1:
2:
3:
4:
5:
6:
7:
8:
9:
10:


11:
12:
13:
14:
15:
16:
17:
18:
19:

20:
21:
22:
23:

24:
25:

26:
27:
28:
29:
30:
31:
32:

33:
34:


35:
36:
37:
38:
39:
40:


41:
42:
43:
44:
45:
46:47:sourceout="${build.xmlc.dir}"
48:includes="**/*.html">
49:

50:
51:
52:
53:
54:
55:
56:
57:
58:

59:


60:
61:
62:
63:
64:

65:
66:67:destdir="${build.classes}"
68:classpathref="build.classpath"
69:debug="${build.debug}"/>

70:
71:72:destdir="${build.classes}"
73:classpathref="build.classpath"
74:debug="${build.debug}"
75:includes="${app.name}/**"
76:/>
77:


78:
79:
80:
81:
82:
83:
84:
85:
86:
87:
88:
89:

90:

91:



92:
93:
94:
95:
96:
97:
98:


99:
100:
101:
102:
103:
104:

105:
106:
107:108:tofile="${build.dir}/multiserver.conf"
109:filtering="on"/>

110:
111:
112:
113:


114:





4:build.xml详细说明
下 面我们将详细讲述这个文件,同样为了方便,我加了行号,当然一些基本的东西我就不再重复了。第四行taskdef任务(task)属于ant的内部任务, 它的作用是定义一个任务,其基本属性有name,classname,在定义时这两个属性都必需有。第八行开始定义一个path,它有一个属性id,通过 这个id的值我们可以在后面引用这个path,参见第68行。目标(target)init(从14行到34行)定义了一些基本属性 (property),主要是为了后面的target使用。在第38行,你会看到depends="init",depends是定义一个目标时的可选属 性,它的意思是如果init目标没有执行(出错或其他原因),这个目标也不会被执行。

从第46行开始定义xmlc任务,到第58行结束,中间有很多参数嵌套在其中,srcdir指定源文件目录,sourceout指定输出目录,includes属性将源文件目录中的所有html文件包括进来。*为通配符。

表示取消警告,表示同时产生接口和实现代码,例如:一个welcome.html,它会产生两个文件: WelcomeHTMLImpl.java,WelcomeHTML.java,WelcomeHTML.java中只定义了一个接口 WelcomeHTML,真正的实现在WelcomeHTMLImpl.java中。表示设置编码,由于xmlc将html文件编译为java类,即使你在html文件中已经设置了编码,在 java类中也不会有作用,必须在编译时设置编码。 这两句相当于在命令行上输入-ssi -keep.其中ssi参数是在编译html文件时将定义的ssi文件包括进来,见html目录下的welcome2.html源代码中有一行: Ant简介-jennyljd-ChinaUnix博客
  • 博客访问: 313297
  • 博文数量: 54
  • 博客积分: 1400
  • 博客等级: 上尉
  • 技术积分: 606
  • 用 户 组: 普通用户
  • 注册时间: 2006-12-03 22:43
文章分类
文章存档

2011年(3)

2010年(26)

2009年(2)

2008年(23)

我的朋友

分类:

2009-02-21 20:15:11

本文描述了ant的基本语法及其如何应用于项目的管理
-. Ant简介
可 能有许多读者并不了解什么是ant,以及如何使用它。但只要你是用过linux,你应该知道make为何物,当我们编译linux内核及一些软件的源程序 时,我们经常需要在控制台下输入make。Make其实就是一个项目管理工具,而ant所实现的功能与make差不多。Ant是apache软件基金会 jakarta项目中的一个子项目,由于是基于java编写的,因此具有很好的跨平台性。Ant由一些内置任务(task)和可选择的任务组成(当然你还 可以编写自己的任务),使用Make时,你需要写一个Makefile文件,而用ant时则需要写一个build.xml文件。由于采用xml的语法,所 以build.xml文件很容易书写和维护,且结构很清晰,而不像Makefile文件有那么多的限制(例如在tab符号前有一个空格的话,命令就不会执 行)。Ant的优点远不止这些,它还很容易的集成到一些开发环境中(例如visual age,jbuilder,netbeans)。

二.Ant的安装及配置
安装
Ant 目前的版本是1.3,首先到下载ant最新版本1.3,解压到C: /ant(window操作系统) 或者/usr/local/ant(linux操作系统),由于我们要用到xmlc ,而ant1.3中并没有包含它,所以我们需要David.Li为ant写的xmlc任务。具体url为http: //。将下载后的文件中的 ant.jar替换掉ant1.3中ant.jar.这样ant的版本变为1.2.

2.设置路径
(1):windows98操作系统
编辑C:\enhydra\.bashrc,加入下面三行

export ANT_HOME=/ant
export JAVA_HOME=/jdk-1.2.2
export PATH=${PATH}:${ANT_HOME}/bin

(2):Linux操作系统
编辑/etc/profile或者 用户目录下的.bashrc文件,加入下面三行

export ANT_HOME=/usr/local/ant
export JAVA_HOME=/usr/local/jdk-1.2.2
export PATH=${PATH}:${ANT_HOME}/bin

三:用ant管理项目
1:基本的文件目录结构 解压到任意目录,我们可以看到目录树结构如下
├─bin
├─docs
│ ├─ant2
│ ├─api
│ │ └─org
│ │ └─apache
│ │ └─tools
│ │ ├─ant
│ │ │ ├─taskdefs
│ │ │ │ ├─compilers
│ │ │ │ └─optional
│ │ │ │ ├─clearcase
│ │ │ │ ├─depend
│ │ │ │ │ └─constantpool
│ │ │ │ ├─dotnet
│ │ │ │ ├─ejb
│ │ │ │ ├─ide
│ │ │ │ ├─javacc
│ │ │ │ ├─jlink
│ │ │ │ ├─jsp
│ │ │ │ ├─junit
│ │ │ │ ├─metamata
│ │ │ │ ├─net
│ │ │ │ ├─perforce
│ │ │ │ ├─scm
│ │ │ │ ├─sound
│ │ │ │ └─vss
│ │ │ ├─types
│ │ │ └─util
│ │ │ └─regexp
│ │ ├─mail
│ │ └─tar
│ └─manual
│ ├─CoreTasks
│ ├─CoreTypes
│ ├─Integration
│ └─OptionalTasks
└─lib





在这个目录树结构中,与传统的项目不同的是,我们用build.xml取代了Makefile,在讲述这个build.xml文件前,我们先了解一个基本的 build.xml文件的结构。

2:build.xml的基本书写规范
下面我们就来讲述这个文件的书写方法,下面是这个文件的全部内容
1.
2.
3.
4.
5.
6.

7.





为 了方便说明,我们为每一行加了行号,第一行是xml文件的基本要素,第二行说明这是一个项目,第七行说明项目的结束 ,在第二行中,name="MyProject"说明此项目的名称,这个属性可有可无。basedir="."说明基本目录,此属性可有可无。 default="dist"说明项目的缺省目标(target)是什么,这个属性必须有。所谓目标(target)就是一系列任务(task)组成的一 个集合。每个任务(task)的书写方法如下:
<任务名 属性1="属性1的值" 属性2="属性2的值" ....... />




第 三行定义了一些属性(property),以便后面使用,这非常类似于编程中定义的全局变量。从第四行开始定义目标(target),name= "init"指明了此目标的名称,name属性在定义目标时必须有,当然定义目标时还有其他一些属性可选,例如depends,unless,具体请参考 ant的文档。第五行开始定义此目标内的任务,其中mkdir时ant的内部任务名,dir是此任务的属性,其值为${dist}。此任务就是创建一个目 录。其中${dist}是获取dist属性的值(就是我们在第三行定义的)。如上就是一个基本的build.xml文件的写法。你可以在命令行上输入 ant -buildfile build.xml

看一下你的当前目录下是否多了一个dist目录。如果出错,则可能是你没有把ant配置好,参见前面讲的安装及配置,看一下哪儿出了错。

3:build.xml文件
build.xml文件如下,其中有的注释和无关的代码删掉了,且做了一下小小的改动
1:
2:
3:
4:
5:
6:
7:
8:
9:
10:


11:
12:
13:
14:
15:
16:
17:
18:
19:

20:
21:
22:
23:

24:
25:

26:
27:
28:
29:
30:
31:
32:

33:
34:


35:
36:
37:
38:
39:
40:


41:
42:
43:
44:
45:
46:47:sourceout="${build.xmlc.dir}"
48:includes="**/*.html">
49:

50:
51:
52:
53:
54:
55:
56:
57:
58:

59:


60:
61:
62:
63:
64:

65:
66:67:destdir="${build.classes}"
68:classpathref="build.classpath"
69:debug="${build.debug}"/>

70:
71:72:destdir="${build.classes}"
73:classpathref="build.classpath"
74:debug="${build.debug}"
75:includes="${app.name}/**"
76:/>
77:


78:
79:
80:
81:
82:
83:
84:
85:
86:
87:
88:
89:

90:

91:



92:
93:
94:
95:
96:
97:
98:


99:
100:
101:
102:
103:
104:

105:
106:
107:108:tofile="${build.dir}/multiserver.conf"
109:filtering="on"/>

110:
111:
112:
113:


114:





4:build.xml详细说明
下 面我们将详细讲述这个文件,同样为了方便,我加了行号,当然一些基本的东西我就不再重复了。第四行taskdef任务(task)属于ant的内部任务, 它的作用是定义一个任务,其基本属性有name,classname,在定义时这两个属性都必需有。第八行开始定义一个path,它有一个属性id,通过 这个id的值我们可以在后面引用这个path,参见第68行。目标(target)init(从14行到34行)定义了一些基本属性 (property),主要是为了后面的target使用。在第38行,你会看到depends="init",depends是定义一个目标时的可选属 性,它的意思是如果init目标没有执行(出错或其他原因),这个目标也不会被执行。

从第46行开始定义xmlc任务,到第58行结束,中间有很多参数嵌套在其中,srcdir指定源文件目录,sourceout指定输出目录,includes属性将源文件目录中的所有html文件包括进来。*为通配符。

表示取消警告,表示同时产生接口和实现代码,例如:一个welcome.html,它会产生两个文件: WelcomeHTMLImpl.java,WelcomeHTML.java,WelcomeHTML.java中只定义了一个接口 WelcomeHTML,真正的实现在WelcomeHTMLImpl.java中。表示设置编码,由于xmlc将html文件编译为java类,即使你在html文件中已经设置了编码,在 java类中也不会有作用,必须在编译时设置编码。 这两句相当于在命令行上输入-ssi -keep.其中ssi参数是在编译html文件时将定义的ssi文件包括进来,见html目录下的welcome2.html源代码中有一行: Ant简介-jennyljd-ChinaUnix博客
  • 博客访问: 313298
  • 博文数量: 54
  • 博客积分: 1400
  • 博客等级: 上尉
  • 技术积分: 606
  • 用 户 组: 普通用户
  • 注册时间: 2006-12-03 22:43
文章分类
文章存档

2011年(3)

2010年(26)

2009年(2)

2008年(23)

我的朋友

分类:

2009-02-21 20:15:11

本文描述了ant的基本语法及其如何应用于项目的管理
-. Ant简介
可 能有许多读者并不了解什么是ant,以及如何使用它。但只要你是用过linux,你应该知道make为何物,当我们编译linux内核及一些软件的源程序 时,我们经常需要在控制台下输入make。Make其实就是一个项目管理工具,而ant所实现的功能与make差不多。Ant是apache软件基金会 jakarta项目中的一个子项目,由于是基于java编写的,因此具有很好的跨平台性。Ant由一些内置任务(task)和可选择的任务组成(当然你还 可以编写自己的任务),使用Make时,你需要写一个Makefile文件,而用ant时则需要写一个build.xml文件。由于采用xml的语法,所 以build.xml文件很容易书写和维护,且结构很清晰,而不像Makefile文件有那么多的限制(例如在tab符号前有一个空格的话,命令就不会执 行)。Ant的优点远不止这些,它还很容易的集成到一些开发环境中(例如visual age,jbuilder,netbeans)。

二.Ant的安装及配置
安装
Ant 目前的版本是1.3,首先到下载ant最新版本1.3,解压到C: /ant(window操作系统) 或者/usr/local/ant(linux操作系统),由于我们要用到xmlc ,而ant1.3中并没有包含它,所以我们需要David.Li为ant写的xmlc任务。具体url为http: //。将下载后的文件中的 ant.jar替换掉ant1.3中ant.jar.这样ant的版本变为1.2.

2.设置路径
(1):windows98操作系统
编辑C:\enhydra\.bashrc,加入下面三行

export ANT_HOME=/ant
export JAVA_HOME=/jdk-1.2.2
export PATH=${PATH}:${ANT_HOME}/bin

(2):Linux操作系统
编辑/etc/profile或者 用户目录下的.bashrc文件,加入下面三行

export ANT_HOME=/usr/local/ant
export JAVA_HOME=/usr/local/jdk-1.2.2
export PATH=${PATH}:${ANT_HOME}/bin

三:用ant管理项目
1:基本的文件目录结构 解压到任意目录,我们可以看到目录树结构如下
├─bin
├─docs
│ ├─ant2
│ ├─api
│ │ └─org
│ │ └─apache
│ │ └─tools
│ │ ├─ant
│ │ │ ├─taskdefs
│ │ │ │ ├─compilers
│ │ │ │ └─optional
│ │ │ │ ├─clearcase
│ │ │ │ ├─depend
│ │ │ │ │ └─constantpool
│ │ │ │ ├─dotnet
│ │ │ │ ├─ejb
│ │ │ │ ├─ide
│ │ │ │ ├─javacc
│ │ │ │ ├─jlink
│ │ │ │ ├─jsp
│ │ │ │ ├─junit
│ │ │ │ ├─metamata
│ │ │ │ ├─net
│ │ │ │ ├─perforce
│ │ │ │ ├─scm
│ │ │ │ ├─sound
│ │ │ │ └─vss
│ │ │ ├─types
│ │ │ └─util
│ │ │ └─regexp
│ │ ├─mail
│ │ └─tar
│ └─manual
│ ├─CoreTasks
│ ├─CoreTypes
│ ├─Integration
│ └─OptionalTasks
└─lib





在这个目录树结构中,与传统的项目不同的是,我们用build.xml取代了Makefile,在讲述这个build.xml文件前,我们先了解一个基本的 build.xml文件的结构。

2:build.xml的基本书写规范
下面我们就来讲述这个文件的书写方法,下面是这个文件的全部内容
1.
2.
3.
4.
5.
6.

7.





为 了方便说明,我们为每一行加了行号,第一行是xml文件的基本要素,第二行说明这是一个项目,第七行说明项目的结束 ,在第二行中,name="MyProject"说明此项目的名称,这个属性可有可无。basedir="."说明基本目录,此属性可有可无。 default="dist"说明项目的缺省目标(target)是什么,这个属性必须有。所谓目标(target)就是一系列任务(task)组成的一 个集合。每个任务(task)的书写方法如下:
<任务名 属性1="属性1的值" 属性2="属性2的值" ....... />




第 三行定义了一些属性(property),以便后面使用,这非常类似于编程中定义的全局变量。从第四行开始定义目标(target),name= "init"指明了此目标的名称,name属性在定义目标时必须有,当然定义目标时还有其他一些属性可选,例如depends,unless,具体请参考 ant的文档。第五行开始定义此目标内的任务,其中mkdir时ant的内部任务名,dir是此任务的属性,其值为${dist}。此任务就是创建一个目 录。其中${dist}是获取dist属性的值(就是我们在第三行定义的)。如上就是一个基本的build.xml文件的写法。你可以在命令行上输入 ant -buildfile build.xml

看一下你的当前目录下是否多了一个dist目录。如果出错,则可能是你没有把ant配置好,参见前面讲的安装及配置,看一下哪儿出了错。

3:build.xml文件
build.xml文件如下,其中有的注释和无关的代码删掉了,且做了一下小小的改动
1:
2:
3:
4:
5:
6:
7:
8:
9:
10:


11:
12:
13:
14:
15:
16:
17:
18:
19:

20:
21:
22:
23:

24:
25:

26:
27:
28:
29:
30:
31:
32:

33:
34:


35:
36:
37:
38:
39:
40:


41:
42:
43:
44:
45:
46:47:sourceout="${build.xmlc.dir}"
48:includes="**/*.html">
49:

50:
51:
52:
53:
54:
55:
56:
57:
58:

59:


60:
61:
62:
63:
64:

65:
66:67:destdir="${build.classes}"
68:classpathref="build.classpath"
69:debug="${build.debug}"/>

70:
71:72:destdir="${build.classes}"
73:classpathref="build.classpath"
74:debug="${build.debug}"
75:includes="${app.name}/**"
76:/>
77:


78:
79:
80:
81:
82:
83:
84:
85:
86:
87:
88:
89:

90:

91:



92:
93:
94:
95:
96:
97:
98:


99:
100:
101:
102:
103:
104:

105:
106:
107:108:tofile="${build.dir}/multiserver.conf"
109:filtering="on"/>

110:
111:
112:
113:


114:





4:build.xml详细说明
下 面我们将详细讲述这个文件,同样为了方便,我加了行号,当然一些基本的东西我就不再重复了。第四行taskdef任务(task)属于ant的内部任务, 它的作用是定义一个任务,其基本属性有name,classname,在定义时这两个属性都必需有。第八行开始定义一个path,它有一个属性id,通过 这个id的值我们可以在后面引用这个path,参见第68行。目标(target)init(从14行到34行)定义了一些基本属性 (property),主要是为了后面的target使用。在第38行,你会看到depends="init",depends是定义一个目标时的可选属 性,它的意思是如果init目标没有执行(出错或其他原因),这个目标也不会被执行。

从第46行开始定义xmlc任务,到第58行结束,中间有很多参数嵌套在其中,srcdir指定源文件目录,sourceout指定输出目录,includes属性将源文件目录中的所有html文件包括进来。*为通配符。

表示取消警告,表示同时产生接口和实现代码,例如:一个welcome.html,它会产生两个文件: WelcomeHTMLImpl.java,WelcomeHTML.java,WelcomeHTML.java中只定义了一个接口 WelcomeHTML,真正的实现在WelcomeHTMLImpl.java中。表示设置编码,由于xmlc将html文件编译为java类,即使你在html文件中已经设置了编码,在 java类中也不会有作用,必须在编译时设置编码。 这两句相当于在命令行上输入-ssi -keep.其中ssi参数是在编译html文件时将定义的ssi文件包括进来,见html目录下的welcome2.html源代码中有一行: Ant简介-jennyljd-ChinaUnix博客
  • 博客访问: 313289
  • 博文数量: 54
  • 博客积分: 1400
  • 博客等级: 上尉
  • 技术积分: 606
  • 用 户 组: 普通用户
  • 注册时间: 2006-12-03 22:43
文章分类
文章存档

2011年(3)

2010年(26)

2009年(2)

2008年(23)

我的朋友

分类:

2009-02-21 20:15:11

本文描述了ant的基本语法及其如何应用于项目的管理
-. Ant简介
可 能有许多读者并不了解什么是ant,以及如何使用它。但只要你是用过linux,你应该知道make为何物,当我们编译linux内核及一些软件的源程序 时,我们经常需要在控制台下输入make。Make其实就是一个项目管理工具,而ant所实现的功能与make差不多。Ant是apache软件基金会 jakarta项目中的一个子项目,由于是基于java编写的,因此具有很好的跨平台性。Ant由一些内置任务(task)和可选择的任务组成(当然你还 可以编写自己的任务),使用Make时,你需要写一个Makefile文件,而用ant时则需要写一个build.xml文件。由于采用xml的语法,所 以build.xml文件很容易书写和维护,且结构很清晰,而不像Makefile文件有那么多的限制(例如在tab符号前有一个空格的话,命令就不会执 行)。Ant的优点远不止这些,它还很容易的集成到一些开发环境中(例如visual age,jbuilder,netbeans)。

二.Ant的安装及配置
安装
Ant 目前的版本是1.3,首先到下载ant最新版本1.3,解压到C: /ant(window操作系统) 或者/usr/local/ant(linux操作系统),由于我们要用到xmlc ,而ant1.3中并没有包含它,所以我们需要David.Li为ant写的xmlc任务。具体url为http: //。将下载后的文件中的 ant.jar替换掉ant1.3中ant.jar.这样ant的版本变为1.2.

2.设置路径
(1):windows98操作系统
编辑C:\enhydra\.bashrc,加入下面三行

export ANT_HOME=/ant
export JAVA_HOME=/jdk-1.2.2
export PATH=${PATH}:${ANT_HOME}/bin

(2):Linux操作系统
编辑/etc/profile或者 用户目录下的.bashrc文件,加入下面三行

export ANT_HOME=/usr/local/ant
export JAVA_HOME=/usr/local/jdk-1.2.2
export PATH=${PATH}:${ANT_HOME}/bin

三:用ant管理项目
1:基本的文件目录结构 解压到任意目录,我们可以看到目录树结构如下
├─bin
├─docs
│ ├─ant2
│ ├─api
│ │ └─org
│ │ └─apache
│ │ └─tools
│ │ ├─ant
│ │ │ ├─taskdefs
│ │ │ │ ├─compilers
│ │ │ │ └─optional
│ │ │ │ ├─clearcase
│ │ │ │ ├─depend
│ │ │ │ │ └─constantpool
│ │ │ │ ├─dotnet
│ │ │ │ ├─ejb
│ │ │ │ ├─ide
│ │ │ │ ├─javacc
│ │ │ │ ├─jlink
│ │ │ │ ├─jsp
│ │ │ │ ├─junit
│ │ │ │ ├─metamata
│ │ │ │ ├─net
│ │ │ │ ├─perforce
│ │ │ │ ├─scm
│ │ │ │ ├─sound
│ │ │ │ └─vss
│ │ │ ├─types
│ │ │ └─util
│ │ │ └─regexp
│ │ ├─mail
│ │ └─tar
│ └─manual
│ ├─CoreTasks
│ ├─CoreTypes
│ ├─Integration
│ └─OptionalTasks
└─lib





在这个目录树结构中,与传统的项目不同的是,我们用build.xml取代了Makefile,在讲述这个build.xml文件前,我们先了解一个基本的 build.xml文件的结构。

2:build.xml的基本书写规范
下面我们就来讲述这个文件的书写方法,下面是这个文件的全部内容
1.
2.
3.
4.
5.
6.

7.





为 了方便说明,我们为每一行加了行号,第一行是xml文件的基本要素,第二行说明这是一个项目,第七行说明项目的结束 ,在第二行中,name="MyProject"说明此项目的名称,这个属性可有可无。basedir="."说明基本目录,此属性可有可无。 default="dist"说明项目的缺省目标(target)是什么,这个属性必须有。所谓目标(target)就是一系列任务(task)组成的一 个集合。每个任务(task)的书写方法如下:
<任务名 属性1="属性1的值" 属性2="属性2的值" ....... />




第 三行定义了一些属性(property),以便后面使用,这非常类似于编程中定义的全局变量。从第四行开始定义目标(target),name= "init"指明了此目标的名称,name属性在定义目标时必须有,当然定义目标时还有其他一些属性可选,例如depends,unless,具体请参考 ant的文档。第五行开始定义此目标内的任务,其中mkdir时ant的内部任务名,dir是此任务的属性,其值为${dist}。此任务就是创建一个目 录。其中${dist}是获取dist属性的值(就是我们在第三行定义的)。如上就是一个基本的build.xml文件的写法。你可以在命令行上输入 ant -buildfile build.xml

看一下你的当前目录下是否多了一个dist目录。如果出错,则可能是你没有把ant配置好,参见前面讲的安装及配置,看一下哪儿出了错。

3:build.xml文件
build.xml文件如下,其中有的注释和无关的代码删掉了,且做了一下小小的改动
1:
2:
3:
4:
5:
6:
7:
8:
9:
10:


11:
12:
13:
14:
15:
16:
17:
18:
19:

20:
21:
22:
23:

24:
25:

26:
27:
28:
29:
30:
31:
32:

33:
34:


35:
36:
37:
38:
39:
40:


41:
42:
43:
44:
45:
46:47:sourceout="${build.xmlc.dir}"
48:includes="**/*.html">
49:

50:
51:
52:
53:
54:
55:
56:
57:
58:

59:


60:
61:
62:
63:
64:

65:
66:67:destdir="${build.classes}"
68:classpathref="build.classpath"
69:debug="${build.debug}"/>

70:
71:72:destdir="${build.classes}"
73:classpathref="build.classpath"
74:debug="${build.debug}"
75:includes="${app.name}/**"
76:/>
77:


78:
79:
80:
81:
82:
83:
84:
85:
86:
87:
88:
89:

90:

91:



92:
93:
94:
95:
96:
97:
98:


99:
100:
101:
102:
103:
104:

105:
106:
107:108:tofile="${build.dir}/multiserver.conf"
109:filtering="on"/>

110:
111:
112:
113:


114:





4:build.xml详细说明
下 面我们将详细讲述这个文件,同样为了方便,我加了行号,当然一些基本的东西我就不再重复了。第四行taskdef任务(task)属于ant的内部任务, 它的作用是定义一个任务,其基本属性有name,classname,在定义时这两个属性都必需有。第八行开始定义一个path,它有一个属性id,通过 这个id的值我们可以在后面引用这个path,参见第68行。目标(target)init(从14行到34行)定义了一些基本属性 (property),主要是为了后面的target使用。在第38行,你会看到depends="init",depends是定义一个目标时的可选属 性,它的意思是如果init目标没有执行(出错或其他原因),这个目标也不会被执行。

从第46行开始定义xmlc任务,到第58行结束,中间有很多参数嵌套在其中,srcdir指定源文件目录,sourceout指定输出目录,includes属性将源文件目录中的所有html文件包括进来。*为通配符。

表示取消警告,表示同时产生接口和实现代码,例如:一个welcome.html,它会产生两个文件: WelcomeHTMLImpl.java,WelcomeHTML.java,WelcomeHTML.java中只定义了一个接口 WelcomeHTML,真正的实现在WelcomeHTMLImpl.java中。表示设置编码,由于xmlc将html文件编译为java类,即使你在html文件中已经设置了编码,在 java类中也不会有作用,必须在编译时设置编码。 这两句相当于在命令行上输入-ssi -keep.其中ssi参数是在编译html文件时将定义的ssi文件包括进来,见html目录下的welcome2.html源代码中有一行: Ant简介-jennyljd-ChinaUnix博客
  • 博客访问: 313300
  • 博文数量: 54
  • 博客积分: 1400
  • 博客等级: 上尉
  • 技术积分: 606
  • 用 户 组: 普通用户
  • 注册时间: 2006-12-03 22:43
文章分类
文章存档

2011年(3)

2010年(26)

2009年(2)

2008年(23)

我的朋友

分类:

2009-02-21 20:15:11

本文描述了ant的基本语法及其如何应用于项目的管理
-. Ant简介
可 能有许多读者并不了解什么是ant,以及如何使用它。但只要你是用过linux,你应该知道make为何物,当我们编译linux内核及一些软件的源程序 时,我们经常需要在控制台下输入make。Make其实就是一个项目管理工具,而ant所实现的功能与make差不多。Ant是apache软件基金会 jakarta项目中的一个子项目,由于是基于java编写的,因此具有很好的跨平台性。Ant由一些内置任务(task)和可选择的任务组成(当然你还 可以编写自己的任务),使用Make时,你需要写一个Makefile文件,而用ant时则需要写一个build.xml文件。由于采用xml的语法,所 以build.xml文件很容易书写和维护,且结构很清晰,而不像Makefile文件有那么多的限制(例如在tab符号前有一个空格的话,命令就不会执 行)。Ant的优点远不止这些,它还很容易的集成到一些开发环境中(例如visual age,jbuilder,netbeans)。

二.Ant的安装及配置
安装
Ant 目前的版本是1.3,首先到下载ant最新版本1.3,解压到C: /ant(window操作系统) 或者/usr/local/ant(linux操作系统),由于我们要用到xmlc ,而ant1.3中并没有包含它,所以我们需要David.Li为ant写的xmlc任务。具体url为http: //。将下载后的文件中的 ant.jar替换掉ant1.3中ant.jar.这样ant的版本变为1.2.

2.设置路径
(1):windows98操作系统
编辑C:\enhydra\.bashrc,加入下面三行

export ANT_HOME=/ant
export JAVA_HOME=/jdk-1.2.2
export PATH=${PATH}:${ANT_HOME}/bin

(2):Linux操作系统
编辑/etc/profile或者 用户目录下的.bashrc文件,加入下面三行

export ANT_HOME=/usr/local/ant
export JAVA_HOME=/usr/local/jdk-1.2.2
export PATH=${PATH}:${ANT_HOME}/bin

三:用ant管理项目
1:基本的文件目录结构 解压到任意目录,我们可以看到目录树结构如下
├─bin
├─docs
│ ├─ant2
│ ├─api
│ │ └─org
│ │ └─apache
│ │ └─tools
│ │ ├─ant
│ │ │ ├─taskdefs
│ │ │ │ ├─compilers
│ │ │ │ └─optional
│ │ │ │ ├─clearcase
│ │ │ │ ├─depend
│ │ │ │ │ └─constantpool
│ │ │ │ ├─dotnet
│ │ │ │ ├─ejb
│ │ │ │ ├─ide
│ │ │ │ ├─javacc
│ │ │ │ ├─jlink
│ │ │ │ ├─jsp
│ │ │ │ ├─junit
│ │ │ │ ├─metamata
│ │ │ │ ├─net
│ │ │ │ ├─perforce
│ │ │ │ ├─scm
│ │ │ │ ├─sound
│ │ │ │ └─vss
│ │ │ ├─types
│ │ │ └─util
│ │ │ └─regexp
│ │ ├─mail
│ │ └─tar
│ └─manual
│ ├─CoreTasks
│ ├─CoreTypes
│ ├─Integration
│ └─OptionalTasks
└─lib





在这个目录树结构中,与传统的项目不同的是,我们用build.xml取代了Makefile,在讲述这个build.xml文件前,我们先了解一个基本的 build.xml文件的结构。

2:build.xml的基本书写规范
下面我们就来讲述这个文件的书写方法,下面是这个文件的全部内容
1.
2.
3.
4.
5.
6.

7.





为 了方便说明,我们为每一行加了行号,第一行是xml文件的基本要素,第二行说明这是一个项目,第七行说明项目的结束 ,在第二行中,name="MyProject"说明此项目的名称,这个属性可有可无。basedir="."说明基本目录,此属性可有可无。 default="dist"说明项目的缺省目标(target)是什么,这个属性必须有。所谓目标(target)就是一系列任务(task)组成的一 个集合。每个任务(task)的书写方法如下:
<任务名 属性1="属性1的值" 属性2="属性2的值" ....... />




第 三行定义了一些属性(property),以便后面使用,这非常类似于编程中定义的全局变量。从第四行开始定义目标(target),name= "init"指明了此目标的名称,name属性在定义目标时必须有,当然定义目标时还有其他一些属性可选,例如depends,unless,具体请参考 ant的文档。第五行开始定义此目标内的任务,其中mkdir时ant的内部任务名,dir是此任务的属性,其值为${dist}。此任务就是创建一个目 录。其中${dist}是获取dist属性的值(就是我们在第三行定义的)。如上就是一个基本的build.xml文件的写法。你可以在命令行上输入 ant -buildfile build.xml

看一下你的当前目录下是否多了一个dist目录。如果出错,则可能是你没有把ant配置好,参见前面讲的安装及配置,看一下哪儿出了错。

3:build.xml文件
build.xml文件如下,其中有的注释和无关的代码删掉了,且做了一下小小的改动
1:
2:
3:
4:
5:
6:
7:
8:
9:
10:


11:
12:
13:
14:
15:
16:
17:
18:
19:

20:
21:
22:
23:

24:
25:

26:
27:
28:
29:
30:
31:
32:

33:
34:


35:
36:
37:
38:
39:
40:


41:
42:
43:
44:
45:
46:47:sourceout="${build.xmlc.dir}"
48:includes="**/*.html">
49:

50:
51:
52:
53:
54:
55:
56:
57:
58:

59:


60:
61:
62:
63:
64:

65:
66:67:destdir="${build.classes}"
68:classpathref="build.classpath"
69:debug="${build.debug}"/>

70:
71:72:destdir="${build.classes}"
73:classpathref="build.classpath"
74:debug="${build.debug}"
75:includes="${app.name}/**"
76:/>
77:


78:
79:
80:
81:
82:
83:
84:
85:
86:
87:
88:
89:

90:

91:



92:
93:
94:
95:
96:
97:
98:


99:
100:
101:
102:
103:
104:

105:
106:
107:108:tofile="${build.dir}/multiserver.conf"
109:filtering="on"/>

110:
111:
112:
113:


114:





4:build.xml详细说明
下 面我们将详细讲述这个文件,同样为了方便,我加了行号,当然一些基本的东西我就不再重复了。第四行taskdef任务(task)属于ant的内部任务, 它的作用是定义一个任务,其基本属性有name,classname,在定义时这两个属性都必需有。第八行开始定义一个path,它有一个属性id,通过 这个id的值我们可以在后面引用这个path,参见第68行。目标(target)init(从14行到34行)定义了一些基本属性 (property),主要是为了后面的target使用。在第38行,你会看到depends="init",depends是定义一个目标时的可选属 性,它的意思是如果init目标没有执行(出错或其他原因),这个目标也不会被执行。

从第46行开始定义xmlc任务,到第58行结束,中间有很多参数嵌套在其中,srcdir指定源文件目录,sourceout指定输出目录,includes属性将源文件目录中的所有html文件包括进来。*为通配符。

表示取消警告,表示同时产生接口和实现代码,例如:一个welcome.html,它会产生两个文件: WelcomeHTMLImpl.java,WelcomeHTML.java,WelcomeHTML.java中只定义了一个接口 WelcomeHTML,真正的实现在WelcomeHTMLImpl.java中。表示设置编码,由于xmlc将html文件编译为java类,即使你在html文件中已经设置了编码,在 java类中也不会有作用,必须在编译时设置编码。 这两句相当于在命令行上输入-ssi -keep.其中ssi参数是在编译html文件时将定义的ssi文件包括进来,见html目录下的welcome2.html源代码中有一行: Ant简介-jennyljd-ChinaUnix博客
  • 博客访问: 313301
  • 博文数量: 54
  • 博客积分: 1400
  • 博客等级: 上尉
  • 技术积分: 606
  • 用 户 组: 普通用户
  • 注册时间: 2006-12-03 22:43
文章分类
文章存档

2011年(3)

2010年(26)

2009年(2)

2008年(23)

我的朋友

分类:

2009-02-21 20:15:11

本文描述了ant的基本语法及其如何应用于项目的管理
-. Ant简介
可 能有许多读者并不了解什么是ant,以及如何使用它。但只要你是用过linux,你应该知道make为何物,当我们编译linux内核及一些软件的源程序 时,我们经常需要在控制台下输入make。Make其实就是一个项目管理工具,而ant所实现的功能与make差不多。Ant是apache软件基金会 jakarta项目中的一个子项目,由于是基于java编写的,因此具有很好的跨平台性。Ant由一些内置任务(task)和可选择的任务组成(当然你还 可以编写自己的任务),使用Make时,你需要写一个Makefile文件,而用ant时则需要写一个build.xml文件。由于采用xml的语法,所 以build.xml文件很容易书写和维护,且结构很清晰,而不像Makefile文件有那么多的限制(例如在tab符号前有一个空格的话,命令就不会执 行)。Ant的优点远不止这些,它还很容易的集成到一些开发环境中(例如visual age,jbuilder,netbeans)。

二.Ant的安装及配置
安装
Ant 目前的版本是1.3,首先到下载ant最新版本1.3,解压到C: /ant(window操作系统) 或者/usr/local/ant(linux操作系统),由于我们要用到xmlc ,而ant1.3中并没有包含它,所以我们需要David.Li为ant写的xmlc任务。具体url为http: //。将下载后的文件中的 ant.jar替换掉ant1.3中ant.jar.这样ant的版本变为1.2.

2.设置路径
(1):windows98操作系统
编辑C:\enhydra\.bashrc,加入下面三行

export ANT_HOME=/ant
export JAVA_HOME=/jdk-1.2.2
export PATH=${PATH}:${ANT_HOME}/bin

(2):Linux操作系统
编辑/etc/profile或者 用户目录下的.bashrc文件,加入下面三行

export ANT_HOME=/usr/local/ant
export JAVA_HOME=/usr/local/jdk-1.2.2
export PATH=${PATH}:${ANT_HOME}/bin

三:用ant管理项目
1:基本的文件目录结构 解压到任意目录,我们可以看到目录树结构如下
├─bin
├─docs
│ ├─ant2
│ ├─api
│ │ └─org
│ │ └─apache
│ │ └─tools
│ │ ├─ant
│ │ │ ├─taskdefs
│ │ │ │ ├─compilers
│ │ │ │ └─optional
│ │ │ │ ├─clearcase
│ │ │ │ ├─depend
│ │ │ │ │ └─constantpool
│ │ │ │ ├─dotnet
│ │ │ │ ├─ejb
│ │ │ │ ├─ide
│ │ │ │ ├─javacc
│ │ │ │ ├─jlink
│ │ │ │ ├─jsp
│ │ │ │ ├─junit
│ │ │ │ ├─metamata
│ │ │ │ ├─net
│ │ │ │ ├─perforce
│ │ │ │ ├─scm
│ │ │ │ ├─sound
│ │ │ │ └─vss
│ │ │ ├─types
│ │ │ └─util
│ │ │ └─regexp
│ │ ├─mail
│ │ └─tar
│ └─manual
│ ├─CoreTasks
│ ├─CoreTypes
│ ├─Integration
│ └─OptionalTasks
└─lib





在这个目录树结构中,与传统的项目不同的是,我们用build.xml取代了Makefile,在讲述这个build.xml文件前,我们先了解一个基本的 build.xml文件的结构。

2:build.xml的基本书写规范
下面我们就来讲述这个文件的书写方法,下面是这个文件的全部内容
1.
2.
3.
4.
5.
6.

7.





为 了方便说明,我们为每一行加了行号,第一行是xml文件的基本要素,第二行说明这是一个项目,第七行说明项目的结束 ,在第二行中,name="MyProject"说明此项目的名称,这个属性可有可无。basedir="."说明基本目录,此属性可有可无。 default="dist"说明项目的缺省目标(target)是什么,这个属性必须有。所谓目标(target)就是一系列任务(task)组成的一 个集合。每个任务(task)的书写方法如下:
<任务名 属性1="属性1的值" 属性2="属性2的值" ....... />




第 三行定义了一些属性(property),以便后面使用,这非常类似于编程中定义的全局变量。从第四行开始定义目标(target),name= "init"指明了此目标的名称,name属性在定义目标时必须有,当然定义目标时还有其他一些属性可选,例如depends,unless,具体请参考 ant的文档。第五行开始定义此目标内的任务,其中mkdir时ant的内部任务名,dir是此任务的属性,其值为${dist}。此任务就是创建一个目 录。其中${dist}是获取dist属性的值(就是我们在第三行定义的)。如上就是一个基本的build.xml文件的写法。你可以在命令行上输入 ant -buildfile build.xml

看一下你的当前目录下是否多了一个dist目录。如果出错,则可能是你没有把ant配置好,参见前面讲的安装及配置,看一下哪儿出了错。

3:build.xml文件
build.xml文件如下,其中有的注释和无关的代码删掉了,且做了一下小小的改动
1:
2:
3:
4:
5:
6:
7:
8:
9:
10:


11:
12:
13:
14:
15:
16:
17:
18:
19:

20:
21:
22:
23:

24:
25:

26:
27:
28:
29:
30:
31:
32:

33:
34:


35:
36:
37:
38:
39:
40:


41:
42:
43:
44:
45:
46:47:sourceout="${build.xmlc.dir}"
48:includes="**/*.html">
49:

50:
51:
52:
53:
54:
55:
56:
57:
58:

59:


60:
61:
62:
63:
64:

65:
66:67:destdir="${build.classes}"
68:classpathref="build.classpath"
69:debug="${build.debug}"/>

70:
71:72:destdir="${build.classes}"
73:classpathref="build.classpath"
74:debug="${build.debug}"
75:includes="${app.name}/**"
76:/>
77:


78:
79:
80:
81:
82:
83:
84:
85:
86:
87:
88:
89:

90:

91:



92:
93:
94:
95:
96:
97:
98:


99:
100:
101:
102:
103:
104:

105:
106:
107:108:tofile="${build.dir}/multiserver.conf"
109:filtering="on"/>

110:
111:
112:
113:


114:





4:build.xml详细说明
下 面我们将详细讲述这个文件,同样为了方便,我加了行号,当然一些基本的东西我就不再重复了。第四行taskdef任务(task)属于ant的内部任务, 它的作用是定义一个任务,其基本属性有name,classname,在定义时这两个属性都必需有。第八行开始定义一个path,它有一个属性id,通过 这个id的值我们可以在后面引用这个path,参见第68行。目标(target)init(从14行到34行)定义了一些基本属性 (property),主要是为了后面的target使用。在第38行,你会看到depends="init",depends是定义一个目标时的可选属 性,它的意思是如果init目标没有执行(出错或其他原因),这个目标也不会被执行。

从第46行开始定义xmlc任务,到第58行结束,中间有很多参数嵌套在其中,srcdir指定源文件目录,sourceout指定输出目录,includes属性将源文件目录中的所有html文件包括进来。*为通配符。

表示取消警告,表示同时产生接口和实现代码,例如:一个welcome.html,它会产生两个文件: WelcomeHTMLImpl.java,WelcomeHTML.java,WelcomeHTML.java中只定义了一个接口 WelcomeHTML,真正的实现在WelcomeHTMLImpl.java中。表示设置编码,由于xmlc将html文件编译为java类,即使你在html文件中已经设置了编码,在 java类中也不会有作用,必须在编译时设置编码。 这两句相当于在命令行上输入-ssi -keep.其中ssi参数是在编译html文件时将定义的ssi文件包括进来,见html目录下的welcome2.html源代码中有一行: Ant简介-jennyljd-ChinaUnix博客
  • 博客访问: 313302
  • 博文数量: 54
  • 博客积分: 1400
  • 博客等级: 上尉
  • 技术积分: 606
  • 用 户 组: 普通用户
  • 注册时间: 2006-12-03 22:43
文章分类
文章存档

2011年(3)

2010年(26)

2009年(2)

2008年(23)

我的朋友

分类:

2009-02-21 20:15:11

本文描述了ant的基本语法及其如何应用于项目的管理
-. Ant简介
可 能有许多读者并不了解什么是ant,以及如何使用它。但只要你是用过linux,你应该知道make为何物,当我们编译linux内核及一些软件的源程序 时,我们经常需要在控制台下输入make。Make其实就是一个项目管理工具,而ant所实现的功能与make差不多。Ant是apache软件基金会 jakarta项目中的一个子项目,由于是基于java编写的,因此具有很好的跨平台性。Ant由一些内置任务(task)和可选择的任务组成(当然你还 可以编写自己的任务),使用Make时,你需要写一个Makefile文件,而用ant时则需要写一个build.xml文件。由于采用xml的语法,所 以build.xml文件很容易书写和维护,且结构很清晰,而不像Makefile文件有那么多的限制(例如在tab符号前有一个空格的话,命令就不会执 行)。Ant的优点远不止这些,它还很容易的集成到一些开发环境中(例如visual age,jbuilder,netbeans)。

二.Ant的安装及配置
安装
Ant 目前的版本是1.3,首先到下载ant最新版本1.3,解压到C: /ant(window操作系统) 或者/usr/local/ant(linux操作系统),由于我们要用到xmlc ,而ant1.3中并没有包含它,所以我们需要David.Li为ant写的xmlc任务。具体url为http: //。将下载后的文件中的 ant.jar替换掉ant1.3中ant.jar.这样ant的版本变为1.2.

2.设置路径
(1):windows98操作系统
编辑C:\enhydra\.bashrc,加入下面三行

export ANT_HOME=/ant
export JAVA_HOME=/jdk-1.2.2
export PATH=${PATH}:${ANT_HOME}/bin

(2):Linux操作系统
编辑/etc/profile或者 用户目录下的.bashrc文件,加入下面三行

export ANT_HOME=/usr/local/ant
export JAVA_HOME=/usr/local/jdk-1.2.2
export PATH=${PATH}:${ANT_HOME}/bin

三:用ant管理项目
1:基本的文件目录结构 解压到任意目录,我们可以看到目录树结构如下
├─bin
├─docs
│ ├─ant2
│ ├─api
│ │ └─org
│ │ └─apache
│ │ └─tools
│ │ ├─ant
│ │ │ ├─taskdefs
│ │ │ │ ├─compilers
│ │ │ │ └─optional
│ │ │ │ ├─clearcase
│ │ │ │ ├─depend
│ │ │ │ │ └─constantpool
│ │ │ │ ├─dotnet
│ │ │ │ ├─ejb
│ │ │ │ ├─ide
│ │ │ │ ├─javacc
│ │ │ │ ├─jlink
│ │ │ │ ├─jsp
│ │ │ │ ├─junit
│ │ │ │ ├─metamata
│ │ │ │ ├─net
│ │ │ │ ├─perforce
│ │ │ │ ├─scm
│ │ │ │ ├─sound
│ │ │ │ └─vss
│ │ │ ├─types
│ │ │ └─util
│ │ │ └─regexp
│ │ ├─mail
│ │ └─tar
│ └─manual
│ ├─CoreTasks
│ ├─CoreTypes
│ ├─Integration
│ └─OptionalTasks
└─lib





在这个目录树结构中,与传统的项目不同的是,我们用build.xml取代了Makefile,在讲述这个build.xml文件前,我们先了解一个基本的 build.xml文件的结构。

2:build.xml的基本书写规范
下面我们就来讲述这个文件的书写方法,下面是这个文件的全部内容
1.
2.
3.
4.
5.
6.

7.





为 了方便说明,我们为每一行加了行号,第一行是xml文件的基本要素,第二行说明这是一个项目,第七行说明项目的结束 ,在第二行中,name="MyProject"说明此项目的名称,这个属性可有可无。basedir="."说明基本目录,此属性可有可无。 default="dist"说明项目的缺省目标(target)是什么,这个属性必须有。所谓目标(target)就是一系列任务(task)组成的一 个集合。每个任务(task)的书写方法如下:
<任务名 属性1="属性1的值" 属性2="属性2的值" ....... />




第 三行定义了一些属性(property),以便后面使用,这非常类似于编程中定义的全局变量。从第四行开始定义目标(target),name= "init"指明了此目标的名称,name属性在定义目标时必须有,当然定义目标时还有其他一些属性可选,例如depends,unless,具体请参考 ant的文档。第五行开始定义此目标内的任务,其中mkdir时ant的内部任务名,dir是此任务的属性,其值为${dist}。此任务就是创建一个目 录。其中${dist}是获取dist属性的值(就是我们在第三行定义的)。如上就是一个基本的build.xml文件的写法。你可以在命令行上输入 ant -buildfile build.xml

看一下你的当前目录下是否多了一个dist目录。如果出错,则可能是你没有把ant配置好,参见前面讲的安装及配置,看一下哪儿出了错。

3:build.xml文件
build.xml文件如下,其中有的注释和无关的代码删掉了,且做了一下小小的改动
1:
2:
3:
4:
5:
6:
7:
8:
9:
10:


11:
12:
13:
14:
15:
16:
17:
18:
19:

20:
21:
22:
23:

24:
25:

26:
27:
28:
29:
30:
31:
32:

33:
34:


35:
36:
37:
38:
39:
40:


41:
42:
43:
44:
45:
46:47:sourceout="${build.xmlc.dir}"
48:includes="**/*.html">
49:

50:
51:
52:
53:
54:
55:
56:
57:
58:

59:


60:
61:
62:
63:
64:

65:
66:67:destdir="${build.classes}"
68:classpathref="build.classpath"
69:debug="${build.debug}"/>

70:
71:72:destdir="${build.classes}"
73:classpathref="build.classpath"
74:debug="${build.debug}"
75:includes="${app.name}/**"
76:/>
77:


78:
79:
80:
81:
82:
83:
84:
85:
86:
87:
88:
89:

90:

91:



92:
93:
94:
95:
96:
97:
98:


99:
100:
101:
102:
103:
104:

105:
106:
107:108:tofile="${build.dir}/multiserver.conf"
109:filtering="on"/>

110:
111:
112:
113:


114:





4:build.xml详细说明
下 面我们将详细讲述这个文件,同样为了方便,我加了行号,当然一些基本的东西我就不再重复了。第四行taskdef任务(task)属于ant的内部任务, 它的作用是定义一个任务,其基本属性有name,classname,在定义时这两个属性都必需有。第八行开始定义一个path,它有一个属性id,通过 这个id的值我们可以在后面引用这个path,参见第68行。目标(target)init(从14行到34行)定义了一些基本属性 (property),主要是为了后面的target使用。在第38行,你会看到depends="init",depends是定义一个目标时的可选属 性,它的意思是如果init目标没有执行(出错或其他原因),这个目标也不会被执行。

从第46行开始定义xmlc任务,到第58行结束,中间有很多参数嵌套在其中,srcdir指定源文件目录,sourceout指定输出目录,includes属性将源文件目录中的所有html文件包括进来。*为通配符。

表示取消警告,表示同时产生接口和实现代码,例如:一个welcome.html,它会产生两个文件: WelcomeHTMLImpl.java,WelcomeHTML.java,WelcomeHTML.java中只定义了一个接口 WelcomeHTML,真正的实现在WelcomeHTMLImpl.java中。表示设置编码,由于xmlc将html文件编译为java类,即使你在html文件中已经设置了编码,在 java类中也不会有作用,必须在编译时设置编码。 这两句相当于在命令行上输入-ssi -keep.其中ssi参数是在编译html文件时将定义的ssi文件包括进来,见html目录下的welcome2.html源代码中有一行: Ant简介-jennyljd-ChinaUnix博客
  • 博客访问: 313303
  • 博文数量: 54
  • 博客积分: 1400
  • 博客等级: 上尉
  • 技术积分: 606
  • 用 户 组: 普通用户
  • 注册时间: 2006-12-03 22:43
文章分类
文章存档

2011年(3)

2010年(26)

2009年(2)

2008年(23)

我的朋友

分类:

2009-02-21 20:15:11

本文描述了ant的基本语法及其如何应用于项目的管理
-. Ant简介
可 能有许多读者并不了解什么是ant,以及如何使用它。但只要你是用过linux,你应该知道make为何物,当我们编译linux内核及一些软件的源程序 时,我们经常需要在控制台下输入make。Make其实就是一个项目管理工具,而ant所实现的功能与make差不多。Ant是apache软件基金会 jakarta项目中的一个子项目,由于是基于java编写的,因此具有很好的跨平台性。Ant由一些内置任务(task)和可选择的任务组成(当然你还 可以编写自己的任务),使用Make时,你需要写一个Makefile文件,而用ant时则需要写一个build.xml文件。由于采用xml的语法,所 以build.xml文件很容易书写和维护,且结构很清晰,而不像Makefile文件有那么多的限制(例如在tab符号前有一个空格的话,命令就不会执 行)。Ant的优点远不止这些,它还很容易的集成到一些开发环境中(例如visual age,jbuilder,netbeans)。

二.Ant的安装及配置
安装
Ant 目前的版本是1.3,首先到下载ant最新版本1.3,解压到C: /ant(window操作系统) 或者/usr/local/ant(linux操作系统),由于我们要用到xmlc ,而ant1.3中并没有包含它,所以我们需要David.Li为ant写的xmlc任务。具体url为http: //。将下载后的文件中的 ant.jar替换掉ant1.3中ant.jar.这样ant的版本变为1.2.

2.设置路径
(1):windows98操作系统
编辑C:\enhydra\.bashrc,加入下面三行

export ANT_HOME=/ant
export JAVA_HOME=/jdk-1.2.2
export PATH=${PATH}:${ANT_HOME}/bin

(2):Linux操作系统
编辑/etc/profile或者 用户目录下的.bashrc文件,加入下面三行

export ANT_HOME=/usr/local/ant
export JAVA_HOME=/usr/local/jdk-1.2.2
export PATH=${PATH}:${ANT_HOME}/bin

三:用ant管理项目
1:基本的文件目录结构 解压到任意目录,我们可以看到目录树结构如下
├─bin
├─docs
│ ├─ant2
│ ├─api
│ │ └─org
│ │ └─apache
│ │ └─tools
│ │ ├─ant
│ │ │ ├─taskdefs
│ │ │ │ ├─compilers
│ │ │ │ └─optional
│ │ │ │ ├─clearcase
│ │ │ │ ├─depend
│ │ │ │ │ └─constantpool
│ │ │ │ ├─dotnet
│ │ │ │ ├─ejb
│ │ │ │ ├─ide
│ │ │ │ ├─javacc
│ │ │ │ ├─jlink
│ │ │ │ ├─jsp
│ │ │ │ ├─junit
│ │ │ │ ├─metamata
│ │ │ │ ├─net
│ │ │ │ ├─perforce
│ │ │ │ ├─scm
│ │ │ │ ├─sound
│ │ │ │ └─vss
│ │ │ ├─types
│ │ │ └─util
│ │ │ └─regexp
│ │ ├─mail
│ │ └─tar
│ └─manual
│ ├─CoreTasks
│ ├─CoreTypes
│ ├─Integration
│ └─OptionalTasks
└─lib





在这个目录树结构中,与传统的项目不同的是,我们用build.xml取代了Makefile,在讲述这个build.xml文件前,我们先了解一个基本的 build.xml文件的结构。

2:build.xml的基本书写规范
下面我们就来讲述这个文件的书写方法,下面是这个文件的全部内容
1.
2.
3.
4.
5.
6.

7.





为 了方便说明,我们为每一行加了行号,第一行是xml文件的基本要素,第二行说明这是一个项目,第七行说明项目的结束 ,在第二行中,name="MyProject"说明此项目的名称,这个属性可有可无。basedir="."说明基本目录,此属性可有可无。 default="dist"说明项目的缺省目标(target)是什么,这个属性必须有。所谓目标(target)就是一系列任务(task)组成的一 个集合。每个任务(task)的书写方法如下:
<任务名 属性1="属性1的值" 属性2="属性2的值" ....... />




第 三行定义了一些属性(property),以便后面使用,这非常类似于编程中定义的全局变量。从第四行开始定义目标(target),name= "init"指明了此目标的名称,name属性在定义目标时必须有,当然定义目标时还有其他一些属性可选,例如depends,unless,具体请参考 ant的文档。第五行开始定义此目标内的任务,其中mkdir时ant的内部任务名,dir是此任务的属性,其值为${dist}。此任务就是创建一个目 录。其中${dist}是获取dist属性的值(就是我们在第三行定义的)。如上就是一个基本的build.xml文件的写法。你可以在命令行上输入 ant -buildfile build.xml

看一下你的当前目录下是否多了一个dist目录。如果出错,则可能是你没有把ant配置好,参见前面讲的安装及配置,看一下哪儿出了错。

3:build.xml文件
build.xml文件如下,其中有的注释和无关的代码删掉了,且做了一下小小的改动
1:
2:
3:
4:
5:
6:
7:
8:
9:
10:


11:
12:
13:
14:
15:
16:
17:
18:
19:

20:
21:
22:
23:

24:
25:

26:
27:
28:
29:
30:
31:
32:

33:
34:


35:
36:
37:
38:
39:
40:


41:
42:
43:
44:
45:
46:47:sourceout="${build.xmlc.dir}"
48:includes="**/*.html">
49:

50:
51:
52:
53:
54:
55:
56:
57:
58:

59:


60:
61:
62:
63:
64:

65:
66:67:destdir="${build.classes}"
68:classpathref="build.classpath"
69:debug="${build.debug}"/>

70:
71:72:destdir="${build.classes}"
73:classpathref="build.classpath"
74:debug="${build.debug}"
75:includes="${app.name}/**"
76:/>
77:


78:
79:
80:
81:
82:
83:
84:
85:
86:
87:
88:
89:

90:

91:



92:
93:
94:
95:
96:
97:
98:


99:
100:
101:
102:
103:
104:

105:
106:
107:108:tofile="${build.dir}/multiserver.conf"
109:filtering="on"/>

110:
111:
112:
113:


114:





4:build.xml详细说明
下 面我们将详细讲述这个文件,同样为了方便,我加了行号,当然一些基本的东西我就不再重复了。第四行taskdef任务(task)属于ant的内部任务, 它的作用是定义一个任务,其基本属性有name,classname,在定义时这两个属性都必需有。第八行开始定义一个path,它有一个属性id,通过 这个id的值我们可以在后面引用这个path,参见第68行。目标(target)init(从14行到34行)定义了一些基本属性 (property),主要是为了后面的target使用。在第38行,你会看到depends="init",depends是定义一个目标时的可选属 性,它的意思是如果init目标没有执行(出错或其他原因),这个目标也不会被执行。

从第46行开始定义xmlc任务,到第58行结束,中间有很多参数嵌套在其中,srcdir指定源文件目录,sourceout指定输出目录,includes属性将源文件目录中的所有html文件包括进来。*为通配符。

表示取消警告,表示同时产生接口和实现代码,例如:一个welcome.html,它会产生两个文件: WelcomeHTMLImpl.java,WelcomeHTML.java,WelcomeHTML.java中只定义了一个接口 WelcomeHTML,真正的实现在WelcomeHTMLImpl.java中。表示设置编码,由于xmlc将html文件编译为java类,即使你在html文件中已经设置了编码,在 java类中也不会有作用,必须在编译时设置编码。 这两句相当于在命令行上输入-ssi -keep.其中ssi参数是在编译html文件时将定义的ssi文件包括进来,见html目录下的welcome2.html源代码中有一行: Ant简介-jennyljd-ChinaUnix博客
  • 博客访问: 313304
  • 博文数量: 54
  • 博客积分: 1400
  • 博客等级: 上尉
  • 技术积分: 606
  • 用 户 组: 普通用户
  • 注册时间: 2006-12-03 22:43
文章分类
文章存档

2011年(3)

2010年(26)

2009年(2)

2008年(23)

我的朋友

分类:

2009-02-21 20:15:11

本文描述了ant的基本语法及其如何应用于项目的管理
-. Ant简介
可 能有许多读者并不了解什么是ant,以及如何使用它。但只要你是用过linux,你应该知道make为何物,当我们编译linux内核及一些软件的源程序 时,我们经常需要在控制台下输入make。Make其实就是一个项目管理工具,而ant所实现的功能与make差不多。Ant是apache软件基金会 jakarta项目中的一个子项目,由于是基于java编写的,因此具有很好的跨平台性。Ant由一些内置任务(task)和可选择的任务组成(当然你还 可以编写自己的任务),使用Make时,你需要写一个Makefile文件,而用ant时则需要写一个build.xml文件。由于采用xml的语法,所 以build.xml文件很容易书写和维护,且结构很清晰,而不像Makefile文件有那么多的限制(例如在tab符号前有一个空格的话,命令就不会执 行)。Ant的优点远不止这些,它还很容易的集成到一些开发环境中(例如visual age,jbuilder,netbeans)。

二.Ant的安装及配置
安装
Ant 目前的版本是1.3,首先到下载ant最新版本1.3,解压到C: /ant(window操作系统) 或者/usr/local/ant(linux操作系统),由于我们要用到xmlc ,而ant1.3中并没有包含它,所以我们需要David.Li为ant写的xmlc任务。具体url为http: //。将下载后的文件中的 ant.jar替换掉ant1.3中ant.jar.这样ant的版本变为1.2.

2.设置路径
(1):windows98操作系统
编辑C:\enhydra\.bashrc,加入下面三行

export ANT_HOME=/ant
export JAVA_HOME=/jdk-1.2.2
export PATH=${PATH}:${ANT_HOME}/bin

(2):Linux操作系统
编辑/etc/profile或者 用户目录下的.bashrc文件,加入下面三行

export ANT_HOME=/usr/local/ant
export JAVA_HOME=/usr/local/jdk-1.2.2
export PATH=${PATH}:${ANT_HOME}/bin

三:用ant管理项目
1:基本的文件目录结构 解压到任意目录,我们可以看到目录树结构如下
├─bin
├─docs
│ ├─ant2
│ ├─api
│ │ └─org
│ │ └─apache
│ │ └─tools
│ │ ├─ant
│ │ │ ├─taskdefs
│ │ │ │ ├─compilers
│ │ │ │ └─optional
│ │ │ │ ├─clearcase
│ │ │ │ ├─depend
│ │ │ │ │ └─constantpool
│ │ │ │ ├─dotnet
│ │ │ │ ├─ejb
│ │ │ │ ├─ide
│ │ │ │ ├─javacc
│ │ │ │ ├─jlink
│ │ │ │ ├─jsp
│ │ │ │ ├─junit
│ │ │ │ ├─metamata
│ │ │ │ ├─net
│ │ │ │ ├─perforce
│ │ │ │ ├─scm
│ │ │ │ ├─sound
│ │ │ │ └─vss
│ │ │ ├─types
│ │ │ └─util
│ │ │ └─regexp
│ │ ├─mail
│ │ └─tar
│ └─manual
│ ├─CoreTasks
│ ├─CoreTypes
│ ├─Integration
│ └─OptionalTasks
└─lib





在这个目录树结构中,与传统的项目不同的是,我们用build.xml取代了Makefile,在讲述这个build.xml文件前,我们先了解一个基本的 build.xml文件的结构。

2:build.xml的基本书写规范
下面我们就来讲述这个文件的书写方法,下面是这个文件的全部内容
1.
2.
3.
4.
5.
6.

7.





为 了方便说明,我们为每一行加了行号,第一行是xml文件的基本要素,第二行说明这是一个项目,第七行说明项目的结束 ,在第二行中,name="MyProject"说明此项目的名称,这个属性可有可无。basedir="."说明基本目录,此属性可有可无。 default="dist"说明项目的缺省目标(target)是什么,这个属性必须有。所谓目标(target)就是一系列任务(task)组成的一 个集合。每个任务(task)的书写方法如下:
<任务名 属性1="属性1的值" 属性2="属性2的值" ....... />




第 三行定义了一些属性(property),以便后面使用,这非常类似于编程中定义的全局变量。从第四行开始定义目标(target),name= "init"指明了此目标的名称,name属性在定义目标时必须有,当然定义目标时还有其他一些属性可选,例如depends,unless,具体请参考 ant的文档。第五行开始定义此目标内的任务,其中mkdir时ant的内部任务名,dir是此任务的属性,其值为${dist}。此任务就是创建一个目 录。其中${dist}是获取dist属性的值(就是我们在第三行定义的)。如上就是一个基本的build.xml文件的写法。你可以在命令行上输入 ant -buildfile build.xml

看一下你的当前目录下是否多了一个dist目录。如果出错,则可能是你没有把ant配置好,参见前面讲的安装及配置,看一下哪儿出了错。

3:build.xml文件
build.xml文件如下,其中有的注释和无关的代码删掉了,且做了一下小小的改动
1:
2:
3:
4:
5:
6:
7:
8:
9:
10:


11:
12:
13:
14:
15:
16:
17:
18:
19:

20:
21:
22:
23:

24:
25:

26:
27:
28:
29:
30:
31:
32:

33:
34:


35:
36:
37:
38:
39:
40:


41:
42:
43:
44:
45:
46:47:sourceout="${build.xmlc.dir}"
48:includes="**/*.html">
49:

50:
51:
52:
53:
54:
55:
56:
57:
58:

59:


60:
61:
62:
63:
64:

65:
66:67:destdir="${build.classes}"
68:classpathref="build.classpath"
69:debug="${build.debug}"/>

70:
71:72:destdir="${build.classes}"
73:classpathref="build.classpath"
74:debug="${build.debug}"
75:includes="${app.name}/**"
76:/>
77:


78:
79:
80:
81:
82:
83:
84:
85:
86:
87:
88:
89:

90:

91:



92:
93:
94:
95:
96:
97:
98:


99:
100:
101:
102:
103:
104:

105:
106:
107:108:tofile="${build.dir}/multiserver.conf"
109:filtering="on"/>

110:
111:
112:
113:


114:





4:build.xml详细说明
下 面我们将详细讲述这个文件,同样为了方便,我加了行号,当然一些基本的东西我就不再重复了。第四行taskdef任务(task)属于ant的内部任务, 它的作用是定义一个任务,其基本属性有name,classname,在定义时这两个属性都必需有。第八行开始定义一个path,它有一个属性id,通过 这个id的值我们可以在后面引用这个path,参见第68行。目标(target)init(从14行到34行)定义了一些基本属性 (property),主要是为了后面的target使用。在第38行,你会看到depends="init",depends是定义一个目标时的可选属 性,它的意思是如果init目标没有执行(出错或其他原因),这个目标也不会被执行。

从第46行开始定义xmlc任务,到第58行结束,中间有很多参数嵌套在其中,srcdir指定源文件目录,sourceout指定输出目录,includes属性将源文件目录中的所有html文件包括进来。*为通配符。

表示取消警告,表示同时产生接口和实现代码,例如:一个welcome.html,它会产生两个文件: WelcomeHTMLImpl.java,WelcomeHTML.java,WelcomeHTML.java中只定义了一个接口 WelcomeHTML,真正的实现在WelcomeHTMLImpl.java中。表示设置编码,由于xmlc将html文件编译为java类,即使你在html文件中已经设置了编码,在 java类中也不会有作用,必须在编译时设置编码。 这两句相当于在命令行上输入-ssi -keep.其中ssi参数是在编译html文件时将定义的ssi文件包括进来,见html目录下的welcome2.html源代码中有一行: Ant简介-jennyljd-ChinaUnix博客
  • 博客访问: 313305
  • 博文数量: 54
  • 博客积分: 1400
  • 博客等级: 上尉
  • 技术积分: 606
  • 用 户 组: 普通用户
  • 注册时间: 2006-12-03 22:43
文章分类
文章存档

2011年(3)

2010年(26)

2009年(2)

2008年(23)

我的朋友

分类:

2009-02-21 20:15:11

本文描述了ant的基本语法及其如何应用于项目的管理
-. Ant简介
可 能有许多读者并不了解什么是ant,以及如何使用它。但只要你是用过linux,你应该知道make为何物,当我们编译linux内核及一些软件的源程序 时,我们经常需要在控制台下输入make。Make其实就是一个项目管理工具,而ant所实现的功能与make差不多。Ant是apache软件基金会 jakarta项目中的一个子项目,由于是基于java编写的,因此具有很好的跨平台性。Ant由一些内置任务(task)和可选择的任务组成(当然你还 可以编写自己的任务),使用Make时,你需要写一个Makefile文件,而用ant时则需要写一个build.xml文件。由于采用xml的语法,所 以build.xml文件很容易书写和维护,且结构很清晰,而不像Makefile文件有那么多的限制(例如在tab符号前有一个空格的话,命令就不会执 行)。Ant的优点远不止这些,它还很容易的集成到一些开发环境中(例如visual age,jbuilder,netbeans)。

二.Ant的安装及配置
安装
Ant 目前的版本是1.3,首先到下载ant最新版本1.3,解压到C: /ant(window操作系统) 或者/usr/local/ant(linux操作系统),由于我们要用到xmlc ,而ant1.3中并没有包含它,所以我们需要David.Li为ant写的xmlc任务。具体url为http: //。将下载后的文件中的 ant.jar替换掉ant1.3中ant.jar.这样ant的版本变为1.2.

2.设置路径
(1):windows98操作系统
编辑C:\enhydra\.bashrc,加入下面三行

export ANT_HOME=/ant
export JAVA_HOME=/jdk-1.2.2
export PATH=${PATH}:${ANT_HOME}/bin

(2):Linux操作系统
编辑/etc/profile或者 用户目录下的.bashrc文件,加入下面三行

export ANT_HOME=/usr/local/ant
export JAVA_HOME=/usr/local/jdk-1.2.2
export PATH=${PATH}:${ANT_HOME}/bin

三:用ant管理项目
1:基本的文件目录结构 解压到任意目录,我们可以看到目录树结构如下
├─bin
├─docs
│ ├─ant2
│ ├─api
│ │ └─org
│ │ └─apache
│ │ └─tools
│ │ ├─ant
│ │ │ ├─taskdefs
│ │ │ │ ├─compilers
│ │ │ │ └─optional
│ │ │ │ ├─clearcase
│ │ │ │ ├─depend
│ │ │ │ │ └─constantpool
│ │ │ │ ├─dotnet
│ │ │ │ ├─ejb
│ │ │ │ ├─ide
│ │ │ │ ├─javacc
│ │ │ │ ├─jlink
│ │ │ │ ├─jsp
│ │ │ │ ├─junit
│ │ │ │ ├─metamata
│ │ │ │ ├─net
│ │ │ │ ├─perforce
│ │ │ │ ├─scm
│ │ │ │ ├─sound
│ │ │ │ └─vss
│ │ │ ├─types
│ │ │ └─util
│ │ │ └─regexp
│ │ ├─mail
│ │ └─tar
│ └─manual
│ ├─CoreTasks
│ ├─CoreTypes
│ ├─Integration
│ └─OptionalTasks
└─lib





在这个目录树结构中,与传统的项目不同的是,我们用build.xml取代了Makefile,在讲述这个build.xml文件前,我们先了解一个基本的 build.xml文件的结构。

2:build.xml的基本书写规范
下面我们就来讲述这个文件的书写方法,下面是这个文件的全部内容
1.
2.
3.
4.
5.
6.

7.





为 了方便说明,我们为每一行加了行号,第一行是xml文件的基本要素,第二行说明这是一个项目,第七行说明项目的结束 ,在第二行中,name="MyProject"说明此项目的名称,这个属性可有可无。basedir="."说明基本目录,此属性可有可无。 default="dist"说明项目的缺省目标(target)是什么,这个属性必须有。所谓目标(target)就是一系列任务(task)组成的一 个集合。每个任务(task)的书写方法如下:
<任务名 属性1="属性1的值" 属性2="属性2的值" ....... />




第 三行定义了一些属性(property),以便后面使用,这非常类似于编程中定义的全局变量。从第四行开始定义目标(target),name= "init"指明了此目标的名称,name属性在定义目标时必须有,当然定义目标时还有其他一些属性可选,例如depends,unless,具体请参考 ant的文档。第五行开始定义此目标内的任务,其中mkdir时ant的内部任务名,dir是此任务的属性,其值为${dist}。此任务就是创建一个目 录。其中${dist}是获取dist属性的值(就是我们在第三行定义的)。如上就是一个基本的build.xml文件的写法。你可以在命令行上输入 ant -buildfile build.xml

看一下你的当前目录下是否多了一个dist目录。如果出错,则可能是你没有把ant配置好,参见前面讲的安装及配置,看一下哪儿出了错。

3:build.xml文件
build.xml文件如下,其中有的注释和无关的代码删掉了,且做了一下小小的改动
1:
2:
3:
4:
5:
6:
7:
8:
9:
10:


11:
12:
13:
14:
15:
16:
17:
18:
19:

20:
21:
22:
23:

24:
25:

26:
27:
28:
29:
30:
31:
32:

33:
34:


35:
36:
37:
38:
39:
40:


41:
42:
43:
44:
45:
46:47:sourceout="${build.xmlc.dir}"
48:includes="**/*.html">
49:

50:
51:
52:
53:
54:
55:
56:
57:
58:

59:


60:
61:
62:
63:
64:

65:
66:67:destdir="${build.classes}"
68:classpathref="build.classpath"
69:debug="${build.debug}"/>

70:
71:72:destdir="${build.classes}"
73:classpathref="build.classpath"
74:debug="${build.debug}"
75:includes="${app.name}/**"
76:/>
77:


78:
79:
80:
81:
82:
83:
84:
85:
86:
87:
88:
89:

90:

91:



92:
93:
94:
95:
96:
97:
98:


99:
100:
101:
102:
103:
104:

105:
106:
107:108:tofile="${build.dir}/multiserver.conf"
109:filtering="on"/>

110:
111:
112:
113:


114:





4:build.xml详细说明
下 面我们将详细讲述这个文件,同样为了方便,我加了行号,当然一些基本的东西我就不再重复了。第四行taskdef任务(task)属于ant的内部任务, 它的作用是定义一个任务,其基本属性有name,classname,在定义时这两个属性都必需有。第八行开始定义一个path,它有一个属性id,通过 这个id的值我们可以在后面引用这个path,参见第68行。目标(target)init(从14行到34行)定义了一些基本属性 (property),主要是为了后面的target使用。在第38行,你会看到depends="init",depends是定义一个目标时的可选属 性,它的意思是如果init目标没有执行(出错或其他原因),这个目标也不会被执行。

从第46行开始定义xmlc任务,到第58行结束,中间有很多参数嵌套在其中,srcdir指定源文件目录,sourceout指定输出目录,includes属性将源文件目录中的所有html文件包括进来。*为通配符。

表示取消警告,表示同时产生接口和实现代码,例如:一个welcome.html,它会产生两个文件: WelcomeHTMLImpl.java,WelcomeHTML.java,WelcomeHTML.java中只定义了一个接口 WelcomeHTML,真正的实现在WelcomeHTMLImpl.java中。表示设置编码,由于xmlc将html文件编译为java类,即使你在html文件中已经设置了编码,在 java类中也不会有作用,必须在编译时设置编码。 这两句相当于在命令行上输入-ssi -keep.其中ssi参数是在编译html文件时将定义的ssi文件包括进来,见html目录下的welcome2.html源代码中有一行: Ant简介-jennyljd-ChinaUnix博客
  • 博客访问: 313306
  • 博文数量: 54
  • 博客积分: 1400
  • 博客等级: 上尉
  • 技术积分: 606
  • 用 户 组: 普通用户
  • 注册时间: 2006-12-03 22:43
文章分类
文章存档

2011年(3)

2010年(26)

2009年(2)

2008年(23)

我的朋友

分类:

2009-02-21 20:15:11

本文描述了ant的基本语法及其如何应用于项目的管理
-. Ant简介
可 能有许多读者并不了解什么是ant,以及如何使用它。但只要你是用过linux,你应该知道make为何物,当我们编译linux内核及一些软件的源程序 时,我们经常需要在控制台下输入make。Make其实就是一个项目管理工具,而ant所实现的功能与make差不多。Ant是apache软件基金会 jakarta项目中的一个子项目,由于是基于java编写的,因此具有很好的跨平台性。Ant由一些内置任务(task)和可选择的任务组成(当然你还 可以编写自己的任务),使用Make时,你需要写一个Makefile文件,而用ant时则需要写一个build.xml文件。由于采用xml的语法,所 以build.xml文件很容易书写和维护,且结构很清晰,而不像Makefile文件有那么多的限制(例如在tab符号前有一个空格的话,命令就不会执 行)。Ant的优点远不止这些,它还很容易的集成到一些开发环境中(例如visual age,jbuilder,netbeans)。

二.Ant的安装及配置
安装
Ant 目前的版本是1.3,首先到下载ant最新版本1.3,解压到C: /ant(window操作系统) 或者/usr/local/ant(linux操作系统),由于我们要用到xmlc ,而ant1.3中并没有包含它,所以我们需要David.Li为ant写的xmlc任务。具体url为http: //。将下载后的文件中的 ant.jar替换掉ant1.3中ant.jar.这样ant的版本变为1.2.

2.设置路径
(1):windows98操作系统
编辑C:\enhydra\.bashrc,加入下面三行

export ANT_HOME=/ant
export JAVA_HOME=/jdk-1.2.2
export PATH=${PATH}:${ANT_HOME}/bin

(2):Linux操作系统
编辑/etc/profile或者 用户目录下的.bashrc文件,加入下面三行

export ANT_HOME=/usr/local/ant
export JAVA_HOME=/usr/local/jdk-1.2.2
export PATH=${PATH}:${ANT_HOME}/bin

三:用ant管理项目
1:基本的文件目录结构 解压到任意目录,我们可以看到目录树结构如下
├─bin
├─docs
│ ├─ant2
│ ├─api
│ │ └─org
│ │ └─apache
│ │ └─tools
│ │ ├─ant
│ │ │ ├─taskdefs
│ │ │ │ ├─compilers
│ │ │ │ └─optional
│ │ │ │ ├─clearcase
│ │ │ │ ├─depend
│ │ │ │ │ └─constantpool
│ │ │ │ ├─dotnet
│ │ │ │ ├─ejb
│ │ │ │ ├─ide
│ │ │ │ ├─javacc
│ │ │ │ ├─jlink
│ │ │ │ ├─jsp
│ │ │ │ ├─junit
│ │ │ │ ├─metamata
│ │ │ │ ├─net
│ │ │ │ ├─perforce
│ │ │ │ ├─scm
│ │ │ │ ├─sound
│ │ │ │ └─vss
│ │ │ ├─types
│ │ │ └─util
│ │ │ └─regexp
│ │ ├─mail
│ │ └─tar
│ └─manual
│ ├─CoreTasks
│ ├─CoreTypes
│ ├─Integration
│ └─OptionalTasks
└─lib





在这个目录树结构中,与传统的项目不同的是,我们用build.xml取代了Makefile,在讲述这个build.xml文件前,我们先了解一个基本的 build.xml文件的结构。

2:build.xml的基本书写规范
下面我们就来讲述这个文件的书写方法,下面是这个文件的全部内容
1.
2.
3.
4.
5.
6.

7.





为 了方便说明,我们为每一行加了行号,第一行是xml文件的基本要素,第二行说明这是一个项目,第七行说明项目的结束 ,在第二行中,name="MyProject"说明此项目的名称,这个属性可有可无。basedir="."说明基本目录,此属性可有可无。 default="dist"说明项目的缺省目标(target)是什么,这个属性必须有。所谓目标(target)就是一系列任务(task)组成的一 个集合。每个任务(task)的书写方法如下:
<任务名 属性1="属性1的值" 属性2="属性2的值" ....... />




第 三行定义了一些属性(property),以便后面使用,这非常类似于编程中定义的全局变量。从第四行开始定义目标(target),name= "init"指明了此目标的名称,name属性在定义目标时必须有,当然定义目标时还有其他一些属性可选,例如depends,unless,具体请参考 ant的文档。第五行开始定义此目标内的任务,其中mkdir时ant的内部任务名,dir是此任务的属性,其值为${dist}。此任务就是创建一个目 录。其中${dist}是获取dist属性的值(就是我们在第三行定义的)。如上就是一个基本的build.xml文件的写法。你可以在命令行上输入 ant -buildfile build.xml

看一下你的当前目录下是否多了一个dist目录。如果出错,则可能是你没有把ant配置好,参见前面讲的安装及配置,看一下哪儿出了错。

3:build.xml文件
build.xml文件如下,其中有的注释和无关的代码删掉了,且做了一下小小的改动
1:
2:
3:
4:
5:
6:
7:
8:
9:
10:


11:
12:
13:
14:
15:
16:
17:
18:
19:

20:
21:
22:
23:

24:
25:

26:
27:
28:
29:
30:
31:
32:

33:
34:


35:
36:
37:
38:
39:
40:


41:
42:
43:
44:
45:
46:47:sourceout="${build.xmlc.dir}"
48:includes="**/*.html">
49:

50:
51:
52:
53:
54:
55:
56:
57:
58:

59:


60:
61:
62:
63:
64:

65:
66:67:destdir="${build.classes}"
68:classpathref="build.classpath"
69:debug="${build.debug}"/>

70:
71:72:destdir="${build.classes}"
73:classpathref="build.classpath"
74:debug="${build.debug}"
75:includes="${app.name}/**"
76:/>
77:


78:
79:
80:
81:
82:
83:
84:
85:
86:
87:
88:
89:

90:

91:



92:
93:
94:
95:
96:
97:
98:


99:
100:
101:
102:
103:
104:

105:
106:
107:108:tofile="${build.dir}/multiserver.conf"
109:filtering="on"/>

110:
111:
112:
113:


114:





4:build.xml详细说明
下 面我们将详细讲述这个文件,同样为了方便,我加了行号,当然一些基本的东西我就不再重复了。第四行taskdef任务(task)属于ant的内部任务, 它的作用是定义一个任务,其基本属性有name,classname,在定义时这两个属性都必需有。第八行开始定义一个path,它有一个属性id,通过 这个id的值我们可以在后面引用这个path,参见第68行。目标(target)init(从14行到34行)定义了一些基本属性 (property),主要是为了后面的target使用。在第38行,你会看到depends="init",depends是定义一个目标时的可选属 性,它的意思是如果init目标没有执行(出错或其他原因),这个目标也不会被执行。

从第46行开始定义xmlc任务,到第58行结束,中间有很多参数嵌套在其中,srcdir指定源文件目录,sourceout指定输出目录,includes属性将源文件目录中的所有html文件包括进来。*为通配符。

表示取消警告,表示同时产生接口和实现代码,例如:一个welcome.html,它会产生两个文件: WelcomeHTMLImpl.java,WelcomeHTML.java,WelcomeHTML.java中只定义了一个接口 WelcomeHTML,真正的实现在WelcomeHTMLImpl.java中。表示设置编码,由于xmlc将html文件编译为java类,即使你在html文件中已经设置了编码,在 java类中也不会有作用,必须在编译时设置编码。 这两句相当于在命令行上输入-ssi -keep.其中ssi参数是在编译html文件时将定义的ssi文件包括进来,见html目录下的welcome2.html源代码中有一行: Ant简介-jennyljd-ChinaUnix博客
  • 博客访问: 313307
  • 博文数量: 54
  • 博客积分: 1400
  • 博客等级: 上尉
  • 技术积分: 606
  • 用 户 组: 普通用户
  • 注册时间: 2006-12-03 22:43
文章分类
文章存档

2011年(3)

2010年(26)

2009年(2)

2008年(23)

我的朋友

分类:

2009-02-21 20:15:11

本文描述了ant的基本语法及其如何应用于项目的管理
-. Ant简介
可 能有许多读者并不了解什么是ant,以及如何使用它。但只要你是用过linux,你应该知道make为何物,当我们编译linux内核及一些软件的源程序 时,我们经常需要在控制台下输入make。Make其实就是一个项目管理工具,而ant所实现的功能与make差不多。Ant是apache软件基金会 jakarta项目中的一个子项目,由于是基于java编写的,因此具有很好的跨平台性。Ant由一些内置任务(task)和可选择的任务组成(当然你还 可以编写自己的任务),使用Make时,你需要写一个Makefile文件,而用ant时则需要写一个build.xml文件。由于采用xml的语法,所 以build.xml文件很容易书写和维护,且结构很清晰,而不像Makefile文件有那么多的限制(例如在tab符号前有一个空格的话,命令就不会执 行)。Ant的优点远不止这些,它还很容易的集成到一些开发环境中(例如visual age,jbuilder,netbeans)。

二.Ant的安装及配置
安装
Ant 目前的版本是1.3,首先到下载ant最新版本1.3,解压到C: /ant(window操作系统) 或者/usr/local/ant(linux操作系统),由于我们要用到xmlc ,而ant1.3中并没有包含它,所以我们需要David.Li为ant写的xmlc任务。具体url为http: //。将下载后的文件中的 ant.jar替换掉ant1.3中ant.jar.这样ant的版本变为1.2.

2.设置路径
(1):windows98操作系统
编辑C:\enhydra\.bashrc,加入下面三行

export ANT_HOME=/ant
export JAVA_HOME=/jdk-1.2.2
export PATH=${PATH}:${ANT_HOME}/bin

(2):Linux操作系统
编辑/etc/profile或者 用户目录下的.bashrc文件,加入下面三行

export ANT_HOME=/usr/local/ant
export JAVA_HOME=/usr/local/jdk-1.2.2
export PATH=${PATH}:${ANT_HOME}/bin

三:用ant管理项目
1:基本的文件目录结构 解压到任意目录,我们可以看到目录树结构如下
├─bin
├─docs
│ ├─ant2
│ ├─api
│ │ └─org
│ │ └─apache
│ │ └─tools
│ │ ├─ant
│ │ │ ├─taskdefs
│ │ │ │ ├─compilers
│ │ │ │ └─optional
│ │ │ │ ├─clearcase
│ │ │ │ ├─depend
│ │ │ │ │ └─constantpool
│ │ │ │ ├─dotnet
│ │ │ │ ├─ejb
│ │ │ │ ├─ide
│ │ │ │ ├─javacc
│ │ │ │ ├─jlink
│ │ │ │ ├─jsp
│ │ │ │ ├─junit
│ │ │ │ ├─metamata
│ │ │ │ ├─net
│ │ │ │ ├─perforce
│ │ │ │ ├─scm
│ │ │ │ ├─sound
│ │ │ │ └─vss
│ │ │ ├─types
│ │ │ └─util
│ │ │ └─regexp
│ │ ├─mail
│ │ └─tar
│ └─manual
│ ├─CoreTasks
│ ├─CoreTypes
│ ├─Integration
│ └─OptionalTasks
└─lib





在这个目录树结构中,与传统的项目不同的是,我们用build.xml取代了Makefile,在讲述这个build.xml文件前,我们先了解一个基本的 build.xml文件的结构。

2:build.xml的基本书写规范
下面我们就来讲述这个文件的书写方法,下面是这个文件的全部内容
1.
2.
3.
4.
5.
6.

7.





为 了方便说明,我们为每一行加了行号,第一行是xml文件的基本要素,第二行说明这是一个项目,第七行说明项目的结束 ,在第二行中,name="MyProject"说明此项目的名称,这个属性可有可无。basedir="."说明基本目录,此属性可有可无。 default="dist"说明项目的缺省目标(target)是什么,这个属性必须有。所谓目标(target)就是一系列任务(task)组成的一 个集合。每个任务(task)的书写方法如下:
<任务名 属性1="属性1的值" 属性2="属性2的值" ....... />




第 三行定义了一些属性(property),以便后面使用,这非常类似于编程中定义的全局变量。从第四行开始定义目标(target),name= "init"指明了此目标的名称,name属性在定义目标时必须有,当然定义目标时还有其他一些属性可选,例如depends,unless,具体请参考 ant的文档。第五行开始定义此目标内的任务,其中mkdir时ant的内部任务名,dir是此任务的属性,其值为${dist}。此任务就是创建一个目 录。其中${dist}是获取dist属性的值(就是我们在第三行定义的)。如上就是一个基本的build.xml文件的写法。你可以在命令行上输入 ant -buildfile build.xml

看一下你的当前目录下是否多了一个dist目录。如果出错,则可能是你没有把ant配置好,参见前面讲的安装及配置,看一下哪儿出了错。

3:build.xml文件
build.xml文件如下,其中有的注释和无关的代码删掉了,且做了一下小小的改动
1:
2:
3:
4:
5:
6:
7:
8:
9:
10:


11:
12:
13:
14:
15:
16:
17:
18:
19:

20:
21:
22:
23:

24:
25:

26:
27:
28:
29:
30:
31:
32:

33:
34:


35:
36:
37:
38:
39:
40:


41:
42:
43:
44:
45:
46:47:sourceout="${build.xmlc.dir}"
48:includes="**/*.html">
49:

50:
51:
52:
53:
54:
55:
56:
57:
58:

59:


60:
61:
62:
63:
64:

65:
66:67:destdir="${build.classes}"
68:classpathref="build.classpath"
69:debug="${build.debug}"/>

70:
71:72:destdir="${build.classes}"
73:classpathref="build.classpath"
74:debug="${build.debug}"
75:includes="${app.name}/**"
76:/>
77:


78:
79:
80:
81:
82:
83:
84:
85:
86:
87:
88:
89:

90:

91:



92:
93:
94:
95:
96:
97:
98:


99:
100:
101:
102:
103:
104:

105:
106:
107:108:tofile="${build.dir}/multiserver.conf"
109:filtering="on"/>

110:
111:
112:
113:


114:





4:build.xml详细说明
下 面我们将详细讲述这个文件,同样为了方便,我加了行号,当然一些基本的东西我就不再重复了。第四行taskdef任务(task)属于ant的内部任务, 它的作用是定义一个任务,其基本属性有name,classname,在定义时这两个属性都必需有。第八行开始定义一个path,它有一个属性id,通过 这个id的值我们可以在后面引用这个path,参见第68行。目标(target)init(从14行到34行)定义了一些基本属性 (property),主要是为了后面的target使用。在第38行,你会看到depends="init",depends是定义一个目标时的可选属 性,它的意思是如果init目标没有执行(出错或其他原因),这个目标也不会被执行。

从第46行开始定义xmlc任务,到第58行结束,中间有很多参数嵌套在其中,srcdir指定源文件目录,sourceout指定输出目录,includes属性将源文件目录中的所有html文件包括进来。*为通配符。

表示取消警告,表示同时产生接口和实现代码,例如:一个welcome.html,它会产生两个文件: WelcomeHTMLImpl.java,WelcomeHTML.java,WelcomeHTML.java中只定义了一个接口 WelcomeHTML,真正的实现在WelcomeHTMLImpl.java中。表示设置编码,由于xmlc将html文件编译为java类,即使你在html文件中已经设置了编码,在 java类中也不会有作用,必须在编译时设置编码。 这两句相当于在命令行上输入-ssi -keep.其中ssi参数是在编译html文件时将定义的ssi文件包括进来,见html目录下的welcome2.html源代码中有一行: Ant简介-jennyljd-ChinaUnix博客
  • 博客访问: 313308
  • 博文数量: 54
  • 博客积分: 1400
  • 博客等级: 上尉
  • 技术积分: 606
  • 用 户 组: 普通用户
  • 注册时间: 2006-12-03 22:43
文章分类
文章存档

2011年(3)

2010年(26)

2009年(2)

2008年(23)

我的朋友

分类:

2009-02-21 20:15:11

本文描述了ant的基本语法及其如何应用于项目的管理
-. Ant简介
可 能有许多读者并不了解什么是ant,以及如何使用它。但只要你是用过linux,你应该知道make为何物,当我们编译linux内核及一些软件的源程序 时,我们经常需要在控制台下输入make。Make其实就是一个项目管理工具,而ant所实现的功能与make差不多。Ant是apache软件基金会 jakarta项目中的一个子项目,由于是基于java编写的,因此具有很好的跨平台性。Ant由一些内置任务(task)和可选择的任务组成(当然你还 可以编写自己的任务),使用Make时,你需要写一个Makefile文件,而用ant时则需要写一个build.xml文件。由于采用xml的语法,所 以build.xml文件很容易书写和维护,且结构很清晰,而不像Makefile文件有那么多的限制(例如在tab符号前有一个空格的话,命令就不会执 行)。Ant的优点远不止这些,它还很容易的集成到一些开发环境中(例如visual age,jbuilder,netbeans)。

二.Ant的安装及配置
安装
Ant 目前的版本是1.3,首先到下载ant最新版本1.3,解压到C: /ant(window操作系统) 或者/usr/local/ant(linux操作系统),由于我们要用到xmlc ,而ant1.3中并没有包含它,所以我们需要David.Li为ant写的xmlc任务。具体url为http: //。将下载后的文件中的 ant.jar替换掉ant1.3中ant.jar.这样ant的版本变为1.2.

2.设置路径
(1):windows98操作系统
编辑C:\enhydra\.bashrc,加入下面三行

export ANT_HOME=/ant
export JAVA_HOME=/jdk-1.2.2
export PATH=${PATH}:${ANT_HOME}/bin

(2):Linux操作系统
编辑/etc/profile或者 用户目录下的.bashrc文件,加入下面三行

export ANT_HOME=/usr/local/ant
export JAVA_HOME=/usr/local/jdk-1.2.2
export PATH=${PATH}:${ANT_HOME}/bin

三:用ant管理项目
1:基本的文件目录结构 解压到任意目录,我们可以看到目录树结构如下
├─bin
├─docs
│ ├─ant2
│ ├─api
│ │ └─org
│ │ └─apache
│ │ └─tools
│ │ ├─ant
│ │ │ ├─taskdefs
│ │ │ │ ├─compilers
│ │ │ │ └─optional
│ │ │ │ ├─clearcase
│ │ │ │ ├─depend
│ │ │ │ │ └─constantpool
│ │ │ │ ├─dotnet
│ │ │ │ ├─ejb
│ │ │ │ ├─ide
│ │ │ │ ├─javacc
│ │ │ │ ├─jlink
│ │ │ │ ├─jsp
│ │ │ │ ├─junit
│ │ │ │ ├─metamata
│ │ │ │ ├─net
│ │ │ │ ├─perforce
│ │ │ │ ├─scm
│ │ │ │ ├─sound
│ │ │ │ └─vss
│ │ │ ├─types
│ │ │ └─util
│ │ │ └─regexp
│ │ ├─mail
│ │ └─tar
│ └─manual
│ ├─CoreTasks
│ ├─CoreTypes
│ ├─Integration
│ └─OptionalTasks
└─lib





在这个目录树结构中,与传统的项目不同的是,我们用build.xml取代了Makefile,在讲述这个build.xml文件前,我们先了解一个基本的 build.xml文件的结构。

2:build.xml的基本书写规范
下面我们就来讲述这个文件的书写方法,下面是这个文件的全部内容
1.
2.
3.
4.
5.
6.

7.





为 了方便说明,我们为每一行加了行号,第一行是xml文件的基本要素,第二行说明这是一个项目,第七行说明项目的结束 ,在第二行中,name="MyProject"说明此项目的名称,这个属性可有可无。basedir="."说明基本目录,此属性可有可无。 default="dist"说明项目的缺省目标(target)是什么,这个属性必须有。所谓目标(target)就是一系列任务(task)组成的一 个集合。每个任务(task)的书写方法如下:
<任务名 属性1="属性1的值" 属性2="属性2的值" ....... />




第 三行定义了一些属性(property),以便后面使用,这非常类似于编程中定义的全局变量。从第四行开始定义目标(target),name= "init"指明了此目标的名称,name属性在定义目标时必须有,当然定义目标时还有其他一些属性可选,例如depends,unless,具体请参考 ant的文档。第五行开始定义此目标内的任务,其中mkdir时ant的内部任务名,dir是此任务的属性,其值为${dist}。此任务就是创建一个目 录。其中${dist}是获取dist属性的值(就是我们在第三行定义的)。如上就是一个基本的build.xml文件的写法。你可以在命令行上输入 ant -buildfile build.xml

看一下你的当前目录下是否多了一个dist目录。如果出错,则可能是你没有把ant配置好,参见前面讲的安装及配置,看一下哪儿出了错。

3:build.xml文件
build.xml文件如下,其中有的注释和无关的代码删掉了,且做了一下小小的改动
1:
2:
3:
4:
5:
6:
7:
8:
9:
10:


11:
12:
13:
14:
15:
16:
17:
18:
19:

20:
21:
22:
23:

24:
25:

26:
27:
28:
29:
30:
31:
32:

33:
34:


35:
36:
37:
38:
39:
40:


41:
42:
43:
44:
45:
46:47:sourceout="${build.xmlc.dir}"
48:includes="**/*.html">
49:

50:
51:
52:
53:
54:
55:
56:
57:
58:

59:


60:
61:
62:
63:
64:

65:
66:67:destdir="${build.classes}"
68:classpathref="build.classpath"
69:debug="${build.debug}"/>

70:
71:72:destdir="${build.classes}"
73:classpathref="build.classpath"
74:debug="${build.debug}"
75:includes="${app.name}/**"
76:/>
77:


78:
79:
80:
81:
82:
83:
84:
85:
86:
87:
88:
89:

90:

91:



92:
93:
94:
95:
96:
97:
98:


99:
100:
101:
102:
103:
104:

105:
106:
107:108:tofile="${build.dir}/multiserver.conf"
109:filtering="on"/>

110:
111:
112:
113:


114:





4:build.xml详细说明
下 面我们将详细讲述这个文件,同样为了方便,我加了行号,当然一些基本的东西我就不再重复了。第四行taskdef任务(task)属于ant的内部任务, 它的作用是定义一个任务,其基本属性有name,classname,在定义时这两个属性都必需有。第八行开始定义一个path,它有一个属性id,通过 这个id的值我们可以在后面引用这个path,参见第68行。目标(target)init(从14行到34行)定义了一些基本属性 (property),主要是为了后面的target使用。在第38行,你会看到depends="init",depends是定义一个目标时的可选属 性,它的意思是如果init目标没有执行(出错或其他原因),这个目标也不会被执行。

从第46行开始定义xmlc任务,到第58行结束,中间有很多参数嵌套在其中,srcdir指定源文件目录,sourceout指定输出目录,includes属性将源文件目录中的所有html文件包括进来。*为通配符。

表示取消警告,表示同时产生接口和实现代码,例如:一个welcome.html,它会产生两个文件: WelcomeHTMLImpl.java,WelcomeHTML.java,WelcomeHTML.java中只定义了一个接口 WelcomeHTML,真正的实现在WelcomeHTMLImpl.java中。表示设置编码,由于xmlc将html文件编译为java类,即使你在html文件中已经设置了编码,在 java类中也不会有作用,必须在编译时设置编码。 这两句相当于在命令行上输入-ssi -keep.其中ssi参数是在编译html文件时将定义的ssi文件包括进来,见html目录下的welcome2.html源代码中有一行: Ant简介-jennyljd-ChinaUnix博客
  • 博客访问: 313309
  • 博文数量: 54
  • 博客积分: 1400
  • 博客等级: 上尉
  • 技术积分: 606
  • 用 户 组: 普通用户
  • 注册时间: 2006-12-03 22:43
文章分类
文章存档

2011年(3)

2010年(26)

2009年(2)

2008年(23)

我的朋友

分类:

2009-02-21 20:15:11

本文描述了ant的基本语法及其如何应用于项目的管理
-. Ant简介
可 能有许多读者并不了解什么是ant,以及如何使用它。但只要你是用过linux,你应该知道make为何物,当我们编译linux内核及一些软件的源程序 时,我们经常需要在控制台下输入make。Make其实就是一个项目管理工具,而ant所实现的功能与make差不多。Ant是apache软件基金会 jakarta项目中的一个子项目,由于是基于java编写的,因此具有很好的跨平台性。Ant由一些内置任务(task)和可选择的任务组成(当然你还 可以编写自己的任务),使用Make时,你需要写一个Makefile文件,而用ant时则需要写一个build.xml文件。由于采用xml的语法,所 以build.xml文件很容易书写和维护,且结构很清晰,而不像Makefile文件有那么多的限制(例如在tab符号前有一个空格的话,命令就不会执 行)。Ant的优点远不止这些,它还很容易的集成到一些开发环境中(例如visual age,jbuilder,netbeans)。

二.Ant的安装及配置
安装
Ant 目前的版本是1.3,首先到下载ant最新版本1.3,解压到C: /ant(window操作系统) 或者/usr/local/ant(linux操作系统),由于我们要用到xmlc ,而ant1.3中并没有包含它,所以我们需要David.Li为ant写的xmlc任务。具体url为http: //。将下载后的文件中的 ant.jar替换掉ant1.3中ant.jar.这样ant的版本变为1.2.

2.设置路径
(1):windows98操作系统
编辑C:\enhydra\.bashrc,加入下面三行

export ANT_HOME=/ant
export JAVA_HOME=/jdk-1.2.2
export PATH=${PATH}:${ANT_HOME}/bin

(2):Linux操作系统
编辑/etc/profile或者 用户目录下的.bashrc文件,加入下面三行

export ANT_HOME=/usr/local/ant
export JAVA_HOME=/usr/local/jdk-1.2.2
export PATH=${PATH}:${ANT_HOME}/bin

三:用ant管理项目
1:基本的文件目录结构 解压到任意目录,我们可以看到目录树结构如下
├─bin
├─docs
│ ├─ant2
│ ├─api
│ │ └─org
│ │ └─apache
│ │ └─tools
│ │ ├─ant
│ │ │ ├─taskdefs
│ │ │ │ ├─compilers
│ │ │ │ └─optional
│ │ │ │ ├─clearcase
│ │ │ │ ├─depend
│ │ │ │ │ └─constantpool
│ │ │ │ ├─dotnet
│ │ │ │ ├─ejb
│ │ │ │ ├─ide
│ │ │ │ ├─javacc
│ │ │ │ ├─jlink
│ │ │ │ ├─jsp
│ │ │ │ ├─junit
│ │ │ │ ├─metamata
│ │ │ │ ├─net
│ │ │ │ ├─perforce
│ │ │ │ ├─scm
│ │ │ │ ├─sound
│ │ │ │ └─vss
│ │ │ ├─types
│ │ │ └─util
│ │ │ └─regexp
│ │ ├─mail
│ │ └─tar
│ └─manual
│ ├─CoreTasks
│ ├─CoreTypes
│ ├─Integration
│ └─OptionalTasks
└─lib





在这个目录树结构中,与传统的项目不同的是,我们用build.xml取代了Makefile,在讲述这个build.xml文件前,我们先了解一个基本的 build.xml文件的结构。

2:build.xml的基本书写规范
下面我们就来讲述这个文件的书写方法,下面是这个文件的全部内容
1.
2.
3.
4.
5.
6.

7.





为 了方便说明,我们为每一行加了行号,第一行是xml文件的基本要素,第二行说明这是一个项目,第七行说明项目的结束 ,在第二行中,name="MyProject"说明此项目的名称,这个属性可有可无。basedir="."说明基本目录,此属性可有可无。 default="dist"说明项目的缺省目标(target)是什么,这个属性必须有。所谓目标(target)就是一系列任务(task)组成的一 个集合。每个任务(task)的书写方法如下:
<任务名 属性1="属性1的值" 属性2="属性2的值" ....... />




第 三行定义了一些属性(property),以便后面使用,这非常类似于编程中定义的全局变量。从第四行开始定义目标(target),name= "init"指明了此目标的名称,name属性在定义目标时必须有,当然定义目标时还有其他一些属性可选,例如depends,unless,具体请参考 ant的文档。第五行开始定义此目标内的任务,其中mkdir时ant的内部任务名,dir是此任务的属性,其值为${dist}。此任务就是创建一个目 录。其中${dist}是获取dist属性的值(就是我们在第三行定义的)。如上就是一个基本的build.xml文件的写法。你可以在命令行上输入 ant -buildfile build.xml

看一下你的当前目录下是否多了一个dist目录。如果出错,则可能是你没有把ant配置好,参见前面讲的安装及配置,看一下哪儿出了错。

3:build.xml文件
build.xml文件如下,其中有的注释和无关的代码删掉了,且做了一下小小的改动
1:
2:
3:
4:
5:
6:
7:
8:
9:
10:


11:
12:
13:
14:
15:
16:
17:
18:
19:

20:
21:
22:
23:

24:
25:

26:
27:
28:
29:
30:
31:
32:

33:
34:


35:
36:
37:
38:
39:
40:


41:
42:
43:
44:
45:
46:47:sourceout="${build.xmlc.dir}"
48:includes="**/*.html">
49:

50:
51:
52:
53:
54:
55:
56:
57:
58:

59:


60:
61:
62:
63:
64:

65:
66:67:destdir="${build.classes}"
68:classpathref="build.classpath"
69:debug="${build.debug}"/>

70:
71:72:destdir="${build.classes}"
73:classpathref="build.classpath"
74:debug="${build.debug}"
75:includes="${app.name}/**"
76:/>
77:


78:
79:
80:
81:
82:
83:
84:
85:
86:
87:
88:
89:

90:

91:



92:
93:
94:
95:
96:
97:
98:


99:
100:
101:
102:
103:
104:

105:
106:
107:108:tofile="${build.dir}/multiserver.conf"
109:filtering="on"/>

110:
111:
112:
113:


114:





4:build.xml详细说明
下 面我们将详细讲述这个文件,同样为了方便,我加了行号,当然一些基本的东西我就不再重复了。第四行taskdef任务(task)属于ant的内部任务, 它的作用是定义一个任务,其基本属性有name,classname,在定义时这两个属性都必需有。第八行开始定义一个path,它有一个属性id,通过 这个id的值我们可以在后面引用这个path,参见第68行。目标(target)init(从14行到34行)定义了一些基本属性 (property),主要是为了后面的target使用。在第38行,你会看到depends="init",depends是定义一个目标时的可选属 性,它的意思是如果init目标没有执行(出错或其他原因),这个目标也不会被执行。

从第46行开始定义xmlc任务,到第58行结束,中间有很多参数嵌套在其中,srcdir指定源文件目录,sourceout指定输出目录,includes属性将源文件目录中的所有html文件包括进来。*为通配符。

表示取消警告,表示同时产生接口和实现代码,例如:一个welcome.html,它会产生两个文件: WelcomeHTMLImpl.java,WelcomeHTML.java,WelcomeHTML.java中只定义了一个接口 WelcomeHTML,真正的实现在WelcomeHTMLImpl.java中。表示设置编码,由于xmlc将html文件编译为java类,即使你在html文件中已经设置了编码,在 java类中也不会有作用,必须在编译时设置编码。 这两句相当于在命令行上输入-ssi -keep.其中ssi参数是在编译html文件时将定义的ssi文件包括进来,见html目录下的welcome2.html源代码中有一行: Ant简介-jennyljd-ChinaUnix博客
  • 博客访问: 313310
  • 博文数量: 54
  • 博客积分: 1400
  • 博客等级: 上尉
  • 技术积分: 606
  • 用 户 组: 普通用户
  • 注册时间: 2006-12-03 22:43
文章分类
文章存档

2011年(3)

2010年(26)

2009年(2)

2008年(23)

我的朋友

分类:

2009-02-21 20:15:11

本文描述了ant的基本语法及其如何应用于项目的管理
-. Ant简介
可 能有许多读者并不了解什么是ant,以及如何使用它。但只要你是用过linux,你应该知道make为何物,当我们编译linux内核及一些软件的源程序 时,我们经常需要在控制台下输入make。Make其实就是一个项目管理工具,而ant所实现的功能与make差不多。Ant是apache软件基金会 jakarta项目中的一个子项目,由于是基于java编写的,因此具有很好的跨平台性。Ant由一些内置任务(task)和可选择的任务组成(当然你还 可以编写自己的任务),使用Make时,你需要写一个Makefile文件,而用ant时则需要写一个build.xml文件。由于采用xml的语法,所 以build.xml文件很容易书写和维护,且结构很清晰,而不像Makefile文件有那么多的限制(例如在tab符号前有一个空格的话,命令就不会执 行)。Ant的优点远不止这些,它还很容易的集成到一些开发环境中(例如visual age,jbuilder,netbeans)。

二.Ant的安装及配置
安装
Ant 目前的版本是1.3,首先到下载ant最新版本1.3,解压到C: /ant(window操作系统) 或者/usr/local/ant(linux操作系统),由于我们要用到xmlc ,而ant1.3中并没有包含它,所以我们需要David.Li为ant写的xmlc任务。具体url为http: //。将下载后的文件中的 ant.jar替换掉ant1.3中ant.jar.这样ant的版本变为1.2.

2.设置路径
(1):windows98操作系统
编辑C:\enhydra\.bashrc,加入下面三行

export ANT_HOME=/ant
export JAVA_HOME=/jdk-1.2.2
export PATH=${PATH}:${ANT_HOME}/bin

(2):Linux操作系统
编辑/etc/profile或者 用户目录下的.bashrc文件,加入下面三行

export ANT_HOME=/usr/local/ant
export JAVA_HOME=/usr/local/jdk-1.2.2
export PATH=${PATH}:${ANT_HOME}/bin

三:用ant管理项目
1:基本的文件目录结构 解压到任意目录,我们可以看到目录树结构如下
├─bin
├─docs
│ ├─ant2
│ ├─api
│ │ └─org
│ │ └─apache
│ │ └─tools
│ │ ├─ant
│ │ │ ├─taskdefs
│ │ │ │ ├─compilers
│ │ │ │ └─optional
│ │ │ │ ├─clearcase
│ │ │ │ ├─depend
│ │ │ │ │ └─constantpool
│ │ │ │ ├─dotnet
│ │ │ │ ├─ejb
│ │ │ │ ├─ide
│ │ │ │ ├─javacc
│ │ │ │ ├─jlink
│ │ │ │ ├─jsp
│ │ │ │ ├─junit
│ │ │ │ ├─metamata
│ │ │ │ ├─net
│ │ │ │ ├─perforce
│ │ │ │ ├─scm
│ │ │ │ ├─sound
│ │ │ │ └─vss
│ │ │ ├─types
│ │ │ └─util
│ │ │ └─regexp
│ │ ├─mail
│ │ └─tar
│ └─manual
│ ├─CoreTasks
│ ├─CoreTypes
│ ├─Integration
│ └─OptionalTasks
└─lib





在这个目录树结构中,与传统的项目不同的是,我们用build.xml取代了Makefile,在讲述这个build.xml文件前,我们先了解一个基本的 build.xml文件的结构。

2:build.xml的基本书写规范
下面我们就来讲述这个文件的书写方法,下面是这个文件的全部内容
1.
2.
3.
4.
5.
6.

7.





为 了方便说明,我们为每一行加了行号,第一行是xml文件的基本要素,第二行说明这是一个项目,第七行说明项目的结束 ,在第二行中,name="MyProject"说明此项目的名称,这个属性可有可无。basedir="."说明基本目录,此属性可有可无。 default="dist"说明项目的缺省目标(target)是什么,这个属性必须有。所谓目标(target)就是一系列任务(task)组成的一 个集合。每个任务(task)的书写方法如下:
<任务名 属性1="属性1的值" 属性2="属性2的值" ....... />




第 三行定义了一些属性(property),以便后面使用,这非常类似于编程中定义的全局变量。从第四行开始定义目标(target),name= "init"指明了此目标的名称,name属性在定义目标时必须有,当然定义目标时还有其他一些属性可选,例如depends,unless,具体请参考 ant的文档。第五行开始定义此目标内的任务,其中mkdir时ant的内部任务名,dir是此任务的属性,其值为${dist}。此任务就是创建一个目 录。其中${dist}是获取dist属性的值(就是我们在第三行定义的)。如上就是一个基本的build.xml文件的写法。你可以在命令行上输入 ant -buildfile build.xml

看一下你的当前目录下是否多了一个dist目录。如果出错,则可能是你没有把ant配置好,参见前面讲的安装及配置,看一下哪儿出了错。

3:build.xml文件
build.xml文件如下,其中有的注释和无关的代码删掉了,且做了一下小小的改动
1:
2:
3:
4:
5:
6:
7:
8:
9:
10:


11:
12:
13:
14:
15:
16:
17:
18:
19:

20:
21:
22:
23:

24:
25:

26:
27:
28:
29:
30:
31:
32:

33:
34:


35:
36:
37:
38:
39:
40:


41:
42:
43:
44:
45:
46:47:sourceout="${build.xmlc.dir}"
48:includes="**/*.html">
49:

50:
51:
52:
53:
54:
55:
56:
57:
58:

59:


60:
61:
62:
63:
64:

65:
66:67:destdir="${build.classes}"
68:classpathref="build.classpath"
69:debug="${build.debug}"/>

70:
71:72:destdir="${build.classes}"
73:classpathref="build.classpath"
74:debug="${build.debug}"
75:includes="${app.name}/**"
76:/>
77:


78:
79:
80:
81:
82:
83:
84:
85:
86:
87:
88:
89:

90:

91:



92:
93:
94:
95:
96:
97:
98:


99:
100:
101:
102:
103:
104:

105:
106:
107:108:tofile="${build.dir}/multiserver.conf"
109:filtering="on"/>

110:
111:
112:
113:


114:





4:build.xml详细说明
下 面我们将详细讲述这个文件,同样为了方便,我加了行号,当然一些基本的东西我就不再重复了。第四行taskdef任务(task)属于ant的内部任务, 它的作用是定义一个任务,其基本属性有name,classname,在定义时这两个属性都必需有。第八行开始定义一个path,它有一个属性id,通过 这个id的值我们可以在后面引用这个path,参见第68行。目标(target)init(从14行到34行)定义了一些基本属性 (property),主要是为了后面的target使用。在第38行,你会看到depends="init",depends是定义一个目标时的可选属 性,它的意思是如果init目标没有执行(出错或其他原因),这个目标也不会被执行。

从第46行开始定义xmlc任务,到第58行结束,中间有很多参数嵌套在其中,srcdir指定源文件目录,sourceout指定输出目录,includes属性将源文件目录中的所有html文件包括进来。*为通配符。

表示取消警告,表示同时产生接口和实现代码,例如:一个welcome.html,它会产生两个文件: WelcomeHTMLImpl.java,WelcomeHTML.java,WelcomeHTML.java中只定义了一个接口 WelcomeHTML,真正的实现在WelcomeHTMLImpl.java中。表示设置编码,由于xmlc将html文件编译为java类,即使你在html文件中已经设置了编码,在 java类中也不会有作用,必须在编译时设置编码。 这两句相当于在命令行上输入-ssi -keep.其中ssi参数是在编译html文件时将定义的ssi文件包括进来,见html目录下的welcome2.html源代码中有一行: Ant简介-jennyljd-ChinaUnix博客
  • 博客访问: 313311
  • 博文数量: 54
  • 博客积分: 1400
  • 博客等级: 上尉
  • 技术积分: 606
  • 用 户 组: 普通用户
  • 注册时间: 2006-12-03 22:43
文章分类
文章存档

2011年(3)

2010年(26)

2009年(2)

2008年(23)

我的朋友

分类:

2009-02-21 20:15:11

本文描述了ant的基本语法及其如何应用于项目的管理
-. Ant简介
可 能有许多读者并不了解什么是ant,以及如何使用它。但只要你是用过linux,你应该知道make为何物,当我们编译linux内核及一些软件的源程序 时,我们经常需要在控制台下输入make。Make其实就是一个项目管理工具,而ant所实现的功能与make差不多。Ant是apache软件基金会 jakarta项目中的一个子项目,由于是基于java编写的,因此具有很好的跨平台性。Ant由一些内置任务(task)和可选择的任务组成(当然你还 可以编写自己的任务),使用Make时,你需要写一个Makefile文件,而用ant时则需要写一个build.xml文件。由于采用xml的语法,所 以build.xml文件很容易书写和维护,且结构很清晰,而不像Makefile文件有那么多的限制(例如在tab符号前有一个空格的话,命令就不会执 行)。Ant的优点远不止这些,它还很容易的集成到一些开发环境中(例如visual age,jbuilder,netbeans)。

二.Ant的安装及配置
安装
Ant 目前的版本是1.3,首先到下载ant最新版本1.3,解压到C: /ant(window操作系统) 或者/usr/local/ant(linux操作系统),由于我们要用到xmlc ,而ant1.3中并没有包含它,所以我们需要David.Li为ant写的xmlc任务。具体url为http: //。将下载后的文件中的 ant.jar替换掉ant1.3中ant.jar.这样ant的版本变为1.2.

2.设置路径
(1):windows98操作系统
编辑C:\enhydra\.bashrc,加入下面三行

export ANT_HOME=/ant
export JAVA_HOME=/jdk-1.2.2
export PATH=${PATH}:${ANT_HOME}/bin

(2):Linux操作系统
编辑/etc/profile或者 用户目录下的.bashrc文件,加入下面三行

export ANT_HOME=/usr/local/ant
export JAVA_HOME=/usr/local/jdk-1.2.2
export PATH=${PATH}:${ANT_HOME}/bin

三:用ant管理项目
1:基本的文件目录结构 解压到任意目录,我们可以看到目录树结构如下
├─bin
├─docs
│ ├─ant2
│ ├─api
│ │ └─org
│ │ └─apache
│ │ └─tools
│ │ ├─ant
│ │ │ ├─taskdefs
│ │ │ │ ├─compilers
│ │ │ │ └─optional
│ │ │ │ ├─clearcase
│ │ │ │ ├─depend
│ │ │ │ │ └─constantpool
│ │ │ │ ├─dotnet
│ │ │ │ ├─ejb
│ │ │ │ ├─ide
│ │ │ │ ├─javacc
│ │ │ │ ├─jlink
│ │ │ │ ├─jsp
│ │ │ │ ├─junit
│ │ │ │ ├─metamata
│ │ │ │ ├─net
│ │ │ │ ├─perforce
│ │ │ │ ├─scm
│ │ │ │ ├─sound
│ │ │ │ └─vss
│ │ │ ├─types
│ │ │ └─util
│ │ │ └─regexp
│ │ ├─mail
│ │ └─tar
│ └─manual
│ ├─CoreTasks
│ ├─CoreTypes
│ ├─Integration
│ └─OptionalTasks
└─lib





在这个目录树结构中,与传统的项目不同的是,我们用build.xml取代了Makefile,在讲述这个build.xml文件前,我们先了解一个基本的 build.xml文件的结构。

2:build.xml的基本书写规范
下面我们就来讲述这个文件的书写方法,下面是这个文件的全部内容
1.
2.
3.
4.
5.
6.

7.





为 了方便说明,我们为每一行加了行号,第一行是xml文件的基本要素,第二行说明这是一个项目,第七行说明项目的结束 ,在第二行中,name="MyProject"说明此项目的名称,这个属性可有可无。basedir="."说明基本目录,此属性可有可无。 default="dist"说明项目的缺省目标(target)是什么,这个属性必须有。所谓目标(target)就是一系列任务(task)组成的一 个集合。每个任务(task)的书写方法如下:
<任务名 属性1="属性1的值" 属性2="属性2的值" ....... />




第 三行定义了一些属性(property),以便后面使用,这非常类似于编程中定义的全局变量。从第四行开始定义目标(target),name= "init"指明了此目标的名称,name属性在定义目标时必须有,当然定义目标时还有其他一些属性可选,例如depends,unless,具体请参考 ant的文档。第五行开始定义此目标内的任务,其中mkdir时ant的内部任务名,dir是此任务的属性,其值为${dist}。此任务就是创建一个目 录。其中${dist}是获取dist属性的值(就是我们在第三行定义的)。如上就是一个基本的build.xml文件的写法。你可以在命令行上输入 ant -buildfile build.xml

看一下你的当前目录下是否多了一个dist目录。如果出错,则可能是你没有把ant配置好,参见前面讲的安装及配置,看一下哪儿出了错。

3:build.xml文件
build.xml文件如下,其中有的注释和无关的代码删掉了,且做了一下小小的改动
1:
2:
3:
4:
5:
6:
7:
8:
9:
10:


11:
12:
13:
14:
15:
16:
17:
18:
19:

20:
21:
22:
23:

24:
25:

26:
27:
28:
29:
30:
31:
32:

33:
34:


35:
36:
37:
38:
39:
40:


41:
42:
43:
44:
45:
46:47:sourceout="${build.xmlc.dir}"
48:includes="**/*.html">
49:

50:
51:
52:
53:
54:
55:
56:
57:
58:

59:


60:
61:
62:
63:
64:

65:
66:67:destdir="${build.classes}"
68:classpathref="build.classpath"
69:debug="${build.debug}"/>

70:
71:72:destdir="${build.classes}"
73:classpathref="build.classpath"
74:debug="${build.debug}"
75:includes="${app.name}/**"
76:/>
77:


78:
79:
80:
81:
82:
83:
84:
85:
86:
87:
88:
89:

90:

91:



92:
93:
94:
95:
96:
97:
98:


99:
100:
101:
102:
103:
104:

105:
106:
107:108:tofile="${build.dir}/multiserver.conf"
109:filtering="on"/>

110:
111:
112:
113:


114:





4:build.xml详细说明
下 面我们将详细讲述这个文件,同样为了方便,我加了行号,当然一些基本的东西我就不再重复了。第四行taskdef任务(task)属于ant的内部任务, 它的作用是定义一个任务,其基本属性有name,classname,在定义时这两个属性都必需有。第八行开始定义一个path,它有一个属性id,通过 这个id的值我们可以在后面引用这个path,参见第68行。目标(target)init(从14行到34行)定义了一些基本属性 (property),主要是为了后面的target使用。在第38行,你会看到depends="init",depends是定义一个目标时的可选属 性,它的意思是如果init目标没有执行(出错或其他原因),这个目标也不会被执行。

从第46行开始定义xmlc任务,到第58行结束,中间有很多参数嵌套在其中,srcdir指定源文件目录,sourceout指定输出目录,includes属性将源文件目录中的所有html文件包括进来。*为通配符。

表示取消警告,表示同时产生接口和实现代码,例如:一个welcome.html,它会产生两个文件: WelcomeHTMLImpl.java,WelcomeHTML.java,WelcomeHTML.java中只定义了一个接口 WelcomeHTML,真正的实现在WelcomeHTMLImpl.java中。表示设置编码,由于xmlc将html文件编译为java类,即使你在html文件中已经设置了编码,在 java类中也不会有作用,必须在编译时设置编码。 这两句相当于在命令行上输入-ssi -keep.其中ssi参数是在编译html文件时将定义的ssi文件包括进来,见html目录下的welcome2.html源代码中有一行: Ant简介-jennyljd-ChinaUnix博客
  • 博客访问: 313312
  • 博文数量: 54
  • 博客积分: 1400
  • 博客等级: 上尉
  • 技术积分: 606
  • 用 户 组: 普通用户
  • 注册时间: 2006-12-03 22:43
文章分类
文章存档

2011年(3)

2010年(26)

2009年(2)

2008年(23)

我的朋友

分类:

2009-02-21 20:15:11

本文描述了ant的基本语法及其如何应用于项目的管理
-. Ant简介
可 能有许多读者并不了解什么是ant,以及如何使用它。但只要你是用过linux,你应该知道make为何物,当我们编译linux内核及一些软件的源程序 时,我们经常需要在控制台下输入make。Make其实就是一个项目管理工具,而ant所实现的功能与make差不多。Ant是apache软件基金会 jakarta项目中的一个子项目,由于是基于java编写的,因此具有很好的跨平台性。Ant由一些内置任务(task)和可选择的任务组成(当然你还 可以编写自己的任务),使用Make时,你需要写一个Makefile文件,而用ant时则需要写一个build.xml文件。由于采用xml的语法,所 以build.xml文件很容易书写和维护,且结构很清晰,而不像Makefile文件有那么多的限制(例如在tab符号前有一个空格的话,命令就不会执 行)。Ant的优点远不止这些,它还很容易的集成到一些开发环境中(例如visual age,jbuilder,netbeans)。

二.Ant的安装及配置
安装
Ant 目前的版本是1.3,首先到下载ant最新版本1.3,解压到C: /ant(window操作系统) 或者/usr/local/ant(linux操作系统),由于我们要用到xmlc ,而ant1.3中并没有包含它,所以我们需要David.Li为ant写的xmlc任务。具体url为http: //。将下载后的文件中的 ant.jar替换掉ant1.3中ant.jar.这样ant的版本变为1.2.

2.设置路径
(1):windows98操作系统
编辑C:\enhydra\.bashrc,加入下面三行

export ANT_HOME=/ant
export JAVA_HOME=/jdk-1.2.2
export PATH=${PATH}:${ANT_HOME}/bin

(2):Linux操作系统
编辑/etc/profile或者 用户目录下的.bashrc文件,加入下面三行

export ANT_HOME=/usr/local/ant
export JAVA_HOME=/usr/local/jdk-1.2.2
export PATH=${PATH}:${ANT_HOME}/bin

三:用ant管理项目
1:基本的文件目录结构 解压到任意目录,我们可以看到目录树结构如下
├─bin
├─docs
│ ├─ant2
│ ├─api
│ │ └─org
│ │ └─apache
│ │ └─tools
│ │ ├─ant
│ │ │ ├─taskdefs
│ │ │ │ ├─compilers
│ │ │ │ └─optional
│ │ │ │ ├─clearcase
│ │ │ │ ├─depend
│ │ │ │ │ └─constantpool
│ │ │ │ ├─dotnet
│ │ │ │ ├─ejb
│ │ │ │ ├─ide
│ │ │ │ ├─javacc
│ │ │ │ ├─jlink
│ │ │ │ ├─jsp
│ │ │ │ ├─junit
│ │ │ │ ├─metamata
│ │ │ │ ├─net
│ │ │ │ ├─perforce
│ │ │ │ ├─scm
│ │ │ │ ├─sound
│ │ │ │ └─vss
│ │ │ ├─types
│ │ │ └─util
│ │ │ └─regexp
│ │ ├─mail
│ │ └─tar
│ └─manual
│ ├─CoreTasks
│ ├─CoreTypes
│ ├─Integration
│ └─OptionalTasks
└─lib





在这个目录树结构中,与传统的项目不同的是,我们用build.xml取代了Makefile,在讲述这个build.xml文件前,我们先了解一个基本的 build.xml文件的结构。

2:build.xml的基本书写规范
下面我们就来讲述这个文件的书写方法,下面是这个文件的全部内容
1.
2.
3.
4.
5.
6.

7.





为 了方便说明,我们为每一行加了行号,第一行是xml文件的基本要素,第二行说明这是一个项目,第七行说明项目的结束 ,在第二行中,name="MyProject"说明此项目的名称,这个属性可有可无。basedir="."说明基本目录,此属性可有可无。 default="dist"说明项目的缺省目标(target)是什么,这个属性必须有。所谓目标(target)就是一系列任务(task)组成的一 个集合。每个任务(task)的书写方法如下:
<任务名 属性1="属性1的值" 属性2="属性2的值" ....... />




第 三行定义了一些属性(property),以便后面使用,这非常类似于编程中定义的全局变量。从第四行开始定义目标(target),name= "init"指明了此目标的名称,name属性在定义目标时必须有,当然定义目标时还有其他一些属性可选,例如depends,unless,具体请参考 ant的文档。第五行开始定义此目标内的任务,其中mkdir时ant的内部任务名,dir是此任务的属性,其值为${dist}。此任务就是创建一个目 录。其中${dist}是获取dist属性的值(就是我们在第三行定义的)。如上就是一个基本的build.xml文件的写法。你可以在命令行上输入 ant -buildfile build.xml

看一下你的当前目录下是否多了一个dist目录。如果出错,则可能是你没有把ant配置好,参见前面讲的安装及配置,看一下哪儿出了错。

3:build.xml文件
build.xml文件如下,其中有的注释和无关的代码删掉了,且做了一下小小的改动
1:
2:
3:
4:
5:
6:
7:
8:
9:
10:


11:
12:
13:
14:
15:
16:
17:
18:
19:

20:
21:
22:
23:

24:
25:

26:
27:
28:
29:
30:
31:
32:

33:
34:


35:
36:
37:
38:
39:
40:


41:
42:
43:
44:
45:
46:47:sourceout="${build.xmlc.dir}"
48:includes="**/*.html">
49:

50:
51:
52:
53:
54:
55:
56:
57:
58:

59:


60:
61:
62:
63:
64:

65:
66:67:destdir="${build.classes}"
68:classpathref="build.classpath"
69:debug="${build.debug}"/>

70:
71:72:destdir="${build.classes}"
73:classpathref="build.classpath"
74:debug="${build.debug}"
75:includes="${app.name}/**"
76:/>
77:


78:
79:
80:
81:
82:
83:
84:
85:
86:
87:
88:
89:

90:

91:



92:
93:
94:
95:
96:
97:
98:


99:
100:
101:
102:
103:
104:

105:
106:
107:108:tofile="${build.dir}/multiserver.conf"
109:filtering="on"/>

110:
111:
112:
113:


114:





4:build.xml详细说明
下 面我们将详细讲述这个文件,同样为了方便,我加了行号,当然一些基本的东西我就不再重复了。第四行taskdef任务(task)属于ant的内部任务, 它的作用是定义一个任务,其基本属性有name,classname,在定义时这两个属性都必需有。第八行开始定义一个path,它有一个属性id,通过 这个id的值我们可以在后面引用这个path,参见第68行。目标(target)init(从14行到34行)定义了一些基本属性 (property),主要是为了后面的target使用。在第38行,你会看到depends="init",depends是定义一个目标时的可选属 性,它的意思是如果init目标没有执行(出错或其他原因),这个目标也不会被执行。

从第46行开始定义xmlc任务,到第58行结束,中间有很多参数嵌套在其中,srcdir指定源文件目录,sourceout指定输出目录,includes属性将源文件目录中的所有html文件包括进来。*为通配符。

表示取消警告,表示同时产生接口和实现代码,例如:一个welcome.html,它会产生两个文件: WelcomeHTMLImpl.java,WelcomeHTML.java,WelcomeHTML.java中只定义了一个接口 WelcomeHTML,真正的实现在WelcomeHTMLImpl.java中。表示设置编码,由于xmlc将html文件编译为java类,即使你在html文件中已经设置了编码,在 java类中也不会有作用,必须在编译时设置编码。 这两句相当于在命令行上输入-ssi -keep.其中ssi参数是在编译html文件时将定义的ssi文件包括进来,见html目录下的welcome2.html源代码中有一行: Ant简介-jennyljd-ChinaUnix博客
  • 博客访问: 313313
  • 博文数量: 54
  • 博客积分: 1400
  • 博客等级: 上尉
  • 技术积分: 606
  • 用 户 组: 普通用户
  • 注册时间: 2006-12-03 22:43
文章分类
文章存档

2011年(3)

2010年(26)

2009年(2)

2008年(23)

我的朋友

分类:

2009-02-21 20:15:11

本文描述了ant的基本语法及其如何应用于项目的管理
-. Ant简介
可 能有许多读者并不了解什么是ant,以及如何使用它。但只要你是用过linux,你应该知道make为何物,当我们编译linux内核及一些软件的源程序 时,我们经常需要在控制台下输入make。Make其实就是一个项目管理工具,而ant所实现的功能与make差不多。Ant是apache软件基金会 jakarta项目中的一个子项目,由于是基于java编写的,因此具有很好的跨平台性。Ant由一些内置任务(task)和可选择的任务组成(当然你还 可以编写自己的任务),使用Make时,你需要写一个Makefile文件,而用ant时则需要写一个build.xml文件。由于采用xml的语法,所 以build.xml文件很容易书写和维护,且结构很清晰,而不像Makefile文件有那么多的限制(例如在tab符号前有一个空格的话,命令就不会执 行)。Ant的优点远不止这些,它还很容易的集成到一些开发环境中(例如visual age,jbuilder,netbeans)。

二.Ant的安装及配置
安装
Ant 目前的版本是1.3,首先到下载ant最新版本1.3,解压到C: /ant(window操作系统) 或者/usr/local/ant(linux操作系统),由于我们要用到xmlc ,而ant1.3中并没有包含它,所以我们需要David.Li为ant写的xmlc任务。具体url为http: //。将下载后的文件中的 ant.jar替换掉ant1.3中ant.jar.这样ant的版本变为1.2.

2.设置路径
(1):windows98操作系统
编辑C:\enhydra\.bashrc,加入下面三行

export ANT_HOME=/ant
export JAVA_HOME=/jdk-1.2.2
export PATH=${PATH}:${ANT_HOME}/bin

(2):Linux操作系统
编辑/etc/profile或者 用户目录下的.bashrc文件,加入下面三行

export ANT_HOME=/usr/local/ant
export JAVA_HOME=/usr/local/jdk-1.2.2
export PATH=${PATH}:${ANT_HOME}/bin

三:用ant管理项目
1:基本的文件目录结构 解压到任意目录,我们可以看到目录树结构如下
├─bin
├─docs
│ ├─ant2
│ ├─api
│ │ └─org
│ │ └─apache
│ │ └─tools
│ │ ├─ant
│ │ │ ├─taskdefs
│ │ │ │ ├─compilers
│ │ │ │ └─optional
│ │ │ │ ├─clearcase
│ │ │ │ ├─depend
│ │ │ │ │ └─constantpool
│ │ │ │ ├─dotnet
│ │ │ │ ├─ejb
│ │ │ │ ├─ide
│ │ │ │ ├─javacc
│ │ │ │ ├─jlink
│ │ │ │ ├─jsp
│ │ │ │ ├─junit
│ │ │ │ ├─metamata
│ │ │ │ ├─net
│ │ │ │ ├─perforce
│ │ │ │ ├─scm
│ │ │ │ ├─sound
│ │ │ │ └─vss
│ │ │ ├─types
│ │ │ └─util
│ │ │ └─regexp
│ │ ├─mail
│ │ └─tar
│ └─manual
│ ├─CoreTasks
│ ├─CoreTypes
│ ├─Integration
│ └─OptionalTasks
└─lib





在这个目录树结构中,与传统的项目不同的是,我们用build.xml取代了Makefile,在讲述这个build.xml文件前,我们先了解一个基本的 build.xml文件的结构。

2:build.xml的基本书写规范
下面我们就来讲述这个文件的书写方法,下面是这个文件的全部内容
1.
2.
3.
4.
5.
6.

7.





为 了方便说明,我们为每一行加了行号,第一行是xml文件的基本要素,第二行说明这是一个项目,第七行说明项目的结束 ,在第二行中,name="MyProject"说明此项目的名称,这个属性可有可无。basedir="."说明基本目录,此属性可有可无。 default="dist"说明项目的缺省目标(target)是什么,这个属性必须有。所谓目标(target)就是一系列任务(task)组成的一 个集合。每个任务(task)的书写方法如下:
<任务名 属性1="属性1的值" 属性2="属性2的值" ....... />




第 三行定义了一些属性(property),以便后面使用,这非常类似于编程中定义的全局变量。从第四行开始定义目标(target),name= "init"指明了此目标的名称,name属性在定义目标时必须有,当然定义目标时还有其他一些属性可选,例如depends,unless,具体请参考 ant的文档。第五行开始定义此目标内的任务,其中mkdir时ant的内部任务名,dir是此任务的属性,其值为${dist}。此任务就是创建一个目 录。其中${dist}是获取dist属性的值(就是我们在第三行定义的)。如上就是一个基本的build.xml文件的写法。你可以在命令行上输入 ant -buildfile build.xml

看一下你的当前目录下是否多了一个dist目录。如果出错,则可能是你没有把ant配置好,参见前面讲的安装及配置,看一下哪儿出了错。

3:build.xml文件
build.xml文件如下,其中有的注释和无关的代码删掉了,且做了一下小小的改动
1:
2:
3:
4:
5:
6:
7:
8:
9:
10:


11:
12:
13:
14:
15:
16:
17:
18:
19:

20:
21:
22:
23:

24:
25:

26:
27:
28:
29:
30:
31:
32:

33:
34:


35:
36:
37:
38:
39:
40:


41:
42:
43:
44:
45:
46:47:sourceout="${build.xmlc.dir}"
48:includes="**/*.html">
49:

50:
51:
52:
53:
54:
55:
56:
57:
58:

59:


60:
61:
62:
63:
64:

65:
66:67:destdir="${build.classes}"
68:classpathref="build.classpath"
69:debug="${build.debug}"/>

70:
71:72:destdir="${build.classes}"
73:classpathref="build.classpath"
74:debug="${build.debug}"
75:includes="${app.name}/**"
76:/>
77:


78:
79:
80:
81:
82:
83:
84:
85:
86:
87:
88:
89:

90:

91:



92:
93:
94:
95:
96:
97:
98:


99:
100:
101:
102:
103:
104:

105:
106:
107:108:tofile="${build.dir}/multiserver.conf"
109:filtering="on"/>

110:
111:
112:
113:


114:





4:build.xml详细说明
下 面我们将详细讲述这个文件,同样为了方便,我加了行号,当然一些基本的东西我就不再重复了。第四行taskdef任务(task)属于ant的内部任务, 它的作用是定义一个任务,其基本属性有name,classname,在定义时这两个属性都必需有。第八行开始定义一个path,它有一个属性id,通过 这个id的值我们可以在后面引用这个path,参见第68行。目标(target)init(从14行到34行)定义了一些基本属性 (property),主要是为了后面的target使用。在第38行,你会看到depends="init",depends是定义一个目标时的可选属 性,它的意思是如果init目标没有执行(出错或其他原因),这个目标也不会被执行。

从第46行开始定义xmlc任务,到第58行结束,中间有很多参数嵌套在其中,srcdir指定源文件目录,sourceout指定输出目录,includes属性将源文件目录中的所有html文件包括进来。*为通配符。

表示取消警告,表示同时产生接口和实现代码,例如:一个welcome.html,它会产生两个文件: WelcomeHTMLImpl.java,WelcomeHTML.java,WelcomeHTML.java中只定义了一个接口 WelcomeHTML,真正的实现在WelcomeHTMLImpl.java中。表示设置编码,由于xmlc将html文件编译为java类,即使你在html文件中已经设置了编码,在 java类中也不会有作用,必须在编译时设置编码。 这两句相当于在命令行上输入-ssi -keep.其中ssi参数是在编译html文件时将定义的ssi文件包括进来,见html目录下的welcome2.html源代码中有一行: Ant简介-jennyljd-ChinaUnix博客
  • 博客访问: 313304
  • 博文数量: 54
  • 博客积分: 1400
  • 博客等级: 上尉
  • 技术积分: 606
  • 用 户 组: 普通用户
  • 注册时间: 2006-12-03 22:43
文章分类
文章存档

2011年(3)

2010年(26)

2009年(2)

2008年(23)

我的朋友

分类:

2009-02-21 20:15:11

本文描述了ant的基本语法及其如何应用于项目的管理
-. Ant简介
可 能有许多读者并不了解什么是ant,以及如何使用它。但只要你是用过linux,你应该知道make为何物,当我们编译linux内核及一些软件的源程序 时,我们经常需要在控制台下输入make。Make其实就是一个项目管理工具,而ant所实现的功能与make差不多。Ant是apache软件基金会 jakarta项目中的一个子项目,由于是基于java编写的,因此具有很好的跨平台性。Ant由一些内置任务(task)和可选择的任务组成(当然你还 可以编写自己的任务),使用Make时,你需要写一个Makefile文件,而用ant时则需要写一个build.xml文件。由于采用xml的语法,所 以build.xml文件很容易书写和维护,且结构很清晰,而不像Makefile文件有那么多的限制(例如在tab符号前有一个空格的话,命令就不会执 行)。Ant的优点远不止这些,它还很容易的集成到一些开发环境中(例如visual age,jbuilder,netbeans)。

二.Ant的安装及配置
安装
Ant 目前的版本是1.3,首先到下载ant最新版本1.3,解压到C: /ant(window操作系统) 或者/usr/local/ant(linux操作系统),由于我们要用到xmlc ,而ant1.3中并没有包含它,所以我们需要David.Li为ant写的xmlc任务。具体url为http: //。将下载后的文件中的 ant.jar替换掉ant1.3中ant.jar.这样ant的版本变为1.2.

2.设置路径
(1):windows98操作系统
编辑C:\enhydra\.bashrc,加入下面三行

export ANT_HOME=/ant
export JAVA_HOME=/jdk-1.2.2
export PATH=${PATH}:${ANT_HOME}/bin

(2):Linux操作系统
编辑/etc/profile或者 用户目录下的.bashrc文件,加入下面三行

export ANT_HOME=/usr/local/ant
export JAVA_HOME=/usr/local/jdk-1.2.2
export PATH=${PATH}:${ANT_HOME}/bin

三:用ant管理项目
1:基本的文件目录结构 解压到任意目录,我们可以看到目录树结构如下
├─bin
├─docs
│ ├─ant2
│ ├─api
│ │ └─org
│ │ └─apache
│ │ └─tools
│ │ ├─ant
│ │ │ ├─taskdefs
│ │ │ │ ├─compilers
│ │ │ │ └─optional
│ │ │ │ ├─clearcase
│ │ │ │ ├─depend
│ │ │ │ │ └─constantpool
│ │ │ │ ├─dotnet
│ │ │ │ ├─ejb
│ │ │ │ ├─ide
│ │ │ │ ├─javacc
│ │ │ │ ├─jlink
│ │ │ │ ├─jsp
│ │ │ │ ├─junit
│ │ │ │ ├─metamata
│ │ │ │ ├─net
│ │ │ │ ├─perforce
│ │ │ │ ├─scm
│ │ │ │ ├─sound
│ │ │ │ └─vss
│ │ │ ├─types
│ │ │ └─util
│ │ │ └─regexp
│ │ ├─mail
│ │ └─tar
│ └─manual
│ ├─CoreTasks
│ ├─CoreTypes
│ ├─Integration
│ └─OptionalTasks
└─lib





在这个目录树结构中,与传统的项目不同的是,我们用build.xml取代了Makefile,在讲述这个build.xml文件前,我们先了解一个基本的 build.xml文件的结构。

2:build.xml的基本书写规范
下面我们就来讲述这个文件的书写方法,下面是这个文件的全部内容
1.
2.
3.
4.
5.
6.

7.





为 了方便说明,我们为每一行加了行号,第一行是xml文件的基本要素,第二行说明这是一个项目,第七行说明项目的结束 ,在第二行中,name="MyProject"说明此项目的名称,这个属性可有可无。basedir="."说明基本目录,此属性可有可无。 default="dist"说明项目的缺省目标(target)是什么,这个属性必须有。所谓目标(target)就是一系列任务(task)组成的一 个集合。每个任务(task)的书写方法如下:
<任务名 属性1="属性1的值" 属性2="属性2的值" ....... />




第 三行定义了一些属性(property),以便后面使用,这非常类似于编程中定义的全局变量。从第四行开始定义目标(target),name= "init"指明了此目标的名称,name属性在定义目标时必须有,当然定义目标时还有其他一些属性可选,例如depends,unless,具体请参考 ant的文档。第五行开始定义此目标内的任务,其中mkdir时ant的内部任务名,dir是此任务的属性,其值为${dist}。此任务就是创建一个目 录。其中${dist}是获取dist属性的值(就是我们在第三行定义的)。如上就是一个基本的build.xml文件的写法。你可以在命令行上输入 ant -buildfile build.xml

看一下你的当前目录下是否多了一个dist目录。如果出错,则可能是你没有把ant配置好,参见前面讲的安装及配置,看一下哪儿出了错。

3:build.xml文件
build.xml文件如下,其中有的注释和无关的代码删掉了,且做了一下小小的改动
1:
2:
3:
4:
5:
6:
7:
8:
9:
10:


11:
12:
13:
14:
15:
16:
17:
18:
19:

20:
21:
22:
23:

24:
25:

26:
27:
28:
29:
30:
31:
32:

33:
34:


35:
36:
37:
38:
39:
40:


41:
42:
43:
44:
45:
46:47:sourceout="${build.xmlc.dir}"
48:includes="**/*.html">
49:

50:
51:
52:
53:
54:
55:
56:
57:
58:

59:


60:
61:
62:
63:
64:

65:
66:67:destdir="${build.classes}"
68:classpathref="build.classpath"
69:debug="${build.debug}"/>

70:
71:72:destdir="${build.classes}"
73:classpathref="build.classpath"
74:debug="${build.debug}"
75:includes="${app.name}/**"
76:/>
77:


78:
79:
80:
81:
82:
83:
84:
85:
86:
87:
88:
89:

90:

91:



92:
93:
94:
95:
96:
97:
98:


99:
100:
101:
102:
103:
104:

105:
106:
107:108:tofile="${build.dir}/multiserver.conf"
109:filtering="on"/>

110:
111:
112:
113:


114:





4:build.xml详细说明
下 面我们将详细讲述这个文件,同样为了方便,我加了行号,当然一些基本的东西我就不再重复了。第四行taskdef任务(task)属于ant的内部任务, 它的作用是定义一个任务,其基本属性有name,classname,在定义时这两个属性都必需有。第八行开始定义一个path,它有一个属性id,通过 这个id的值我们可以在后面引用这个path,参见第68行。目标(target)init(从14行到34行)定义了一些基本属性 (property),主要是为了后面的target使用。在第38行,你会看到depends="init",depends是定义一个目标时的可选属 性,它的意思是如果init目标没有执行(出错或其他原因),这个目标也不会被执行。

从第46行开始定义xmlc任务,到第58行结束,中间有很多参数嵌套在其中,srcdir指定源文件目录,sourceout指定输出目录,includes属性将源文件目录中的所有html文件包括进来。*为通配符。

表示取消警告,表示同时产生接口和实现代码,例如:一个welcome.html,它会产生两个文件: WelcomeHTMLImpl.java,WelcomeHTML.java,WelcomeHTML.java中只定义了一个接口 WelcomeHTML,真正的实现在WelcomeHTMLImpl.java中。表示设置编码,由于xmlc将html文件编译为java类,即使你在html文件中已经设置了编码,在 java类中也不会有作用,必须在编译时设置编码。 这两句相当于在命令行上输入-ssi -keep.其中ssi参数是在编译html文件时将定义的ssi文件包括进来,见html目录下的welcome2.html源代码中有一行: Ant简介-jennyljd-ChinaUnix博客
  • 博客访问: 313315
  • 博文数量: 54
  • 博客积分: 1400
  • 博客等级: 上尉
  • 技术积分: 606
  • 用 户 组: 普通用户
  • 注册时间: 2006-12-03 22:43
文章分类
文章存档

2011年(3)

2010年(26)

2009年(2)

2008年(23)

我的朋友

分类:

2009-02-21 20:15:11

本文描述了ant的基本语法及其如何应用于项目的管理
-. Ant简介
可 能有许多读者并不了解什么是ant,以及如何使用它。但只要你是用过linux,你应该知道make为何物,当我们编译linux内核及一些软件的源程序 时,我们经常需要在控制台下输入make。Make其实就是一个项目管理工具,而ant所实现的功能与make差不多。Ant是apache软件基金会 jakarta项目中的一个子项目,由于是基于java编写的,因此具有很好的跨平台性。Ant由一些内置任务(task)和可选择的任务组成(当然你还 可以编写自己的任务),使用Make时,你需要写一个Makefile文件,而用ant时则需要写一个build.xml文件。由于采用xml的语法,所 以build.xml文件很容易书写和维护,且结构很清晰,而不像Makefile文件有那么多的限制(例如在tab符号前有一个空格的话,命令就不会执 行)。Ant的优点远不止这些,它还很容易的集成到一些开发环境中(例如visual age,jbuilder,netbeans)。

二.Ant的安装及配置
安装
Ant 目前的版本是1.3,首先到下载ant最新版本1.3,解压到C: /ant(window操作系统) 或者/usr/local/ant(linux操作系统),由于我们要用到xmlc ,而ant1.3中并没有包含它,所以我们需要David.Li为ant写的xmlc任务。具体url为http: //。将下载后的文件中的 ant.jar替换掉ant1.3中ant.jar.这样ant的版本变为1.2.

2.设置路径
(1):windows98操作系统
编辑C:\enhydra\.bashrc,加入下面三行

export ANT_HOME=/ant
export JAVA_HOME=/jdk-1.2.2
export PATH=${PATH}:${ANT_HOME}/bin

(2):Linux操作系统
编辑/etc/profile或者 用户目录下的.bashrc文件,加入下面三行

export ANT_HOME=/usr/local/ant
export JAVA_HOME=/usr/local/jdk-1.2.2
export PATH=${PATH}:${ANT_HOME}/bin

三:用ant管理项目
1:基本的文件目录结构 解压到任意目录,我们可以看到目录树结构如下
├─bin
├─docs
│ ├─ant2
│ ├─api
│ │ └─org
│ │ └─apache
│ │ └─tools
│ │ ├─ant
│ │ │ ├─taskdefs
│ │ │ │ ├─compilers
│ │ │ │ └─optional
│ │ │ │ ├─clearcase
│ │ │ │ ├─depend
│ │ │ │ │ └─constantpool
│ │ │ │ ├─dotnet
│ │ │ │ ├─ejb
│ │ │ │ ├─ide
│ │ │ │ ├─javacc
│ │ │ │ ├─jlink
│ │ │ │ ├─jsp
│ │ │ │ ├─junit
│ │ │ │ ├─metamata
│ │ │ │ ├─net
│ │ │ │ ├─perforce
│ │ │ │ ├─scm
│ │ │ │ ├─sound
│ │ │ │ └─vss
│ │ │ ├─types
│ │ │ └─util
│ │ │ └─regexp
│ │ ├─mail
│ │ └─tar
│ └─manual
│ ├─CoreTasks
│ ├─CoreTypes
│ ├─Integration
│ └─OptionalTasks
└─lib





在这个目录树结构中,与传统的项目不同的是,我们用build.xml取代了Makefile,在讲述这个build.xml文件前,我们先了解一个基本的 build.xml文件的结构。

2:build.xml的基本书写规范
下面我们就来讲述这个文件的书写方法,下面是这个文件的全部内容
1.
2.
3.
4.
5.
6.

7.





为 了方便说明,我们为每一行加了行号,第一行是xml文件的基本要素,第二行说明这是一个项目,第七行说明项目的结束 ,在第二行中,name="MyProject"说明此项目的名称,这个属性可有可无。basedir="."说明基本目录,此属性可有可无。 default="dist"说明项目的缺省目标(target)是什么,这个属性必须有。所谓目标(target)就是一系列任务(task)组成的一 个集合。每个任务(task)的书写方法如下:
<任务名 属性1="属性1的值" 属性2="属性2的值" ....... />




第 三行定义了一些属性(property),以便后面使用,这非常类似于编程中定义的全局变量。从第四行开始定义目标(target),name= "init"指明了此目标的名称,name属性在定义目标时必须有,当然定义目标时还有其他一些属性可选,例如depends,unless,具体请参考 ant的文档。第五行开始定义此目标内的任务,其中mkdir时ant的内部任务名,dir是此任务的属性,其值为${dist}。此任务就是创建一个目 录。其中${dist}是获取dist属性的值(就是我们在第三行定义的)。如上就是一个基本的build.xml文件的写法。你可以在命令行上输入 ant -buildfile build.xml

看一下你的当前目录下是否多了一个dist目录。如果出错,则可能是你没有把ant配置好,参见前面讲的安装及配置,看一下哪儿出了错。

3:build.xml文件
build.xml文件如下,其中有的注释和无关的代码删掉了,且做了一下小小的改动
1:
2:
3:
4:
5:
6:
7:
8:
9:
10:


11:
12:
13:
14:
15:
16:
17:
18:
19:

20:
21:
22:
23:

24:
25:

26:
27:
28:
29:
30:
31:
32:

33:
34:


35:
36:
37:
38:
39:
40:


41:
42:
43:
44:
45:
46:47:sourceout="${build.xmlc.dir}"
48:includes="**/*.html">
49:

50:
51:
52:
53:
54:
55:
56:
57:
58:

59:


60:
61:
62:
63:
64:

65:
66:67:destdir="${build.classes}"
68:classpathref="build.classpath"
69:debug="${build.debug}"/>

70:
71:72:destdir="${build.classes}"
73:classpathref="build.classpath"
74:debug="${build.debug}"
75:includes="${app.name}/**"
76:/>
77:


78:
79:
80:
81:
82:
83:
84:
85:
86:
87:
88:
89:

90:

91:



92:
93:
94:
95:
96:
97:
98:


99:
100:
101:
102:
103:
104:

105:
106:
107:108:tofile="${build.dir}/multiserver.conf"
109:filtering="on"/>

110:
111:
112:
113:


114:





4:build.xml详细说明
下 面我们将详细讲述这个文件,同样为了方便,我加了行号,当然一些基本的东西我就不再重复了。第四行taskdef任务(task)属于ant的内部任务, 它的作用是定义一个任务,其基本属性有name,classname,在定义时这两个属性都必需有。第八行开始定义一个path,它有一个属性id,通过 这个id的值我们可以在后面引用这个path,参见第68行。目标(target)init(从14行到34行)定义了一些基本属性 (property),主要是为了后面的target使用。在第38行,你会看到depends="init",depends是定义一个目标时的可选属 性,它的意思是如果init目标没有执行(出错或其他原因),这个目标也不会被执行。

从第46行开始定义xmlc任务,到第58行结束,中间有很多参数嵌套在其中,srcdir指定源文件目录,sourceout指定输出目录,includes属性将源文件目录中的所有html文件包括进来。*为通配符。

表示取消警告,表示同时产生接口和实现代码,例如:一个welcome.html,它会产生两个文件: WelcomeHTMLImpl.java,WelcomeHTML.java,WelcomeHTML.java中只定义了一个接口 WelcomeHTML,真正的实现在WelcomeHTMLImpl.java中。表示设置编码,由于xmlc将html文件编译为java类,即使你在html文件中已经设置了编码,在 java类中也不会有作用,必须在编译时设置编码。 这两句相当于在命令行上输入-ssi -keep.其中ssi参数是在编译html文件时将定义的ssi文件包括进来,见html目录下的welcome2.html源代码中有一行: Ant简介-jennyljd-ChinaUnix博客
  • 博客访问: 313316
  • 博文数量: 54
  • 博客积分: 1400
  • 博客等级: 上尉
  • 技术积分: 606
  • 用 户 组: 普通用户
  • 注册时间: 2006-12-03 22:43
文章分类
文章存档

2011年(3)

2010年(26)

2009年(2)

2008年(23)

我的朋友

分类:

2009-02-21 20:15:11

本文描述了ant的基本语法及其如何应用于项目的管理
-. Ant简介
可 能有许多读者并不了解什么是ant,以及如何使用它。但只要你是用过linux,你应该知道make为何物,当我们编译linux内核及一些软件的源程序 时,我们经常需要在控制台下输入make。Make其实就是一个项目管理工具,而ant所实现的功能与make差不多。Ant是apache软件基金会 jakarta项目中的一个子项目,由于是基于java编写的,因此具有很好的跨平台性。Ant由一些内置任务(task)和可选择的任务组成(当然你还 可以编写自己的任务),使用Make时,你需要写一个Makefile文件,而用ant时则需要写一个build.xml文件。由于采用xml的语法,所 以build.xml文件很容易书写和维护,且结构很清晰,而不像Makefile文件有那么多的限制(例如在tab符号前有一个空格的话,命令就不会执 行)。Ant的优点远不止这些,它还很容易的集成到一些开发环境中(例如visual age,jbuilder,netbeans)。

二.Ant的安装及配置
安装
Ant 目前的版本是1.3,首先到下载ant最新版本1.3,解压到C: /ant(window操作系统) 或者/usr/local/ant(linux操作系统),由于我们要用到xmlc ,而ant1.3中并没有包含它,所以我们需要David.Li为ant写的xmlc任务。具体url为http: //。将下载后的文件中的 ant.jar替换掉ant1.3中ant.jar.这样ant的版本变为1.2.

2.设置路径
(1):windows98操作系统
编辑C:\enhydra\.bashrc,加入下面三行

export ANT_HOME=/ant
export JAVA_HOME=/jdk-1.2.2
export PATH=${PATH}:${ANT_HOME}/bin

(2):Linux操作系统
编辑/etc/profile或者 用户目录下的.bashrc文件,加入下面三行

export ANT_HOME=/usr/local/ant
export JAVA_HOME=/usr/local/jdk-1.2.2
export PATH=${PATH}:${ANT_HOME}/bin

三:用ant管理项目
1:基本的文件目录结构 解压到任意目录,我们可以看到目录树结构如下
├─bin
├─docs
│ ├─ant2
│ ├─api
│ │ └─org
│ │ └─apache
│ │ └─tools
│ │ ├─ant
│ │ │ ├─taskdefs
│ │ │ │ ├─compilers
│ │ │ │ └─optional
│ │ │ │ ├─clearcase
│ │ │ │ ├─depend
│ │ │ │ │ └─constantpool
│ │ │ │ ├─dotnet
│ │ │ │ ├─ejb
│ │ │ │ ├─ide
│ │ │ │ ├─javacc
│ │ │ │ ├─jlink
│ │ │ │ ├─jsp
│ │ │ │ ├─junit
│ │ │ │ ├─metamata
│ │ │ │ ├─net
│ │ │ │ ├─perforce
│ │ │ │ ├─scm
│ │ │ │ ├─sound
│ │ │ │ └─vss
│ │ │ ├─types
│ │ │ └─util
│ │ │ └─regexp
│ │ ├─mail
│ │ └─tar
│ └─manual
│ ├─CoreTasks
│ ├─CoreTypes
│ ├─Integration
│ └─OptionalTasks
└─lib





在这个目录树结构中,与传统的项目不同的是,我们用build.xml取代了Makefile,在讲述这个build.xml文件前,我们先了解一个基本的 build.xml文件的结构。

2:build.xml的基本书写规范
下面我们就来讲述这个文件的书写方法,下面是这个文件的全部内容
1.
2.
3.
4.
5.
6.

7.





为 了方便说明,我们为每一行加了行号,第一行是xml文件的基本要素,第二行说明这是一个项目,第七行说明项目的结束 ,在第二行中,name="MyProject"说明此项目的名称,这个属性可有可无。basedir="."说明基本目录,此属性可有可无。 default="dist"说明项目的缺省目标(target)是什么,这个属性必须有。所谓目标(target)就是一系列任务(task)组成的一 个集合。每个任务(task)的书写方法如下:
<任务名 属性1="属性1的值" 属性2="属性2的值" ....... />




第 三行定义了一些属性(property),以便后面使用,这非常类似于编程中定义的全局变量。从第四行开始定义目标(target),name= "init"指明了此目标的名称,name属性在定义目标时必须有,当然定义目标时还有其他一些属性可选,例如depends,unless,具体请参考 ant的文档。第五行开始定义此目标内的任务,其中mkdir时ant的内部任务名,dir是此任务的属性,其值为${dist}。此任务就是创建一个目 录。其中${dist}是获取dist属性的值(就是我们在第三行定义的)。如上就是一个基本的build.xml文件的写法。你可以在命令行上输入 ant -buildfile build.xml

看一下你的当前目录下是否多了一个dist目录。如果出错,则可能是你没有把ant配置好,参见前面讲的安装及配置,看一下哪儿出了错。

3:build.xml文件
build.xml文件如下,其中有的注释和无关的代码删掉了,且做了一下小小的改动
1:
2:
3:
4:
5:
6:
7:
8:
9:
10:


11:
12:
13:
14:
15:
16:
17:
18:
19:

20:
21:
22:
23:

24:
25:

26:
27:
28:
29:
30:
31:
32:

33:
34:


35:
36:
37:
38:
39:
40:


41:
42:
43:
44:
45:
46:47:sourceout="${build.xmlc.dir}"
48:includes="**/*.html">
49:

50:
51:
52:
53:
54:
55:
56:
57:
58:

59:


60:
61:
62:
63:
64:

65:
66:67:destdir="${build.classes}"
68:classpathref="build.classpath"
69:debug="${build.debug}"/>

70:
71:72:destdir="${build.classes}"
73:classpathref="build.classpath"
74:debug="${build.debug}"
75:includes="${app.name}/**"
76:/>
77:


78:
79:
80:
81:
82:
83:
84:
85:
86:
87:
88:
89:

90:

91:



92:
93:
94:
95:
96:
97:
98:


99:
100:
101:
102:
103:
104:

105:
106:
107:108:tofile="${build.dir}/multiserver.conf"
109:filtering="on"/>

110:
111:
112:
113:


114:





4:build.xml详细说明
下 面我们将详细讲述这个文件,同样为了方便,我加了行号,当然一些基本的东西我就不再重复了。第四行taskdef任务(task)属于ant的内部任务, 它的作用是定义一个任务,其基本属性有name,classname,在定义时这两个属性都必需有。第八行开始定义一个path,它有一个属性id,通过 这个id的值我们可以在后面引用这个path,参见第68行。目标(target)init(从14行到34行)定义了一些基本属性 (property),主要是为了后面的target使用。在第38行,你会看到depends="init",depends是定义一个目标时的可选属 性,它的意思是如果init目标没有执行(出错或其他原因),这个目标也不会被执行。

从第46行开始定义xmlc任务,到第58行结束,中间有很多参数嵌套在其中,srcdir指定源文件目录,sourceout指定输出目录,includes属性将源文件目录中的所有html文件包括进来。*为通配符。

表示取消警告,表示同时产生接口和实现代码,例如:一个welcome.html,它会产生两个文件: WelcomeHTMLImpl.java,WelcomeHTML.java,WelcomeHTML.java中只定义了一个接口 WelcomeHTML,真正的实现在WelcomeHTMLImpl.java中。表示设置编码,由于xmlc将html文件编译为java类,即使你在html文件中已经设置了编码,在 java类中也不会有作用,必须在编译时设置编码。 这两句相当于在命令行上输入-ssi -keep.其中ssi参数是在编译html文件时将定义的ssi文件包括进来,见html目录下的welcome2.html源代码中有一行: Ant简介-jennyljd-ChinaUnix博客
  • 博客访问: 313317
  • 博文数量: 54
  • 博客积分: 1400
  • 博客等级: 上尉
  • 技术积分: 606
  • 用 户 组: 普通用户
  • 注册时间: 2006-12-03 22:43
文章分类
文章存档

2011年(3)

2010年(26)

2009年(2)

2008年(23)

我的朋友

分类:

2009-02-21 20:15:11

本文描述了ant的基本语法及其如何应用于项目的管理
-. Ant简介
可 能有许多读者并不了解什么是ant,以及如何使用它。但只要你是用过linux,你应该知道make为何物,当我们编译linux内核及一些软件的源程序 时,我们经常需要在控制台下输入make。Make其实就是一个项目管理工具,而ant所实现的功能与make差不多。Ant是apache软件基金会 jakarta项目中的一个子项目,由于是基于java编写的,因此具有很好的跨平台性。Ant由一些内置任务(task)和可选择的任务组成(当然你还 可以编写自己的任务),使用Make时,你需要写一个Makefile文件,而用ant时则需要写一个build.xml文件。由于采用xml的语法,所 以build.xml文件很容易书写和维护,且结构很清晰,而不像Makefile文件有那么多的限制(例如在tab符号前有一个空格的话,命令就不会执 行)。Ant的优点远不止这些,它还很容易的集成到一些开发环境中(例如visual age,jbuilder,netbeans)。

二.Ant的安装及配置
安装
Ant 目前的版本是1.3,首先到下载ant最新版本1.3,解压到C: /ant(window操作系统) 或者/usr/local/ant(linux操作系统),由于我们要用到xmlc ,而ant1.3中并没有包含它,所以我们需要David.Li为ant写的xmlc任务。具体url为http: //。将下载后的文件中的 ant.jar替换掉ant1.3中ant.jar.这样ant的版本变为1.2.

2.设置路径
(1):windows98操作系统
编辑C:\enhydra\.bashrc,加入下面三行

export ANT_HOME=/ant
export JAVA_HOME=/jdk-1.2.2
export PATH=${PATH}:${ANT_HOME}/bin

(2):Linux操作系统
编辑/etc/profile或者 用户目录下的.bashrc文件,加入下面三行

export ANT_HOME=/usr/local/ant
export JAVA_HOME=/usr/local/jdk-1.2.2
export PATH=${PATH}:${ANT_HOME}/bin

三:用ant管理项目
1:基本的文件目录结构 解压到任意目录,我们可以看到目录树结构如下
├─bin
├─docs
│ ├─ant2
│ ├─api
│ │ └─org
│ │ └─apache
│ │ └─tools
│ │ ├─ant
│ │ │ ├─taskdefs
│ │ │ │ ├─compilers
│ │ │ │ └─optional
│ │ │ │ ├─clearcase
│ │ │ │ ├─depend
│ │ │ │ │ └─constantpool
│ │ │ │ ├─dotnet
│ │ │ │ ├─ejb
│ │ │ │ ├─ide
│ │ │ │ ├─javacc
│ │ │ │ ├─jlink
│ │ │ │ ├─jsp
│ │ │ │ ├─junit
│ │ │ │ ├─metamata
│ │ │ │ ├─net
│ │ │ │ ├─perforce
│ │ │ │ ├─scm
│ │ │ │ ├─sound
│ │ │ │ └─vss
│ │ │ ├─types
│ │ │ └─util
│ │ │ └─regexp
│ │ ├─mail
│ │ └─tar
│ └─manual
│ ├─CoreTasks
│ ├─CoreTypes
│ ├─Integration
│ └─OptionalTasks
└─lib





在这个目录树结构中,与传统的项目不同的是,我们用build.xml取代了Makefile,在讲述这个build.xml文件前,我们先了解一个基本的 build.xml文件的结构。

2:build.xml的基本书写规范
下面我们就来讲述这个文件的书写方法,下面是这个文件的全部内容
1.
2.
3.
4.
5.
6.

7.





为 了方便说明,我们为每一行加了行号,第一行是xml文件的基本要素,第二行说明这是一个项目,第七行说明项目的结束 ,在第二行中,name="MyProject"说明此项目的名称,这个属性可有可无。basedir="."说明基本目录,此属性可有可无。 default="dist"说明项目的缺省目标(target)是什么,这个属性必须有。所谓目标(target)就是一系列任务(task)组成的一 个集合。每个任务(task)的书写方法如下:
<任务名 属性1="属性1的值" 属性2="属性2的值" ....... />




第 三行定义了一些属性(property),以便后面使用,这非常类似于编程中定义的全局变量。从第四行开始定义目标(target),name= "init"指明了此目标的名称,name属性在定义目标时必须有,当然定义目标时还有其他一些属性可选,例如depends,unless,具体请参考 ant的文档。第五行开始定义此目标内的任务,其中mkdir时ant的内部任务名,dir是此任务的属性,其值为${dist}。此任务就是创建一个目 录。其中${dist}是获取dist属性的值(就是我们在第三行定义的)。如上就是一个基本的build.xml文件的写法。你可以在命令行上输入 ant -buildfile build.xml

看一下你的当前目录下是否多了一个dist目录。如果出错,则可能是你没有把ant配置好,参见前面讲的安装及配置,看一下哪儿出了错。

3:build.xml文件
build.xml文件如下,其中有的注释和无关的代码删掉了,且做了一下小小的改动
1:
2:
3:
4:
5:
6:
7:
8:
9:
10:


11:
12:
13:
14:
15:
16:
17:
18:
19:

20:
21:
22:
23:

24:
25:

26:
27:
28:
29:
30:
31:
32:

33:
34:


35:
36:
37:
38:
39:
40:


41:
42:
43:
44:
45:
46:47:sourceout="${build.xmlc.dir}"
48:includes="**/*.html">
49:

50:
51:
52:
53:
54:
55:
56:
57:
58:

59:


60:
61:
62:
63:
64:

65:
66:67:destdir="${build.classes}"
68:classpathref="build.classpath"
69:debug="${build.debug}"/>

70:
71:72:destdir="${build.classes}"
73:classpathref="build.classpath"
74:debug="${build.debug}"
75:includes="${app.name}/**"
76:/>
77:


78:
79:
80:
81:
82:
83:
84:
85:
86:
87:
88:
89:

90:

91:



92:
93:
94:
95:
96:
97:
98:


99:
100:
101:
102:
103:
104:

105:
106:
107:108:tofile="${build.dir}/multiserver.conf"
109:filtering="on"/>

110:
111:
112:
113:


114:





4:build.xml详细说明
下 面我们将详细讲述这个文件,同样为了方便,我加了行号,当然一些基本的东西我就不再重复了。第四行taskdef任务(task)属于ant的内部任务, 它的作用是定义一个任务,其基本属性有name,classname,在定义时这两个属性都必需有。第八行开始定义一个path,它有一个属性id,通过 这个id的值我们可以在后面引用这个path,参见第68行。目标(target)init(从14行到34行)定义了一些基本属性 (property),主要是为了后面的target使用。在第38行,你会看到depends="init",depends是定义一个目标时的可选属 性,它的意思是如果init目标没有执行(出错或其他原因),这个目标也不会被执行。

从第46行开始定义xmlc任务,到第58行结束,中间有很多参数嵌套在其中,srcdir指定源文件目录,sourceout指定输出目录,includes属性将源文件目录中的所有html文件包括进来。*为通配符。

表示取消警告,表示同时产生接口和实现代码,例如:一个welcome.html,它会产生两个文件: WelcomeHTMLImpl.java,WelcomeHTML.java,WelcomeHTML.java中只定义了一个接口 WelcomeHTML,真正的实现在WelcomeHTMLImpl.java中。表示设置编码,由于xmlc将html文件编译为java类,即使你在html文件中已经设置了编码,在 java类中也不会有作用,必须在编译时设置编码。 这两句相当于在命令行上输入-ssi -keep.其中ssi参数是在编译html文件时将定义的ssi文件包括进来,见html目录下的welcome2.html源代码中有一行: Ant简介-jennyljd-ChinaUnix博客
  • 博客访问: 313318
  • 博文数量: 54
  • 博客积分: 1400
  • 博客等级: 上尉
  • 技术积分: 606
  • 用 户 组: 普通用户
  • 注册时间: 2006-12-03 22:43
文章分类
文章存档

2011年(3)

2010年(26)

2009年(2)

2008年(23)

我的朋友

分类:

2009-02-21 20:15:11

本文描述了ant的基本语法及其如何应用于项目的管理
-. Ant简介
可 能有许多读者并不了解什么是ant,以及如何使用它。但只要你是用过linux,你应该知道make为何物,当我们编译linux内核及一些软件的源程序 时,我们经常需要在控制台下输入make。Make其实就是一个项目管理工具,而ant所实现的功能与make差不多。Ant是apache软件基金会 jakarta项目中的一个子项目,由于是基于java编写的,因此具有很好的跨平台性。Ant由一些内置任务(task)和可选择的任务组成(当然你还 可以编写自己的任务),使用Make时,你需要写一个Makefile文件,而用ant时则需要写一个build.xml文件。由于采用xml的语法,所 以build.xml文件很容易书写和维护,且结构很清晰,而不像Makefile文件有那么多的限制(例如在tab符号前有一个空格的话,命令就不会执 行)。Ant的优点远不止这些,它还很容易的集成到一些开发环境中(例如visual age,jbuilder,netbeans)。

二.Ant的安装及配置
安装
Ant 目前的版本是1.3,首先到下载ant最新版本1.3,解压到C: /ant(window操作系统) 或者/usr/local/ant(linux操作系统),由于我们要用到xmlc ,而ant1.3中并没有包含它,所以我们需要David.Li为ant写的xmlc任务。具体url为http: //。将下载后的文件中的 ant.jar替换掉ant1.3中ant.jar.这样ant的版本变为1.2.

2.设置路径
(1):windows98操作系统
编辑C:\enhydra\.bashrc,加入下面三行

export ANT_HOME=/ant
export JAVA_HOME=/jdk-1.2.2
export PATH=${PATH}:${ANT_HOME}/bin

(2):Linux操作系统
编辑/etc/profile或者 用户目录下的.bashrc文件,加入下面三行

export ANT_HOME=/usr/local/ant
export JAVA_HOME=/usr/local/jdk-1.2.2
export PATH=${PATH}:${ANT_HOME}/bin

三:用ant管理项目
1:基本的文件目录结构 解压到任意目录,我们可以看到目录树结构如下
├─bin
├─docs
│ ├─ant2
│ ├─api
│ │ └─org
│ │ └─apache
│ │ └─tools
│ │ ├─ant
│ │ │ ├─taskdefs
│ │ │ │ ├─compilers
│ │ │ │ └─optional
│ │ │ │ ├─clearcase
│ │ │ │ ├─depend
│ │ │ │ │ └─constantpool
│ │ │ │ ├─dotnet
│ │ │ │ ├─ejb
│ │ │ │ ├─ide
│ │ │ │ ├─javacc
│ │ │ │ ├─jlink
│ │ │ │ ├─jsp
│ │ │ │ ├─junit
│ │ │ │ ├─metamata
│ │ │ │ ├─net
│ │ │ │ ├─perforce
│ │ │ │ ├─scm
│ │ │ │ ├─sound
│ │ │ │ └─vss
│ │ │ ├─types
│ │ │ └─util
│ │ │ └─regexp
│ │ ├─mail
│ │ └─tar
│ └─manual
│ ├─CoreTasks
│ ├─CoreTypes
│ ├─Integration
│ └─OptionalTasks
└─lib





在这个目录树结构中,与传统的项目不同的是,我们用build.xml取代了Makefile,在讲述这个build.xml文件前,我们先了解一个基本的 build.xml文件的结构。

2:build.xml的基本书写规范
下面我们就来讲述这个文件的书写方法,下面是这个文件的全部内容
1.
2.
3.
4.
5.
6.

7.





为 了方便说明,我们为每一行加了行号,第一行是xml文件的基本要素,第二行说明这是一个项目,第七行说明项目的结束 ,在第二行中,name="MyProject"说明此项目的名称,这个属性可有可无。basedir="."说明基本目录,此属性可有可无。 default="dist"说明项目的缺省目标(target)是什么,这个属性必须有。所谓目标(target)就是一系列任务(task)组成的一 个集合。每个任务(task)的书写方法如下:
<任务名 属性1="属性1的值" 属性2="属性2的值" ....... />




第 三行定义了一些属性(property),以便后面使用,这非常类似于编程中定义的全局变量。从第四行开始定义目标(target),name= "init"指明了此目标的名称,name属性在定义目标时必须有,当然定义目标时还有其他一些属性可选,例如depends,unless,具体请参考 ant的文档。第五行开始定义此目标内的任务,其中mkdir时ant的内部任务名,dir是此任务的属性,其值为${dist}。此任务就是创建一个目 录。其中${dist}是获取dist属性的值(就是我们在第三行定义的)。如上就是一个基本的build.xml文件的写法。你可以在命令行上输入 ant -buildfile build.xml

看一下你的当前目录下是否多了一个dist目录。如果出错,则可能是你没有把ant配置好,参见前面讲的安装及配置,看一下哪儿出了错。

3:build.xml文件
build.xml文件如下,其中有的注释和无关的代码删掉了,且做了一下小小的改动
1:
2:
3:
4:
5:
6:
7:
8:
9:
10:


11:
12:
13:
14:
15:
16:
17:
18:
19:

20:
21:
22:
23:

24:
25:

26:
27:
28:
29:
30:
31:
32:

33:
34:


35:
36:
37:
38:
39:
40:


41:
42:
43:
44:
45:
46:47:sourceout="${build.xmlc.dir}"
48:includes="**/*.html">
49:

50:
51:
52:
53:
54:
55:
56:
57:
58:

59:


60:
61:
62:
63:
64:

65:
66:67:destdir="${build.classes}"
68:classpathref="build.classpath"
69:debug="${build.debug}"/>

70:
71:72:destdir="${build.classes}"
73:classpathref="build.classpath"
74:debug="${build.debug}"
75:includes="${app.name}/**"
76:/>
77:


78:
79:
80:
81:
82:
83:
84:
85:
86:
87:
88:
89:

90:

91:



92:
93:
94:
95:
96:
97:
98:


99:
100:
101:
102:
103:
104:

105:
106:
107:108:tofile="${build.dir}/multiserver.conf"
109:filtering="on"/>

110:
111:
112:
113:


114:





4:build.xml详细说明
下 面我们将详细讲述这个文件,同样为了方便,我加了行号,当然一些基本的东西我就不再重复了。第四行taskdef任务(task)属于ant的内部任务, 它的作用是定义一个任务,其基本属性有name,classname,在定义时这两个属性都必需有。第八行开始定义一个path,它有一个属性id,通过 这个id的值我们可以在后面引用这个path,参见第68行。目标(target)init(从14行到34行)定义了一些基本属性 (property),主要是为了后面的target使用。在第38行,你会看到depends="init",depends是定义一个目标时的可选属 性,它的意思是如果init目标没有执行(出错或其他原因),这个目标也不会被执行。

从第46行开始定义xmlc任务,到第58行结束,中间有很多参数嵌套在其中,srcdir指定源文件目录,sourceout指定输出目录,includes属性将源文件目录中的所有html文件包括进来。*为通配符。

表示取消警告,表示同时产生接口和实现代码,例如:一个welcome.html,它会产生两个文件: WelcomeHTMLImpl.java,WelcomeHTML.java,WelcomeHTML.java中只定义了一个接口 WelcomeHTML,真正的实现在WelcomeHTMLImpl.java中。表示设置编码,由于xmlc将html文件编译为java类,即使你在html文件中已经设置了编码,在 java类中也不会有作用,必须在编译时设置编码。 这两句相当于在命令行上输入-ssi -keep.其中ssi参数是在编译html文件时将定义的ssi文件包括进来,见html目录下的welcome2.html源代码中有一行: Ant简介-jennyljd-ChinaUnix博客
  • 博客访问: 313319
  • 博文数量: 54
  • 博客积分: 1400
  • 博客等级: 上尉
  • 技术积分: 606
  • 用 户 组: 普通用户
  • 注册时间: 2006-12-03 22:43
文章分类
文章存档

2011年(3)

2010年(26)

2009年(2)

2008年(23)

我的朋友

分类:

2009-02-21 20:15:11

本文描述了ant的基本语法及其如何应用于项目的管理
-. Ant简介
可 能有许多读者并不了解什么是ant,以及如何使用它。但只要你是用过linux,你应该知道make为何物,当我们编译linux内核及一些软件的源程序 时,我们经常需要在控制台下输入make。Make其实就是一个项目管理工具,而ant所实现的功能与make差不多。Ant是apache软件基金会 jakarta项目中的一个子项目,由于是基于java编写的,因此具有很好的跨平台性。Ant由一些内置任务(task)和可选择的任务组成(当然你还 可以编写自己的任务),使用Make时,你需要写一个Makefile文件,而用ant时则需要写一个build.xml文件。由于采用xml的语法,所 以build.xml文件很容易书写和维护,且结构很清晰,而不像Makefile文件有那么多的限制(例如在tab符号前有一个空格的话,命令就不会执 行)。Ant的优点远不止这些,它还很容易的集成到一些开发环境中(例如visual age,jbuilder,netbeans)。

二.Ant的安装及配置
安装
Ant 目前的版本是1.3,首先到下载ant最新版本1.3,解压到C: /ant(window操作系统) 或者/usr/local/ant(linux操作系统),由于我们要用到xmlc ,而ant1.3中并没有包含它,所以我们需要David.Li为ant写的xmlc任务。具体url为http: //。将下载后的文件中的 ant.jar替换掉ant1.3中ant.jar.这样ant的版本变为1.2.

2.设置路径
(1):windows98操作系统
编辑C:\enhydra\.bashrc,加入下面三行

export ANT_HOME=/ant
export JAVA_HOME=/jdk-1.2.2
export PATH=${PATH}:${ANT_HOME}/bin

(2):Linux操作系统
编辑/etc/profile或者 用户目录下的.bashrc文件,加入下面三行

export ANT_HOME=/usr/local/ant
export JAVA_HOME=/usr/local/jdk-1.2.2
export PATH=${PATH}:${ANT_HOME}/bin

三:用ant管理项目
1:基本的文件目录结构 解压到任意目录,我们可以看到目录树结构如下
├─bin
├─docs
│ ├─ant2
│ ├─api
│ │ └─org
│ │ └─apache
│ │ └─tools
│ │ ├─ant
│ │ │ ├─taskdefs
│ │ │ │ ├─compilers
│ │ │ │ └─optional
│ │ │ │ ├─clearcase
│ │ │ │ ├─depend
│ │ │ │ │ └─constantpool
│ │ │ │ ├─dotnet
│ │ │ │ ├─ejb
│ │ │ │ ├─ide
│ │ │ │ ├─javacc
│ │ │ │ ├─jlink
│ │ │ │ ├─jsp
│ │ │ │ ├─junit
│ │ │ │ ├─metamata
│ │ │ │ ├─net
│ │ │ │ ├─perforce
│ │ │ │ ├─scm
│ │ │ │ ├─sound
│ │ │ │ └─vss
│ │ │ ├─types
│ │ │ └─util
│ │ │ └─regexp
│ │ ├─mail
│ │ └─tar
│ └─manual
│ ├─CoreTasks
│ ├─CoreTypes
│ ├─Integration
│ └─OptionalTasks
└─lib





在这个目录树结构中,与传统的项目不同的是,我们用build.xml取代了Makefile,在讲述这个build.xml文件前,我们先了解一个基本的 build.xml文件的结构。

2:build.xml的基本书写规范
下面我们就来讲述这个文件的书写方法,下面是这个文件的全部内容
1.
2.
3.
4.
5.
6.

7.





为 了方便说明,我们为每一行加了行号,第一行是xml文件的基本要素,第二行说明这是一个项目,第七行说明项目的结束 ,在第二行中,name="MyProject"说明此项目的名称,这个属性可有可无。basedir="."说明基本目录,此属性可有可无。 default="dist"说明项目的缺省目标(target)是什么,这个属性必须有。所谓目标(target)就是一系列任务(task)组成的一 个集合。每个任务(task)的书写方法如下:
<任务名 属性1="属性1的值" 属性2="属性2的值" ....... />




第 三行定义了一些属性(property),以便后面使用,这非常类似于编程中定义的全局变量。从第四行开始定义目标(target),name= "init"指明了此目标的名称,name属性在定义目标时必须有,当然定义目标时还有其他一些属性可选,例如depends,unless,具体请参考 ant的文档。第五行开始定义此目标内的任务,其中mkdir时ant的内部任务名,dir是此任务的属性,其值为${dist}。此任务就是创建一个目 录。其中${dist}是获取dist属性的值(就是我们在第三行定义的)。如上就是一个基本的build.xml文件的写法。你可以在命令行上输入 ant -buildfile build.xml

看一下你的当前目录下是否多了一个dist目录。如果出错,则可能是你没有把ant配置好,参见前面讲的安装及配置,看一下哪儿出了错。

3:build.xml文件
build.xml文件如下,其中有的注释和无关的代码删掉了,且做了一下小小的改动
1:
2:
3:
4:
5:
6:
7:
8:
9:
10:


11:
12:
13:
14:
15:
16:
17:
18:
19:

20:
21:
22:
23:

24:
25:

26:
27:
28:
29:
30:
31:
32:

33:
34:


35:
36:
37:
38:
39:
40:


41:
42:
43:
44:
45:
46:47:sourceout="${build.xmlc.dir}"
48:includes="**/*.html">
49:

50:
51:
52:
53:
54:
55:
56:
57:
58:

59:


60:
61:
62:
63:
64:

65:
66:67:destdir="${build.classes}"
68:classpathref="build.classpath"
69:debug="${build.debug}"/>

70:
71:72:destdir="${build.classes}"
73:classpathref="build.classpath"
74:debug="${build.debug}"
75:includes="${app.name}/**"
76:/>
77:


78:
79:
80:
81:
82:
83:
84:
85:
86:
87:
88:
89:

90:

91:



92:
93:
94:
95:
96:
97:
98:


99:
100:
101:
102:
103:
104:

105:
106:
107:108:tofile="${build.dir}/multiserver.conf"
109:filtering="on"/>

110:
111:
112:
113:


114:





4:build.xml详细说明
下 面我们将详细讲述这个文件,同样为了方便,我加了行号,当然一些基本的东西我就不再重复了。第四行taskdef任务(task)属于ant的内部任务, 它的作用是定义一个任务,其基本属性有name,classname,在定义时这两个属性都必需有。第八行开始定义一个path,它有一个属性id,通过 这个id的值我们可以在后面引用这个path,参见第68行。目标(target)init(从14行到34行)定义了一些基本属性 (property),主要是为了后面的target使用。在第38行,你会看到depends="init",depends是定义一个目标时的可选属 性,它的意思是如果init目标没有执行(出错或其他原因),这个目标也不会被执行。

从第46行开始定义xmlc任务,到第58行结束,中间有很多参数嵌套在其中,srcdir指定源文件目录,sourceout指定输出目录,includes属性将源文件目录中的所有html文件包括进来。*为通配符。

表示取消警告,表示同时产生接口和实现代码,例如:一个welcome.html,它会产生两个文件: WelcomeHTMLImpl.java,WelcomeHTML.java,WelcomeHTML.java中只定义了一个接口 WelcomeHTML,真正的实现在WelcomeHTMLImpl.java中。表示设置编码,由于xmlc将html文件编译为java类,即使你在html文件中已经设置了编码,在 java类中也不会有作用,必须在编译时设置编码。 这两句相当于在命令行上输入-ssi -keep.其中ssi参数是在编译html文件时将定义的ssi文件包括进来,见html目录下的welcome2.html源代码中有一行: Ant简介-jennyljd-ChinaUnix博客
  • 博客访问: 313320
  • 博文数量: 54
  • 博客积分: 1400
  • 博客等级: 上尉
  • 技术积分: 606
  • 用 户 组: 普通用户
  • 注册时间: 2006-12-03 22:43
文章分类
文章存档

2011年(3)

2010年(26)

2009年(2)

2008年(23)

我的朋友

分类:

2009-02-21 20:15:11

本文描述了ant的基本语法及其如何应用于项目的管理
-. Ant简介
可 能有许多读者并不了解什么是ant,以及如何使用它。但只要你是用过linux,你应该知道make为何物,当我们编译linux内核及一些软件的源程序 时,我们经常需要在控制台下输入make。Make其实就是一个项目管理工具,而ant所实现的功能与make差不多。Ant是apache软件基金会 jakarta项目中的一个子项目,由于是基于java编写的,因此具有很好的跨平台性。Ant由一些内置任务(task)和可选择的任务组成(当然你还 可以编写自己的任务),使用Make时,你需要写一个Makefile文件,而用ant时则需要写一个build.xml文件。由于采用xml的语法,所 以build.xml文件很容易书写和维护,且结构很清晰,而不像Makefile文件有那么多的限制(例如在tab符号前有一个空格的话,命令就不会执 行)。Ant的优点远不止这些,它还很容易的集成到一些开发环境中(例如visual age,jbuilder,netbeans)。

二.Ant的安装及配置
安装
Ant 目前的版本是1.3,首先到下载ant最新版本1.3,解压到C: /ant(window操作系统) 或者/usr/local/ant(linux操作系统),由于我们要用到xmlc ,而ant1.3中并没有包含它,所以我们需要David.Li为ant写的xmlc任务。具体url为http: //。将下载后的文件中的 ant.jar替换掉ant1.3中ant.jar.这样ant的版本变为1.2.

2.设置路径
(1):windows98操作系统
编辑C:\enhydra\.bashrc,加入下面三行

export ANT_HOME=/ant
export JAVA_HOME=/jdk-1.2.2
export PATH=${PATH}:${ANT_HOME}/bin

(2):Linux操作系统
编辑/etc/profile或者 用户目录下的.bashrc文件,加入下面三行

export ANT_HOME=/usr/local/ant
export JAVA_HOME=/usr/local/jdk-1.2.2
export PATH=${PATH}:${ANT_HOME}/bin

三:用ant管理项目
1:基本的文件目录结构 解压到任意目录,我们可以看到目录树结构如下
├─bin
├─docs
│ ├─ant2
│ ├─api
│ │ └─org
│ │ └─apache
│ │ └─tools
│ │ ├─ant
│ │ │ ├─taskdefs
│ │ │ │ ├─compilers
│ │ │ │ └─optional
│ │ │ │ ├─clearcase
│ │ │ │ ├─depend
│ │ │ │ │ └─constantpool
│ │ │ │ ├─dotnet
│ │ │ │ ├─ejb
│ │ │ │ ├─ide
│ │ │ │ ├─javacc
│ │ │ │ ├─jlink
│ │ │ │ ├─jsp
│ │ │ │ ├─junit
│ │ │ │ ├─metamata
│ │ │ │ ├─net
│ │ │ │ ├─perforce
│ │ │ │ ├─scm
│ │ │ │ ├─sound
│ │ │ │ └─vss
│ │ │ ├─types
│ │ │ └─util
│ │ │ └─regexp
│ │ ├─mail
│ │ └─tar
│ └─manual
│ ├─CoreTasks
│ ├─CoreTypes
│ ├─Integration
│ └─OptionalTasks
└─lib





在这个目录树结构中,与传统的项目不同的是,我们用build.xml取代了Makefile,在讲述这个build.xml文件前,我们先了解一个基本的 build.xml文件的结构。

2:build.xml的基本书写规范
下面我们就来讲述这个文件的书写方法,下面是这个文件的全部内容
1.
2.
3.
4.
5.
6.

7.





为 了方便说明,我们为每一行加了行号,第一行是xml文件的基本要素,第二行说明这是一个项目,第七行说明项目的结束 ,在第二行中,name="MyProject"说明此项目的名称,这个属性可有可无。basedir="."说明基本目录,此属性可有可无。 default="dist"说明项目的缺省目标(target)是什么,这个属性必须有。所谓目标(target)就是一系列任务(task)组成的一 个集合。每个任务(task)的书写方法如下:
<任务名 属性1="属性1的值" 属性2="属性2的值" ....... />




第 三行定义了一些属性(property),以便后面使用,这非常类似于编程中定义的全局变量。从第四行开始定义目标(target),name= "init"指明了此目标的名称,name属性在定义目标时必须有,当然定义目标时还有其他一些属性可选,例如depends,unless,具体请参考 ant的文档。第五行开始定义此目标内的任务,其中mkdir时ant的内部任务名,dir是此任务的属性,其值为${dist}。此任务就是创建一个目 录。其中${dist}是获取dist属性的值(就是我们在第三行定义的)。如上就是一个基本的build.xml文件的写法。你可以在命令行上输入 ant -buildfile build.xml

看一下你的当前目录下是否多了一个dist目录。如果出错,则可能是你没有把ant配置好,参见前面讲的安装及配置,看一下哪儿出了错。

3:build.xml文件
build.xml文件如下,其中有的注释和无关的代码删掉了,且做了一下小小的改动
1:
2:
3:
4:
5:
6:
7:
8:
9:
10:


11:
12:
13:
14:
15:
16:
17:
18:
19:

20:
21:
22:
23:

24:
25:

26:
27:
28:
29:
30:
31:
32:

33:
34:


35:
36:
37:
38:
39:
40:


41:
42:
43:
44:
45:
46:47:sourceout="${build.xmlc.dir}"
48:includes="**/*.html">
49:

50:
51:
52:
53:
54:
55:
56:
57:
58:

59:


60:
61:
62:
63:
64:

65:
66:67:destdir="${build.classes}"
68:classpathref="build.classpath"
69:debug="${build.debug}"/>

70:
71:72:destdir="${build.classes}"
73:classpathref="build.classpath"
74:debug="${build.debug}"
75:includes="${app.name}/**"
76:/>
77:


78:
79:
80:
81:
82:
83:
84:
85:
86:
87:
88:
89:

90:

91:



92:
93:
94:
95:
96:
97:
98:


99:
100:
101:
102:
103:
104:

105:
106:
107:108:tofile="${build.dir}/multiserver.conf"
109:filtering="on"/>

110:
111:
112:
113:


114:





4:build.xml详细说明
下 面我们将详细讲述这个文件,同样为了方便,我加了行号,当然一些基本的东西我就不再重复了。第四行taskdef任务(task)属于ant的内部任务, 它的作用是定义一个任务,其基本属性有name,classname,在定义时这两个属性都必需有。第八行开始定义一个path,它有一个属性id,通过 这个id的值我们可以在后面引用这个path,参见第68行。目标(target)init(从14行到34行)定义了一些基本属性 (property),主要是为了后面的target使用。在第38行,你会看到depends="init",depends是定义一个目标时的可选属 性,它的意思是如果init目标没有执行(出错或其他原因),这个目标也不会被执行。

从第46行开始定义xmlc任务,到第58行结束,中间有很多参数嵌套在其中,srcdir指定源文件目录,sourceout指定输出目录,includes属性将源文件目录中的所有html文件包括进来。*为通配符。

表示取消警告,表示同时产生接口和实现代码,例如:一个welcome.html,它会产生两个文件: WelcomeHTMLImpl.java,WelcomeHTML.java,WelcomeHTML.java中只定义了一个接口 WelcomeHTML,真正的实现在WelcomeHTMLImpl.java中。表示设置编码,由于xmlc将html文件编译为java类,即使你在html文件中已经设置了编码,在 java类中也不会有作用,必须在编译时设置编码。 这两句相当于在命令行上输入-ssi -keep.其中ssi参数是在编译html文件时将定义的ssi文件包括进来,见html目录下的welcome2.html源代码中有一行: Ant简介-jennyljd-ChinaUnix博客
  • 博客访问: 313321
  • 博文数量: 54
  • 博客积分: 1400
  • 博客等级: 上尉
  • 技术积分: 606
  • 用 户 组: 普通用户
  • 注册时间: 2006-12-03 22:43
文章分类
文章存档

2011年(3)

2010年(26)

2009年(2)

2008年(23)

我的朋友

分类:

2009-02-21 20:15:11

本文描述了ant的基本语法及其如何应用于项目的管理
-. Ant简介
可 能有许多读者并不了解什么是ant,以及如何使用它。但只要你是用过linux,你应该知道make为何物,当我们编译linux内核及一些软件的源程序 时,我们经常需要在控制台下输入make。Make其实就是一个项目管理工具,而ant所实现的功能与make差不多。Ant是apache软件基金会 jakarta项目中的一个子项目,由于是基于java编写的,因此具有很好的跨平台性。Ant由一些内置任务(task)和可选择的任务组成(当然你还 可以编写自己的任务),使用Make时,你需要写一个Makefile文件,而用ant时则需要写一个build.xml文件。由于采用xml的语法,所 以build.xml文件很容易书写和维护,且结构很清晰,而不像Makefile文件有那么多的限制(例如在tab符号前有一个空格的话,命令就不会执 行)。Ant的优点远不止这些,它还很容易的集成到一些开发环境中(例如visual age,jbuilder,netbeans)。

二.Ant的安装及配置
安装
Ant 目前的版本是1.3,首先到下载ant最新版本1.3,解压到C: /ant(window操作系统) 或者/usr/local/ant(linux操作系统),由于我们要用到xmlc ,而ant1.3中并没有包含它,所以我们需要David.Li为ant写的xmlc任务。具体url为http: //。将下载后的文件中的 ant.jar替换掉ant1.3中ant.jar.这样ant的版本变为1.2.

2.设置路径
(1):windows98操作系统
编辑C:\enhydra\.bashrc,加入下面三行

export ANT_HOME=/ant
export JAVA_HOME=/jdk-1.2.2
export PATH=${PATH}:${ANT_HOME}/bin

(2):Linux操作系统
编辑/etc/profile或者 用户目录下的.bashrc文件,加入下面三行

export ANT_HOME=/usr/local/ant
export JAVA_HOME=/usr/local/jdk-1.2.2
export PATH=${PATH}:${ANT_HOME}/bin

三:用ant管理项目
1:基本的文件目录结构 解压到任意目录,我们可以看到目录树结构如下
├─bin
├─docs
│ ├─ant2
│ ├─api
│ │ └─org
│ │ └─apache
│ │ └─tools
│ │ ├─ant
│ │ │ ├─taskdefs
│ │ │ │ ├─compilers
│ │ │ │ └─optional
│ │ │ │ ├─clearcase
│ │ │ │ ├─depend
│ │ │ │ │ └─constantpool
│ │ │ │ ├─dotnet
│ │ │ │ ├─ejb
│ │ │ │ ├─ide
│ │ │ │ ├─javacc
│ │ │ │ ├─jlink
│ │ │ │ ├─jsp
│ │ │ │ ├─junit
│ │ │ │ ├─metamata
│ │ │ │ ├─net
│ │ │ │ ├─perforce
│ │ │ │ ├─scm
│ │ │ │ ├─sound
│ │ │ │ └─vss
│ │ │ ├─types
│ │ │ └─util
│ │ │ └─regexp
│ │ ├─mail
│ │ └─tar
│ └─manual
│ ├─CoreTasks
│ ├─CoreTypes
│ ├─Integration
│ └─OptionalTasks
└─lib





在这个目录树结构中,与传统的项目不同的是,我们用build.xml取代了Makefile,在讲述这个build.xml文件前,我们先了解一个基本的 build.xml文件的结构。

2:build.xml的基本书写规范
下面我们就来讲述这个文件的书写方法,下面是这个文件的全部内容
1.
2.
3.
4.
5.
6.

7.





为 了方便说明,我们为每一行加了行号,第一行是xml文件的基本要素,第二行说明这是一个项目,第七行说明项目的结束 ,在第二行中,name="MyProject"说明此项目的名称,这个属性可有可无。basedir="."说明基本目录,此属性可有可无。 default="dist"说明项目的缺省目标(target)是什么,这个属性必须有。所谓目标(target)就是一系列任务(task)组成的一 个集合。每个任务(task)的书写方法如下:
<任务名 属性1="属性1的值" 属性2="属性2的值" ....... />




第 三行定义了一些属性(property),以便后面使用,这非常类似于编程中定义的全局变量。从第四行开始定义目标(target),name= "init"指明了此目标的名称,name属性在定义目标时必须有,当然定义目标时还有其他一些属性可选,例如depends,unless,具体请参考 ant的文档。第五行开始定义此目标内的任务,其中mkdir时ant的内部任务名,dir是此任务的属性,其值为${dist}。此任务就是创建一个目 录。其中${dist}是获取dist属性的值(就是我们在第三行定义的)。如上就是一个基本的build.xml文件的写法。你可以在命令行上输入 ant -buildfile build.xml

看一下你的当前目录下是否多了一个dist目录。如果出错,则可能是你没有把ant配置好,参见前面讲的安装及配置,看一下哪儿出了错。

3:build.xml文件
build.xml文件如下,其中有的注释和无关的代码删掉了,且做了一下小小的改动
1:
2:
3:
4:
5:
6:
7:
8:
9:
10:


11:
12:
13:
14:
15:
16:
17:
18:
19:

20:
21:
22:
23:

24:
25:

26:
27:
28:
29:
30:
31:
32:

33:
34:


35:
36:
37:
38:
39:
40:


41:
42:
43:
44:
45:
46:47:sourceout="${build.xmlc.dir}"
48:includes="**/*.html">
49:

50:
51:
52:
53:
54:
55:
56:
57:
58:

59:


60:
61:
62:
63:
64:

65:
66:67:destdir="${build.classes}"
68:classpathref="build.classpath"
69:debug="${build.debug}"/>

70:
71:72:destdir="${build.classes}"
73:classpathref="build.classpath"
74:debug="${build.debug}"
75:includes="${app.name}/**"
76:/>
77:


78:
79:
80:
81:
82:
83:
84:
85:
86:
87:
88:
89:

90:

91:



92:
93:
94:
95:
96:
97:
98:


99:
100:
101:
102:
103:
104:

105:
106:
107:108:tofile="${build.dir}/multiserver.conf"
109:filtering="on"/>

110:
111:
112:
113:


114:





4:build.xml详细说明
下 面我们将详细讲述这个文件,同样为了方便,我加了行号,当然一些基本的东西我就不再重复了。第四行taskdef任务(task)属于ant的内部任务, 它的作用是定义一个任务,其基本属性有name,classname,在定义时这两个属性都必需有。第八行开始定义一个path,它有一个属性id,通过 这个id的值我们可以在后面引用这个path,参见第68行。目标(target)init(从14行到34行)定义了一些基本属性 (property),主要是为了后面的target使用。在第38行,你会看到depends="init",depends是定义一个目标时的可选属 性,它的意思是如果init目标没有执行(出错或其他原因),这个目标也不会被执行。

从第46行开始定义xmlc任务,到第58行结束,中间有很多参数嵌套在其中,srcdir指定源文件目录,sourceout指定输出目录,includes属性将源文件目录中的所有html文件包括进来。*为通配符。

表示取消警告,表示同时产生接口和实现代码,例如:一个welcome.html,它会产生两个文件: WelcomeHTMLImpl.java,WelcomeHTML.java,WelcomeHTML.java中只定义了一个接口 WelcomeHTML,真正的实现在WelcomeHTMLImpl.java中。表示设置编码,由于xmlc将html文件编译为java类,即使你在html文件中已经设置了编码,在 java类中也不会有作用,必须在编译时设置编码。 这两句相当于在命令行上输入-ssi -keep.其中ssi参数是在编译html文件时将定义的ssi文件包括进来,见html目录下的welcome2.html源代码中有一行: Ant简介-jennyljd-ChinaUnix博客
  • 博客访问: 313322
  • 博文数量: 54
  • 博客积分: 1400
  • 博客等级: 上尉
  • 技术积分: 606
  • 用 户 组: 普通用户
  • 注册时间: 2006-12-03 22:43
文章分类
文章存档

2011年(3)

2010年(26)

2009年(2)

2008年(23)

我的朋友

分类:

2009-02-21 20:15:11

本文描述了ant的基本语法及其如何应用于项目的管理
-. Ant简介
可 能有许多读者并不了解什么是ant,以及如何使用它。但只要你是用过linux,你应该知道make为何物,当我们编译linux内核及一些软件的源程序 时,我们经常需要在控制台下输入make。Make其实就是一个项目管理工具,而ant所实现的功能与make差不多。Ant是apache软件基金会 jakarta项目中的一个子项目,由于是基于java编写的,因此具有很好的跨平台性。Ant由一些内置任务(task)和可选择的任务组成(当然你还 可以编写自己的任务),使用Make时,你需要写一个Makefile文件,而用ant时则需要写一个build.xml文件。由于采用xml的语法,所 以build.xml文件很容易书写和维护,且结构很清晰,而不像Makefile文件有那么多的限制(例如在tab符号前有一个空格的话,命令就不会执 行)。Ant的优点远不止这些,它还很容易的集成到一些开发环境中(例如visual age,jbuilder,netbeans)。

二.Ant的安装及配置
安装
Ant 目前的版本是1.3,首先到下载ant最新版本1.3,解压到C: /ant(window操作系统) 或者/usr/local/ant(linux操作系统),由于我们要用到xmlc ,而ant1.3中并没有包含它,所以我们需要David.Li为ant写的xmlc任务。具体url为http: //。将下载后的文件中的 ant.jar替换掉ant1.3中ant.jar.这样ant的版本变为1.2.

2.设置路径
(1):windows98操作系统
编辑C:\enhydra\.bashrc,加入下面三行

export ANT_HOME=/ant
export JAVA_HOME=/jdk-1.2.2
export PATH=${PATH}:${ANT_HOME}/bin

(2):Linux操作系统
编辑/etc/profile或者 用户目录下的.bashrc文件,加入下面三行

export ANT_HOME=/usr/local/ant
export JAVA_HOME=/usr/local/jdk-1.2.2
export PATH=${PATH}:${ANT_HOME}/bin

三:用ant管理项目
1:基本的文件目录结构 解压到任意目录,我们可以看到目录树结构如下
├─bin
├─docs
│ ├─ant2
│ ├─api
│ │ └─org
│ │ └─apache
│ │ └─tools
│ │ ├─ant
│ │ │ ├─taskdefs
│ │ │ │ ├─compilers
│ │ │ │ └─optional
│ │ │ │ ├─clearcase
│ │ │ │ ├─depend
│ │ │ │ │ └─constantpool
│ │ │ │ ├─dotnet
│ │ │ │ ├─ejb
│ │ │ │ ├─ide
│ │ │ │ ├─javacc
│ │ │ │ ├─jlink
│ │ │ │ ├─jsp
│ │ │ │ ├─junit
│ │ │ │ ├─metamata
│ │ │ │ ├─net
│ │ │ │ ├─perforce
│ │ │ │ ├─scm
│ │ │ │ ├─sound
│ │ │ │ └─vss
│ │ │ ├─types
│ │ │ └─util
│ │ │ └─regexp
│ │ ├─mail
│ │ └─tar
│ └─manual
│ ├─CoreTasks
│ ├─CoreTypes
│ ├─Integration
│ └─OptionalTasks
└─lib





在这个目录树结构中,与传统的项目不同的是,我们用build.xml取代了Makefile,在讲述这个build.xml文件前,我们先了解一个基本的 build.xml文件的结构。

2:build.xml的基本书写规范
下面我们就来讲述这个文件的书写方法,下面是这个文件的全部内容
1.
2.
3.
4.
5.
6.

7.





为 了方便说明,我们为每一行加了行号,第一行是xml文件的基本要素,第二行说明这是一个项目,第七行说明项目的结束 ,在第二行中,name="MyProject"说明此项目的名称,这个属性可有可无。basedir="."说明基本目录,此属性可有可无。 default="dist"说明项目的缺省目标(target)是什么,这个属性必须有。所谓目标(target)就是一系列任务(task)组成的一 个集合。每个任务(task)的书写方法如下:
<任务名 属性1="属性1的值" 属性2="属性2的值" ....... />




第 三行定义了一些属性(property),以便后面使用,这非常类似于编程中定义的全局变量。从第四行开始定义目标(target),name= "init"指明了此目标的名称,name属性在定义目标时必须有,当然定义目标时还有其他一些属性可选,例如depends,unless,具体请参考 ant的文档。第五行开始定义此目标内的任务,其中mkdir时ant的内部任务名,dir是此任务的属性,其值为${dist}。此任务就是创建一个目 录。其中${dist}是获取dist属性的值(就是我们在第三行定义的)。如上就是一个基本的build.xml文件的写法。你可以在命令行上输入 ant -buildfile build.xml

看一下你的当前目录下是否多了一个dist目录。如果出错,则可能是你没有把ant配置好,参见前面讲的安装及配置,看一下哪儿出了错。

3:build.xml文件
build.xml文件如下,其中有的注释和无关的代码删掉了,且做了一下小小的改动
1:
2:
3:
4:
5:
6:
7:
8:
9:
10:


11:
12:
13:
14:
15:
16:
17:
18:
19:

20:
21:
22:
23:

24:
25:

26:
27:
28:
29:
30:
31:
32:

33:
34:


35:
36:
37:
38:
39:
40:


41:
42:
43:
44:
45:
46:47:sourceout="${build.xmlc.dir}"
48:includes="**/*.html">
49:

50:
51:
52:
53:
54:
55:
56:
57:
58:

59:


60:
61:
62:
63:
64:

65:
66:67:destdir="${build.classes}"
68:classpathref="build.classpath"
69:debug="${build.debug}"/>

70:
71:72:destdir="${build.classes}"
73:classpathref="build.classpath"
74:debug="${build.debug}"
75:includes="${app.name}/**"
76:/>
77:


78:
79:
80:
81:
82:
83:
84:
85:
86:
87:
88:
89:

90:

91:



92:
93:
94:
95:
96:
97:
98:


99:
100:
101:
102:
103:
104:

105:
106:
107:108:tofile="${build.dir}/multiserver.conf"
109:filtering="on"/>

110:
111:
112:
113:


114:





4:build.xml详细说明
下 面我们将详细讲述这个文件,同样为了方便,我加了行号,当然一些基本的东西我就不再重复了。第四行taskdef任务(task)属于ant的内部任务, 它的作用是定义一个任务,其基本属性有name,classname,在定义时这两个属性都必需有。第八行开始定义一个path,它有一个属性id,通过 这个id的值我们可以在后面引用这个path,参见第68行。目标(target)init(从14行到34行)定义了一些基本属性 (property),主要是为了后面的target使用。在第38行,你会看到depends="init",depends是定义一个目标时的可选属 性,它的意思是如果init目标没有执行(出错或其他原因),这个目标也不会被执行。

从第46行开始定义xmlc任务,到第58行结束,中间有很多参数嵌套在其中,srcdir指定源文件目录,sourceout指定输出目录,includes属性将源文件目录中的所有html文件包括进来。*为通配符。

表示取消警告,表示同时产生接口和实现代码,例如:一个welcome.html,它会产生两个文件: WelcomeHTMLImpl.java,WelcomeHTML.java,WelcomeHTML.java中只定义了一个接口 WelcomeHTML,真正的实现在WelcomeHTMLImpl.java中。表示设置编码,由于xmlc将html文件编译为java类,即使你在html文件中已经设置了编码,在 java类中也不会有作用,必须在编译时设置编码。 这两句相当于在命令行上输入-ssi -keep.其中ssi参数是在编译html文件时将定义的ssi文件包括进来,见html目录下的welcome2.html源代码中有一行: 。keep参数会保留编译html文件后产生的java文件。第57行意思是将包更名,由于html文 件在antDemo/presentation/html目录下,因此产生的java类属于antDemo.presentation.html包,我们 通过new属性的值将属于此包的类改为属于新的包,使用xmlc时,一般以上几个参数就足够了,要想使用更多的参数,请参见xmlc task定义的源代码 。

从第63行到77行,目标(target)定义了编译时的细节,编译分为两部分,分别编译xmlc产生的 java类和项目中的java类(表现层,商务层,数据层中的代码)。javac这个任务中,srcdir属性指定java文件存放位置,destdir 属性指定编译后的class文件存放位置,classpathref属性指定classpath,debug属性设置关闭还是打开调试信息, includes属性起一个过滤作用,它指定编译那些文件,否则javac将会编译srcdir属性指定的目录下的所有java文件。

81 行到91行开始将将程序中用到的其他文件也复制到目标目录,以便下一步打包。在copy任务中,todir属性指定目标目录,至于复制那些文件,则由嵌套 在copy任务中的fileset任务来指定。在fileset中,dir指定基本目录,include和exclude属性用来过滤文件,符合条件的文 件将会被复制到目标目录。

95行到98行开始将程序打包,jarfile属性指定打包后的文件名,basedir指定基本目录,基本目录下的文件及子目录都会按照其本来的组织结构放到jar文件中。

102行到113行,开始复制配置文件,配置文件包括AntDemo.conf,multiserver.conf,start.其中第112行,chmod任务将start文件的属性改为对任何人可执行和可读。

通过上面的讲解,你可能看出使用ant的优越性,ant可以方便的管理一个大型的项目,当然其他的项目也可以,重要的是,你可以很容易的对它的task进行扩充。相信越来越多的人会使用ant来进行项目的管理。

四:小技巧:
由于使用ant时可能出错,而屏幕不够大的话,可能看不清,最好将编译出错信息放入一个文件中,如下这样使用ant:
ant -buildfile build.xml -logfile error.log

就会将出错信息放入error.log中,由于使用buildfile参数,因此xml文件名不一定时build.xml,可以为任意xml 文件,如project.xml
阅读(77785) | 评论(0) | 转发(0) |
给主人留下些什么吧!~~
。keep参数会保留编译html文件后产生的java文件。第57行意思是将包更名,由于html文 件在antDemo/presentation/html目录下,因此产生的java类属于antDemo.presentation.html包,我们 通过new属性的值将属于此包的类改为属于新的包,使用xmlc时,一般以上几个参数就足够了,要想使用更多的参数,请参见xmlc task定义的源代码 。

从第63行到77行,目标(target)定义了编译时的细节,编译分为两部分,分别编译xmlc产生的 java类和项目中的java类(表现层,商务层,数据层中的代码)。javac这个任务中,srcdir属性指定java文件存放位置,destdir 属性指定编译后的class文件存放位置,classpathref属性指定classpath,debug属性设置关闭还是打开调试信息, includes属性起一个过滤作用,它指定编译那些文件,否则javac将会编译srcdir属性指定的目录下的所有java文件。

81 行到91行开始将将程序中用到的其他文件也复制到目标目录,以便下一步打包。在copy任务中,todir属性指定目标目录,至于复制那些文件,则由嵌套 在copy任务中的fileset任务来指定。在fileset中,dir指定基本目录,include和exclude属性用来过滤文件,符合条件的文 件将会被复制到目标目录。

95行到98行开始将程序打包,jarfile属性指定打包后的文件名,basedir指定基本目录,基本目录下的文件及子目录都会按照其本来的组织结构放到jar文件中。

102行到113行,开始复制配置文件,配置文件包括AntDemo.conf,multiserver.conf,start.其中第112行,chmod任务将start文件的属性改为对任何人可执行和可读。

通过上面的讲解,你可能看出使用ant的优越性,ant可以方便的管理一个大型的项目,当然其他的项目也可以,重要的是,你可以很容易的对它的task进行扩充。相信越来越多的人会使用ant来进行项目的管理。

四:小技巧:
由于使用ant时可能出错,而屏幕不够大的话,可能看不清,最好将编译出错信息放入一个文件中,如下这样使用ant:
ant -buildfile build.xml -logfile error.log

就会将出错信息放入error.log中,由于使用buildfile参数,因此xml文件名不一定时build.xml,可以为任意xml 文件,如project.xml
阅读(77784) | 评论(0) | 转发(0) |
给主人留下些什么吧!~~
。keep参数会保留编译html文件后产生的java文件。第57行意思是将包更名,由于html文 件在antDemo/presentation/html目录下,因此产生的java类属于antDemo.presentation.html包,我们 通过new属性的值将属于此包的类改为属于新的包,使用xmlc时,一般以上几个参数就足够了,要想使用更多的参数,请参见xmlc task定义的源代码 。

从第63行到77行,目标(target)定义了编译时的细节,编译分为两部分,分别编译xmlc产生的 java类和项目中的java类(表现层,商务层,数据层中的代码)。javac这个任务中,srcdir属性指定java文件存放位置,destdir 属性指定编译后的class文件存放位置,classpathref属性指定classpath,debug属性设置关闭还是打开调试信息, includes属性起一个过滤作用,它指定编译那些文件,否则javac将会编译srcdir属性指定的目录下的所有java文件。

81 行到91行开始将将程序中用到的其他文件也复制到目标目录,以便下一步打包。在copy任务中,todir属性指定目标目录,至于复制那些文件,则由嵌套 在copy任务中的fileset任务来指定。在fileset中,dir指定基本目录,include和exclude属性用来过滤文件,符合条件的文 件将会被复制到目标目录。

95行到98行开始将程序打包,jarfile属性指定打包后的文件名,basedir指定基本目录,基本目录下的文件及子目录都会按照其本来的组织结构放到jar文件中。

102行到113行,开始复制配置文件,配置文件包括AntDemo.conf,multiserver.conf,start.其中第112行,chmod任务将start文件的属性改为对任何人可执行和可读。

通过上面的讲解,你可能看出使用ant的优越性,ant可以方便的管理一个大型的项目,当然其他的项目也可以,重要的是,你可以很容易的对它的task进行扩充。相信越来越多的人会使用ant来进行项目的管理。

四:小技巧:
由于使用ant时可能出错,而屏幕不够大的话,可能看不清,最好将编译出错信息放入一个文件中,如下这样使用ant:
ant -buildfile build.xml -logfile error.log

就会将出错信息放入error.log中,由于使用buildfile参数,因此xml文件名不一定时build.xml,可以为任意xml 文件,如project.xml
阅读(77783) | 评论(0) | 转发(0) |
给主人留下些什么吧!~~
。keep参数会保留编译html文件后产生的java文件。第57行意思是将包更名,由于html文 件在antDemo/presentation/html目录下,因此产生的java类属于antDemo.presentation.html包,我们 通过new属性的值将属于此包的类改为属于新的包,使用xmlc时,一般以上几个参数就足够了,要想使用更多的参数,请参见xmlc task定义的源代码 。

从第63行到77行,目标(target)定义了编译时的细节,编译分为两部分,分别编译xmlc产生的 java类和项目中的java类(表现层,商务层,数据层中的代码)。javac这个任务中,srcdir属性指定java文件存放位置,destdir 属性指定编译后的class文件存放位置,classpathref属性指定classpath,debug属性设置关闭还是打开调试信息, includes属性起一个过滤作用,它指定编译那些文件,否则javac将会编译srcdir属性指定的目录下的所有java文件。

81 行到91行开始将将程序中用到的其他文件也复制到目标目录,以便下一步打包。在copy任务中,todir属性指定目标目录,至于复制那些文件,则由嵌套 在copy任务中的fileset任务来指定。在fileset中,dir指定基本目录,include和exclude属性用来过滤文件,符合条件的文 件将会被复制到目标目录。

95行到98行开始将程序打包,jarfile属性指定打包后的文件名,basedir指定基本目录,基本目录下的文件及子目录都会按照其本来的组织结构放到jar文件中。

102行到113行,开始复制配置文件,配置文件包括AntDemo.conf,multiserver.conf,start.其中第112行,chmod任务将start文件的属性改为对任何人可执行和可读。

通过上面的讲解,你可能看出使用ant的优越性,ant可以方便的管理一个大型的项目,当然其他的项目也可以,重要的是,你可以很容易的对它的task进行扩充。相信越来越多的人会使用ant来进行项目的管理。

四:小技巧:
由于使用ant时可能出错,而屏幕不够大的话,可能看不清,最好将编译出错信息放入一个文件中,如下这样使用ant:
ant -buildfile build.xml -logfile error.log

就会将出错信息放入error.log中,由于使用buildfile参数,因此xml文件名不一定时build.xml,可以为任意xml 文件,如project.xml
阅读(77782) | 评论(0) | 转发(0) |
给主人留下些什么吧!~~
。keep参数会保留编译html文件后产生的java文件。第57行意思是将包更名,由于html文 件在antDemo/presentation/html目录下,因此产生的java类属于antDemo.presentation.html包,我们 通过new属性的值将属于此包的类改为属于新的包,使用xmlc时,一般以上几个参数就足够了,要想使用更多的参数,请参见xmlc task定义的源代码 。

从第63行到77行,目标(target)定义了编译时的细节,编译分为两部分,分别编译xmlc产生的 java类和项目中的java类(表现层,商务层,数据层中的代码)。javac这个任务中,srcdir属性指定java文件存放位置,destdir 属性指定编译后的class文件存放位置,classpathref属性指定classpath,debug属性设置关闭还是打开调试信息, includes属性起一个过滤作用,它指定编译那些文件,否则javac将会编译srcdir属性指定的目录下的所有java文件。

81 行到91行开始将将程序中用到的其他文件也复制到目标目录,以便下一步打包。在copy任务中,todir属性指定目标目录,至于复制那些文件,则由嵌套 在copy任务中的fileset任务来指定。在fileset中,dir指定基本目录,include和exclude属性用来过滤文件,符合条件的文 件将会被复制到目标目录。

95行到98行开始将程序打包,jarfile属性指定打包后的文件名,basedir指定基本目录,基本目录下的文件及子目录都会按照其本来的组织结构放到jar文件中。

102行到113行,开始复制配置文件,配置文件包括AntDemo.conf,multiserver.conf,start.其中第112行,chmod任务将start文件的属性改为对任何人可执行和可读。

通过上面的讲解,你可能看出使用ant的优越性,ant可以方便的管理一个大型的项目,当然其他的项目也可以,重要的是,你可以很容易的对它的task进行扩充。相信越来越多的人会使用ant来进行项目的管理。

四:小技巧:
由于使用ant时可能出错,而屏幕不够大的话,可能看不清,最好将编译出错信息放入一个文件中,如下这样使用ant:
ant -buildfile build.xml -logfile error.log

就会将出错信息放入error.log中,由于使用buildfile参数,因此xml文件名不一定时build.xml,可以为任意xml 文件,如project.xml
阅读(77781) | 评论(0) | 转发(0) |
给主人留下些什么吧!~~
。keep参数会保留编译html文件后产生的java文件。第57行意思是将包更名,由于html文 件在antDemo/presentation/html目录下,因此产生的java类属于antDemo.presentation.html包,我们 通过new属性的值将属于此包的类改为属于新的包,使用xmlc时,一般以上几个参数就足够了,要想使用更多的参数,请参见xmlc task定义的源代码 。

从第63行到77行,目标(target)定义了编译时的细节,编译分为两部分,分别编译xmlc产生的 java类和项目中的java类(表现层,商务层,数据层中的代码)。javac这个任务中,srcdir属性指定java文件存放位置,destdir 属性指定编译后的class文件存放位置,classpathref属性指定classpath,debug属性设置关闭还是打开调试信息, includes属性起一个过滤作用,它指定编译那些文件,否则javac将会编译srcdir属性指定的目录下的所有java文件。

81 行到91行开始将将程序中用到的其他文件也复制到目标目录,以便下一步打包。在copy任务中,todir属性指定目标目录,至于复制那些文件,则由嵌套 在copy任务中的fileset任务来指定。在fileset中,dir指定基本目录,include和exclude属性用来过滤文件,符合条件的文 件将会被复制到目标目录。

95行到98行开始将程序打包,jarfile属性指定打包后的文件名,basedir指定基本目录,基本目录下的文件及子目录都会按照其本来的组织结构放到jar文件中。

102行到113行,开始复制配置文件,配置文件包括AntDemo.conf,multiserver.conf,start.其中第112行,chmod任务将start文件的属性改为对任何人可执行和可读。

通过上面的讲解,你可能看出使用ant的优越性,ant可以方便的管理一个大型的项目,当然其他的项目也可以,重要的是,你可以很容易的对它的task进行扩充。相信越来越多的人会使用ant来进行项目的管理。

四:小技巧:
由于使用ant时可能出错,而屏幕不够大的话,可能看不清,最好将编译出错信息放入一个文件中,如下这样使用ant:
ant -buildfile build.xml -logfile error.log

就会将出错信息放入error.log中,由于使用buildfile参数,因此xml文件名不一定时build.xml,可以为任意xml 文件,如project.xml
阅读(77780) | 评论(0) | 转发(0) |
给主人留下些什么吧!~~
。keep参数会保留编译html文件后产生的java文件。第57行意思是将包更名,由于html文 件在antDemo/presentation/html目录下,因此产生的java类属于antDemo.presentation.html包,我们 通过new属性的值将属于此包的类改为属于新的包,使用xmlc时,一般以上几个参数就足够了,要想使用更多的参数,请参见xmlc task定义的源代码 。

从第63行到77行,目标(target)定义了编译时的细节,编译分为两部分,分别编译xmlc产生的 java类和项目中的java类(表现层,商务层,数据层中的代码)。javac这个任务中,srcdir属性指定java文件存放位置,destdir 属性指定编译后的class文件存放位置,classpathref属性指定classpath,debug属性设置关闭还是打开调试信息, includes属性起一个过滤作用,它指定编译那些文件,否则javac将会编译srcdir属性指定的目录下的所有java文件。

81 行到91行开始将将程序中用到的其他文件也复制到目标目录,以便下一步打包。在copy任务中,todir属性指定目标目录,至于复制那些文件,则由嵌套 在copy任务中的fileset任务来指定。在fileset中,dir指定基本目录,include和exclude属性用来过滤文件,符合条件的文 件将会被复制到目标目录。

95行到98行开始将程序打包,jarfile属性指定打包后的文件名,basedir指定基本目录,基本目录下的文件及子目录都会按照其本来的组织结构放到jar文件中。

102行到113行,开始复制配置文件,配置文件包括AntDemo.conf,multiserver.conf,start.其中第112行,chmod任务将start文件的属性改为对任何人可执行和可读。

通过上面的讲解,你可能看出使用ant的优越性,ant可以方便的管理一个大型的项目,当然其他的项目也可以,重要的是,你可以很容易的对它的task进行扩充。相信越来越多的人会使用ant来进行项目的管理。

四:小技巧:
由于使用ant时可能出错,而屏幕不够大的话,可能看不清,最好将编译出错信息放入一个文件中,如下这样使用ant:
ant -buildfile build.xml -logfile error.log

就会将出错信息放入error.log中,由于使用buildfile参数,因此xml文件名不一定时build.xml,可以为任意xml 文件,如project.xml
阅读(77779) | 评论(0) | 转发(0) |
给主人留下些什么吧!~~
。keep参数会保留编译html文件后产生的java文件。第57行意思是将包更名,由于html文 件在antDemo/presentation/html目录下,因此产生的java类属于antDemo.presentation.html包,我们 通过new属性的值将属于此包的类改为属于新的包,使用xmlc时,一般以上几个参数就足够了,要想使用更多的参数,请参见xmlc task定义的源代码 。

从第63行到77行,目标(target)定义了编译时的细节,编译分为两部分,分别编译xmlc产生的 java类和项目中的java类(表现层,商务层,数据层中的代码)。javac这个任务中,srcdir属性指定java文件存放位置,destdir 属性指定编译后的class文件存放位置,classpathref属性指定classpath,debug属性设置关闭还是打开调试信息, includes属性起一个过滤作用,它指定编译那些文件,否则javac将会编译srcdir属性指定的目录下的所有java文件。

81 行到91行开始将将程序中用到的其他文件也复制到目标目录,以便下一步打包。在copy任务中,todir属性指定目标目录,至于复制那些文件,则由嵌套 在copy任务中的fileset任务来指定。在fileset中,dir指定基本目录,include和exclude属性用来过滤文件,符合条件的文 件将会被复制到目标目录。

95行到98行开始将程序打包,jarfile属性指定打包后的文件名,basedir指定基本目录,基本目录下的文件及子目录都会按照其本来的组织结构放到jar文件中。

102行到113行,开始复制配置文件,配置文件包括AntDemo.conf,multiserver.conf,start.其中第112行,chmod任务将start文件的属性改为对任何人可执行和可读。

通过上面的讲解,你可能看出使用ant的优越性,ant可以方便的管理一个大型的项目,当然其他的项目也可以,重要的是,你可以很容易的对它的task进行扩充。相信越来越多的人会使用ant来进行项目的管理。

四:小技巧:
由于使用ant时可能出错,而屏幕不够大的话,可能看不清,最好将编译出错信息放入一个文件中,如下这样使用ant:
ant -buildfile build.xml -logfile error.log

就会将出错信息放入error.log中,由于使用buildfile参数,因此xml文件名不一定时build.xml,可以为任意xml 文件,如project.xml
阅读(77778) | 评论(0) | 转发(0) |
给主人留下些什么吧!~~
。keep参数会保留编译html文件后产生的java文件。第57行意思是将包更名,由于html文 件在antDemo/presentation/html目录下,因此产生的java类属于antDemo.presentation.html包,我们 通过new属性的值将属于此包的类改为属于新的包,使用xmlc时,一般以上几个参数就足够了,要想使用更多的参数,请参见xmlc task定义的源代码 。

从第63行到77行,目标(target)定义了编译时的细节,编译分为两部分,分别编译xmlc产生的 java类和项目中的java类(表现层,商务层,数据层中的代码)。javac这个任务中,srcdir属性指定java文件存放位置,destdir 属性指定编译后的class文件存放位置,classpathref属性指定classpath,debug属性设置关闭还是打开调试信息, includes属性起一个过滤作用,它指定编译那些文件,否则javac将会编译srcdir属性指定的目录下的所有java文件。

81 行到91行开始将将程序中用到的其他文件也复制到目标目录,以便下一步打包。在copy任务中,todir属性指定目标目录,至于复制那些文件,则由嵌套 在copy任务中的fileset任务来指定。在fileset中,dir指定基本目录,include和exclude属性用来过滤文件,符合条件的文 件将会被复制到目标目录。

95行到98行开始将程序打包,jarfile属性指定打包后的文件名,basedir指定基本目录,基本目录下的文件及子目录都会按照其本来的组织结构放到jar文件中。

102行到113行,开始复制配置文件,配置文件包括AntDemo.conf,multiserver.conf,start.其中第112行,chmod任务将start文件的属性改为对任何人可执行和可读。

通过上面的讲解,你可能看出使用ant的优越性,ant可以方便的管理一个大型的项目,当然其他的项目也可以,重要的是,你可以很容易的对它的task进行扩充。相信越来越多的人会使用ant来进行项目的管理。

四:小技巧:
由于使用ant时可能出错,而屏幕不够大的话,可能看不清,最好将编译出错信息放入一个文件中,如下这样使用ant:
ant -buildfile build.xml -logfile error.log

就会将出错信息放入error.log中,由于使用buildfile参数,因此xml文件名不一定时build.xml,可以为任意xml 文件,如project.xml
阅读(77777) | 评论(0) | 转发(0) |
给主人留下些什么吧!~~
。keep参数会保留编译html文件后产生的java文件。第57行意思是将包更名,由于html文 件在antDemo/presentation/html目录下,因此产生的java类属于antDemo.presentation.html包,我们 通过new属性的值将属于此包的类改为属于新的包,使用xmlc时,一般以上几个参数就足够了,要想使用更多的参数,请参见xmlc task定义的源代码 。

从第63行到77行,目标(target)定义了编译时的细节,编译分为两部分,分别编译xmlc产生的 java类和项目中的java类(表现层,商务层,数据层中的代码)。javac这个任务中,srcdir属性指定java文件存放位置,destdir 属性指定编译后的class文件存放位置,classpathref属性指定classpath,debug属性设置关闭还是打开调试信息, includes属性起一个过滤作用,它指定编译那些文件,否则javac将会编译srcdir属性指定的目录下的所有java文件。

81 行到91行开始将将程序中用到的其他文件也复制到目标目录,以便下一步打包。在copy任务中,todir属性指定目标目录,至于复制那些文件,则由嵌套 在copy任务中的fileset任务来指定。在fileset中,dir指定基本目录,include和exclude属性用来过滤文件,符合条件的文 件将会被复制到目标目录。

95行到98行开始将程序打包,jarfile属性指定打包后的文件名,basedir指定基本目录,基本目录下的文件及子目录都会按照其本来的组织结构放到jar文件中。

102行到113行,开始复制配置文件,配置文件包括AntDemo.conf,multiserver.conf,start.其中第112行,chmod任务将start文件的属性改为对任何人可执行和可读。

通过上面的讲解,你可能看出使用ant的优越性,ant可以方便的管理一个大型的项目,当然其他的项目也可以,重要的是,你可以很容易的对它的task进行扩充。相信越来越多的人会使用ant来进行项目的管理。

四:小技巧:
由于使用ant时可能出错,而屏幕不够大的话,可能看不清,最好将编译出错信息放入一个文件中,如下这样使用ant:
ant -buildfile build.xml -logfile error.log

就会将出错信息放入error.log中,由于使用buildfile参数,因此xml文件名不一定时build.xml,可以为任意xml 文件,如project.xml
阅读(77776) | 评论(0) | 转发(0) |
给主人留下些什么吧!~~
。keep参数会保留编译html文件后产生的java文件。第57行意思是将包更名,由于html文 件在antDemo/presentation/html目录下,因此产生的java类属于antDemo.presentation.html包,我们 通过new属性的值将属于此包的类改为属于新的包,使用xmlc时,一般以上几个参数就足够了,要想使用更多的参数,请参见xmlc task定义的源代码 。

从第63行到77行,目标(target)定义了编译时的细节,编译分为两部分,分别编译xmlc产生的 java类和项目中的java类(表现层,商务层,数据层中的代码)。javac这个任务中,srcdir属性指定java文件存放位置,destdir 属性指定编译后的class文件存放位置,classpathref属性指定classpath,debug属性设置关闭还是打开调试信息, includes属性起一个过滤作用,它指定编译那些文件,否则javac将会编译srcdir属性指定的目录下的所有java文件。

81 行到91行开始将将程序中用到的其他文件也复制到目标目录,以便下一步打包。在copy任务中,todir属性指定目标目录,至于复制那些文件,则由嵌套 在copy任务中的fileset任务来指定。在fileset中,dir指定基本目录,include和exclude属性用来过滤文件,符合条件的文 件将会被复制到目标目录。

95行到98行开始将程序打包,jarfile属性指定打包后的文件名,basedir指定基本目录,基本目录下的文件及子目录都会按照其本来的组织结构放到jar文件中。

102行到113行,开始复制配置文件,配置文件包括AntDemo.conf,multiserver.conf,start.其中第112行,chmod任务将start文件的属性改为对任何人可执行和可读。

通过上面的讲解,你可能看出使用ant的优越性,ant可以方便的管理一个大型的项目,当然其他的项目也可以,重要的是,你可以很容易的对它的task进行扩充。相信越来越多的人会使用ant来进行项目的管理。

四:小技巧:
由于使用ant时可能出错,而屏幕不够大的话,可能看不清,最好将编译出错信息放入一个文件中,如下这样使用ant:
ant -buildfile build.xml -logfile error.log

就会将出错信息放入error.log中,由于使用buildfile参数,因此xml文件名不一定时build.xml,可以为任意xml 文件,如project.xml
阅读(77775) | 评论(0) | 转发(0) |
给主人留下些什么吧!~~
。keep参数会保留编译html文件后产生的java文件。第57行意思是将包更名,由于html文 件在antDemo/presentation/html目录下,因此产生的java类属于antDemo.presentation.html包,我们 通过new属性的值将属于此包的类改为属于新的包,使用xmlc时,一般以上几个参数就足够了,要想使用更多的参数,请参见xmlc task定义的源代码 。

从第63行到77行,目标(target)定义了编译时的细节,编译分为两部分,分别编译xmlc产生的 java类和项目中的java类(表现层,商务层,数据层中的代码)。javac这个任务中,srcdir属性指定java文件存放位置,destdir 属性指定编译后的class文件存放位置,classpathref属性指定classpath,debug属性设置关闭还是打开调试信息, includes属性起一个过滤作用,它指定编译那些文件,否则javac将会编译srcdir属性指定的目录下的所有java文件。

81 行到91行开始将将程序中用到的其他文件也复制到目标目录,以便下一步打包。在copy任务中,todir属性指定目标目录,至于复制那些文件,则由嵌套 在copy任务中的fileset任务来指定。在fileset中,dir指定基本目录,include和exclude属性用来过滤文件,符合条件的文 件将会被复制到目标目录。

95行到98行开始将程序打包,jarfile属性指定打包后的文件名,basedir指定基本目录,基本目录下的文件及子目录都会按照其本来的组织结构放到jar文件中。

102行到113行,开始复制配置文件,配置文件包括AntDemo.conf,multiserver.conf,start.其中第112行,chmod任务将start文件的属性改为对任何人可执行和可读。

通过上面的讲解,你可能看出使用ant的优越性,ant可以方便的管理一个大型的项目,当然其他的项目也可以,重要的是,你可以很容易的对它的task进行扩充。相信越来越多的人会使用ant来进行项目的管理。

四:小技巧:
由于使用ant时可能出错,而屏幕不够大的话,可能看不清,最好将编译出错信息放入一个文件中,如下这样使用ant:
ant -buildfile build.xml -logfile error.log

就会将出错信息放入error.log中,由于使用buildfile参数,因此xml文件名不一定时build.xml,可以为任意xml 文件,如project.xml
阅读(77774) | 评论(0) | 转发(0) |
给主人留下些什么吧!~~
。keep参数会保留编译html文件后产生的java文件。第57行意思是将包更名,由于html文 件在antDemo/presentation/html目录下,因此产生的java类属于antDemo.presentation.html包,我们 通过new属性的值将属于此包的类改为属于新的包,使用xmlc时,一般以上几个参数就足够了,要想使用更多的参数,请参见xmlc task定义的源代码 。

从第63行到77行,目标(target)定义了编译时的细节,编译分为两部分,分别编译xmlc产生的 java类和项目中的java类(表现层,商务层,数据层中的代码)。javac这个任务中,srcdir属性指定java文件存放位置,destdir 属性指定编译后的class文件存放位置,classpathref属性指定classpath,debug属性设置关闭还是打开调试信息, includes属性起一个过滤作用,它指定编译那些文件,否则javac将会编译srcdir属性指定的目录下的所有java文件。

81 行到91行开始将将程序中用到的其他文件也复制到目标目录,以便下一步打包。在copy任务中,todir属性指定目标目录,至于复制那些文件,则由嵌套 在copy任务中的fileset任务来指定。在fileset中,dir指定基本目录,include和exclude属性用来过滤文件,符合条件的文 件将会被复制到目标目录。

95行到98行开始将程序打包,jarfile属性指定打包后的文件名,basedir指定基本目录,基本目录下的文件及子目录都会按照其本来的组织结构放到jar文件中。

102行到113行,开始复制配置文件,配置文件包括AntDemo.conf,multiserver.conf,start.其中第112行,chmod任务将start文件的属性改为对任何人可执行和可读。

通过上面的讲解,你可能看出使用ant的优越性,ant可以方便的管理一个大型的项目,当然其他的项目也可以,重要的是,你可以很容易的对它的task进行扩充。相信越来越多的人会使用ant来进行项目的管理。

四:小技巧:
由于使用ant时可能出错,而屏幕不够大的话,可能看不清,最好将编译出错信息放入一个文件中,如下这样使用ant:
ant -buildfile build.xml -logfile error.log

就会将出错信息放入error.log中,由于使用buildfile参数,因此xml文件名不一定时build.xml,可以为任意xml 文件,如project.xml
阅读(77773) | 评论(0) | 转发(0) |
给主人留下些什么吧!~~
。keep参数会保留编译html文件后产生的java文件。第57行意思是将包更名,由于html文 件在antDemo/presentation/html目录下,因此产生的java类属于antDemo.presentation.html包,我们 通过new属性的值将属于此包的类改为属于新的包,使用xmlc时,一般以上几个参数就足够了,要想使用更多的参数,请参见xmlc task定义的源代码 。

从第63行到77行,目标(target)定义了编译时的细节,编译分为两部分,分别编译xmlc产生的 java类和项目中的java类(表现层,商务层,数据层中的代码)。javac这个任务中,srcdir属性指定java文件存放位置,destdir 属性指定编译后的class文件存放位置,classpathref属性指定classpath,debug属性设置关闭还是打开调试信息, includes属性起一个过滤作用,它指定编译那些文件,否则javac将会编译srcdir属性指定的目录下的所有java文件。

81 行到91行开始将将程序中用到的其他文件也复制到目标目录,以便下一步打包。在copy任务中,todir属性指定目标目录,至于复制那些文件,则由嵌套 在copy任务中的fileset任务来指定。在fileset中,dir指定基本目录,include和exclude属性用来过滤文件,符合条件的文 件将会被复制到目标目录。

95行到98行开始将程序打包,jarfile属性指定打包后的文件名,basedir指定基本目录,基本目录下的文件及子目录都会按照其本来的组织结构放到jar文件中。

102行到113行,开始复制配置文件,配置文件包括AntDemo.conf,multiserver.conf,start.其中第112行,chmod任务将start文件的属性改为对任何人可执行和可读。

通过上面的讲解,你可能看出使用ant的优越性,ant可以方便的管理一个大型的项目,当然其他的项目也可以,重要的是,你可以很容易的对它的task进行扩充。相信越来越多的人会使用ant来进行项目的管理。

四:小技巧:
由于使用ant时可能出错,而屏幕不够大的话,可能看不清,最好将编译出错信息放入一个文件中,如下这样使用ant:
ant -buildfile build.xml -logfile error.log

就会将出错信息放入error.log中,由于使用buildfile参数,因此xml文件名不一定时build.xml,可以为任意xml 文件,如project.xml
阅读(77772) | 评论(0) | 转发(0) |
给主人留下些什么吧!~~
。keep参数会保留编译html文件后产生的java文件。第57行意思是将包更名,由于html文 件在antDemo/presentation/html目录下,因此产生的java类属于antDemo.presentation.html包,我们 通过new属性的值将属于此包的类改为属于新的包,使用xmlc时,一般以上几个参数就足够了,要想使用更多的参数,请参见xmlc task定义的源代码 。

从第63行到77行,目标(target)定义了编译时的细节,编译分为两部分,分别编译xmlc产生的 java类和项目中的java类(表现层,商务层,数据层中的代码)。javac这个任务中,srcdir属性指定java文件存放位置,destdir 属性指定编译后的class文件存放位置,classpathref属性指定classpath,debug属性设置关闭还是打开调试信息, includes属性起一个过滤作用,它指定编译那些文件,否则javac将会编译srcdir属性指定的目录下的所有java文件。

81 行到91行开始将将程序中用到的其他文件也复制到目标目录,以便下一步打包。在copy任务中,todir属性指定目标目录,至于复制那些文件,则由嵌套 在copy任务中的fileset任务来指定。在fileset中,dir指定基本目录,include和exclude属性用来过滤文件,符合条件的文 件将会被复制到目标目录。

95行到98行开始将程序打包,jarfile属性指定打包后的文件名,basedir指定基本目录,基本目录下的文件及子目录都会按照其本来的组织结构放到jar文件中。

102行到113行,开始复制配置文件,配置文件包括AntDemo.conf,multiserver.conf,start.其中第112行,chmod任务将start文件的属性改为对任何人可执行和可读。

通过上面的讲解,你可能看出使用ant的优越性,ant可以方便的管理一个大型的项目,当然其他的项目也可以,重要的是,你可以很容易的对它的task进行扩充。相信越来越多的人会使用ant来进行项目的管理。

四:小技巧:
由于使用ant时可能出错,而屏幕不够大的话,可能看不清,最好将编译出错信息放入一个文件中,如下这样使用ant:
ant -buildfile build.xml -logfile error.log

就会将出错信息放入error.log中,由于使用buildfile参数,因此xml文件名不一定时build.xml,可以为任意xml 文件,如project.xml
阅读(77771) | 评论(0) | 转发(0) |
给主人留下些什么吧!~~
。keep参数会保留编译html文件后产生的java文件。第57行意思是将包更名,由于html文 件在antDemo/presentation/html目录下,因此产生的java类属于antDemo.presentation.html包,我们 通过new属性的值将属于此包的类改为属于新的包,使用xmlc时,一般以上几个参数就足够了,要想使用更多的参数,请参见xmlc task定义的源代码 。

从第63行到77行,目标(target)定义了编译时的细节,编译分为两部分,分别编译xmlc产生的 java类和项目中的java类(表现层,商务层,数据层中的代码)。javac这个任务中,srcdir属性指定java文件存放位置,destdir 属性指定编译后的class文件存放位置,classpathref属性指定classpath,debug属性设置关闭还是打开调试信息, includes属性起一个过滤作用,它指定编译那些文件,否则javac将会编译srcdir属性指定的目录下的所有java文件。

81 行到91行开始将将程序中用到的其他文件也复制到目标目录,以便下一步打包。在copy任务中,todir属性指定目标目录,至于复制那些文件,则由嵌套 在copy任务中的fileset任务来指定。在fileset中,dir指定基本目录,include和exclude属性用来过滤文件,符合条件的文 件将会被复制到目标目录。

95行到98行开始将程序打包,jarfile属性指定打包后的文件名,basedir指定基本目录,基本目录下的文件及子目录都会按照其本来的组织结构放到jar文件中。

102行到113行,开始复制配置文件,配置文件包括AntDemo.conf,multiserver.conf,start.其中第112行,chmod任务将start文件的属性改为对任何人可执行和可读。

通过上面的讲解,你可能看出使用ant的优越性,ant可以方便的管理一个大型的项目,当然其他的项目也可以,重要的是,你可以很容易的对它的task进行扩充。相信越来越多的人会使用ant来进行项目的管理。

四:小技巧:
由于使用ant时可能出错,而屏幕不够大的话,可能看不清,最好将编译出错信息放入一个文件中,如下这样使用ant:
ant -buildfile build.xml -logfile error.log

就会将出错信息放入error.log中,由于使用buildfile参数,因此xml文件名不一定时build.xml,可以为任意xml 文件,如project.xml
阅读(77770) | 评论(0) | 转发(0) |
给主人留下些什么吧!~~
。keep参数会保留编译html文件后产生的java文件。第57行意思是将包更名,由于html文 件在antDemo/presentation/html目录下,因此产生的java类属于antDemo.presentation.html包,我们 通过new属性的值将属于此包的类改为属于新的包,使用xmlc时,一般以上几个参数就足够了,要想使用更多的参数,请参见xmlc task定义的源代码 。

从第63行到77行,目标(target)定义了编译时的细节,编译分为两部分,分别编译xmlc产生的 java类和项目中的java类(表现层,商务层,数据层中的代码)。javac这个任务中,srcdir属性指定java文件存放位置,destdir 属性指定编译后的class文件存放位置,classpathref属性指定classpath,debug属性设置关闭还是打开调试信息, includes属性起一个过滤作用,它指定编译那些文件,否则javac将会编译srcdir属性指定的目录下的所有java文件。

81 行到91行开始将将程序中用到的其他文件也复制到目标目录,以便下一步打包。在copy任务中,todir属性指定目标目录,至于复制那些文件,则由嵌套 在copy任务中的fileset任务来指定。在fileset中,dir指定基本目录,include和exclude属性用来过滤文件,符合条件的文 件将会被复制到目标目录。

95行到98行开始将程序打包,jarfile属性指定打包后的文件名,basedir指定基本目录,基本目录下的文件及子目录都会按照其本来的组织结构放到jar文件中。

102行到113行,开始复制配置文件,配置文件包括AntDemo.conf,multiserver.conf,start.其中第112行,chmod任务将start文件的属性改为对任何人可执行和可读。

通过上面的讲解,你可能看出使用ant的优越性,ant可以方便的管理一个大型的项目,当然其他的项目也可以,重要的是,你可以很容易的对它的task进行扩充。相信越来越多的人会使用ant来进行项目的管理。

四:小技巧:
由于使用ant时可能出错,而屏幕不够大的话,可能看不清,最好将编译出错信息放入一个文件中,如下这样使用ant:
ant -buildfile build.xml -logfile error.log

就会将出错信息放入error.log中,由于使用buildfile参数,因此xml文件名不一定时build.xml,可以为任意xml 文件,如project.xml
阅读(77769) | 评论(0) | 转发(0) |
给主人留下些什么吧!~~
。keep参数会保留编译html文件后产生的java文件。第57行意思是将包更名,由于html文 件在antDemo/presentation/html目录下,因此产生的java类属于antDemo.presentation.html包,我们 通过new属性的值将属于此包的类改为属于新的包,使用xmlc时,一般以上几个参数就足够了,要想使用更多的参数,请参见xmlc task定义的源代码 。

从第63行到77行,目标(target)定义了编译时的细节,编译分为两部分,分别编译xmlc产生的 java类和项目中的java类(表现层,商务层,数据层中的代码)。javac这个任务中,srcdir属性指定java文件存放位置,destdir 属性指定编译后的class文件存放位置,classpathref属性指定classpath,debug属性设置关闭还是打开调试信息, includes属性起一个过滤作用,它指定编译那些文件,否则javac将会编译srcdir属性指定的目录下的所有java文件。

81 行到91行开始将将程序中用到的其他文件也复制到目标目录,以便下一步打包。在copy任务中,todir属性指定目标目录,至于复制那些文件,则由嵌套 在copy任务中的fileset任务来指定。在fileset中,dir指定基本目录,include和exclude属性用来过滤文件,符合条件的文 件将会被复制到目标目录。

95行到98行开始将程序打包,jarfile属性指定打包后的文件名,basedir指定基本目录,基本目录下的文件及子目录都会按照其本来的组织结构放到jar文件中。

102行到113行,开始复制配置文件,配置文件包括AntDemo.conf,multiserver.conf,start.其中第112行,chmod任务将start文件的属性改为对任何人可执行和可读。

通过上面的讲解,你可能看出使用ant的优越性,ant可以方便的管理一个大型的项目,当然其他的项目也可以,重要的是,你可以很容易的对它的task进行扩充。相信越来越多的人会使用ant来进行项目的管理。

四:小技巧:
由于使用ant时可能出错,而屏幕不够大的话,可能看不清,最好将编译出错信息放入一个文件中,如下这样使用ant:
ant -buildfile build.xml -logfile error.log

就会将出错信息放入error.log中,由于使用buildfile参数,因此xml文件名不一定时build.xml,可以为任意xml 文件,如project.xml
阅读(77768) | 评论(0) | 转发(0) |
给主人留下些什么吧!~~
。keep参数会保留编译html文件后产生的java文件。第57行意思是将包更名,由于html文 件在antDemo/presentation/html目录下,因此产生的java类属于antDemo.presentation.html包,我们 通过new属性的值将属于此包的类改为属于新的包,使用xmlc时,一般以上几个参数就足够了,要想使用更多的参数,请参见xmlc task定义的源代码 。

从第63行到77行,目标(target)定义了编译时的细节,编译分为两部分,分别编译xmlc产生的 java类和项目中的java类(表现层,商务层,数据层中的代码)。javac这个任务中,srcdir属性指定java文件存放位置,destdir 属性指定编译后的class文件存放位置,classpathref属性指定classpath,debug属性设置关闭还是打开调试信息, includes属性起一个过滤作用,它指定编译那些文件,否则javac将会编译srcdir属性指定的目录下的所有java文件。

81 行到91行开始将将程序中用到的其他文件也复制到目标目录,以便下一步打包。在copy任务中,todir属性指定目标目录,至于复制那些文件,则由嵌套 在copy任务中的fileset任务来指定。在fileset中,dir指定基本目录,include和exclude属性用来过滤文件,符合条件的文 件将会被复制到目标目录。

95行到98行开始将程序打包,jarfile属性指定打包后的文件名,basedir指定基本目录,基本目录下的文件及子目录都会按照其本来的组织结构放到jar文件中。

102行到113行,开始复制配置文件,配置文件包括AntDemo.conf,multiserver.conf,start.其中第112行,chmod任务将start文件的属性改为对任何人可执行和可读。

通过上面的讲解,你可能看出使用ant的优越性,ant可以方便的管理一个大型的项目,当然其他的项目也可以,重要的是,你可以很容易的对它的task进行扩充。相信越来越多的人会使用ant来进行项目的管理。

四:小技巧:
由于使用ant时可能出错,而屏幕不够大的话,可能看不清,最好将编译出错信息放入一个文件中,如下这样使用ant:
ant -buildfile build.xml -logfile error.log

就会将出错信息放入error.log中,由于使用buildfile参数,因此xml文件名不一定时build.xml,可以为任意xml 文件,如project.xml
阅读(77767) | 评论(0) | 转发(0) |
给主人留下些什么吧!~~
。keep参数会保留编译html文件后产生的java文件。第57行意思是将包更名,由于html文 件在antDemo/presentation/html目录下,因此产生的java类属于antDemo.presentation.html包,我们 通过new属性的值将属于此包的类改为属于新的包,使用xmlc时,一般以上几个参数就足够了,要想使用更多的参数,请参见xmlc task定义的源代码 。

从第63行到77行,目标(target)定义了编译时的细节,编译分为两部分,分别编译xmlc产生的 java类和项目中的java类(表现层,商务层,数据层中的代码)。javac这个任务中,srcdir属性指定java文件存放位置,destdir 属性指定编译后的class文件存放位置,classpathref属性指定classpath,debug属性设置关闭还是打开调试信息, includes属性起一个过滤作用,它指定编译那些文件,否则javac将会编译srcdir属性指定的目录下的所有java文件。

81 行到91行开始将将程序中用到的其他文件也复制到目标目录,以便下一步打包。在copy任务中,todir属性指定目标目录,至于复制那些文件,则由嵌套 在copy任务中的fileset任务来指定。在fileset中,dir指定基本目录,include和exclude属性用来过滤文件,符合条件的文 件将会被复制到目标目录。

95行到98行开始将程序打包,jarfile属性指定打包后的文件名,basedir指定基本目录,基本目录下的文件及子目录都会按照其本来的组织结构放到jar文件中。

102行到113行,开始复制配置文件,配置文件包括AntDemo.conf,multiserver.conf,start.其中第112行,chmod任务将start文件的属性改为对任何人可执行和可读。

通过上面的讲解,你可能看出使用ant的优越性,ant可以方便的管理一个大型的项目,当然其他的项目也可以,重要的是,你可以很容易的对它的task进行扩充。相信越来越多的人会使用ant来进行项目的管理。

四:小技巧:
由于使用ant时可能出错,而屏幕不够大的话,可能看不清,最好将编译出错信息放入一个文件中,如下这样使用ant:
ant -buildfile build.xml -logfile error.log

就会将出错信息放入error.log中,由于使用buildfile参数,因此xml文件名不一定时build.xml,可以为任意xml 文件,如project.xml
阅读(77766) | 评论(0) | 转发(0) |
给主人留下些什么吧!~~
。keep参数会保留编译html文件后产生的java文件。第57行意思是将包更名,由于html文 件在antDemo/presentation/html目录下,因此产生的java类属于antDemo.presentation.html包,我们 通过new属性的值将属于此包的类改为属于新的包,使用xmlc时,一般以上几个参数就足够了,要想使用更多的参数,请参见xmlc task定义的源代码 。

从第63行到77行,目标(target)定义了编译时的细节,编译分为两部分,分别编译xmlc产生的 java类和项目中的java类(表现层,商务层,数据层中的代码)。javac这个任务中,srcdir属性指定java文件存放位置,destdir 属性指定编译后的class文件存放位置,classpathref属性指定classpath,debug属性设置关闭还是打开调试信息, includes属性起一个过滤作用,它指定编译那些文件,否则javac将会编译srcdir属性指定的目录下的所有java文件。

81 行到91行开始将将程序中用到的其他文件也复制到目标目录,以便下一步打包。在copy任务中,todir属性指定目标目录,至于复制那些文件,则由嵌套 在copy任务中的fileset任务来指定。在fileset中,dir指定基本目录,include和exclude属性用来过滤文件,符合条件的文 件将会被复制到目标目录。

95行到98行开始将程序打包,jarfile属性指定打包后的文件名,basedir指定基本目录,基本目录下的文件及子目录都会按照其本来的组织结构放到jar文件中。

102行到113行,开始复制配置文件,配置文件包括AntDemo.conf,multiserver.conf,start.其中第112行,chmod任务将start文件的属性改为对任何人可执行和可读。

通过上面的讲解,你可能看出使用ant的优越性,ant可以方便的管理一个大型的项目,当然其他的项目也可以,重要的是,你可以很容易的对它的task进行扩充。相信越来越多的人会使用ant来进行项目的管理。

四:小技巧:
由于使用ant时可能出错,而屏幕不够大的话,可能看不清,最好将编译出错信息放入一个文件中,如下这样使用ant:
ant -buildfile build.xml -logfile error.log

就会将出错信息放入error.log中,由于使用buildfile参数,因此xml文件名不一定时build.xml,可以为任意xml 文件,如project.xml
阅读(77765) | 评论(0) | 转发(0) |
给主人留下些什么吧!~~
。keep参数会保留编译html文件后产生的java文件。第57行意思是将包更名,由于html文 件在antDemo/presentation/html目录下,因此产生的java类属于antDemo.presentation.html包,我们 通过new属性的值将属于此包的类改为属于新的包,使用xmlc时,一般以上几个参数就足够了,要想使用更多的参数,请参见xmlc task定义的源代码 。

从第63行到77行,目标(target)定义了编译时的细节,编译分为两部分,分别编译xmlc产生的 java类和项目中的java类(表现层,商务层,数据层中的代码)。javac这个任务中,srcdir属性指定java文件存放位置,destdir 属性指定编译后的class文件存放位置,classpathref属性指定classpath,debug属性设置关闭还是打开调试信息, includes属性起一个过滤作用,它指定编译那些文件,否则javac将会编译srcdir属性指定的目录下的所有java文件。

81 行到91行开始将将程序中用到的其他文件也复制到目标目录,以便下一步打包。在copy任务中,todir属性指定目标目录,至于复制那些文件,则由嵌套 在copy任务中的fileset任务来指定。在fileset中,dir指定基本目录,include和exclude属性用来过滤文件,符合条件的文 件将会被复制到目标目录。

95行到98行开始将程序打包,jarfile属性指定打包后的文件名,basedir指定基本目录,基本目录下的文件及子目录都会按照其本来的组织结构放到jar文件中。

102行到113行,开始复制配置文件,配置文件包括AntDemo.conf,multiserver.conf,start.其中第112行,chmod任务将start文件的属性改为对任何人可执行和可读。

通过上面的讲解,你可能看出使用ant的优越性,ant可以方便的管理一个大型的项目,当然其他的项目也可以,重要的是,你可以很容易的对它的task进行扩充。相信越来越多的人会使用ant来进行项目的管理。

四:小技巧:
由于使用ant时可能出错,而屏幕不够大的话,可能看不清,最好将编译出错信息放入一个文件中,如下这样使用ant:
ant -buildfile build.xml -logfile error.log

就会将出错信息放入error.log中,由于使用buildfile参数,因此xml文件名不一定时build.xml,可以为任意xml 文件,如project.xml
阅读(77764) | 评论(0) | 转发(0) |
给主人留下些什么吧!~~
。keep参数会保留编译html文件后产生的java文件。第57行意思是将包更名,由于html文 件在antDemo/presentation/html目录下,因此产生的java类属于antDemo.presentation.html包,我们 通过new属性的值将属于此包的类改为属于新的包,使用xmlc时,一般以上几个参数就足够了,要想使用更多的参数,请参见xmlc task定义的源代码 。

从第63行到77行,目标(target)定义了编译时的细节,编译分为两部分,分别编译xmlc产生的 java类和项目中的java类(表现层,商务层,数据层中的代码)。javac这个任务中,srcdir属性指定java文件存放位置,destdir 属性指定编译后的class文件存放位置,classpathref属性指定classpath,debug属性设置关闭还是打开调试信息, includes属性起一个过滤作用,它指定编译那些文件,否则javac将会编译srcdir属性指定的目录下的所有java文件。

81 行到91行开始将将程序中用到的其他文件也复制到目标目录,以便下一步打包。在copy任务中,todir属性指定目标目录,至于复制那些文件,则由嵌套 在copy任务中的fileset任务来指定。在fileset中,dir指定基本目录,include和exclude属性用来过滤文件,符合条件的文 件将会被复制到目标目录。

95行到98行开始将程序打包,jarfile属性指定打包后的文件名,basedir指定基本目录,基本目录下的文件及子目录都会按照其本来的组织结构放到jar文件中。

102行到113行,开始复制配置文件,配置文件包括AntDemo.conf,multiserver.conf,start.其中第112行,chmod任务将start文件的属性改为对任何人可执行和可读。

通过上面的讲解,你可能看出使用ant的优越性,ant可以方便的管理一个大型的项目,当然其他的项目也可以,重要的是,你可以很容易的对它的task进行扩充。相信越来越多的人会使用ant来进行项目的管理。

四:小技巧:
由于使用ant时可能出错,而屏幕不够大的话,可能看不清,最好将编译出错信息放入一个文件中,如下这样使用ant:
ant -buildfile build.xml -logfile error.log

就会将出错信息放入error.log中,由于使用buildfile参数,因此xml文件名不一定时build.xml,可以为任意xml 文件,如project.xml
阅读(77763) | 评论(0) | 转发(0) |
给主人留下些什么吧!~~
。keep参数会保留编译html文件后产生的java文件。第57行意思是将包更名,由于html文 件在antDemo/presentation/html目录下,因此产生的java类属于antDemo.presentation.html包,我们 通过new属性的值将属于此包的类改为属于新的包,使用xmlc时,一般以上几个参数就足够了,要想使用更多的参数,请参见xmlc task定义的源代码 。

从第63行到77行,目标(target)定义了编译时的细节,编译分为两部分,分别编译xmlc产生的 java类和项目中的java类(表现层,商务层,数据层中的代码)。javac这个任务中,srcdir属性指定java文件存放位置,destdir 属性指定编译后的class文件存放位置,classpathref属性指定classpath,debug属性设置关闭还是打开调试信息, includes属性起一个过滤作用,它指定编译那些文件,否则javac将会编译srcdir属性指定的目录下的所有java文件。

81 行到91行开始将将程序中用到的其他文件也复制到目标目录,以便下一步打包。在copy任务中,todir属性指定目标目录,至于复制那些文件,则由嵌套 在copy任务中的fileset任务来指定。在fileset中,dir指定基本目录,include和exclude属性用来过滤文件,符合条件的文 件将会被复制到目标目录。

95行到98行开始将程序打包,jarfile属性指定打包后的文件名,basedir指定基本目录,基本目录下的文件及子目录都会按照其本来的组织结构放到jar文件中。

102行到113行,开始复制配置文件,配置文件包括AntDemo.conf,multiserver.conf,start.其中第112行,chmod任务将start文件的属性改为对任何人可执行和可读。

通过上面的讲解,你可能看出使用ant的优越性,ant可以方便的管理一个大型的项目,当然其他的项目也可以,重要的是,你可以很容易的对它的task进行扩充。相信越来越多的人会使用ant来进行项目的管理。

四:小技巧:
由于使用ant时可能出错,而屏幕不够大的话,可能看不清,最好将编译出错信息放入一个文件中,如下这样使用ant:
ant -buildfile build.xml -logfile error.log

就会将出错信息放入error.log中,由于使用buildfile参数,因此xml文件名不一定时build.xml,可以为任意xml 文件,如project.xml
阅读(77762) | 评论(0) | 转发(0) |
给主人留下些什么吧!~~
。keep参数会保留编译html文件后产生的java文件。第57行意思是将包更名,由于html文 件在antDemo/presentation/html目录下,因此产生的java类属于antDemo.presentation.html包,我们 通过new属性的值将属于此包的类改为属于新的包,使用xmlc时,一般以上几个参数就足够了,要想使用更多的参数,请参见xmlc task定义的源代码 。

从第63行到77行,目标(target)定义了编译时的细节,编译分为两部分,分别编译xmlc产生的 java类和项目中的java类(表现层,商务层,数据层中的代码)。javac这个任务中,srcdir属性指定java文件存放位置,destdir 属性指定编译后的class文件存放位置,classpathref属性指定classpath,debug属性设置关闭还是打开调试信息, includes属性起一个过滤作用,它指定编译那些文件,否则javac将会编译srcdir属性指定的目录下的所有java文件。

81 行到91行开始将将程序中用到的其他文件也复制到目标目录,以便下一步打包。在copy任务中,todir属性指定目标目录,至于复制那些文件,则由嵌套 在copy任务中的fileset任务来指定。在fileset中,dir指定基本目录,include和exclude属性用来过滤文件,符合条件的文 件将会被复制到目标目录。

95行到98行开始将程序打包,jarfile属性指定打包后的文件名,basedir指定基本目录,基本目录下的文件及子目录都会按照其本来的组织结构放到jar文件中。

102行到113行,开始复制配置文件,配置文件包括AntDemo.conf,multiserver.conf,start.其中第112行,chmod任务将start文件的属性改为对任何人可执行和可读。

通过上面的讲解,你可能看出使用ant的优越性,ant可以方便的管理一个大型的项目,当然其他的项目也可以,重要的是,你可以很容易的对它的task进行扩充。相信越来越多的人会使用ant来进行项目的管理。

四:小技巧:
由于使用ant时可能出错,而屏幕不够大的话,可能看不清,最好将编译出错信息放入一个文件中,如下这样使用ant:
ant -buildfile build.xml -logfile error.log

就会将出错信息放入error.log中,由于使用buildfile参数,因此xml文件名不一定时build.xml,可以为任意xml 文件,如project.xml
阅读(77761) | 评论(0) | 转发(0) |
给主人留下些什么吧!~~
。keep参数会保留编译html文件后产生的java文件。第57行意思是将包更名,由于html文 件在antDemo/presentation/html目录下,因此产生的java类属于antDemo.presentation.html包,我们 通过new属性的值将属于此包的类改为属于新的包,使用xmlc时,一般以上几个参数就足够了,要想使用更多的参数,请参见xmlc task定义的源代码 。

从第63行到77行,目标(target)定义了编译时的细节,编译分为两部分,分别编译xmlc产生的 java类和项目中的java类(表现层,商务层,数据层中的代码)。javac这个任务中,srcdir属性指定java文件存放位置,destdir 属性指定编译后的class文件存放位置,classpathref属性指定classpath,debug属性设置关闭还是打开调试信息, includes属性起一个过滤作用,它指定编译那些文件,否则javac将会编译srcdir属性指定的目录下的所有java文件。

81 行到91行开始将将程序中用到的其他文件也复制到目标目录,以便下一步打包。在copy任务中,todir属性指定目标目录,至于复制那些文件,则由嵌套 在copy任务中的fileset任务来指定。在fileset中,dir指定基本目录,include和exclude属性用来过滤文件,符合条件的文 件将会被复制到目标目录。

95行到98行开始将程序打包,jarfile属性指定打包后的文件名,basedir指定基本目录,基本目录下的文件及子目录都会按照其本来的组织结构放到jar文件中。

102行到113行,开始复制配置文件,配置文件包括AntDemo.conf,multiserver.conf,start.其中第112行,chmod任务将start文件的属性改为对任何人可执行和可读。

通过上面的讲解,你可能看出使用ant的优越性,ant可以方便的管理一个大型的项目,当然其他的项目也可以,重要的是,你可以很容易的对它的task进行扩充。相信越来越多的人会使用ant来进行项目的管理。

四:小技巧:
由于使用ant时可能出错,而屏幕不够大的话,可能看不清,最好将编译出错信息放入一个文件中,如下这样使用ant:
ant -buildfile build.xml -logfile error.log

就会将出错信息放入error.log中,由于使用buildfile参数,因此xml文件名不一定时build.xml,可以为任意xml 文件,如project.xml
阅读(77760) | 评论(0) | 转发(0) |
给主人留下些什么吧!~~
。keep参数会保留编译html文件后产生的java文件。第57行意思是将包更名,由于html文 件在antDemo/presentation/html目录下,因此产生的java类属于antDemo.presentation.html包,我们 通过new属性的值将属于此包的类改为属于新的包,使用xmlc时,一般以上几个参数就足够了,要想使用更多的参数,请参见xmlc task定义的源代码 。

从第63行到77行,目标(target)定义了编译时的细节,编译分为两部分,分别编译xmlc产生的 java类和项目中的java类(表现层,商务层,数据层中的代码)。javac这个任务中,srcdir属性指定java文件存放位置,destdir 属性指定编译后的class文件存放位置,classpathref属性指定classpath,debug属性设置关闭还是打开调试信息, includes属性起一个过滤作用,它指定编译那些文件,否则javac将会编译srcdir属性指定的目录下的所有java文件。

81 行到91行开始将将程序中用到的其他文件也复制到目标目录,以便下一步打包。在copy任务中,todir属性指定目标目录,至于复制那些文件,则由嵌套 在copy任务中的fileset任务来指定。在fileset中,dir指定基本目录,include和exclude属性用来过滤文件,符合条件的文 件将会被复制到目标目录。

95行到98行开始将程序打包,jarfile属性指定打包后的文件名,basedir指定基本目录,基本目录下的文件及子目录都会按照其本来的组织结构放到jar文件中。

102行到113行,开始复制配置文件,配置文件包括AntDemo.conf,multiserver.conf,start.其中第112行,chmod任务将start文件的属性改为对任何人可执行和可读。

通过上面的讲解,你可能看出使用ant的优越性,ant可以方便的管理一个大型的项目,当然其他的项目也可以,重要的是,你可以很容易的对它的task进行扩充。相信越来越多的人会使用ant来进行项目的管理。

四:小技巧:
由于使用ant时可能出错,而屏幕不够大的话,可能看不清,最好将编译出错信息放入一个文件中,如下这样使用ant:
ant -buildfile build.xml -logfile error.log

就会将出错信息放入error.log中,由于使用buildfile参数,因此xml文件名不一定时build.xml,可以为任意xml 文件,如project.xml
阅读(77759) | 评论(0) | 转发(0) |
给主人留下些什么吧!~~
。keep参数会保留编译html文件后产生的java文件。第57行意思是将包更名,由于html文 件在antDemo/presentation/html目录下,因此产生的java类属于antDemo.presentation.html包,我们 通过new属性的值将属于此包的类改为属于新的包,使用xmlc时,一般以上几个参数就足够了,要想使用更多的参数,请参见xmlc task定义的源代码 。

从第63行到77行,目标(target)定义了编译时的细节,编译分为两部分,分别编译xmlc产生的 java类和项目中的java类(表现层,商务层,数据层中的代码)。javac这个任务中,srcdir属性指定java文件存放位置,destdir 属性指定编译后的class文件存放位置,classpathref属性指定classpath,debug属性设置关闭还是打开调试信息, includes属性起一个过滤作用,它指定编译那些文件,否则javac将会编译srcdir属性指定的目录下的所有java文件。

81 行到91行开始将将程序中用到的其他文件也复制到目标目录,以便下一步打包。在copy任务中,todir属性指定目标目录,至于复制那些文件,则由嵌套 在copy任务中的fileset任务来指定。在fileset中,dir指定基本目录,include和exclude属性用来过滤文件,符合条件的文 件将会被复制到目标目录。

95行到98行开始将程序打包,jarfile属性指定打包后的文件名,basedir指定基本目录,基本目录下的文件及子目录都会按照其本来的组织结构放到jar文件中。

102行到113行,开始复制配置文件,配置文件包括AntDemo.conf,multiserver.conf,start.其中第112行,chmod任务将start文件的属性改为对任何人可执行和可读。

通过上面的讲解,你可能看出使用ant的优越性,ant可以方便的管理一个大型的项目,当然其他的项目也可以,重要的是,你可以很容易的对它的task进行扩充。相信越来越多的人会使用ant来进行项目的管理。

四:小技巧:
由于使用ant时可能出错,而屏幕不够大的话,可能看不清,最好将编译出错信息放入一个文件中,如下这样使用ant:
ant -buildfile build.xml -logfile error.log

就会将出错信息放入error.log中,由于使用buildfile参数,因此xml文件名不一定时build.xml,可以为任意xml 文件,如project.xml
阅读(77758) | 评论(0) | 转发(0) |
给主人留下些什么吧!~~
。keep参数会保留编译html文件后产生的java文件。第57行意思是将包更名,由于html文 件在antDemo/presentation/html目录下,因此产生的java类属于antDemo.presentation.html包,我们 通过new属性的值将属于此包的类改为属于新的包,使用xmlc时,一般以上几个参数就足够了,要想使用更多的参数,请参见xmlc task定义的源代码 。

从第63行到77行,目标(target)定义了编译时的细节,编译分为两部分,分别编译xmlc产生的 java类和项目中的java类(表现层,商务层,数据层中的代码)。javac这个任务中,srcdir属性指定java文件存放位置,destdir 属性指定编译后的class文件存放位置,classpathref属性指定classpath,debug属性设置关闭还是打开调试信息, includes属性起一个过滤作用,它指定编译那些文件,否则javac将会编译srcdir属性指定的目录下的所有java文件。

81 行到91行开始将将程序中用到的其他文件也复制到目标目录,以便下一步打包。在copy任务中,todir属性指定目标目录,至于复制那些文件,则由嵌套 在copy任务中的fileset任务来指定。在fileset中,dir指定基本目录,include和exclude属性用来过滤文件,符合条件的文 件将会被复制到目标目录。

95行到98行开始将程序打包,jarfile属性指定打包后的文件名,basedir指定基本目录,基本目录下的文件及子目录都会按照其本来的组织结构放到jar文件中。

102行到113行,开始复制配置文件,配置文件包括AntDemo.conf,multiserver.conf,start.其中第112行,chmod任务将start文件的属性改为对任何人可执行和可读。

通过上面的讲解,你可能看出使用ant的优越性,ant可以方便的管理一个大型的项目,当然其他的项目也可以,重要的是,你可以很容易的对它的task进行扩充。相信越来越多的人会使用ant来进行项目的管理。

四:小技巧:
由于使用ant时可能出错,而屏幕不够大的话,可能看不清,最好将编译出错信息放入一个文件中,如下这样使用ant:
ant -buildfile build.xml -logfile error.log

就会将出错信息放入error.log中,由于使用buildfile参数,因此xml文件名不一定时build.xml,可以为任意xml 文件,如project.xml
阅读(77757) | 评论(0) | 转发(0) |
给主人留下些什么吧!~~
。keep参数会保留编译html文件后产生的java文件。第57行意思是将包更名,由于html文 件在antDemo/presentation/html目录下,因此产生的java类属于antDemo.presentation.html包,我们 通过new属性的值将属于此包的类改为属于新的包,使用xmlc时,一般以上几个参数就足够了,要想使用更多的参数,请参见xmlc task定义的源代码 。

从第63行到77行,目标(target)定义了编译时的细节,编译分为两部分,分别编译xmlc产生的 java类和项目中的java类(表现层,商务层,数据层中的代码)。javac这个任务中,srcdir属性指定java文件存放位置,destdir 属性指定编译后的class文件存放位置,classpathref属性指定classpath,debug属性设置关闭还是打开调试信息, includes属性起一个过滤作用,它指定编译那些文件,否则javac将会编译srcdir属性指定的目录下的所有java文件。

81 行到91行开始将将程序中用到的其他文件也复制到目标目录,以便下一步打包。在copy任务中,todir属性指定目标目录,至于复制那些文件,则由嵌套 在copy任务中的fileset任务来指定。在fileset中,dir指定基本目录,include和exclude属性用来过滤文件,符合条件的文 件将会被复制到目标目录。

95行到98行开始将程序打包,jarfile属性指定打包后的文件名,basedir指定基本目录,基本目录下的文件及子目录都会按照其本来的组织结构放到jar文件中。

102行到113行,开始复制配置文件,配置文件包括AntDemo.conf,multiserver.conf,start.其中第112行,chmod任务将start文件的属性改为对任何人可执行和可读。

通过上面的讲解,你可能看出使用ant的优越性,ant可以方便的管理一个大型的项目,当然其他的项目也可以,重要的是,你可以很容易的对它的task进行扩充。相信越来越多的人会使用ant来进行项目的管理。

四:小技巧:
由于使用ant时可能出错,而屏幕不够大的话,可能看不清,最好将编译出错信息放入一个文件中,如下这样使用ant:
ant -buildfile build.xml -logfile error.log

就会将出错信息放入error.log中,由于使用buildfile参数,因此xml文件名不一定时build.xml,可以为任意xml 文件,如project.xml
阅读(77756) | 评论(0) | 转发(0) |
给主人留下些什么吧!~~
。keep参数会保留编译html文件后产生的java文件。第57行意思是将包更名,由于html文 件在antDemo/presentation/html目录下,因此产生的java类属于antDemo.presentation.html包,我们 通过new属性的值将属于此包的类改为属于新的包,使用xmlc时,一般以上几个参数就足够了,要想使用更多的参数,请参见xmlc task定义的源代码 。

从第63行到77行,目标(target)定义了编译时的细节,编译分为两部分,分别编译xmlc产生的 java类和项目中的java类(表现层,商务层,数据层中的代码)。javac这个任务中,srcdir属性指定java文件存放位置,destdir 属性指定编译后的class文件存放位置,classpathref属性指定classpath,debug属性设置关闭还是打开调试信息, includes属性起一个过滤作用,它指定编译那些文件,否则javac将会编译srcdir属性指定的目录下的所有java文件。

81 行到91行开始将将程序中用到的其他文件也复制到目标目录,以便下一步打包。在copy任务中,todir属性指定目标目录,至于复制那些文件,则由嵌套 在copy任务中的fileset任务来指定。在fileset中,dir指定基本目录,include和exclude属性用来过滤文件,符合条件的文 件将会被复制到目标目录。

95行到98行开始将程序打包,jarfile属性指定打包后的文件名,basedir指定基本目录,基本目录下的文件及子目录都会按照其本来的组织结构放到jar文件中。

102行到113行,开始复制配置文件,配置文件包括AntDemo.conf,multiserver.conf,start.其中第112行,chmod任务将start文件的属性改为对任何人可执行和可读。

通过上面的讲解,你可能看出使用ant的优越性,ant可以方便的管理一个大型的项目,当然其他的项目也可以,重要的是,你可以很容易的对它的task进行扩充。相信越来越多的人会使用ant来进行项目的管理。

四:小技巧:
由于使用ant时可能出错,而屏幕不够大的话,可能看不清,最好将编译出错信息放入一个文件中,如下这样使用ant:
ant -buildfile build.xml -logfile error.log

就会将出错信息放入error.log中,由于使用buildfile参数,因此xml文件名不一定时build.xml,可以为任意xml 文件,如project.xml
阅读(77755) | 评论(0) | 转发(0) |
给主人留下些什么吧!~~
。keep参数会保留编译html文件后产生的java文件。第57行意思是将包更名,由于html文 件在antDemo/presentation/html目录下,因此产生的java类属于antDemo.presentation.html包,我们 通过new属性的值将属于此包的类改为属于新的包,使用xmlc时,一般以上几个参数就足够了,要想使用更多的参数,请参见xmlc task定义的源代码 。

从第63行到77行,目标(target)定义了编译时的细节,编译分为两部分,分别编译xmlc产生的 java类和项目中的java类(表现层,商务层,数据层中的代码)。javac这个任务中,srcdir属性指定java文件存放位置,destdir 属性指定编译后的class文件存放位置,classpathref属性指定classpath,debug属性设置关闭还是打开调试信息, includes属性起一个过滤作用,它指定编译那些文件,否则javac将会编译srcdir属性指定的目录下的所有java文件。

81 行到91行开始将将程序中用到的其他文件也复制到目标目录,以便下一步打包。在copy任务中,todir属性指定目标目录,至于复制那些文件,则由嵌套 在copy任务中的fileset任务来指定。在fileset中,dir指定基本目录,include和exclude属性用来过滤文件,符合条件的文 件将会被复制到目标目录。

95行到98行开始将程序打包,jarfile属性指定打包后的文件名,basedir指定基本目录,基本目录下的文件及子目录都会按照其本来的组织结构放到jar文件中。

102行到113行,开始复制配置文件,配置文件包括AntDemo.conf,multiserver.conf,start.其中第112行,chmod任务将start文件的属性改为对任何人可执行和可读。

通过上面的讲解,你可能看出使用ant的优越性,ant可以方便的管理一个大型的项目,当然其他的项目也可以,重要的是,你可以很容易的对它的task进行扩充。相信越来越多的人会使用ant来进行项目的管理。

四:小技巧:
由于使用ant时可能出错,而屏幕不够大的话,可能看不清,最好将编译出错信息放入一个文件中,如下这样使用ant:
ant -buildfile build.xml -logfile error.log

就会将出错信息放入error.log中,由于使用buildfile参数,因此xml文件名不一定时build.xml,可以为任意xml 文件,如project.xml
阅读(77754) | 评论(0) | 转发(0) |
给主人留下些什么吧!~~
。keep参数会保留编译html文件后产生的java文件。第57行意思是将包更名,由于html文 件在antDemo/presentation/html目录下,因此产生的java类属于antDemo.presentation.html包,我们 通过new属性的值将属于此包的类改为属于新的包,使用xmlc时,一般以上几个参数就足够了,要想使用更多的参数,请参见xmlc task定义的源代码 。

从第63行到77行,目标(target)定义了编译时的细节,编译分为两部分,分别编译xmlc产生的 java类和项目中的java类(表现层,商务层,数据层中的代码)。javac这个任务中,srcdir属性指定java文件存放位置,destdir 属性指定编译后的class文件存放位置,classpathref属性指定classpath,debug属性设置关闭还是打开调试信息, includes属性起一个过滤作用,它指定编译那些文件,否则javac将会编译srcdir属性指定的目录下的所有java文件。

81 行到91行开始将将程序中用到的其他文件也复制到目标目录,以便下一步打包。在copy任务中,todir属性指定目标目录,至于复制那些文件,则由嵌套 在copy任务中的fileset任务来指定。在fileset中,dir指定基本目录,include和exclude属性用来过滤文件,符合条件的文 件将会被复制到目标目录。

95行到98行开始将程序打包,jarfile属性指定打包后的文件名,basedir指定基本目录,基本目录下的文件及子目录都会按照其本来的组织结构放到jar文件中。

102行到113行,开始复制配置文件,配置文件包括AntDemo.conf,multiserver.conf,start.其中第112行,chmod任务将start文件的属性改为对任何人可执行和可读。

通过上面的讲解,你可能看出使用ant的优越性,ant可以方便的管理一个大型的项目,当然其他的项目也可以,重要的是,你可以很容易的对它的task进行扩充。相信越来越多的人会使用ant来进行项目的管理。

四:小技巧:
由于使用ant时可能出错,而屏幕不够大的话,可能看不清,最好将编译出错信息放入一个文件中,如下这样使用ant:
ant -buildfile build.xml -logfile error.log

就会将出错信息放入error.log中,由于使用buildfile参数,因此xml文件名不一定时build.xml,可以为任意xml 文件,如project.xml
阅读(77753) | 评论(0) | 转发(0) |
给主人留下些什么吧!~~
。keep参数会保留编译html文件后产生的java文件。第57行意思是将包更名,由于html文 件在antDemo/presentation/html目录下,因此产生的java类属于antDemo.presentation.html包,我们 通过new属性的值将属于此包的类改为属于新的包,使用xmlc时,一般以上几个参数就足够了,要想使用更多的参数,请参见xmlc task定义的源代码 。

从第63行到77行,目标(target)定义了编译时的细节,编译分为两部分,分别编译xmlc产生的 java类和项目中的java类(表现层,商务层,数据层中的代码)。javac这个任务中,srcdir属性指定java文件存放位置,destdir 属性指定编译后的class文件存放位置,classpathref属性指定classpath,debug属性设置关闭还是打开调试信息, includes属性起一个过滤作用,它指定编译那些文件,否则javac将会编译srcdir属性指定的目录下的所有java文件。

81 行到91行开始将将程序中用到的其他文件也复制到目标目录,以便下一步打包。在copy任务中,todir属性指定目标目录,至于复制那些文件,则由嵌套 在copy任务中的fileset任务来指定。在fileset中,dir指定基本目录,include和exclude属性用来过滤文件,符合条件的文 件将会被复制到目标目录。

95行到98行开始将程序打包,jarfile属性指定打包后的文件名,basedir指定基本目录,基本目录下的文件及子目录都会按照其本来的组织结构放到jar文件中。

102行到113行,开始复制配置文件,配置文件包括AntDemo.conf,multiserver.conf,start.其中第112行,chmod任务将start文件的属性改为对任何人可执行和可读。

通过上面的讲解,你可能看出使用ant的优越性,ant可以方便的管理一个大型的项目,当然其他的项目也可以,重要的是,你可以很容易的对它的task进行扩充。相信越来越多的人会使用ant来进行项目的管理。

四:小技巧:
由于使用ant时可能出错,而屏幕不够大的话,可能看不清,最好将编译出错信息放入一个文件中,如下这样使用ant:
ant -buildfile build.xml -logfile error.log

就会将出错信息放入error.log中,由于使用buildfile参数,因此xml文件名不一定时build.xml,可以为任意xml 文件,如project.xml
阅读(77752) | 评论(0) | 转发(0) |
给主人留下些什么吧!~~
。keep参数会保留编译html文件后产生的java文件。第57行意思是将包更名,由于html文 件在antDemo/presentation/html目录下,因此产生的java类属于antDemo.presentation.html包,我们 通过new属性的值将属于此包的类改为属于新的包,使用xmlc时,一般以上几个参数就足够了,要想使用更多的参数,请参见xmlc task定义的源代码 。

从第63行到77行,目标(target)定义了编译时的细节,编译分为两部分,分别编译xmlc产生的 java类和项目中的java类(表现层,商务层,数据层中的代码)。javac这个任务中,srcdir属性指定java文件存放位置,destdir 属性指定编译后的class文件存放位置,classpathref属性指定classpath,debug属性设置关闭还是打开调试信息, includes属性起一个过滤作用,它指定编译那些文件,否则javac将会编译srcdir属性指定的目录下的所有java文件。

81 行到91行开始将将程序中用到的其他文件也复制到目标目录,以便下一步打包。在copy任务中,todir属性指定目标目录,至于复制那些文件,则由嵌套 在copy任务中的fileset任务来指定。在fileset中,dir指定基本目录,include和exclude属性用来过滤文件,符合条件的文 件将会被复制到目标目录。

95行到98行开始将程序打包,jarfile属性指定打包后的文件名,basedir指定基本目录,基本目录下的文件及子目录都会按照其本来的组织结构放到jar文件中。

102行到113行,开始复制配置文件,配置文件包括AntDemo.conf,multiserver.conf,start.其中第112行,chmod任务将start文件的属性改为对任何人可执行和可读。

通过上面的讲解,你可能看出使用ant的优越性,ant可以方便的管理一个大型的项目,当然其他的项目也可以,重要的是,你可以很容易的对它的task进行扩充。相信越来越多的人会使用ant来进行项目的管理。

四:小技巧:
由于使用ant时可能出错,而屏幕不够大的话,可能看不清,最好将编译出错信息放入一个文件中,如下这样使用ant:
ant -buildfile build.xml -logfile error.log

就会将出错信息放入error.log中,由于使用buildfile参数,因此xml文件名不一定时build.xml,可以为任意xml 文件,如project.xml
阅读(77751) | 评论(0) | 转发(0) |
给主人留下些什么吧!~~
。keep参数会保留编译html文件后产生的java文件。第57行意思是将包更名,由于html文 件在antDemo/presentation/html目录下,因此产生的java类属于antDemo.presentation.html包,我们 通过new属性的值将属于此包的类改为属于新的包,使用xmlc时,一般以上几个参数就足够了,要想使用更多的参数,请参见xmlc task定义的源代码 。

从第63行到77行,目标(target)定义了编译时的细节,编译分为两部分,分别编译xmlc产生的 java类和项目中的java类(表现层,商务层,数据层中的代码)。javac这个任务中,srcdir属性指定java文件存放位置,destdir 属性指定编译后的class文件存放位置,classpathref属性指定classpath,debug属性设置关闭还是打开调试信息, includes属性起一个过滤作用,它指定编译那些文件,否则javac将会编译srcdir属性指定的目录下的所有java文件。

81 行到91行开始将将程序中用到的其他文件也复制到目标目录,以便下一步打包。在copy任务中,todir属性指定目标目录,至于复制那些文件,则由嵌套 在copy任务中的fileset任务来指定。在fileset中,dir指定基本目录,include和exclude属性用来过滤文件,符合条件的文 件将会被复制到目标目录。

95行到98行开始将程序打包,jarfile属性指定打包后的文件名,basedir指定基本目录,基本目录下的文件及子目录都会按照其本来的组织结构放到jar文件中。

102行到113行,开始复制配置文件,配置文件包括AntDemo.conf,multiserver.conf,start.其中第112行,chmod任务将start文件的属性改为对任何人可执行和可读。

通过上面的讲解,你可能看出使用ant的优越性,ant可以方便的管理一个大型的项目,当然其他的项目也可以,重要的是,你可以很容易的对它的task进行扩充。相信越来越多的人会使用ant来进行项目的管理。

四:小技巧:
由于使用ant时可能出错,而屏幕不够大的话,可能看不清,最好将编译出错信息放入一个文件中,如下这样使用ant:
ant -buildfile build.xml -logfile error.log

就会将出错信息放入error.log中,由于使用buildfile参数,因此xml文件名不一定时build.xml,可以为任意xml 文件,如project.xml
阅读(77750) | 评论(0) | 转发(0) |
给主人留下些什么吧!~~
。keep参数会保留编译html文件后产生的java文件。第57行意思是将包更名,由于html文 件在antDemo/presentation/html目录下,因此产生的java类属于antDemo.presentation.html包,我们 通过new属性的值将属于此包的类改为属于新的包,使用xmlc时,一般以上几个参数就足够了,要想使用更多的参数,请参见xmlc task定义的源代码 。

从第63行到77行,目标(target)定义了编译时的细节,编译分为两部分,分别编译xmlc产生的 java类和项目中的java类(表现层,商务层,数据层中的代码)。javac这个任务中,srcdir属性指定java文件存放位置,destdir 属性指定编译后的class文件存放位置,classpathref属性指定classpath,debug属性设置关闭还是打开调试信息, includes属性起一个过滤作用,它指定编译那些文件,否则javac将会编译srcdir属性指定的目录下的所有java文件。

81 行到91行开始将将程序中用到的其他文件也复制到目标目录,以便下一步打包。在copy任务中,todir属性指定目标目录,至于复制那些文件,则由嵌套 在copy任务中的fileset任务来指定。在fileset中,dir指定基本目录,include和exclude属性用来过滤文件,符合条件的文 件将会被复制到目标目录。

95行到98行开始将程序打包,jarfile属性指定打包后的文件名,basedir指定基本目录,基本目录下的文件及子目录都会按照其本来的组织结构放到jar文件中。

102行到113行,开始复制配置文件,配置文件包括AntDemo.conf,multiserver.conf,start.其中第112行,chmod任务将start文件的属性改为对任何人可执行和可读。

通过上面的讲解,你可能看出使用ant的优越性,ant可以方便的管理一个大型的项目,当然其他的项目也可以,重要的是,你可以很容易的对它的task进行扩充。相信越来越多的人会使用ant来进行项目的管理。

四:小技巧:
由于使用ant时可能出错,而屏幕不够大的话,可能看不清,最好将编译出错信息放入一个文件中,如下这样使用ant:
ant -buildfile build.xml -logfile error.log

就会将出错信息放入error.log中,由于使用buildfile参数,因此xml文件名不一定时build.xml,可以为任意xml 文件,如project.xml
阅读(77749) | 评论(0) | 转发(0) |
给主人留下些什么吧!~~
。keep参数会保留编译html文件后产生的java文件。第57行意思是将包更名,由于html文 件在antDemo/presentation/html目录下,因此产生的java类属于antDemo.presentation.html包,我们 通过new属性的值将属于此包的类改为属于新的包,使用xmlc时,一般以上几个参数就足够了,要想使用更多的参数,请参见xmlc task定义的源代码 。

从第63行到77行,目标(target)定义了编译时的细节,编译分为两部分,分别编译xmlc产生的 java类和项目中的java类(表现层,商务层,数据层中的代码)。javac这个任务中,srcdir属性指定java文件存放位置,destdir 属性指定编译后的class文件存放位置,classpathref属性指定classpath,debug属性设置关闭还是打开调试信息, includes属性起一个过滤作用,它指定编译那些文件,否则javac将会编译srcdir属性指定的目录下的所有java文件。

81 行到91行开始将将程序中用到的其他文件也复制到目标目录,以便下一步打包。在copy任务中,todir属性指定目标目录,至于复制那些文件,则由嵌套 在copy任务中的fileset任务来指定。在fileset中,dir指定基本目录,include和exclude属性用来过滤文件,符合条件的文 件将会被复制到目标目录。

95行到98行开始将程序打包,jarfile属性指定打包后的文件名,basedir指定基本目录,基本目录下的文件及子目录都会按照其本来的组织结构放到jar文件中。

102行到113行,开始复制配置文件,配置文件包括AntDemo.conf,multiserver.conf,start.其中第112行,chmod任务将start文件的属性改为对任何人可执行和可读。

通过上面的讲解,你可能看出使用ant的优越性,ant可以方便的管理一个大型的项目,当然其他的项目也可以,重要的是,你可以很容易的对它的task进行扩充。相信越来越多的人会使用ant来进行项目的管理。

四:小技巧:
由于使用ant时可能出错,而屏幕不够大的话,可能看不清,最好将编译出错信息放入一个文件中,如下这样使用ant:
ant -buildfile build.xml -logfile error.log

就会将出错信息放入error.log中,由于使用buildfile参数,因此xml文件名不一定时build.xml,可以为任意xml 文件,如project.xml
阅读(77748) | 评论(0) | 转发(0) |
给主人留下些什么吧!~~
。keep参数会保留编译html文件后产生的java文件。第57行意思是将包更名,由于html文 件在antDemo/presentation/html目录下,因此产生的java类属于antDemo.presentation.html包,我们 通过new属性的值将属于此包的类改为属于新的包,使用xmlc时,一般以上几个参数就足够了,要想使用更多的参数,请参见xmlc task定义的源代码 。

从第63行到77行,目标(target)定义了编译时的细节,编译分为两部分,分别编译xmlc产生的 java类和项目中的java类(表现层,商务层,数据层中的代码)。javac这个任务中,srcdir属性指定java文件存放位置,destdir 属性指定编译后的class文件存放位置,classpathref属性指定classpath,debug属性设置关闭还是打开调试信息, includes属性起一个过滤作用,它指定编译那些文件,否则javac将会编译srcdir属性指定的目录下的所有java文件。

81 行到91行开始将将程序中用到的其他文件也复制到目标目录,以便下一步打包。在copy任务中,todir属性指定目标目录,至于复制那些文件,则由嵌套 在copy任务中的fileset任务来指定。在fileset中,dir指定基本目录,include和exclude属性用来过滤文件,符合条件的文 件将会被复制到目标目录。

95行到98行开始将程序打包,jarfile属性指定打包后的文件名,basedir指定基本目录,基本目录下的文件及子目录都会按照其本来的组织结构放到jar文件中。

102行到113行,开始复制配置文件,配置文件包括AntDemo.conf,multiserver.conf,start.其中第112行,chmod任务将start文件的属性改为对任何人可执行和可读。

通过上面的讲解,你可能看出使用ant的优越性,ant可以方便的管理一个大型的项目,当然其他的项目也可以,重要的是,你可以很容易的对它的task进行扩充。相信越来越多的人会使用ant来进行项目的管理。

四:小技巧:
由于使用ant时可能出错,而屏幕不够大的话,可能看不清,最好将编译出错信息放入一个文件中,如下这样使用ant:
ant -buildfile build.xml -logfile error.log

就会将出错信息放入error.log中,由于使用buildfile参数,因此xml文件名不一定时build.xml,可以为任意xml 文件,如project.xml
阅读(77747) | 评论(0) | 转发(0) |
给主人留下些什么吧!~~
。keep参数会保留编译html文件后产生的java文件。第57行意思是将包更名,由于html文 件在antDemo/presentation/html目录下,因此产生的java类属于antDemo.presentation.html包,我们 通过new属性的值将属于此包的类改为属于新的包,使用xmlc时,一般以上几个参数就足够了,要想使用更多的参数,请参见xmlc task定义的源代码 。

从第63行到77行,目标(target)定义了编译时的细节,编译分为两部分,分别编译xmlc产生的 java类和项目中的java类(表现层,商务层,数据层中的代码)。javac这个任务中,srcdir属性指定java文件存放位置,destdir 属性指定编译后的class文件存放位置,classpathref属性指定classpath,debug属性设置关闭还是打开调试信息, includes属性起一个过滤作用,它指定编译那些文件,否则javac将会编译srcdir属性指定的目录下的所有java文件。

81 行到91行开始将将程序中用到的其他文件也复制到目标目录,以便下一步打包。在copy任务中,todir属性指定目标目录,至于复制那些文件,则由嵌套 在copy任务中的fileset任务来指定。在fileset中,dir指定基本目录,include和exclude属性用来过滤文件,符合条件的文 件将会被复制到目标目录。

95行到98行开始将程序打包,jarfile属性指定打包后的文件名,basedir指定基本目录,基本目录下的文件及子目录都会按照其本来的组织结构放到jar文件中。

102行到113行,开始复制配置文件,配置文件包括AntDemo.conf,multiserver.conf,start.其中第112行,chmod任务将start文件的属性改为对任何人可执行和可读。

通过上面的讲解,你可能看出使用ant的优越性,ant可以方便的管理一个大型的项目,当然其他的项目也可以,重要的是,你可以很容易的对它的task进行扩充。相信越来越多的人会使用ant来进行项目的管理。

四:小技巧:
由于使用ant时可能出错,而屏幕不够大的话,可能看不清,最好将编译出错信息放入一个文件中,如下这样使用ant:
ant -buildfile build.xml -logfile error.log

就会将出错信息放入error.log中,由于使用buildfile参数,因此xml文件名不一定时build.xml,可以为任意xml 文件,如project.xml
阅读(77746) | 评论(0) | 转发(0) |
给主人留下些什么吧!~~
。keep参数会保留编译html文件后产生的java文件。第57行意思是将包更名,由于html文 件在antDemo/presentation/html目录下,因此产生的java类属于antDemo.presentation.html包,我们 通过new属性的值将属于此包的类改为属于新的包,使用xmlc时,一般以上几个参数就足够了,要想使用更多的参数,请参见xmlc task定义的源代码 。

从第63行到77行,目标(target)定义了编译时的细节,编译分为两部分,分别编译xmlc产生的 java类和项目中的java类(表现层,商务层,数据层中的代码)。javac这个任务中,srcdir属性指定java文件存放位置,destdir 属性指定编译后的class文件存放位置,classpathref属性指定classpath,debug属性设置关闭还是打开调试信息, includes属性起一个过滤作用,它指定编译那些文件,否则javac将会编译srcdir属性指定的目录下的所有java文件。

81 行到91行开始将将程序中用到的其他文件也复制到目标目录,以便下一步打包。在copy任务中,todir属性指定目标目录,至于复制那些文件,则由嵌套 在copy任务中的fileset任务来指定。在fileset中,dir指定基本目录,include和exclude属性用来过滤文件,符合条件的文 件将会被复制到目标目录。

95行到98行开始将程序打包,jarfile属性指定打包后的文件名,basedir指定基本目录,基本目录下的文件及子目录都会按照其本来的组织结构放到jar文件中。

102行到113行,开始复制配置文件,配置文件包括AntDemo.conf,multiserver.conf,start.其中第112行,chmod任务将start文件的属性改为对任何人可执行和可读。

通过上面的讲解,你可能看出使用ant的优越性,ant可以方便的管理一个大型的项目,当然其他的项目也可以,重要的是,你可以很容易的对它的task进行扩充。相信越来越多的人会使用ant来进行项目的管理。

四:小技巧:
由于使用ant时可能出错,而屏幕不够大的话,可能看不清,最好将编译出错信息放入一个文件中,如下这样使用ant:
ant -buildfile build.xml -logfile error.log

就会将出错信息放入error.log中,由于使用buildfile参数,因此xml文件名不一定时build.xml,可以为任意xml 文件,如project.xml
阅读(77745) | 评论(0) | 转发(0) |
给主人留下些什么吧!~~
。keep参数会保留编译html文件后产生的java文件。第57行意思是将包更名,由于html文 件在antDemo/presentation/html目录下,因此产生的java类属于antDemo.presentation.html包,我们 通过new属性的值将属于此包的类改为属于新的包,使用xmlc时,一般以上几个参数就足够了,要想使用更多的参数,请参见xmlc task定义的源代码 。

从第63行到77行,目标(target)定义了编译时的细节,编译分为两部分,分别编译xmlc产生的 java类和项目中的java类(表现层,商务层,数据层中的代码)。javac这个任务中,srcdir属性指定java文件存放位置,destdir 属性指定编译后的class文件存放位置,classpathref属性指定classpath,debug属性设置关闭还是打开调试信息, includes属性起一个过滤作用,它指定编译那些文件,否则javac将会编译srcdir属性指定的目录下的所有java文件。

81 行到91行开始将将程序中用到的其他文件也复制到目标目录,以便下一步打包。在copy任务中,todir属性指定目标目录,至于复制那些文件,则由嵌套 在copy任务中的fileset任务来指定。在fileset中,dir指定基本目录,include和exclude属性用来过滤文件,符合条件的文 件将会被复制到目标目录。

95行到98行开始将程序打包,jarfile属性指定打包后的文件名,basedir指定基本目录,基本目录下的文件及子目录都会按照其本来的组织结构放到jar文件中。

102行到113行,开始复制配置文件,配置文件包括AntDemo.conf,multiserver.conf,start.其中第112行,chmod任务将start文件的属性改为对任何人可执行和可读。

通过上面的讲解,你可能看出使用ant的优越性,ant可以方便的管理一个大型的项目,当然其他的项目也可以,重要的是,你可以很容易的对它的task进行扩充。相信越来越多的人会使用ant来进行项目的管理。

四:小技巧:
由于使用ant时可能出错,而屏幕不够大的话,可能看不清,最好将编译出错信息放入一个文件中,如下这样使用ant:
ant -buildfile build.xml -logfile error.log

就会将出错信息放入error.log中,由于使用buildfile参数,因此xml文件名不一定时build.xml,可以为任意xml 文件,如project.xml
阅读(77744) | 评论(0) | 转发(0) |
给主人留下些什么吧!~~
。keep参数会保留编译html文件后产生的java文件。第57行意思是将包更名,由于html文 件在antDemo/presentation/html目录下,因此产生的java类属于antDemo.presentation.html包,我们 通过new属性的值将属于此包的类改为属于新的包,使用xmlc时,一般以上几个参数就足够了,要想使用更多的参数,请参见xmlc task定义的源代码 。

从第63行到77行,目标(target)定义了编译时的细节,编译分为两部分,分别编译xmlc产生的 java类和项目中的java类(表现层,商务层,数据层中的代码)。javac这个任务中,srcdir属性指定java文件存放位置,destdir 属性指定编译后的class文件存放位置,classpathref属性指定classpath,debug属性设置关闭还是打开调试信息, includes属性起一个过滤作用,它指定编译那些文件,否则javac将会编译srcdir属性指定的目录下的所有java文件。

81 行到91行开始将将程序中用到的其他文件也复制到目标目录,以便下一步打包。在copy任务中,todir属性指定目标目录,至于复制那些文件,则由嵌套 在copy任务中的fileset任务来指定。在fileset中,dir指定基本目录,include和exclude属性用来过滤文件,符合条件的文 件将会被复制到目标目录。

95行到98行开始将程序打包,jarfile属性指定打包后的文件名,basedir指定基本目录,基本目录下的文件及子目录都会按照其本来的组织结构放到jar文件中。

102行到113行,开始复制配置文件,配置文件包括AntDemo.conf,multiserver.conf,start.其中第112行,chmod任务将start文件的属性改为对任何人可执行和可读。

通过上面的讲解,你可能看出使用ant的优越性,ant可以方便的管理一个大型的项目,当然其他的项目也可以,重要的是,你可以很容易的对它的task进行扩充。相信越来越多的人会使用ant来进行项目的管理。

四:小技巧:
由于使用ant时可能出错,而屏幕不够大的话,可能看不清,最好将编译出错信息放入一个文件中,如下这样使用ant:
ant -buildfile build.xml -logfile error.log

就会将出错信息放入error.log中,由于使用buildfile参数,因此xml文件名不一定时build.xml,可以为任意xml 文件,如project.xml
阅读(77743) | 评论(0) | 转发(0) |
给主人留下些什么吧!~~
。keep参数会保留编译html文件后产生的java文件。第57行意思是将包更名,由于html文 件在antDemo/presentation/html目录下,因此产生的java类属于antDemo.presentation.html包,我们 通过new属性的值将属于此包的类改为属于新的包,使用xmlc时,一般以上几个参数就足够了,要想使用更多的参数,请参见xmlc task定义的源代码 。

从第63行到77行,目标(target)定义了编译时的细节,编译分为两部分,分别编译xmlc产生的 java类和项目中的java类(表现层,商务层,数据层中的代码)。javac这个任务中,srcdir属性指定java文件存放位置,destdir 属性指定编译后的class文件存放位置,classpathref属性指定classpath,debug属性设置关闭还是打开调试信息, includes属性起一个过滤作用,它指定编译那些文件,否则javac将会编译srcdir属性指定的目录下的所有java文件。

81 行到91行开始将将程序中用到的其他文件也复制到目标目录,以便下一步打包。在copy任务中,todir属性指定目标目录,至于复制那些文件,则由嵌套 在copy任务中的fileset任务来指定。在fileset中,dir指定基本目录,include和exclude属性用来过滤文件,符合条件的文 件将会被复制到目标目录。

95行到98行开始将程序打包,jarfile属性指定打包后的文件名,basedir指定基本目录,基本目录下的文件及子目录都会按照其本来的组织结构放到jar文件中。

102行到113行,开始复制配置文件,配置文件包括AntDemo.conf,multiserver.conf,start.其中第112行,chmod任务将start文件的属性改为对任何人可执行和可读。

通过上面的讲解,你可能看出使用ant的优越性,ant可以方便的管理一个大型的项目,当然其他的项目也可以,重要的是,你可以很容易的对它的task进行扩充。相信越来越多的人会使用ant来进行项目的管理。

四:小技巧:
由于使用ant时可能出错,而屏幕不够大的话,可能看不清,最好将编译出错信息放入一个文件中,如下这样使用ant:
ant -buildfile build.xml -logfile error.log

就会将出错信息放入error.log中,由于使用buildfile参数,因此xml文件名不一定时build.xml,可以为任意xml 文件,如project.xml
阅读(77742) | 评论(0) | 转发(0) |
给主人留下些什么吧!~~
。keep参数会保留编译html文件后产生的java文件。第57行意思是将包更名,由于html文 件在antDemo/presentation/html目录下,因此产生的java类属于antDemo.presentation.html包,我们 通过new属性的值将属于此包的类改为属于新的包,使用xmlc时,一般以上几个参数就足够了,要想使用更多的参数,请参见xmlc task定义的源代码 。

从第63行到77行,目标(target)定义了编译时的细节,编译分为两部分,分别编译xmlc产生的 java类和项目中的java类(表现层,商务层,数据层中的代码)。javac这个任务中,srcdir属性指定java文件存放位置,destdir 属性指定编译后的class文件存放位置,classpathref属性指定classpath,debug属性设置关闭还是打开调试信息, includes属性起一个过滤作用,它指定编译那些文件,否则javac将会编译srcdir属性指定的目录下的所有java文件。

81 行到91行开始将将程序中用到的其他文件也复制到目标目录,以便下一步打包。在copy任务中,todir属性指定目标目录,至于复制那些文件,则由嵌套 在copy任务中的fileset任务来指定。在fileset中,dir指定基本目录,include和exclude属性用来过滤文件,符合条件的文 件将会被复制到目标目录。

95行到98行开始将程序打包,jarfile属性指定打包后的文件名,basedir指定基本目录,基本目录下的文件及子目录都会按照其本来的组织结构放到jar文件中。

102行到113行,开始复制配置文件,配置文件包括AntDemo.conf,multiserver.conf,start.其中第112行,chmod任务将start文件的属性改为对任何人可执行和可读。

通过上面的讲解,你可能看出使用ant的优越性,ant可以方便的管理一个大型的项目,当然其他的项目也可以,重要的是,你可以很容易的对它的task进行扩充。相信越来越多的人会使用ant来进行项目的管理。

四:小技巧:
由于使用ant时可能出错,而屏幕不够大的话,可能看不清,最好将编译出错信息放入一个文件中,如下这样使用ant:
ant -buildfile build.xml -logfile error.log

就会将出错信息放入error.log中,由于使用buildfile参数,因此xml文件名不一定时build.xml,可以为任意xml 文件,如project.xml
阅读(77741) | 评论(0) | 转发(0) |
给主人留下些什么吧!~~
。keep参数会保留编译html文件后产生的java文件。第57行意思是将包更名,由于html文 件在antDemo/presentation/html目录下,因此产生的java类属于antDemo.presentation.html包,我们 通过new属性的值将属于此包的类改为属于新的包,使用xmlc时,一般以上几个参数就足够了,要想使用更多的参数,请参见xmlc task定义的源代码 。

从第63行到77行,目标(target)定义了编译时的细节,编译分为两部分,分别编译xmlc产生的 java类和项目中的java类(表现层,商务层,数据层中的代码)。javac这个任务中,srcdir属性指定java文件存放位置,destdir 属性指定编译后的class文件存放位置,classpathref属性指定classpath,debug属性设置关闭还是打开调试信息, includes属性起一个过滤作用,它指定编译那些文件,否则javac将会编译srcdir属性指定的目录下的所有java文件。

81 行到91行开始将将程序中用到的其他文件也复制到目标目录,以便下一步打包。在copy任务中,todir属性指定目标目录,至于复制那些文件,则由嵌套 在copy任务中的fileset任务来指定。在fileset中,dir指定基本目录,include和exclude属性用来过滤文件,符合条件的文 件将会被复制到目标目录。

95行到98行开始将程序打包,jarfile属性指定打包后的文件名,basedir指定基本目录,基本目录下的文件及子目录都会按照其本来的组织结构放到jar文件中。

102行到113行,开始复制配置文件,配置文件包括AntDemo.conf,multiserver.conf,start.其中第112行,chmod任务将start文件的属性改为对任何人可执行和可读。

通过上面的讲解,你可能看出使用ant的优越性,ant可以方便的管理一个大型的项目,当然其他的项目也可以,重要的是,你可以很容易的对它的task进行扩充。相信越来越多的人会使用ant来进行项目的管理。

四:小技巧:
由于使用ant时可能出错,而屏幕不够大的话,可能看不清,最好将编译出错信息放入一个文件中,如下这样使用ant:
ant -buildfile build.xml -logfile error.log

就会将出错信息放入error.log中,由于使用buildfile参数,因此xml文件名不一定时build.xml,可以为任意xml 文件,如project.xml
阅读(77740) | 评论(0) | 转发(0) |
给主人留下些什么吧!~~
。keep参数会保留编译html文件后产生的java文件。第57行意思是将包更名,由于html文 件在antDemo/presentation/html目录下,因此产生的java类属于antDemo.presentation.html包,我们 通过new属性的值将属于此包的类改为属于新的包,使用xmlc时,一般以上几个参数就足够了,要想使用更多的参数,请参见xmlc task定义的源代码 。

从第63行到77行,目标(target)定义了编译时的细节,编译分为两部分,分别编译xmlc产生的 java类和项目中的java类(表现层,商务层,数据层中的代码)。javac这个任务中,srcdir属性指定java文件存放位置,destdir 属性指定编译后的class文件存放位置,classpathref属性指定classpath,debug属性设置关闭还是打开调试信息, includes属性起一个过滤作用,它指定编译那些文件,否则javac将会编译srcdir属性指定的目录下的所有java文件。

81 行到91行开始将将程序中用到的其他文件也复制到目标目录,以便下一步打包。在copy任务中,todir属性指定目标目录,至于复制那些文件,则由嵌套 在copy任务中的fileset任务来指定。在fileset中,dir指定基本目录,include和exclude属性用来过滤文件,符合条件的文 件将会被复制到目标目录。

95行到98行开始将程序打包,jarfile属性指定打包后的文件名,basedir指定基本目录,基本目录下的文件及子目录都会按照其本来的组织结构放到jar文件中。

102行到113行,开始复制配置文件,配置文件包括AntDemo.conf,multiserver.conf,start.其中第112行,chmod任务将start文件的属性改为对任何人可执行和可读。

通过上面的讲解,你可能看出使用ant的优越性,ant可以方便的管理一个大型的项目,当然其他的项目也可以,重要的是,你可以很容易的对它的task进行扩充。相信越来越多的人会使用ant来进行项目的管理。

四:小技巧:
由于使用ant时可能出错,而屏幕不够大的话,可能看不清,最好将编译出错信息放入一个文件中,如下这样使用ant:
ant -buildfile build.xml -logfile error.log

就会将出错信息放入error.log中,由于使用buildfile参数,因此xml文件名不一定时build.xml,可以为任意xml 文件,如project.xml
阅读(77739) | 评论(0) | 转发(0) |
给主人留下些什么吧!~~
。keep参数会保留编译html文件后产生的java文件。第57行意思是将包更名,由于html文 件在antDemo/presentation/html目录下,因此产生的java类属于antDemo.presentation.html包,我们 通过new属性的值将属于此包的类改为属于新的包,使用xmlc时,一般以上几个参数就足够了,要想使用更多的参数,请参见xmlc task定义的源代码 。

从第63行到77行,目标(target)定义了编译时的细节,编译分为两部分,分别编译xmlc产生的 java类和项目中的java类(表现层,商务层,数据层中的代码)。javac这个任务中,srcdir属性指定java文件存放位置,destdir 属性指定编译后的class文件存放位置,classpathref属性指定classpath,debug属性设置关闭还是打开调试信息, includes属性起一个过滤作用,它指定编译那些文件,否则javac将会编译srcdir属性指定的目录下的所有java文件。

81 行到91行开始将将程序中用到的其他文件也复制到目标目录,以便下一步打包。在copy任务中,todir属性指定目标目录,至于复制那些文件,则由嵌套 在copy任务中的fileset任务来指定。在fileset中,dir指定基本目录,include和exclude属性用来过滤文件,符合条件的文 件将会被复制到目标目录。

95行到98行开始将程序打包,jarfile属性指定打包后的文件名,basedir指定基本目录,基本目录下的文件及子目录都会按照其本来的组织结构放到jar文件中。

102行到113行,开始复制配置文件,配置文件包括AntDemo.conf,multiserver.conf,start.其中第112行,chmod任务将start文件的属性改为对任何人可执行和可读。

通过上面的讲解,你可能看出使用ant的优越性,ant可以方便的管理一个大型的项目,当然其他的项目也可以,重要的是,你可以很容易的对它的task进行扩充。相信越来越多的人会使用ant来进行项目的管理。

四:小技巧:
由于使用ant时可能出错,而屏幕不够大的话,可能看不清,最好将编译出错信息放入一个文件中,如下这样使用ant:
ant -buildfile build.xml -logfile error.log

就会将出错信息放入error.log中,由于使用buildfile参数,因此xml文件名不一定时build.xml,可以为任意xml 文件,如project.xml
阅读(77738) | 评论(0) | 转发(0) |
给主人留下些什么吧!~~
。keep参数会保留编译html文件后产生的java文件。第57行意思是将包更名,由于html文 件在antDemo/presentation/html目录下,因此产生的java类属于antDemo.presentation.html包,我们 通过new属性的值将属于此包的类改为属于新的包,使用xmlc时,一般以上几个参数就足够了,要想使用更多的参数,请参见xmlc task定义的源代码 。

从第63行到77行,目标(target)定义了编译时的细节,编译分为两部分,分别编译xmlc产生的 java类和项目中的java类(表现层,商务层,数据层中的代码)。javac这个任务中,srcdir属性指定java文件存放位置,destdir 属性指定编译后的class文件存放位置,classpathref属性指定classpath,debug属性设置关闭还是打开调试信息, includes属性起一个过滤作用,它指定编译那些文件,否则javac将会编译srcdir属性指定的目录下的所有java文件。

81 行到91行开始将将程序中用到的其他文件也复制到目标目录,以便下一步打包。在copy任务中,todir属性指定目标目录,至于复制那些文件,则由嵌套 在copy任务中的fileset任务来指定。在fileset中,dir指定基本目录,include和exclude属性用来过滤文件,符合条件的文 件将会被复制到目标目录。

95行到98行开始将程序打包,jarfile属性指定打包后的文件名,basedir指定基本目录,基本目录下的文件及子目录都会按照其本来的组织结构放到jar文件中。

102行到113行,开始复制配置文件,配置文件包括AntDemo.conf,multiserver.conf,start.其中第112行,chmod任务将start文件的属性改为对任何人可执行和可读。

通过上面的讲解,你可能看出使用ant的优越性,ant可以方便的管理一个大型的项目,当然其他的项目也可以,重要的是,你可以很容易的对它的task进行扩充。相信越来越多的人会使用ant来进行项目的管理。

四:小技巧:
由于使用ant时可能出错,而屏幕不够大的话,可能看不清,最好将编译出错信息放入一个文件中,如下这样使用ant:
ant -buildfile build.xml -logfile error.log

就会将出错信息放入error.log中,由于使用buildfile参数,因此xml文件名不一定时build.xml,可以为任意xml 文件,如project.xml
阅读(77737) | 评论(0) | 转发(0) |
给主人留下些什么吧!~~
。keep参数会保留编译html文件后产生的java文件。第57行意思是将包更名,由于html文 件在antDemo/presentation/html目录下,因此产生的java类属于antDemo.presentation.html包,我们 通过new属性的值将属于此包的类改为属于新的包,使用xmlc时,一般以上几个参数就足够了,要想使用更多的参数,请参见xmlc task定义的源代码 。

从第63行到77行,目标(target)定义了编译时的细节,编译分为两部分,分别编译xmlc产生的 java类和项目中的java类(表现层,商务层,数据层中的代码)。javac这个任务中,srcdir属性指定java文件存放位置,destdir 属性指定编译后的class文件存放位置,classpathref属性指定classpath,debug属性设置关闭还是打开调试信息, includes属性起一个过滤作用,它指定编译那些文件,否则javac将会编译srcdir属性指定的目录下的所有java文件。

81 行到91行开始将将程序中用到的其他文件也复制到目标目录,以便下一步打包。在copy任务中,todir属性指定目标目录,至于复制那些文件,则由嵌套 在copy任务中的fileset任务来指定。在fileset中,dir指定基本目录,include和exclude属性用来过滤文件,符合条件的文 件将会被复制到目标目录。

95行到98行开始将程序打包,jarfile属性指定打包后的文件名,basedir指定基本目录,基本目录下的文件及子目录都会按照其本来的组织结构放到jar文件中。

102行到113行,开始复制配置文件,配置文件包括AntDemo.conf,multiserver.conf,start.其中第112行,chmod任务将start文件的属性改为对任何人可执行和可读。

通过上面的讲解,你可能看出使用ant的优越性,ant可以方便的管理一个大型的项目,当然其他的项目也可以,重要的是,你可以很容易的对它的task进行扩充。相信越来越多的人会使用ant来进行项目的管理。

四:小技巧:
由于使用ant时可能出错,而屏幕不够大的话,可能看不清,最好将编译出错信息放入一个文件中,如下这样使用ant:
ant -buildfile build.xml -logfile error.log

就会将出错信息放入error.log中,由于使用buildfile参数,因此xml文件名不一定时build.xml,可以为任意xml 文件,如project.xml
阅读(77736) | 评论(0) | 转发(0) |
给主人留下些什么吧!~~
。keep参数会保留编译html文件后产生的java文件。第57行意思是将包更名,由于html文 件在antDemo/presentation/html目录下,因此产生的java类属于antDemo.presentation.html包,我们 通过new属性的值将属于此包的类改为属于新的包,使用xmlc时,一般以上几个参数就足够了,要想使用更多的参数,请参见xmlc task定义的源代码 。

从第63行到77行,目标(target)定义了编译时的细节,编译分为两部分,分别编译xmlc产生的 java类和项目中的java类(表现层,商务层,数据层中的代码)。javac这个任务中,srcdir属性指定java文件存放位置,destdir 属性指定编译后的class文件存放位置,classpathref属性指定classpath,debug属性设置关闭还是打开调试信息, includes属性起一个过滤作用,它指定编译那些文件,否则javac将会编译srcdir属性指定的目录下的所有java文件。

81 行到91行开始将将程序中用到的其他文件也复制到目标目录,以便下一步打包。在copy任务中,todir属性指定目标目录,至于复制那些文件,则由嵌套 在copy任务中的fileset任务来指定。在fileset中,dir指定基本目录,include和exclude属性用来过滤文件,符合条件的文 件将会被复制到目标目录。

95行到98行开始将程序打包,jarfile属性指定打包后的文件名,basedir指定基本目录,基本目录下的文件及子目录都会按照其本来的组织结构放到jar文件中。

102行到113行,开始复制配置文件,配置文件包括AntDemo.conf,multiserver.conf,start.其中第112行,chmod任务将start文件的属性改为对任何人可执行和可读。

通过上面的讲解,你可能看出使用ant的优越性,ant可以方便的管理一个大型的项目,当然其他的项目也可以,重要的是,你可以很容易的对它的task进行扩充。相信越来越多的人会使用ant来进行项目的管理。

四:小技巧:
由于使用ant时可能出错,而屏幕不够大的话,可能看不清,最好将编译出错信息放入一个文件中,如下这样使用ant:
ant -buildfile build.xml -logfile error.log

就会将出错信息放入error.log中,由于使用buildfile参数,因此xml文件名不一定时build.xml,可以为任意xml 文件,如project.xml
阅读(77735) | 评论(0) | 转发(0) |
给主人留下些什么吧!~~
。keep参数会保留编译html文件后产生的java文件。第57行意思是将包更名,由于html文 件在antDemo/presentation/html目录下,因此产生的java类属于antDemo.presentation.html包,我们 通过new属性的值将属于此包的类改为属于新的包,使用xmlc时,一般以上几个参数就足够了,要想使用更多的参数,请参见xmlc task定义的源代码 。

从第63行到77行,目标(target)定义了编译时的细节,编译分为两部分,分别编译xmlc产生的 java类和项目中的java类(表现层,商务层,数据层中的代码)。javac这个任务中,srcdir属性指定java文件存放位置,destdir 属性指定编译后的class文件存放位置,classpathref属性指定classpath,debug属性设置关闭还是打开调试信息, includes属性起一个过滤作用,它指定编译那些文件,否则javac将会编译srcdir属性指定的目录下的所有java文件。

81 行到91行开始将将程序中用到的其他文件也复制到目标目录,以便下一步打包。在copy任务中,todir属性指定目标目录,至于复制那些文件,则由嵌套 在copy任务中的fileset任务来指定。在fileset中,dir指定基本目录,include和exclude属性用来过滤文件,符合条件的文 件将会被复制到目标目录。

95行到98行开始将程序打包,jarfile属性指定打包后的文件名,basedir指定基本目录,基本目录下的文件及子目录都会按照其本来的组织结构放到jar文件中。

102行到113行,开始复制配置文件,配置文件包括AntDemo.conf,multiserver.conf,start.其中第112行,chmod任务将start文件的属性改为对任何人可执行和可读。

通过上面的讲解,你可能看出使用ant的优越性,ant可以方便的管理一个大型的项目,当然其他的项目也可以,重要的是,你可以很容易的对它的task进行扩充。相信越来越多的人会使用ant来进行项目的管理。

四:小技巧:
由于使用ant时可能出错,而屏幕不够大的话,可能看不清,最好将编译出错信息放入一个文件中,如下这样使用ant:
ant -buildfile build.xml -logfile error.log

就会将出错信息放入error.log中,由于使用buildfile参数,因此xml文件名不一定时build.xml,可以为任意xml 文件,如project.xml
阅读(77734) | 评论(0) | 转发(0) |
给主人留下些什么吧!~~