|
|
Optimize with a SATA RAID Storage Solution
Range of capacities as low as $1250 per TB. Ideal if you currently rely on servers/disks/JBODs
A defined build process is an essential part of any development cycle because it helps close the gap between the development, integration, test, and production environments. A build process alone will speed the migration of software from one environment to another. It also removes many issues related to compilation, classpath, or properties that cost many projects time and money.
Ant is a platform-independent scripting tool that lets you construct your build scripts in much the same fashion as the "make" tool in C or C++. You can use a large number of built-in tasks in Ant without any customization. Some of the most important tasks are shown in the following table but explained in more detail in the example that follows.
Here are some useful commands that are built in the Ant distribution.
| Command | Description |
|---|---|
| Ant | Used to execute another ant process from within the current one. |
| Copydir | Used to copy an entire directory. |
| Copyfile | Used to copy a single file. |
| Cvs | Handles packages/modules retrieved from a CVS repository. |
| Delete | Deletes either a single file or all files in a specified directory and its sub-directories. |
| Deltree | Deletes a directory with all its files and subdirectories. |
| Exec | Executes a system command. When the os attribute is specified, then the command is only executed when Ant is run on one of the specified operating systems. |
| Get | Gets a file from an URL. |
| Jar | Jars a set of files. |
| Java | Executes a Java class within the running (Ant) VM or forks another VM if specified. |
| Javac | Compiles a source tree within the running (Ant) VM. |
| Javadoc/Javadoc2 | Generates code documentation using the javadoc tool. |
| Mkdir | Makes a directory. |
| Property | Sets a property (by name and value), or set of properties (from file or resource) in the project. |
| Rmic | Runs the rmic compiler for a certain class. |
| Tstamp | Sets the DSTAMP, TSTAMP, and TODAY properties in the current project. |
| Style | Processes a set of documents via XSLT. |
While other tools are available for doing software builds, Ant is easy to use and can be mastered within minutes. In addition, Ant lets you create expanded functionality by extending some of its classes. I will show this expansion in a following example.
You must install three components on your machine to run Ant: JDK, XML parser, and Ant (see Resources for links).
In many cases, the XML parser is part of the lib files distributed with the Servlet runner or the Web Server. If not, the free XML parser from java.sun.com is sufficient.
Ant installation consists of downloading the files, adding the class libraries to the classpath, and adding the Ant binaries to the path.
This example scenario should help show you the value of Ant and provide insight into its benefits and how you can use it.
Because a large amount of the current Java development is focused on server-side Java, I have chosen a server-side application for the example. Developers working on server-side Java applications are typically interested in the compilation of servlets, deployment of JSP files, and deployment of HTML files, configuration files, or images.
A common scheme for doing this build would involve the development of small scripts in platform-specific languages based on the server's operating system. For example, a developer working on an NT machine could create a batch file that performs the compilation tasks and then runs the deployment. However, if the production environment had Unix or Linux, the developer would have to rewrite the script, ensuring that the scripts were in sync.
So, I've hopefully convinced you of the need to use Ant and shown how simple it is to install. Now I'll show you how simple Ant is to use by stepping through an example that performs simple compilation and deployment.
<project name="simpleCompile" default="deploy" basedir=".">
<target name="init">
<property name="sourceDir" value="src"/ >
<property name="outputDir" value="classes" />
<property name="deployJSP" value="/web/deploy/jsp" />
<property name="deployProperties" value="/web/deploy/conf" />
</target>
<target name="clean" depends="init">
<deltree dir="${outputDir}" />
</target>
<target name="prepare" depends="clean">
<mkdir dir="${outputDir}" />
</target>
<target name="compile" depends="prepare">
<javac srcdir="${sourceDir}" destdir="${outputDir}" />
</target>
<target name="deploy" depends="compile,init">
<copydir src="${jsp}" dest="${deployJSP}"/>
<copyfile src="server.properties" dest="${deployProperties}"/>
</target>
</project>
There's a lot to explain in the above example. First, you should understand the structure of the simple.xml file. It is a well-formatted XML file containing a project entity that is comprised of several target entities.
The first line contains information about the overall project that is to be built.
<project name="simpleCompile" default="deploy" basedir=".">
The most important elements of the project line are the default and the basedir.
The default attribute references the default target that is to be executed. Because Ant is a command-line build tool, it is possible
to execute only a subset of the target steps in the Ant file. For example, I could perform the following command:
% ant -buildfile simple.xml init
That will execute the ant command and run through the simple.xml file until the init target is reached. So, in this example, the default is deploy. The Ant process invoked in the following line will run through the simple.xml file until the deploy command is reached:
% ant -buildfile simple.xml
The basedir attribute is fairly self-explanatory as it is the base directory from which the relative references contained in the build
file are retrieved. Each project can have only one basedir attribute so you can choose to either include the fully qualified directory location or break the large project file into
smaller project files with different basedir attributes.
The next line of interest is the target line. Two different versions are shown here:
<target name="init"> <target name="clean" depends="init">
The target element contains four attributes: name, if, unless, and depends. Ant requires the name attribute, but the other three attributes are optional.
Using depends, you can stack the Ant tasks so that a dependent task is not initiated until the task that it depends on is completed. In
the above example, the clean task will not start until the init task has completed. The depends attribute may also contain a list of comma-separated values indicating several tasks that the task in discussion depends
on.
The if and unless commands let you specify commands that are to be performed either if a certain property is set or unless that property is set. The if will execute when the property value is set, and the unless will execute if the value is not set. You can use the available command to set those properties as shown in a following example, or you can set them via the command line.
The init target from the simple example contains four lines of property commands as shown here:
<property name="sourceDir" value="src" />
These property lines let you specify commonly used directories or files. A property is a simple name value pair that allows you to refer
to the directory or file as a logical entity rather than a physical one.
If you wanted to reference the sourceDir variable later in the Ant file, you could simply use the following syntax to alert Ant to obtain the value for this tag:
${sourceDir}.
Two other commands present in the above buildfile are:
<deltree dir="${ outputDir }" />
<mkdir dir="${ outputDir }" />
These commands are used to ensure that there are no extraneous files in the outputDir (or classes directory when dereferenced as mentioned above). The first command removes the entire tree contained under the outputDir. The second command creates the directory again.
The last line of major interest to the developer is the following compilation line:
<javac srcdir="${sourceDir}" destdir="${outputDir}" />
The javac command requires a source directory (the input location of the .java files) and a destination directory (the output location
of the .classes file). It is important to note that all directories must either exist prior to the running of the ant command or be created using the mkdir command. Ant does not create directories based upon intuition, so you must create the outputDir, using the mkdir command prior to the compilation step above.
After the compile task has completed, the deploy task will perform the copy operation to move all JSP files from the source directory to a deployment directory. By using
the copydir command, you copy the entire JSP directory from one location to another. I used the copyfile command to copy a single properties file as part of the build.