Table Of ContentJavaServer Pages™, Second Edition
By Larne Pekowsky
Publisher : Addison Wesley
Pub Date : August 15, 2003
ISBN : 0-321-15079-1
Pages : 368
Slots : 1
1
Copyright
Preface
Acknowledgements
Chapter 1. Introduction
Section 1.1. A Brief History of the Web
Section 1.2. Basic Dynamic Page Generation
Section 1.3. Solving CGI Problems
Section 1.4. Welcome to Java News Today
Section 1.5. Trying the Examples
Chapter 2. Simple JSPs
Section 2.1. Removing Text from a JSP
Section 2.2. JSP Errors
Section 2.3. Including Text in a JSP
Section 2.4. The Phases of a JSP
Section 2.5. Creating Custom Error Pages
Section 2.6. Java News Today
Section 2.7. Summary and Conclusions
Section 2.8. Tags Learned in This Chapter
Chapter 3. Using Beans
Section 3.1. Splitting Big Tasks into Manageable Pieces
Section 3.2. Defining Beans
Section 3.3. JavaBean Tags
Section 3.4. Making Data Available Throughout an Application
Section 3.5. Special Actions When Beans Are Created
2
Section 3.6. Making Beans Last Forever
Section 3.7. Java News Today and Beans
Section 3.8. Future Directions
Section 3.9. Summary and Conclusions
Section 3.10. Tags Learned in This Chapter
Chapter 4. The Standard Tag Library
Section 4.1. Tag Libraries
Section 4.2. Tags with Bodies
Section 4.3. Dynamic Attributes in Tags
Section 4.4. Displaying Expressions
Section 4.5. Formatting Output
Section 4.6. Compound Data in the Expression Language
Section 4.7. Browser Detection
Section 4.8. Combining Tags
Section 4.9. Selecting among Multiple Choices
Section 4.10. Summary and Conclusions
Section 4.11. Tags Learned in this Chapter
Chapter 5. Java News Today: Part I
Section 5.1. The Beans
Section 5.2. The Header
Section 5.3. The Left-Hand Navigation
Section 5.4. The Login Page
Section 5.5. The Quiz Result Page
Section 5.6. The Section Page
3
Section 5.7. The Article Page
Section 5.8. The Remaining Pages
Section 5.9. Summary and Conclusions
Section 5.10. Tags Learned in this Chapter
Chapter 6. Databases
Section 6.1. A Quick Introduction to Databases
Section 6.2. A Language for Databases
Section 6.3. Using SQL Directly from JSPs
Section 6.4. Inserting Data from JSPs
Section 6.5. SQL and Beans
Section 6.6. Summary and Conclusions
Section 6.7. Tags Learned in This Chapter
Chapter 7. Java News Today: Part 2
Section 7.1. Designing the Tables
Section 7.2. Adding Articles
Section 7.3. User Pages
Section 7.4. Other User Preferences
Section 7.5. Advertising
Section 7.6. Summary and Conclusions
Chapter 8. Working with XML
Section 8.1. A Brief Introduction to XML
Section 8.2. Using XML in JSPs
Section 8.3. Selecting Data from an XML Document
4
Section 8.4. Processing XML in JSPs
Section 8.5. Formatting XML
Section 8.6. Java News Today and XML
Section 8.7. Summary and Conclusions
Section 8.8. Tags Learned in this Chapter
Chapter 9. A Small Cup of Java
Section 9.1. Expressions
Section 9.2. Types
Section 9.3. Storing Values
Section 9.4. Method Calls
Section 9.5. Conditionally Evaluating Code
Section 9.6. Evaluating the Same Code Multiple Times
Section 9.7. Grouping Code
Section 9.8. Handling Errors
Section 9.9. Modeling a Problem with Objects
Section 9.10. Objects in Java
Section 9.11. Building Objects from Classes
Section 9.12. Sometimes Nothing Is Something
Section 9.13. Building Classes from Other Classes
Section 9.14. Interfaces
Section 9.15. Creating Groups of Classes and Interfaces
Section 9.16. Using Java in JSPs
Section 9.17. Database Access from Java
Section 9.18. Summary and Conclusions
5
Chapter 10. Writing Beans
Section 10.1. How Beans Are Implemented
Section 10.2. Automatic Type Conversion
Section 10.3. How Beans Work
Section 10.4. Bean Serialization
Section 10.5. Events
Section 10.6. Special Events
Section 10.7. Bean Errors
Section 10.8. Summary and Conclusions
Chapter 11. Servlets
Section 11.1. The Servlet Life Cycle
Section 11.2. The Servlet Class Hierarchy
Section 11.3. Servlet Events
Section 11.4. Forwarding and Including Requests
Section 11.5. Using Scopes from Servlets
Section 11.6. Using Beans from Servlets
Section 11.7. The JSP Classes
Section 11.8. Intercepting Requests
Section 11.9. Summary and Conclusions
Chapter 12. The Controller
Section 12.1. Some Common Controller Tasks
Section 12.2. Support for Controllers: Struts
Section 12.3. Summary and Conclusions
6
Chapter 13. Creating New Tag Libraries
Section 13.1. The Tag Life Cycle
Section 13.2. Tags without Bodies
Section 13.3. Tags with Bodies
Section 13.4. Using the Expression Language
Section 13.5. JSPs as Custom Tags
Section 13.6. Summary and Conclusions
Chapter 14. Advanced Topics
Section 14.1. Declaring Variables and Methods
Section 14.2. Extending Different Classes
Section 14.3. Returning Other Kinds of Data
Section 14.4. Threads
Section 14.5. Advanced Error Handling
Section 14.6. Summary and Conclusions
Appendix A. Summary of Tags
Section A.1. Built-in Tags
Section A.2. Core Tags
Section A.3. Format, Parsing, and Internationalization Tags
Section A.4. SQL Tags
Section A.5. XML Tags
Appendix B. Configuring a Web Application
Section B.1. Layout of the Directories
Section B.2. The Web.xml File
7
Preface
This is a book about how to use an exciting and powerful technology, JavaServer Pages,
(JSP) to create dynamic, interactive Web sites. As the name implies, this technology is
based on the Java programming language and inherits many of the language's features
and benefits. Most notably, Java makes JSPs available on almost every kind of computer
and operating system and certainly all those in common use.
JavaServer Pages are now a mature and stable technology, already in use in thousands of
companies. But maturity has certainly not led to stagnation! Recently, a new version of
the JSP specification was released, bringing new capabilities and possibilities. In addition,
several companion technologies have been developed to augment the fundamental
specification. The new specification, as well as the most important of these associated
technologies, are all covered in this book. Throughout this book, effort has been made to
show the capabilities of all these tools and to discuss how they can best be used.
One of the most important features of JavaServer Pages is how easy they are to use.
Anyone who is reasonably comfortable with HTML (Hypertext Markup Language) can
learn to write JavaServer Pages by using a few simple tags that may do very sophisticated
things behind the scenes, along with small packages of code called JavaBeans. This
allows for a very productive working relationship between HTML experts who build
pages and Java programmers who build beans and new tags.
Both kinds of developer will find material of interest in this book. Chapter 1 gives a brief
history of the Web, setting JSPs in context and clarifying what they are, how they work,
and why they work that way. Chapter 2 introduces some of the simpler features of JSPs
and shows just how easy the transition from HTML to JSP is.
The next two chapters introduce the two vital technologies that give JSPs their enormous
power and flexibility: JavaBeans in Chapter 3 and custom tags in Chapter 4. These tags
are presented as page authors will use them: components that hide all the complexities of
Java behind simple interfaces that can be combined and used in limitless ways. Chapter 5
uses beans and tags to build a fully functional Web site.
One of the great benefits of JSPs is that they make it possible for pages to interact with
complex systems. A very common such system is a database. Chapter 6 introduces
database concepts and discusses easy ways in which a page author can access data.
Chapter 7 uses this information to expand the utility of the site built in Chapter 5.
XML (Extensible Markup Language) is an increasingly important technology, and JSPs
are already well equipped to work with XML. This topic is covered in Chapter 8.
8
The first eight chapters comprise a logical first half of the book, dealing with the myriad
things page authors can do with JSPs without knowing anything about Java. The
remainder of the book delves under the hood to explain how all this is accomplished and
how Java programmers can extend the capabilities of JSPs. For readers who are not yet
familiar with Java, Chapter 9 introduces the language.
Chapter 10 covers the process of creating new beans. Chapter 11 covers a technology,
called servlets, that underlies JSPs. This information is then used in Chapter 12 to talk
about controllers, Java code that helps pieces of a Web site work together simply and
cleanly. Chapter 13 discusses how to use Java to create new tags. Chapter 14 covers a
few remaining advanced topics.
Readers who are not interested in programming will get the most out of this book by
reading Chapters 1 through 9, which comprise a complete course on how to use JSPs,
beans, tags, and related technologies to build just about any Web site imaginable. At that
point, such readers may wish to learn a little Java from Chapter 9 and then proceed on
through the rest of the book in order to understand better how everything works.
On the other hand, readers who already know Java but who may not be familiar with
JSPs, the new features added as part of the latest specification, or related technologies
will want to move quickly through Chapter 2 to get a feel for JSP syntax and then go
through Chapters 3 and 4 to see how JSPs interface with Java via tags and beans.
Programmers may then wish to proceed to Chapter 10 to see how new beans are created,
and from there through the second half of the book in order to understand servlets and
tags.
Finally, as amazing as it may seem, there is absolutely no cost to developing and
deploying JSPs! There is no need to buy a special server or particular hardware or
operating system. All the tools needed, and many others, have been released for free by
the Apache group. The CD-ROM accompanying this book contains these tools, as well as
all the examples from the book. It is my sincere hope that this book, in conjunction with
these tools, will help you get the most out of this revolutionary new technology for
building exciting, compelling Web sites.
9
Acknowledgements
This book is very much a group effort, and I am deeply indebted to everyone who helped
make it possible.
It has been my great pleasure to work with some of the brightest and most dedicated
people in New York at CapitalThinking. Although there are too many to name, I want to
thank them all for helping to keep technology fun and exciting enough to write about.
Almost every real-world consideration regarding server-side Java that appears in this
book came out of projects my colleagues and I worked on.
Many thanks and high praise to everyone at the Apache project behind Tomcat, the
standard tag libraries, struts, and so much more. Their decision to make such high-quality
tools free and open source deserves a round of applause from every Java and JSP
developer.
All the code in this book was developed on a FreeBSD system. I owe a debt of gratitude
to everyone behind both the operating system and the Java ports.
I would also like to thank everyone who took the time to read over the manuscript and
make suggestions. The final result is profoundly better for their efforts.
This book would be nothing but a collection of unread bits on my hard drive if not for
everyone at Addison-Wesley, including Ann Sellers, Jacqui Doucette, Debby Van Dijk,
Michael Mullen, Mary O'Brien, and the many others whom I may not have been lucky
enough to work with directly.
Finally, I would like to thank the artists who created the music that kept me company
while I was writing. Many of their names appear in examples scattered throughout the
text.
. . . and I wrote this book for evil gray monkeys who haunt me. . .
10
