Ant datatype
An Ant datatype is equivalent to a Java class Behind the scenes they are actually
implemented as such Datatypes store complex pieces of
information used in the build For example
Datatypes can store a list of files to compile
Datatypes can store a set of directories to delete
Ant datatype
The datatypes act as a parameter to tasks
You can declare them inside a task or define them outside, give them a name, and then pass that name to a task
A typical Ant build has to handle files and paths, especially the notorious classpath
The fileset and path datatypes crop up throughout Ant build files
Example use of fileset datatype
<fileset id="source.fileset“ dir="src" includes=“**/*.java" This specifies all java files under all sub-
directories of dir src By providing an id attribute, we’re defining a
reference, this reference name can be used later wherever a fileset is expected
For example, copying our source code to another directory:
<copy todir="backup"><fileset refid="source.fileset"/>
</copy>
Datatype path
A path is an ordered list of elements, where each element can be a file or a directory
It describes paths such as the Java CLASSPATH, or the PATH environment variable of Unix and Windows.
It may have a task-specific name, such as <classpath> above, or it may just have the simple name <path>
Datatype path
Example<path>
<pathelement location= "lib/junit.jar" />
</path>
This definition contains one element, whose location attribute can specify a single file or directory
Datatype path
If you need to specify multiple files or directories, you may use path instead of location
For example<path>
<pathelement path=“build/classes;lib/junit.jar” />
</path> This path attribute separates its parameters into
individual elements, using either a semicolor (;) or colon (:) to split them
Datatype path
Directories used in datatype path can be separated by either a forward slash (/) or a back-slash (\), regardless of operating systems A build file should not have to care about what
system it runs on
Datatype path
One exception related to the property file However, if you are using Windows for your
homework/lab, in your property file build.properties for ANT, you need to make sure using "/" in your path.
Do not use "\" in your path in your property file for Windows (Inside Ant build file build.xml, it does not matter if you use "\" or "/" in your path).
Datatype path
For example, following build.properties file has the correct path.---------build.properties-------------tomcat.home=c:/apache-tomcat-6.0.18application=lab5-1--------------------------------------
If you use tomcat.home=c:\apache-tomcat-6.0.18, it will cause trouble to you when deploy it. In this case, what happened is that Ant will ignore "\" and deploy everything to a directory tree under your current directory where build.xml is located.
Datatype path
If a path structure consists of only a single path or location, it can be specified using a shortcut form as in
<path location=“lib/junit.jar” />
or with multiple files separated by either the : or ; path separator
<path path=“build/classes:lib/junit.jar” />
Datatype path
Paths can include a set of files
<path>
<fileset dir=“lib”>
<include name=“*.jar” />
<fileset>
</path>
Datatype path
How to use a path? A standalone path declaration can be given a
name via its id attribute<path location=“lib/junit.jar” id=“junit.path” />
The name can be referenced whenever a path is needed
<path refid=“junit.path” /> The other way to use a path is inline
For example, javac task has the element <classpath>
Datatype fileset
A fileset is a set of files rooted from a single directory This includes all the files in the directory tree,
including files in all subdirectories recursively For example
<copy todir=“newweb”> <fileset dir=“web” /></copy>
All files from the web dir (including sub-directories) are copied to the newweb directory
Datatype fileset
A fileset can contain multiple patternsets which restricts the files in the fileset to those that match or don’t match a specified pattern
For example, to include all jsp files in a dir<copy todir=“newweb”>
<fileset dir=“web” includes=“**/*.jsp” />
</copy> Had we only specified just *.jsp, only the jsp files in
the web dir would have been copied, but the files in any subdir would not have been copied
Datatype fileset
Files can also be excluded using attribute exclude
For example
<patternset> <include name=“**/*.jsp” />
<exclude name=“**/test/order*.jsp” />
</patternset>
Ant property
An Ant property represents any string-specified itemAnt properties are essential not just to share information around the build, but to control build files from the outsideExample<property name="host" value="localhost" /> After defining this property, if you want to use the property later, you
can use ${host} For example <echo>host=${host}</echo>
Ant property
Although Ant property’s functionality looks like a programming language’s variable, ant property is immutable: you cannot change them
The first task, project, or person to set a property fixes it for that build
Use datatype and properties
<project name="mybuild" default="compile"><property name="build.classes.dir" location="build/classes" /><path id="compile.classpath"> <pathelement location="lib/junit.jar" /></path><mkdir dir="${build.classes.dir}" /><target name="compile" > <javac
destdir="${build.classes.dir}"debug="true"srcdir="src">
<classpath refid="compile.classpath" /> </javac></target>
</project>
We set a property to the directory where we want to compile our source
We declare a datatype path for JARs to use in the compile
${…} denotes the use of the property
<classpath> element declares the classpath for the compiler
Setting a property to a filename or directory name
In our previous example, we use <property name="build.classes.dir" location="build/classes" />
You can actually use <property name="build.classes.dir" value="build/classes" />
It essential does the same thing in this example
Using attribute location sets the property to the absolute filename of the given file. If the value of this attribute is an absolute path, it is left unchanged (with / and \ characters converted to the current platforms conventions). Otherwise it is taken as a path relative to the project's basedir and expanded.
Using attribute value sets the property to be whatever value that is given. No automatic absolute path conversion involved.
Flexibility of Ant Propertiesant -Dapplication=fly
Buildfile: C:\j2ee_class\lab4-3\build.xml
init:
[mkdir] Created dir: C:\j2ee_class\lab4-3\classes
[mkdir] Created dir: c:\tomcat-6.0.26\webapps\fly
[mkdir] Created dir: c:\tomcat-6.0.26\webapps\fly\WEB-INF
[mkdir] Created dir: c:\tomcat-6.0.26\webapps\fly\WEB-INF\classes
compile:
[javac] C:\j2ee_class\lab4-3\build.xml:27: warning: 'includeantrunt
ds
deploy:
[copy] Copying 2 files to c:\tomcat-6.0.26\webapps\fly
[copy] Copying 1 file to c:\tomcat-6.0.26\webapps\fly\WEB-INF
BUILD SUCCESSFUL
Total time: 0 secondspplication=fly
Although I have a build.properties file having the following contents:
tomcat.home=c:/tomcat-6.0.26
application=lab4-3
• I can run
ant -Dapplication=fly
to make it deploy files to a different place without changing the build.properties file.
Flexibility of Ant Properties
The reason that Ant makes properties to be immutable (you cannot change them) is that
It let you control build files from the outsideCommand line
IDEs
Automated build systems
Whoever sets a property first fixes its value. This is the direct opposite of variables in a program, where the last assignment becomes its value
Ant’s property override rule turns every property into a place in which someone can deliberately override the build file to meet their needs