Professional Java.JDK.5.Edition (Wrox)

Chapter 14

need to contain a project and a target element. Here is a quick example of the syntax of a very basic build.xml file that just displays a “Hello World!” message:

<project name=”antTest” default=”Hello” basedir=”.”> <description>A very simple build.xml file</description>

<target name=”Hello”>

<echo message=”Hello World!”/> </target>

</project>

In order to run this example, you would change directory to the directory that contains the build.xml file from a console window and simply type ant. ANT will automatically look for the file named build.xml as a default. Once ANT finds the file, it executes it based on the default target supplied in the project element of the build file. In this case, the default target and only target is Hello. The output is shown in the following example:

C:\btest>ant

Buildfile: build.xml

Hello:

[echo] Hello World!

BUILD SUCCESSFUL

Total time: 0 seconds

The ANT manual does a terrific job of explaining the different XML elements such as project, target, classpath, filesets, and so forth, so there isn’t a need to explain them in-depth here. What is needed is to show you how to glue them all together. This next example will show you how to create a complete Web Archive (WAR) file using ANT. This example contains two files: a mybuild.properties file to contain the properties you will read in for Ant to use, and the staple build.xml file that is the main build file that Ant will execute. The following is the content of the mybuild.properties file:

#Xerces home directory xerces.home = C:\\xerces-2_6_2

#The name of the .jar file to create

jar.name = myantwebapp.jar

# The name of the .war file to create war.name = myantwebapp.war

The first property shows a third-party tool location that you will need for compiling and packaging the source code. The next two properties list the name that you want the JAR and the final WAR file to be called. It’s time now to dissect the complex build.xml file. This file is made up of four targets, three of which are dependent upon another target. When a dependency occurs in an ANT target, ANT must execute the dependency first. So, if target D is dependent on target C, and target C is dependent on target B, and target B is dependent on target A, ANT would execute the targets in the following order: A, B, C, then D:

<project name=”MYANTWEBAPP” default=”createWAR” basedir=”.”>

<description>This a real world example of using ANT.</description>

656

Packaging and Deploying Your Java Applications

The <project> tag defines a name for the project and requires you to supply a default target to execute. In this case, you want ANT to run the createWAR target first. The createWAR target has a dependency chain, as I explained in the A, B, C, and D target example. The basedir attribute is asking which directory it should use as a base for execution. The . signifies the current directory:

<property file=”mybuild.properties”/>

<!-- set global properties for this build --> <property name=”src” location=”src”/> <property name=”jsps” location=”jsp”/> <property name=”build” location=”build”/> <property name=”dist” location=”dist”/>

Now, you are telling ANT to read in the properties from mybuild.properties and to also create four additional properties: src, jsps, build, and dist. These can now all be accessed by their property name with the following syntax — ${propertyname} — in the ANT build file:

<path id=”everything”>

<fileset dir=”${xerces.home}”> <include name=”xercesImpl.jar”/> <include name=”xml-apis.jar”/>

</fileset>

<pathelement location=”${build}”/> </path>

The <path> tag will be used by the build file to incorporate the files in the path into a classpath that will be used to compile source code. Here, two Xerces jar files are being built into a path element named everything:

<target name=”clean” description=”Deletes the build and dist directories” > <delete dir=”${build}”/>

<delete dir=”${dist}”/> </target>

The first target, clean, gets executed first and simply deletes the build and distribution directories. The <delete> tag is an ANT task. ANT has a multitude of tasks that can perform many operations. Refer to the Ant manual for more information:

<target name=”init” depends=”clean”> <mkdir dir=”${build}”/>

<mkdir dir=”${dist}”/> </target>

The second target, init, depends on clean. Once clean deletes the build and dist directories, the init target recreates them. These two targets ensure that the build and dist directories will be empty before you start compiling your source code:

<target name=”createJAR” depends=”init” description=”Compiles source and creates new JAR” >

<javac classpathref=”everything” classpath=”${src}” srcdir=”${src}”

657

Chapter 14

destdir=”${build}”/>

<mkdir dir=”${dist}/lib”/>

<echo message=”Creating jar: ${dist}\lib\${jar.name}”/>

<jar destfile=”${dist}/lib/${jar.name}” includes=”**/*.class” basedir=”${build}” compress=”true” index=”true” update=”true”/>

</target>

The third target, createJAR, depends on init and uses the ANT task <javac> to compile any source code that is in the SRC directory. You should also take note that the classpathref references the path that was built earlier called everything. The <javac> task will use the everything path in its classpath for compiling the source files. After the files are compiled, a very handy Ant task called <jar> is used to create a JAR file into the lib directory that was created:

<target name=”createWAR” depends=”createJAR”>

<copy preservelastmodified=”true” overwrite=”true” todir=”${jsps}/WEB-INF/lib”>

<fileset dir=”${dist}/lib”> <include name=”${jar.name}”/>

</fileset>

</copy>

<mkdir dir=”${dist}/war”/>

<war destfile=”${dist}/war/${war.name}” webxml=”${jsps}/WEB-INF/web.xml”

update=”true”>

<fileset dir=”${jsps}” includes=”*.html,*.jsp,*.doc” excludes=”*.jar,*.war”/>

<webinf dir=”${jsps}/WEB-INF” includes=”*.wsdd,*.lst”/>

<lib dir=”${jsps}/WEB-INF/lib” includes=”*.jar,*.war,*.zip”/> <zipfileset dir=”${jsps}/images” prefix=”images” excludes=”*.psd”/>

</war>

</target>

</project>

The final target, createWAR, depends on createJAR and is used to create a WAR file. The JAR file was created and moved to the WAR files WEB-INF/lib directory because it has utilities that the WAR file needs. The other files, which you can see in the fileset, are then moved into position to create the WAR file. The WAR file is created using another handy ANT task called <WAR>.

This ANT build file example can now be run over and over every time you need to recompile and package your program. This example shows just how useful and easy it is to use ANT. If you need to replace Xerces with a new version, all that is required is a property change to mybuild.properties. However, this example barely touches on all the different ANT tasks that are available to you. The ANT manual that comes with the Ant distribution should explain all the tasks in great detail.

658

Packaging and Deploying Your Java Applications

Summar y

Packaging and deploying Java applications vary depending on the program you are currently working on. This chapter touched on the most popular types of Java applications that you will come across. It took you through the intricacies of the different Java archive files — JAR, WAR, and EAR — and kept going right into applet land. It also supplied you with a few helpful tools for managing your classpath and an explanation of already existing Java tools that can aid you in your packaging efforts such as the jarsigner and keytool tools.

This chapter discussed the great innovations of Java Web Start and how it can be the technology of the future for deploying thick, rich clients to users over browser-based technologies. Finally, this chapter examined the usefulness of ANT and how it can make a developer’s building and configuration management woes a thing of the past.

659

algorithms, replacing on the fly

664

665