Practical Java. Using ant, JUnit and log4j. LearningPatterns, Inc. Collaborative Education Services

Size: px

Start display at page:

Download "Practical Java. Using ant, JUnit and log4j. LearningPatterns, Inc. Collaborative Education Services"

Lambert Jennings
6 years ago
Views:

1 Using ant, JUnit and log4j LearningPatterns, Inc. Collaborative Education Services Training Mentoring Courseware Consulting Student Guide

2 This material is copyrighted by LearningPatterns Inc. This content and shall not be reproduced, edited, or distributed, in hard copy or soft copy format, without express written consent of LearningPatterns Inc. Copyright 2008 LearningPatterns Inc. For more information about Java or Enterprise Java training, or other advanced Java training classes, consulting or courseware development services, or to add your name to our monthly mailing list, please visit or Our courses are available globally for license, instruction, customization and/or purchase. LearningPatterns. Inc. Global Java Education, Courseware & Consulting Services Wanaque Ave. #188 Pompton Lakes, NJ USA voice fax Java, Enterprise JavaBeans and all Java-based trademarks and logo trademarks are registered trademarks of Sun Microsystems, Inc., in the United States and other countries. LearningPatterns and its logos are trademarks of LearningPatterns Inc. All other products referenced herein are trademarks of their respective holders.

3 Table of Contents - Practical Java PRACTICAL JAVA... 1 WORKSHOP OVERVIEW... 2 WORKSHOP OBJECTIVES... 3 WORKSHOP AGENDA... 4 CODE CONVENTIONS... 5 LABS... 6 SESSION 1: INTRODUCTION TO ANT...7 LESSON OBJECTIVES... 8 OVERVIEW... 9 WHAT IS ANT? A SIMPLE BUILD FILE RUNNING ANT INSTALLING AND RUNNING ANT...13 ACQUIRING ANT ANT INSTALLATION RUNNING ANT COMMAND LINE OPTIONS LAB 1.1 SETTING UP THE ENVIRONMENT ANT BASICS ANT BUILDFILES AND PROJECTS ANT TARGETS A MORE COMPLICATED BUILDFILE ANT TASKS THE <JAVAC> TASK THE <JAVA> AND <DELETE> TASKS A COMPLETE BUILDFILE RUNNING OUR BUILDFILE HOW IS ANT USEFUL? LAB 1.2 WORKING WITH BUILDFILES WORKING WITH PROPERTIES WORKING WITH PROPERTIES BUILT-IN PROPERTIES LAB 1.3 WORKING WITH PROPERTIES END OF SESSION SESSION 2: WORKING WITH PATHS AND RESOURCE COLLECTIONS LESSON OBJECTIVES PATHS PATH-LIKE STRUCTURES SPECIFYING THE CLASSPATH NESTED <CLASSPATH> ELEMENT NESTED <CLASSPATH> ELEMENT LAB 2.1 WORKING WITH PATHS RESOURCE COLLECTIONS RESOURCE COLLECTIONS Copyright 2008, LearningPatterns Inc. All rights reserved i

4 PATTERNS PATTERNS NESTED <INCLUDE> AND <EXCLUDE> OTHER USES OF <FILESET> USING <PATH> LAB 2.2 WORKING WITH FILESET SESSION 3: ANT TASKS LESSON OBJECTIVES <JAVAC> AND <JAVA> <JAVAC> - SPECIFYING SOURCE FILES <JAVAC> - COMPILER OPTIONS <JAVA> - PASSING ARGUMENTS <JAVA> - FORKING AND JVM ARGUMENTS LAB 3.1 WORKING WITH <JAVAC> AND <JAVA> OTHER TASKS CREATING ARCHIVES WITH <JAR> CREATING ARCHIVES WITH <JAR> CREATING WEB ARCHIVES WITH <WAR> EXAMPLE OF <WAR> EXAMPLE OF <WAR> OTHER ARCHIVE TASKS FILE RELATED TASKS...93 OTHER USEFUL TASKS INCLUDING NEW TASKS [OPTIONAL] LAB 3.2 WORKING WITH <JAR> AND <WAR> SESSION 4: ANT MODULARITY LESSON OBJECTIVES PROPERTIES FILES PROPERTIES FILES LAB 4.1 WORKING WITH PROPERTIES FILES [OPTIONAL] MODULARIZING BUILD FILES <IMPORT> - IMPORTING ANOTHER BUILDFILE BUILDFILE DEFINING COMMON TARGETS BUILDFILE IMPORTING ANOTHER <ANT> - INVOKING ANOTHER BUILD USING <ANT> [OPTIONAL] LAB 4.2 REVIEW <IMPORT> AND <ANT> SESSION 5: JUNIT LESSON OBJECTIVES JUNIT OVERVIEW TESTING OVERVIEW - UNIT TESTING JUNIT OVERVIEW WRITING A TEST - SIMPLE EXAMPLE RUNNING A TEST - SIMPLE EXAMPLE LAB 5.1 RUNNING JUNIT WRITING JUNIT TESTS Copyright 2008, LearningPatterns Inc. All rights reserved ii

5 WHAT IS A UNIT TEST THE ORG.JUNIT.ASSERT CLASS THE ORG.JUNIT.ASSERT CLASS THE ASSERT CLASS AND STATIC IMPORTS WRITING TESTS A SIMPLE TEST CLASS TESTING FOR EXCEPTIONS RUNNING THE TESTS THE RESULT AND FAILURE CLASSES EXAMPLE - RUNNING TESTS WHAT TO TEST LAB 5.2 WORKING WITH JUNIT SESSION 6: ORGANIZING TESTS WITH JUNIT LESSON OBJECTIVES FIXTURES AND SUITES TEST FIXTURES TEST FIXTURE EXAMPLE TEST SUITES TEST SUITE EXAMPLE LAB 6.1 TEST FIXTURES AND TEST SUITES <JUNIT> ANT TASK <JUNIT> ANT TASK <JUNIT> OUTPUT SETTING UP ANT FOR USING <JUNIT> [OPTIONAL] JUNIT JUNIT 3 OVERVIEW JUNIT 3 EXAMPLE JUNIT 3 EXAMPLE GUI RUNNER TEST SUITES IN JUNIT SESSION 7: INTRODUCTION TO LOGGING & LOG4J LESSON OBJECTIVES OVERVIEW LOGGING OVERVIEW APACHE LOG4J OVERVIEW APACHE LOG4J OVERVIEW USING LOG4J LOG4J - SIMPLE EXAMPLE LAB 7.1 USING LOG4J CONFIGURING LOG4J LAB 7.2 CONFIGURING LOG4J LOGGERS, LEVELS, AND APPENDERS LOG4J LOGGERS USING LOGGERS LOG4J APPENDERS CONFIGURATION FILE DETAILS CONFIGURING APPENDERS AND LOGGERS LOGGER HIERARCHY CONFIGURING LOGGER LEVELS Copyright 2008, LearningPatterns Inc. All rights reserved iii

6 LEVEL INHERITANCE LAB 7.3 CONFIGURING LEVELS LOG4J APPENDERS CONFIGURING APPENDERS APPENDER ADDITIVITY ADDITIVITY EXAMPLE LAB 7.4 APPENDERS LAYOUTS LAYOUT PATTERNLAYOUT PATTERNLAYOUT HTMLLAYOUT ABOUT CATEGORIES AND PRIORITIES LAB 7.5 LAYOUTS OTHER DETAILS DISABLING DEBUGGING AND PERFORMANCE JAVA LOGGING APACHE COMMONS LOGGING RECAP RECAP OF WHAT WE'VE DONE WHAT ELSE IS THERE RESOURCES Copyright 2008, LearningPatterns Inc. All rights reserved iv

8 Workshop Overview This is 1-day course covering the use of a number of tools that can help you become more productive and produce better code in your day-to-day programming with Java The course, at a high level, covers the following areas of Java technology ant: A Java-based build tool that uses XML configuration files to control the build JUnit: A testing framework that simplifies writing and maintaining test code. This course uses JUnit 4, and the Java 5 annotations associated with it. Logging with log4j, Commons Logging, or Java logging: Logging packages that make logging efficient and easy to use Copyright 2008 LearningPatterns Inc. All rights reserved. 2

9 Workshop Objectives At completion you should understand the tools we cover, and be able to use their capabilities in the following areas: ant: Understand how ant and buildfiles work Create buildfiles, and use ant to control a build Use the many built-in ant tasks Build modular buildfiles JUnit: Be familiar with testing and test-driven development Use JUnit to create good testing structures for your Java code Logging: Understand and use log4j for logging Be aware of other logging choices available in Java Copyright 2008 LearningPatterns Inc. All rights reserved. 3

10 Workshop Agenda Session 1: Introduction to ant Session 2: Ant Paths and Resource Collections Session 3: Ant Tasks Session 4: Ant Modularity Session 5: Introduction to JUnit Session 6: Organizing Tests with JUnit Session 7: Introduction to Logging and log4j Copyright 2008 LearningPatterns Inc. All rights reserved. 4

11 Code Conventions Code that is inline in the text will appear in a fixed-width code font, such at this: JavaTeacher teacher = new JavaTeacher() Any class names, such as JavaTeacher, method names, or other code fragments will also appear in the same font If we want to emphasize a particular piece of code, we'll also bold it (and in the slide, change it's color) such as BeanFactory Filenames will be in italics, such as JavaInstructor.java Lastly, longer code examples will appear in a separate code box as shown below package com.javatunes.teach; public class JavaInstructor implements Teacher { public void teach() { System.out.println("BeanFactories are way cool"); } } Copyright 2008 LearningPatterns Inc. All rights reserved. 5

12 Labs Lab The workshop consists of approximately 50% discussion, 50% hands-on lab exercises, including a series of brief labs Many of the labs follow a common fictional case study - JavaTunes, an online music store The labs are contained directly in the course book, and have detailed instructions on what needs to be done The course includes setup zip files that contain skeleton code for the labs Students just need to add code for the particular capabilities that they are working with There is also a solution zip file that contains completed lab code Lab slides contain an icon like the one in the upper right corner of this slide The end of each lab is clearly marked with a stop like this one to the right STOP Copyright 2008 LearningPatterns Inc. All rights reserved. 6

14 Lesson Objectives Understand the background and need for a tool like ant Understand how ant is used to control the building of Java software projects Learn basic ant capabilities, and use them to build Java software projects Copyright 2008 LearningPatterns Inc. All rights reserved. 8

16 What is ant? ant is a cross-platform Java-based build tool that uses XML configuration files to control the building of software projects Handles many common software project tasks Compiling code, building archives (zip, jar, etc), running programs Working with files and directories - copying, creating, deleting Creating sets of files / directories, and using them e.g in classpaths Much, much more Allows you to create your own tasks by writing Java classes Provides for easy extensibility and integration with other software e.g. Apache Tomcat has tasks to deploy to a Tomcat server ant is mostly used in the Java world But there are other versions and tools for other environments For example, there is a.net version, and a version for C/C++ ant stands for "Another Neat Tool" according to the initial author (James Duncan Davidson) Later explanations go along the lines of "ants do an extremely good job at building things", or "ants are very small and can carry a weight dozens of times their own" - describing what Ant is intended to be. [ant FAQ] ant was created in conjunction with the Tomcat Web server To help build Tomcat It was noticed by other open source / Apache developers, and became widely used in that community Eventually it was promoted to a project of its own, and released to the general Java community It has since become one of the most popular build tools around Copyright 2008 LearningPatterns Inc. All rights reserved. 10

17 A Simple Build File To illustrate ant, let's look at the fairly simple build file below without going into all of its details - which we'll look at later Our build file is named build.xml - the default build file name It allows us to echo some messages to the console <?xml version="1.0"?> <project name="helloant" default="hello">  <target name="hello" > <echo>hello Ant World!</echo> </target>  <target name="bye"> <echo>bye - Thanks for using Ant</echo> </target> </project> The XML declaration at the very top of the file is standard XML It's the standard preamble for normal XML documents, and not specific to ant It is not required by ant, but it's a good idea to include it Copyright 2008 LearningPatterns Inc. All rights reserved. 11

Running Ant Below left, is our working directory, with the ant build file, build.xml We can run ant by typing ant on the command line We've set up build.

this all in depth later We'll talk in just a little bit about installing ant, and setting up your environment so that it is easy to run ant comes with its own XML parser, so it doesn't need any

18 Running Ant Below left, is our working directory, with the ant build file, build.xml We can run ant by typing ant on the command line We've set up build.xml to tell ant to echo some text to the console Below right, we can see the ant output At bottom right, we see the output from running the bye target - which echoes a different message - we'll cover this all in depth later We'll talk in just a little bit about installing ant, and setting up your environment so that it is easy to run ant comes with its own XML parser, so it doesn't need any additional installation for working with the XML files The build.cmd file shown in the Lab directory is there to help you easily run ant without changing your environment We'll talk about it in the lab Copyright 2008 LearningPatterns Inc. All rights reserved. 12

20 Acquiring ant The ant website is: ant is an open source project managed by Apache You can download ant from the "Binary Distribution" link off the home page (source downloads are also available) Available as.zip,.tar.gz and other formats Just uncompress (e.g. unzip) the distribution to your file system Default location is to C:\, but you can put it anywhere you want The resulting install directory - known as ANT_HOME will be named something like C:\apache-ant Most Java IDEs ship with ant already installed For example, Eclipse, NetBeans, & IntelliJ IDEA all include ant Generally, these IDEs also allow you to upgrade the ant version In this section, we will assume that you are working with version of ant If you are working with a different version, then the installation directory will change Depending on what other version you use, other things may change also Any 1.6.x version should also be similar to this Earlier versions will have greater differences.tar.gz is a gzip compressed tar file Copyright 2008 LearningPatterns Inc. All rights reserved. 14

ant Installation The ant directory structure is shown at bottom Only the lib and bin directories are needed to run ant There is a complete set of documentation in the docs dir This is an extremely

21 ant Installation The ant directory structure is shown at bottom Only the lib and bin directories are needed to run ant There is a complete set of documentation in the docs dir This is an extremely useful resource - use it! Additional setup that is needed: Set the ANT_HOME environment variable to the ant install dir add ANT_HOME\bin to your path Set your JAVA_HOME environment variable to your Java install The startup scripts that run ant, need to know where ANT_HOME is They can sometimes guess what ANT_HOME is, but it's better to set it ANT_HOME\bin contains the startup scripts for running ant To run ant easily from a command prompt, this directory should be on your path If you don't want to change your path (or can't) there are other ways of doing this, which we'll show in the labs JAVA_HOME is necessary if you want to use Java related tasks such as <javac> for compiling Java files Copyright 2008 LearningPatterns Inc. All rights reserved. 15

22 Running ant When installed as described previously, it's simple Just type ant at the command line, as seen in our examples By default, ant will use build.xml in the current directory as the build file It will run the target specified in the default attribute of the <project> tag You can specify a different build file using -buildfile file, e.g. ant -buildfile mybuildfile.xml You can also specify different target(s) by listing them after the ant command, for example Run the hello target: ant hello Run the hello and bye targets ant hello bye You can also specify a buildfile with the -file, or -f options They are synonyms for -buildfile We'll learn more about targets and the rest of the buildfile very soon Copyright 2008 LearningPatterns Inc. All rights reserved. 16

23 Command Line Options ant has many options - we list some important ones here: Type ant -help at the command line for a complete list of options The documentation has more information about ant -help, -h print the ant help message -version print the version information and exit -diagnostics print information that might be helpful to diagnose or report problems (useful for debugging if ant doesn't run properly) -quiet, -q be extra quiet -verbose, -v be extra verbose (useful for debugging build scripts) -debug, -d print debugging information (useful for debugging build scripts) -D<property>=<value> use value for given property Copyright 2008 LearningPatterns Inc. All rights reserved. 17

25 Lab 1.1 Set up the Environment Lab Overview: In this lab, we will become familiar with the lab structure, set up our working environment, and test it to make sure it is running well The end goal is to compile and run an application using ant Objectives: Become familiar with the lab structure Set up our environment Compile and run a simple application using ant Builds on previous labs: None Approximate Time: minutes Copyright 2008 LearningPatterns Inc. All rights reserved. 19

26 Release Level Lab This manual has been tested with and contains instructions for running the labs using the following platforms: Java 5 (Java Development Kit 1.5.0_xx) Apache Ant An editor of your choice If you don't have a programmers editor on your computer, we recommend Notepad++ which is downloadable at: The labs should work with most recent ant versions This manual contains the instructions for the platform above Complete lab instructions for this platform are included in the student manual All recent versions of ant should work fine There is nothing fancy in the ant build files If you want to run with J2SE 1.4, that should be fine for many of the labs However, the JUnit labs are designed for JUnit 4, which requires Java 5 If you don't have a programmers editor, we highly recommend that you install one Windows Notepad is not very friendly at all for programmers Notepad++ as mentioned in the slide is easy to install and use All labs have been tested on Microsoft Windows XP using the software listed above Copyright 2008 LearningPatterns Inc. All rights reserved. 20

27 Information Content and Task Content Lab Within a lab, information only content is presented in the normal way the same as in the student manual pages Like these bullets at the top of the page Tasks that the student needs to perform are in a box with a slightly different look to help you identify them An example appears below Tasks to Perform Look at these instructions, and notice the different look of the box as compared to that above Make a note of how it looks, as future labs will use this format OK Now get out your setup CD; we're ready to start working Copyright 2008 LearningPatterns Inc. All rights reserved. 21

28 Extract the Lab Setup Zip File Lab To set up the labs, you'll need the course setup zip file * It has a name like: JPract_LabSetup_.zip Our base working directory for this course will be C:\StudentWork\JPRACT This directory will be created when we extract the Setup zip It includes a directory structure and files (e.g., Java files, XML files, other files) that will be needed in the labs All instructions assume that this zip file is extracted to C:\. If you choose a different directory, please adjust accordingly Tasks to Perform Unzip the lab setup file to C:\ This will create the directory structure, described in the next slide, containing files that you will need for doing the labs The setup zip will either be given to you on a CD or supplied by your instructor The nnnn stands for the version number of the course The CD may also contain additional folders with extra content InstallFiles: Extra software install files (e.g. simple editor) Resources: Documentation, specifications, etc. Which extra files are supplied will vary based on space limitations Copyright 2008 LearningPatterns Inc. All rights reserved. 22

29 Setup Environment Lab Tasks to Perform Make sure that ant 1.7.x is installed likely in a directory such as C:\apache-ant-1.7.x If it's been installed in a different directory, you'll need to modify the instructions in the lab to refer to your install directory If it isn't installed, you'll need to download it (from and unzip it Make sure that you have Java 5 installed Likely installed in a directory like C:\Program Files\Java\jdk1.5.x If not, you'll need to install it It can be downloaded from: Copyright 2008 LearningPatterns Inc. All rights reserved. 23

$Lab Directory Structure Lab StudentWork\JPRACT\workspace will contain the following folders: common: shared files LabNN : Root directory for Lab NN LabNN/bin/ : some labs put compiled code here (we$

30 Lab Directory Structure Lab StudentWork\JPRACT\workspace will contain the following folders: common: shared files LabNN : Root directory for Lab NN LabNN/bin/ : some labs put compiled code here (we use bin to be Eclipse compatible) LabNN/src/ : Some labs hold Java source here StudentWork\JPRACT contains LabSetup: files needed for lab work LabNN: directory for any lab with additional setup files Resources : Extra files (e.g. docs), software Copyright 2008 LearningPatterns Inc. All rights reserved. 24

31 Configuring Your Environment Lab The root lab directory where you will do your work for this lab is: C:\StudentWork\JPRACT\workspace\Lab01.1 This directory already exists in your workspace you'll need to edit files under this directory, and build the application from within this directory In general, all the files you will work on for a lab will be under the root directory (and instructions are given relative to this directory) First, you'll need to configure your system to run ant There are two ways to do this One way sets your environment variables and path One way uses batch files supplied by us to run the ant program Most common is to configure your system to use ant directly If you don't want to configure your system (or can't), you can use our batch files Copyright 2008 LearningPatterns Inc. All rights reserved. 25

32 Option 1: Configure Your System Lab Tasks to Perform Check your ANT_HOME, PATH and JAVA_HOME environment variable in any command window, by typing C:\>set ANT_HOME C:\>set PATH C:\>set JAVA_HOME ANT_HOME should point to your Ant installation (e.g. C:\apache-ant-1.7.0) PATH needs to contain %ANT_HOME%\bin JAVA_HOME should point to your Java installation (e.g. C:\Program Files\Java\jdk1.5.0_06) If you need to update (or create) any of the above, locate the environment variables dialog box (see notes) In the User variables section, create or update each of the environment variables above to contain values that are correct for your system For ANT_HOME and JAVA_HOME, if your system has ant or Java installed at a different location, you would use the location that is correct for your system To get the environment variables dialog box: Windows 2000 and XP: Start Settings...Control Panel System Advanced tab Environment Variables You can set environment variables in the dialog box there. Another approach is to right click on the MyComputer icon and select Properties Advanced tab Environment Variables Windows NT: Start Settings Control Panel System Environment. You can set environment variables in the dialog box there. NOTE: always close and reopen command windows or editors after changing an environment variable to make sure they use the new value. Copyright 2008 LearningPatterns Inc. All rights reserved. 26

33 Option 2: Use Our Batch Files Lab We supply a command file, build.cmd, to invoke ant for the labs It uses the file common\buildsetenv.cmd to configure the environment props needed to run ant Tasks to Perform Open common/buildsetenv.cmd with a text editor Check the ANT_HOME and JAVA_HOME environment variables, and modifies them if necessary * These are used to invoke ant properly from the command line When running labs, instead of invoking the ant program directly (e.g. ant bye), use build.cmd to invoke ant, e.g. build bye The ANT_HOME environment variable is used to invoke ant in our build command script, and will be set something like this: set ANT_HOME=C:\apache-ant The JAVA_HOME environment variable points to the Java home directory If you do not have the full Java JDK on your classpath, AND if you do not have the JAVA_HOME environment variable set, then you'll need to set JAVA_HOME in this file There is a sample command that sets it that is commented out You'll need to uncomment it, and modify it so it points to the correct location for Java 5 in your environment Copyright 2008 LearningPatterns Inc. All rights reserved. 27

34 Test Out Ant Lab The Lab01.1 directory contains a build.xml file (the ant configuration file) as shown in the student manual example Running ant from the command line should run the hello task in the buildfile - if everything is set up properly Tasks to Perform Open a command window in workspace\lab01.1, and run ant with no arguments as shown below > ant This runs the default run target to compile and run the app If using our command file, build.cmd then type build instead > build In future lab instructions, we'll assume you use ant directly If you don't, just substitute build wherever you see ant See the next slide for expected output build.cmd uses the buildsetenv.cmd file you just configured to find ant To make it easier to open command windows in the lab dirs, we've included a utility in the setup that allows you to right click on a folder to open a command prompt in it To install this: Go to the Resources\InstallFiles\CommandPromptHere folder Right click on the.reg file there, and select Merge Once you've done that, right clicking on a folder will show a Command Prompt Here selection in the context menu - Select that to open a command prompt in the directory Copyright 2008 LearningPatterns Inc. All rights reserved. 28

35 The Results of the Build Lab Tasks to Perform Check that your output is similar to that shown below If ant doesn't run at all, check to make sure that your ANT_HOME and PATH are correct You can try running ant -diagnostics to find out if your system is configured properly Try running the bye target also Check with your instructor if you need help STOP Copyright 2008 LearningPatterns Inc. All rights reserved. 29

37 ant Buildfiles and Projects ant buildfiles are written in XML, and contain: One (only) top-level project (defined in <project>) At least one target (configured in <target>s) Working with buildfiles is the largest part of using ant <project> : Top level container for most buildfile contents - including all targets Can contain a <description> element describing the project <project> defines three attributes name: The name of the project default: Default target to use, if not specified when running ant basedir: Base directory from which path calculations are done <?xml version="1.0"?> <project name="helloant" default="hello" basedir="."> <description>this is our first buildfile</description>  </project> ant defines a specific set of XML elements to create build files e.g. <project> and <target> Build files consist of a single top-level <project> containing one or more <target> elements <project> may also contain other elements (e.g. <property>) that we'll cover later The <description> element can be used by tools to describe build files It is also used if you run ant with the -projecthelp option Additional details about the project attributes include: name: Can be any combination of alphanumeric characters that constitute valid XML. default: Was required in versions prior to version 1.6, but a default target is no longer required. Starting with 1.6.0, there is an implicit target which contains any and all top-level tasks and/or types. This target will always be executed as part of the project's initialization, even when Ant is run with the -projecthelp option. basedir: The base directory from which any relative directories used within the Ant build file are referenced from. If this is omitted the parent directory of the build file will be used Copyright 2008 LearningPatterns Inc. All rights reserved. 31

38 ant Targets <target> contains a collection of tasks to execute Targets are named - name can be used in the build file, and when invoking ant <target> attributes include: name: Name of the target depends: Comma separated list of targets this target depends on Ant will try to execute the targets in the depends attribute in the order they appear Dependencies give you a way to specify the order of execution of targets description: Short description of the target's function - used when running ant with -projecthelp When running ant, you can specify the target(s) to execute ant - Run the default target (if any) ant hello - Run the hello target ant hello bye - Run the hello target, then the bye target ant dependencies allow you to specify that a certain target should not run until its prerequisite targets have been run Ant tries to execute the targets in the depends attribute in the order they appear (left to right) Keep in mind that it is possible that a target can get executed earlier when an earlier target depends on it - for example, looking at the following targets/dependencies: <target name="a"/> <target name="b" depends="a"/> <target name="c" depends="b"/> <target name="d" depends="c,b,a"/> Suppose we want to execute target D. From its depends attribute, you might think that first target C, then B and then A is executed. Wrong! C depends on B, and B depends on A, so first A is executed, then B, then C, and finally D. Targets without a description are deemed internal, and will not be listed when ant is run with projecthelp A target also has the ability to perform its execution if (or unless) a property has been set This is done using the "if" or "unless" attributes Copyright 2008 LearningPatterns Inc. All rights reserved. 32

39 A More Complicated Buildfile In the buildfile below, we can see a number of targets, some of which depend on other targets We'll show the tasks for the targets shortly The all target has no tasks - it's only there to collect its dependencies, and it is used as the default target Not required, but often useful <?xml version="1.0"?>  <project name="helloant" default="all"> <target name="clean" description="deletes compiled files">  </target> <target name="compile" description="compiles the source">  </target> <target name="run" depends="compile" description="runs HelloAnt">  </target> <target name="all" depends="clean, compile, run" description="runs everything"/> </project> There is nothing special about the all target It can have normal tasks, as well as depends targets In this example, it has no tasks defined It is used to provided a convenient target to execute all the other targets Copyright 2008 LearningPatterns Inc. All rights reserved. 33

40 ant Tasks A task represents an action that you want executed Large selection of pre-defined tasks for many common needs Over 90 core tasks, and many additional optional tasks Many additional tasks written by others - e.g, tasks to deploy to the Tomcat Web server Can write your own task, by writing a Java class that extends org.apache.tools.ant.task * We will not attempt to cover all the ant tasks We'll cover the most common tasks - read the docs for others Each task defines an element, with attributes specific to that task, written a follows: <taskname attribute1="val1" attributen="valn"> Writing your own tasks is beyond the scope of this course It's not very hard, and the ant manual has instructions on how to do it You can extend the Task class mentioned in the slide, or one of a small number of specialized classes that ant supplies (e.g. JDBCTask) There are so many tasks that come with ant, that it would be impossible to cover them all in a short course like this Once you are familiar with ant, it is fairly easy to learn what the different tasks that are available do LOOK AT THE DOCUMENTATION! Copyright 2008 LearningPatterns Inc. All rights reserved. 34

41 The <javac> Task Lets review the <javac> task to explore the task structure <javac srcdir="."/> <javac> compiles a Java source tree rooted at srcdir By default,.class files are put in the same directory as the source The destdir attribute specifies a different location for.class files (considered good practice) <javac> searches the source tree, compares each.java file to its.class files (if it exists) and compiles the source if needed If the.class file is newer than the.java file, it won't compile it Below, we show <javac> configured to compile all the.java files under the src dir, and place the.class files in the build dir <javac srcdir="src" destdir="build"/> <javac> will recursively scan the srcdir directory and its subdirectories for files to compile <javac> will only compile those source files that it believes it needs to If a classfile already exists, and that classfile's corresponding source file hasn't been changed since the classfile was generated, then that source file won't be recompiled The output of the javac task shows the number of source files that were actually compiled It is good practice to write a clean target that removes any generated classfiles from that target directory - This can then be used if you want to make sure that all of the source files are compiled This behavior characterizes many of Ant's tasks: If the task can determine that the requested operation doesn't need to be performed, then it will be skipped [IBM DeveloperWorks - Apache Ant 101: Make Java builds a snap] Copyright 2008 LearningPatterns Inc. All rights reserved. 35

42 The <java> and <delete> Tasks <java> executes a Java class within the running Ant VM The classname attribute specifies the Java class to execute The classpath attribute allows you to set the classpath Multiple items allowed in the classpath, separated by either ":" or ";" The fork attribute allows you to execute within another VM * Below, we use<java> to run the HelloAnt program <java classname="helloant" classpath="."/> <delete> deletes a file, a directory, or a collection of files The file or dir attribute specify a file or dir to delete For example, below we specify a task to delete HelloAnt.class <delete file="helloant.class"/> Sometimes you want to execute in a separate VM, because of side effects within the VM from ant itself The ant reference manual suggests that if you are seeing odd behavior when using <java> try using <java fork="true" > to use a new VM For the classpath, ant converts whatever separator character you use into the appropriate character for the OS The <javac> task also runs within the same VM This is usually desirable because it is much more efficient to run javac within the same process - however it can have side effects Windows Note:When the modern compiler is used in unforked mode on Windows, it locks up the files present in the classpath of the <javac> task, and does not release them. The side effect of this is that you will not be able to delete or move those files later on in the build. The workaround is to fork when invoking the compiler. [Ant Reference Manual] Copyright 2008 LearningPatterns Inc. All rights reserved. 36

43 A Complete Buildfile Below, we show a complete buildfile, with all tasks included clean uses <delete> to delete HelloAnt.class, compile uses <javac> to compile all Java files in/below the current directory run uses <java> to run the HelloAnt program all provides a convenient way to run all the targets in the buildfile On the next slide we show various runs of ant with this buildfile <?xml version="1.0"?>  <project name="helloant" default="all"> <target name="clean" description="deletes compiled file"> <delete file="helloant.class"/> </target> <target name="compile" description="compiles the source"> <javac srcdir="."/> </target> <target name="run" depends="compile" description="runs HelloAnt"> <java classname="helloant" classpath="."/> </target> <target name="all" depends="clean, compile, run" description="runs everything"> </target> </project> Copyright 2008 LearningPatterns Inc. All rights reserved. 37

44 Running our Buildfile ant -projecthelp Shows different targets with their descriptions ant all Runs the clean, compile, run targets ant run Don't need to compile again, so compile does nothing Copyright 2008 LearningPatterns Inc. All rights reserved. 38

45 How is ant Useful? The core functionality of ant is to automate the build process for Java software systems In the previous example, ant automated the building of our system (and also ran our program) The needed steps were configured in the XML build file (by default named build.xml) ant has support for much more complex build scenarios For example, multiple source directories, working with version control systems (e.g. CVS) creating archives such as an EAR or WAR, multiple projects (e.g. an EAR and a WAR project), etc. This simplifies our build process tremendously The more complex our build requirements, the more ant helps us Building complex software projects by hand can be very tedious and error prone Carrying out all the proper steps in their proper order can be very complicated An automated build tool, that knows the proper sequence of steps, makes it much easier Ant was created to provide a true cross-platform build tool. It uses XML to control the build - An XML file is created containing targets where various tasks needed in a build get executed It replaces tools like make, which used platform-specific shell commands to define tasks ant uses Java classes to extend its capabilities Each task is run by a Java object that implements a particular Task interface The standard Ant tasks are already implemented You can define your own tasks by writing new Java classes implementing Task It is very powerful and very widely used You don't need an IDE to use Ant It is a very simple, non-gui build tool Copyright 2008 LearningPatterns Inc. All rights reserved. 39

47 Lab 1.2 Working with Buildfiles Lab Overview: In this lab, we will work with a simple buildfile There are various targets in the buildfile that you'll need to complete so they work properly Objectives: Become familiar with the different parts of a basic ant buildfile Create a simple buildfile for ant Builds on previous labs: none Approximate Time: minutes Copyright 2008 LearningPatterns Inc. All rights reserved. 41

48 Lab Preparation Lab The root lab directory where you will do all your work is: C:\StudentWork\JPRACT\workspace\Lab01.2 This is a new lab directory which already exists in your workspace The Lab01.2 directory contains the TeachMeAnt Java program and build.xml with the following targets that should work as follows: clean: Remove the compiled Java files compile: Compile Java source in the Lab01.2 directory run: Run the TeachMeAnt program (run should depend on the compile target, so compilation will happen first if needed) all: Depends on the clean, compile, and run targets, but doesn't have any tasks of its own Tasks to Perform Close all files from any previous labs If your editor allows you to configure a home directory, you can set it to the root lab directory Open a command prompt in the root lab directory described above Copyright 2008 LearningPatterns Inc. All rights reserved. 42

49 Finish build.xml Lab Open up build.xml for editing Tasks to Perform Look for the TODOs, and finish up the following elements so the targets work as described on the previous page: <project>, <javac>, <delete>, <java>, and the all target Note that TeachMeAnt.java is directly in the Lab01.2 directory Save the file Open up a command window in the Lab01.2 directory Run ant to test the build file Run it with the -projecthelp option, with the all target, and with the "clean and run" targets Does it work properly? If you have problems compiling or running, check that JAVA_HOME is correct, and try the -verbose, or -debug options to get more information Copyright 2008 LearningPatterns Inc. All rights reserved. 43

50 [Optional] build.xml Lab [Optional] Tasks to Perform Once you've got build.xml completely finished, you can try the following if you have time Rename build.xml to something else (e.g. mybuild.xml) Run ant using -buildfile (or -f) to use your buildfile Create a directory, src, and move TeachMeAnt.java to src Remember to delete TeachMeAnt.class manually What change do you need to make to your buildfile for it to work? Hint - look at the <javac>, <java>, and <delete> targets Make the changes, and test your buildfile Modify <javac> so compiled files go into the build directory Create the build directory yourself (we'll automate this later) Make any other needed changes to build.xml, and run it We'll soon see how properties make your life easier! STOP Copyright 2008 LearningPatterns Inc. All rights reserved. 44

51 Working With Properties Ant allows you to define properties with a name and value within your buildfiles They are immutable - once set, they can't be changed They ease maintenance of build files, and are often used in multiple locations or build files Properties can be defined using <property> Usually defined under <project> <property name="build.dir" value="build"/> Properties can be used in tasks with the syntax ${propname} i.e. - a dollar sign, with the property name in curly braces Below, we use the build.dir property to specify that <javac> should put all compiled files in the build directory <javac srcdir="src" destdir="${build.dir}"/> Often, property values are used in multiple locations in the build file, so using properties makes maintenance much easier e.g. we might use the build.dir property in a clean target, to remove all the compiled files Properties are similar to string constants in a programming language - they are immutable This is one of the reasons that that targets tend to run consistently without side effects Properties can also be set in properties files (covered later), or when invoking ant Properties are defined on the command line using the syntax: -Dname=value, for example -Dbuild.dir=build <property> can also appear inside a target The property is set when the target is executed - this is not that commonly used In the event you should need to include this construct literally (i.e. without property substitutions), simply "escape" the '$' character by doubling it For example, the following task <echo>$${build.dir}=${build.dir}</echo> Would output: ${build.dir}=build Copyright 2008 LearningPatterns Inc. All rights reserved. 45

52 Working With Properties <property> also has a location attribute to make it easier to refer to files and directories It converts the path separator to the platform specific value <property name=db.file location="resources/javatunes.db"/> Properties can be used anywhere in a buildfile At bottom, we see how a property (build.dir) is used to define another property (main.class) <project name="helloant" default="run"> <description>a more complicated buildfile</description> <property name="build.dir" value="build"/> <property name="main.class" value="${build.dir}/teachmeant.class"/>  </project> When using the location attribute, the property is set 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. Copyright 2008 LearningPatterns Inc. All rights reserved. 46

53 Built-in Properties Ant provides access to all the system properties as if they had been defined with <property> For example, ${os.name} expands to the OS name Ant itself includes the following built-in properties basedir: Absolute path of project's basedir (set with basedir attribute of <project>) ant.file: Absolute path of the buildfile ant.version: Version of Ant ant.project.name: Name of project currently executing (set with name attribute of <project>) ant.java.version: The JVM version Ant detected For a list of all the system properties, see the Javadoc of java.lang.system.getproperties() Currently ant.java.version can hold the values "1.2", "1.3", "1.4", "1.5", and "1.6" Copyright 2008 LearningPatterns Inc. All rights reserved. 47

55 Lab 1.3 Working with Properties Lab Overview: In this lab, we will add properties to a buildfile There are various targets in the buildfile that you'll need to complete so they work properly Objectives: Become familiar with using properties in an ant buildfile Become more familiar with <javac>, <java> and other tasks, including using separate source and build directories Builds on previous labs: none Approximate Time: minutes Copyright 2008 LearningPatterns Inc. All rights reserved. 49

56 Lab Preparation Lab The root lab directory where you will do all your work is: C:\StudentWork\JPRACT\workspace\Lab01.3 This is a new lab directory which already exists in your workspace The Lab01.3 directory contains the TeachMeAnt Java program as in the last lab, with these changes The source is in the src directory, and TeachMeAnt is now in a package (com.javatunes) Note that <javac> will automatically deal with the package structure, as long as the source and build directories are set up The compiled files should be placed in the build directory Tasks to Perform Close all files from any previous labs If your editor allows you to configure a home directory, you can set it to the root lab directory Open a command prompt in the root lab directory described above Of course, since the class is in a package, there are directories that mirror the package structure Underneath the src directory, there is a com directory, and underneath the com directory, there is a javatunes directory <javac> automatically looks for Java classes in subdirectories Therefore, it will find any classes that are in a package There is nothing you need to do to make that happen It also automatically places the compiled output into the proper package directory - creating the directories if it needs to Copyright 2008 LearningPatterns Inc. All rights reserved. 50

57 Finish build.xml Lab Open up build.xml for editing Tasks to Perform Define the following properties: src.dir which points to the src directory build.dir which points to the build directory prog.class holding com.javatunes.teachmeant (our program) Look at all the other elements in the build file, looking for TODOs, and finish them up using the properties you just defined Save the file Open up a command window in the Lab01.3 directory Run ant with the all target to test the build file Does it work properly? If you have problems try the -verbose, or -debug options for ant to get more information STOP Copyright 2008 LearningPatterns Inc. All rights reserved. 51

60 Lesson Objectives Understand how to work with path-like information in ant (e.g. classpath) Work with resource collections, such as collections of files or directories, in ant Copyright 2008 LearningPatterns Inc. All rights reserved. 54

62 Path-like Structures There are a number of common situations where you need to specify a path e.g. - Specifying the Java classpath Paths generally consist of a series of files or directories separated by a separator character (usually ":" or ";") For example, the path containing the current directory (dot), the lib/utils.jar file, and the servlet-api.jar file in C:/apache-tomcat /lib could be represented by the path:.;lib/utils.jar;c:/apache-tomcat /lib/servlet-api.jar Path-like structures can be used in <javac> and <java> They both allow a classpath attribute - which takes a path-like structure to specify the classpath to use Copyright 2008 LearningPatterns Inc. All rights reserved. 56

63 Specifying the Classpath In the buildfile fragment below, we have two properties that define jar files - log4j.jar, and util.jar <javac> uses these properties in its classpath attribute In effect, you are passing the two jar files (log4j jar and utils.jar) to the javac executable to use for the classpath You can also use classpath with <java> to include jars on the runtime classpath <property name="lib.dir" value="lib"/> <property name="log4j.jar" value="${lib.dir}/log4j jar"/> <property name="util.jar" value="${lib.dir}/utils.jar"/> <target name="compile" description="compiles the source"> <javac srcdir="${src.dir}" destdir="${build.dir}" classpath="${log4j.jar};${util.jar}"/> </target> Note that we could have used the ":" character as a separator also This is not significant, as ant translates whatever you use to the appropriate separator character for whatever OS you're running on Copyright 2008 LearningPatterns Inc. All rights reserved. 57

64 Nested <classpath> Element Wherever you need a path-like value, a nested <classpath> element can be used For example, with <javac> and <java> <classpath> can contain nested <pathelement> elements to define classpath entries, as shown below The location attribute of <pathelement> can contain a single file or directory relative to the project base (or an absolute filename) There are many other ways to specify paths, which we'll look at shortly <javac srcdir="${src.dir}" destdir="${build.dir}"> <classpath> <pathelement location="${log4j.jar}"/> <pathelement location="${util.jar}"/> </classpath> </javac> Copyright 2008 LearningPatterns Inc. All rights reserved. 58

65 Nested <classpath> Element <pathelement> can also contain a path attribute (rather than location) The path attribute accepts colon- or semicolon-separated lists of locations - as shown in the common.path property in the example below common.path is a path that contains two jar files In the example below, it is used in a pathelement of the classpath for the <java> task <property name="common.path" value="${log4j.jar};${util.jar}"/> <java classname="com.javatunes.teachmeant"> <classpath> <pathelement path="${common.path}"/> <pathelement location="${build.dir}"/> </classpath> </java> The path attribute is intended to be used with predefined paths In any other case, multiple elements with location attributes should be preferred Copyright 2008 LearningPatterns Inc. All rights reserved. 59

Table of Contents Intermediate Java

Table of Contents Intermediate Java Intermediate Java and OO Development 1 Course Overview 2 Workshop Agenda 3 Workshop Agenda 4 Workshop Objectives - Java 5 Workshop Objectives - Tools 6 Course Methodology