Enhanced descriptions from Syndetics:

Encompassing Java-centric software project best practices for designing and automating build, test, and deployment processes using ANT, this book is written for developers using Java in large software projects and those who have reached the limits of classic IDE development systems. Benefiting developers who apply extreme programming methodology to Java projects, this resource provides detailed coverage of ANT and explains how to use it in large projects and extend it when needed. In addition to using ANT for Java applications, it includes discussions of servlets and J2EE applications, which cover the majority of Java development projects.

Table of contents provided by Syndetics

• Foreword (p. xxv)
• Preface (p. xxvii)
• Acknowledgments (p. xxix)
• About this book (p. xxxi)
• About the authors (p. xxxvi)
• About the cover illustration (p. xxxvii)
• Part 1 Learning Ant (p. 1)
• 1 Introducing Ant (p. 3)
• 1.1 What is Ant? (p. 3)
• 1.2 The core concepts of Ant (p. 5)
• 1.3 Why use Ant? (p. 10)
• 1.4 The evolution of Ant (p. 14)
• 1.5 Ant and software development methodologies (p. 16)
• 1.6 Our example project (p. 17)
• 1.7 Yeah, but can Ant... (p. 19)
• 1.8 Beyond Java development (p. 21)
• 1.9 Summary (p. 22)
• 2 Getting started with Ant (p. 23)
• 2.1 Defining our first project (p. 23)
• 2.2 Step one: verifying the tools are in place (p. 24)
• 2.3 Step two: writing your first Ant build file (p. 24)
• 2.4 Step three: running your first build (p. 26)
• 2.5 Step four: imposing structure (p. 31)
• 2.6 Step five: running our program (p. 39)
• 2.7 Ant command line options (p. 41)
• 2.8 The final build file (p. 44)
• 2.9 Summary (p. 46)
• 3 Understanding Ant datatypes and properties (p. 47)
• 3.1 Preliminaries (p. 48)
• 3.2 Introducing datatypes and properties with [left angle bracket]javac[right angle bracket] (p. 49)
• 3.3 Paths (p. 51)
• 3.4 Filesets (p. 52)
• 3.5 Patternsets (p. 54)
• 3.6 Selectors (p. 56)
• 3.7 Datatype element naming (p. 57)
• 3.8 Filterset (p. 58)
• 3.9 FilterChains and FilterReaders (p. 59)
• 3.10 Mappers (p. 61)
• 3.11 Additional Ant datatypes (p. 65)
• 3.12 Properties (p. 66)
• 3.13 Controlling Ant with properties (p. 77)
• 3.14 References (p. 79)
• 3.15 Best practices (p. 82)
• 3.16 Summary (p. 83)
• 4 Testing with JUnit (p. 85)
• 4.1 Refactoring (p. 86)
• 4.2 Java main() testing (p. 86)
• 4.3 JUnit primer (p. 87)
• 4.4 Applying unit tests to our application (p. 92)
• 4.5 The JUnit task--[left angle bracket]junit (p. 94)
• 4.6 Test failures are build failures (p. 97)
• 4.7 Generating test result reports (p. 100)
• 4.8 Short-circuiting tests (p. 105)
• 4.9 Best practices (p. 109)
• 4.10 Summary (p. 110)
• 5 Executing programs (p. 111)
• 5.1 Why you need to run external programs (p. 111)
• 5.2 Running Java programs (p. 112)
• 5.3 Starting native programs with (p. 124)
• 5.4 Bulk execution with (p. 130)
• 5.5 Processing output (p. 131)
• 5.6 Limitations on execution (p. 132)
• 5.7 Best practices (p. 132)
• 5.8 Summary (p. 133)
• 6 Packaging projects (p. 134)
• 6.1 Moving, copying, and deleting files (p. 135)
• 6.2 Preparing to package (p. 139)
• 6.3 Creating archive files (p. 146)
• 6.4 Creating Zip files (p. 154)
• 6.5 Creating tar files (p. 158)
• 6.6 Creating web applications with WAR files (p. 160)
• 6.7 Testing packaging (p. 161)
• 6.8 Summary (p. 162)
• 7 Deployment (p. 163)
• 7.1 Example deployment problems (p. 164)
• 7.2 Tasks for deployment (p. 165)
• 7.3 FTP-based distribution of a packaged application (p. 171)
• 7.4 Email-based distribution of a packaged application (p. 173)
• 7.5 Local deployment to Tomcat 4.x (p. 174)
• 7.6 Remote deployment to Tomcat (p. 181)
• 7.7 Testing deployment (p. 187)
• 7.8 Summary (p. 187)
• 8 Putting it all together (p. 188)
• 8.1 Our application thus far (p. 188)
• 8.2 Building the custom Ant task library (p. 189)
• 8.3 Loading common properties across multiple projects (p. 194)
• 8.4 Handling versioned dependencies (p. 196)
• 8.5 Build file philosophy (p. 200)
• 8.6 Summary (p. 201)
• Part 2 Applying Ant (p. 203)
• 9 Using Ant in your development projects (p. 205)
• 9.1 Designing an Ant-based build process (p. 206)
• 9.2 Migrating to Ant (p. 209)
• 9.3 The ten steps of migration (p. 210)
• 9.4 Master builds: managing large projects (p. 212)
• 9.5 Managing child project builds (p. 221)
• 9.6 Creating reusable library build files (p. 228)
• 9.7 Looking ahead: large project support evolution (p. 230)
• 9.8 Ant project best practices (p. 231)
• 9.9 Summary (p. 233)
• 10 Beyond Ant's core tasks (p. 234)
• 10.1 Understanding types of tasks (p. 235)
• 10.2 Optional tasks in action (p. 237)
• 10.3 Using software configuration management tasks (p. 245)
• 10.4 Using third-party tasks (p. 247)
• 10.5 Notable third-party tasks (p. 248)
• 10.6 The ant-contrib tasks (p. 253)
• 10.7 Sharing task definitions among projects (p. 258)
• 10.8 Best practices (p. 258)
• 10.9 Summary (p. 259)
• 11 XDoclet (p. 260)
• 11.1 Installing XDoclet (p. 261)
• 11.2 To-do list generation (p. 261)
• 11.3 XDoclet architecture (p. 262)
• 11.4 Writing your own XDoclet template (p. 265)
• 11.5 Advanced XDoclet (p. 273)
• 11.6 The direction of XDoclet (p. 275)
• 11.7 XDoclet best practices (p. 276)
• 11.8 Summary (p. 277)
• 12 Developing for the web (p. 278)
• 12.1 How are web applications different? (p. 279)
• 12.2 Working with tag libraries (p. 280)
• 12.3 Compiling JSP pages (p. 288)
• 12.4 Customizing web applications (p. 292)
• 12.5 Generating static content (p. 297)
• 12.6 Testing web applications with HttpUnit (p. 299)
• 12.7 Server-side testing with Cactus (p. 310)
• 12.8 Summary (p. 315)
• 13 Working with XML (p. 317)
• 13.1 Preamble: all about XML libraries (p. 318)
• 13.2 Validating XML (p. 319)
• 13.3 Transforming XML with XSLT (p. 323)
• 13.4 Generating an XML build log (p. 327)
• 13.5 Loading XML data into Ant properties (p. 331)
• 13.6 Next steps in XML processing (p. 332)
• 13.7 Summary (p. 332)
• 14 Enterprise JavaBeans (p. 333)
• 14.1 EJB overview (p. 333)
• 14.2 A simple EJB build (p. 335)
• 14.3 Using Ant's EJB tasks (p. 336)
• 14.4 Using [left angle bracket]ejbjar[right angle bracket] (p. 337)
• 14.5 Using XDoclet for EJB development (p. 340)
• 14.6 Middlegen (p. 345)
• 14.7 Deploying to J2EE application servers (p. 348)
• 14.8 A complete EJB example (p. 349)
• 14.9 Best practices in EJB projects (p. 354)
• 14.10 Summary (p. 354)
• 15 Working with web services (p. 355)
• 15.1 What are web services and what is SOAP? (p. 356)
• 15.2 Creating a SOAP client application with Ant (p. 357)
• 15.3 Creating a SOAP service with Axis and Ant (p. 363)
• 15.4 Adding web services to an existing web application (p. 367)
• 15.5 Writing a client for our SOAP service (p. 371)
• 15.6 What is interoperability, and why is it a problem? (p. 376)
• 15.7 Building a C# client (p. 376)
• 15.8 The rigorous way to build a web service (p. 381)
• 15.9 Reviewing web service development (p. 382)
• 15.10 Calling Ant via SOAP (p. 383)
• 15.11 Summary (p. 384)
• 16 Continuous integration (p. 386)
• 16.1 Scheduling Ant builds with the operating system (p. 387)
• 16.2 CruiseControl (p. 388)
• 16.3 Anthill (p. 397)
• 16.4 Gump (p. 401)
• 16.5 Comparison of continuous integration tools (p. 405)
• 16.6 Summary (p. 406)
• 17 Developing native code (p. 407)
• 17.1 The challenge of native code (p. 407)
• 17.2 Using existing build tools (p. 408)
• 17.3 Introducing the [left angle bracket]cc[right angle bracket] task (p. 410)
• 17.4 Building a JNI library in Ant (p. 412)
• 17.5 Going cross-platform (p. 422)
• 17.6 Looking at [left angle bracket]cc[right angle bracket] in more detail (p. 425)
• 17.7 Distributing native libraries (p. 429)
• 17.8 Summary (p. 430)
• 18 Production deployment (p. 431)
• 18.1 The challenge of different application servers (p. 432)
• 18.2 Working with operations (p. 437)
• 18.3 Addressing the deployment challenge with Ant (p. 440)
• 18.4 Introducing Ant's deployment power tools (p. 442)
• 18.5 Building a production deployment process (p. 446)
• 18.6 Deploying to specific application servers (p. 456)
• 18.7 Verifying deployment (p. 459)
• 18.8 Best practices (p. 462)
• 18.9 Summary (p. 463)
• Part 3 Extending Ant (p. 465)
• 19 Writing Ant tasks (p. 467)
• 19.1 What exactly is an Ant task? (p. 468)
• 19.2 Ant API primer (p. 470)
• 19.3 How tasks get data (p. 474)
• 19.4 Creating a basic Ant Task subclass (p. 483)
• 19.5 Operating on a fileset (p. 485)
• 19.6 Error handling (p. 486)
• 19.7 Testing Ant tasks (p. 487)
• 19.8 Executing external programs (p. 487)
• 19.9 Executing a Java program within a task (p. 490)
• 19.10 Supporting arbitrarily named elements and attributes (p. 493)
• 19.11 Building a task library (p. 495)
• 19.12 Supporting multiple versions of Ant (p. 497)
• 19.13 Summary (p. 497)
• 20 Extending Ant Further (p. 498)
• 20.1 Scripting within Ant (p. 499)
• 20.2 Listeners and loggers (p. 502)
• 20.3 Developing a custom mapper (p. 514)
• 20.4 Creating custom selectors (p. 515)
• 20.5 Implementing a custom filter (p. 517)
• 20.6 Summary (p. 520)
• A Installation (p. 523)
• B XML primer as it applies to Ant (p. 532)
• C IDE integration (p. 536)
• D The elements of Ant style (p. 544)
• E Ant task reference (p. 561)
• Resources (p. 621)
• Index (p. 625)
• License (p. 635)

Author notes provided by Syndetics