1. Chapter 1 Introduction

   1. A Brief History of the Web

   2. What Are Java Servlets?

   3. JavaServer Pages

   4. JSP Model 1 and Model 2 Architectures

   5. Why Is Model-View-Controller So Important?

   6. What Is a Framework?

   7. Alternatives to Struts

2. Chapter 2 Inside the Web Tier

   1. An Architecture Overview

   2. The HTTP Request/Response Phase

   3. Struts and Scope

   4. Using URL Parameters

   5. Forward Versus Redirect

3. Chapter 3 Overview of the Struts Framework

   1. A Banking Account Example

   2. Looking at the Big Picture

   3. Struts Controller Components

   4. Struts Model Components

   5. Struts View Components

   6. Multiple Application Support

   7. Summary

4. Chapter 4 Configuring Struts Applications

   1. The Storefront Application

   2. What Is a Web Application?

   3. The Web Application Directory Structure

   4. The Web Application Deployment Descriptor

   5. Configuring the web.xml File for Struts

   6. The Struts Configuration File

   7. The Digester Component

   8. The Struts Console Tool

   9. Reloading the Configuration Files

5. Chapter 5 Struts Controller Components

   1. The Controller Mechanism

   2. The Utilities Classes

6. Chapter 6 Struts Model Components

   1. The "M" in MVC

   2. What Is a Business Object?

   3. Persistence

   4. What Does Struts Offer for the Model?

7. Chapter 7 Struts View Components

   1. What Is a View?

   2. What Are ActionForms?

   3. Using ActionErrors

   4. Performing Presentation Validation

   5. Using the DynaActionForm Class

   6. Looking Ahead to JavaServer Faces

8. Chapter 8 JSP Custom Tag Libraries

   1. Custom Tags Overview

   2. Tag Libraries Included with Struts

   3. Using JavaBeans with Struts Tags

   4. Struts HTML Tags

   5. Logic Tags

   6. Bean Tags

   7. Nested Tags

   8. Other Useful Tag Libraries

   9. The JSP Standard Tag Library (JSTL)

9. Chapter 9 Extending the Struts Framework

   1. What Are Extension Points?

   2. General Extension Points

   3. Controller Extension Points

   4. Extending View Components

   5. Downsides to Extending the Framework

10. Chapter 10 Exception Handling

    1. Java Exception Handling

    2. Performance Impact of Exception Handling

    3. System Versus Application Exceptions

    4. Using Chained Exceptions

    5. Exception Handling Provided by Struts

    6. Tying Up the Loose Ends

    7. Conclusion

11. Chapter 11 The Validator Framework

    1. The Need for a Validation Framework

    2. Installing and Configuring the Validator

    3. Using an ActionForm with the Validator

    4. Creating Your Own Validation Rules

    5. The Validator and JSP Custom Tags

    6. Internationalizing the Validation

    7. Using the Validator Outside of Struts

12. Chapter 12 Internationalization and Struts

    1. What Is Internationalization?

    2. Support for I18N in Java

    3. Internationalizing Your Struts Applications

    4. Exception Handling and Internationalization

13. Chapter 13 Struts and Enterprise JavaBeans

    1. Implementing the Storefront Service Using EJB

    2. Interfacing Struts to EJB

    3. Conclusion

14. Chapter 14 Using Tiles

    1. Understanding Templates

    2. Installing and Configuring Tiles

    3. Using Tiles

    4. The Tiles Tag Library

    5. Using Definitions

    6. Internationalization Support with Tiles

15. Chapter 15 Logging in a Struts Application

    1. Logging in a Web Application

    2. Using the Servlet Container for Logging

    3. Jakarta Commons Logging

    4. Using the log4j Package

    5. Using Commons Logging in JSP Pages

    6. The Performance Impact of log4j

    7. Third-Party log4j Extensions

    8. Java 1.4 Logging API

16. Chapter 16 Packaging Your Struts Application

    1. To Package or Not to Package

    2. Packaging the Application as a WAR File

    3. Building Your Struts Applications with Ant

    4. Creating an Automated Build Environment

    5. Restarting Your Server Remotely

17. Chapter 17 Addressing Performance

    1. What Is Good Performance?

    2. Performance Versus Load Testing

    3. Performance- and Stress-Testing Tools

    4. Testing the Storefront Application

    5. Performance and Scalability Gotchas

18. Chapter 18 JavaServer Faces

    1. Struts and JavaServer Faces

    2. Overview of JSF Architecture

    3. Installing and Running the Example Struts-Faces Application

    4. Converting Existing Struts Applications to JSF

    5. Further Reading

1. Appendix A Changes Since Struts 1.0

   1. ActionServlet and RequestProcessor

   2. Modifications to the Struts Action Class

   3. Changes to web.xml and struts-config.xml

   4. Action Statics Changed

   5. TagUtils and ModuleUtils

   6. New Features of Struts 1.1

   7. The Struts Validator

   8. Change to Commons Logging

   9. Removal of Admin Actions

   10. Deprecation of the GenericDataSource

   11. Dependency on Commons Projects

2. Appendix B Downloading and Installing Struts

   1. The Binary Versus Source Distributions

   2. Tips on Installing Struts in Tomcat

   3. Tips on Installing Struts in WebLogic

   4. Tips on Installing Struts in WebSphere

3. Appendix C Resources

   1. The Struts Mailing Lists

   2. The Struts Resource Web Page

   3. Tiles Site

   4. Nested Tags Site

   5. The Struts Console

   6. Easy Struts Project

4. Colophon

Our look is the result of reader comments, our own experimentation, and feedback from distribution channels. Distinctive covers complement our distinctive approach to technical topics, breathing personality and life into potentially dry subjects. The animal on the cover of Programming Jakarta Struts, Second Edition is a Percheron draft horse. This breed originated in the province of Le Perche in northwestern France. Purebreds are predominantly blackor gray, and some have white markings on their heads and feet. They weigh an average of 2000 pounds and are usually 16 to 17 hands (64 to 68 inches) high. Percherons adapt well to many climates and are extremely versatile: their ruggedness and power makes them ideal for hauling heavy loads, their placid nature makes them easy to handle, and their natural grace and beauty complement the finest horse-drawn carriages. They can be ridden, and some have even been made into jumpers.

In 732 A.D., Arabian horses abandoned by the Moors after the Battle of Tours were bred with native Flemish stock, producing the first Percherons. When the Crusaders invaded ten centuries later, more Arabian blood was added to the breed. However, the number of Percherons dwindled during the French Revolution, as horse breeding was suppressed. After the revolution, the new French government revived the breed by establishing a stud program for army mounts, using two Arabian sires at Le Pin, Normandy. In 1832 a foal named Jean Le Blanc was born in Le Perche, and all current Percheron bloodlines trace directly back to this horse.

Le Perche has since exported purebred stockworldwide, and an official Breed Association registers Percherons to ensure that the line remains genetically pure. The breed was most popular after World War I, when farmers from both Britain and the United States became familiar with them while serving in the armed forces. A 1930 U.S. census showed that registered Percherons outnumbered other draft horses by a margin of three to one, but after World War II, the farm tractor nearly replaced the breed entirely. However, it was kept alive by many farmers, especially those in Amish communities. Today, Percherons continue to work on farms and often perform in competition at livestockfairs. They are also used used to provide recreational hay, sleigh, and carriage rides. Philip Dangler was the production editor and copyeditor for Programming Jakarta Struts, Second Edition. Mary Brady, Emily Quill, and Darren Kelly provided quality control. Julie Hawks wrote the index.

Emma Colby designed the cover of this book, based on a series design by Edie Freedman. The cover image is a 19th-century engraving from the Dover Pictorial Archive. Emma Colby produced the cover layout with QuarkXPress 4.1 using Adobe's ITC Garamond font.

Melanie Wang designed the interior layout, based on a series design by David Futato. This book was converted to FrameMaker 5.5.6 by Andrew Savikas with a format conversion tool created by ErikRay, Jason McIntosh, Neil Walls, and Mike Sierra that uses Perl and XML technologies. The text font is Linotype Birka; the heading font is Adobe Myriad Condensed; and the code font is LucasFont's TheSans Mono Condensed. The illustrations that appear in the bookwere produced by Robert Romano and Jessamyn Read using Macromedia FreeHand 9 and Adobe Photoshop 6. The tip and warning icons were drawn by Christopher Bing. This colophon was written by Philip Dangler.