Paperback
-
PICK UP IN STORECheck Availability at Nearby Stores
Available within 2 business hours
Related collections and offers
Overview
Product Details
| ISBN-13: | 9780072133196 |
|---|---|
| Publisher: | McGraw-Hill Companies, The |
| Publication date: | 09/01/2001 |
| Series: | Beginner's Guides (Osborne) |
| Pages: | 528 |
| Product dimensions: | 7.34(w) x 9.26(h) x 1.13(d) |
About the Author
Bharathi Natarajan is a Lead Engineer at Artesia Technologies and has co-authored articles appearing in JavaPro and JavaReport magazines. He has an undergraduate degree and a graduate degree in computer science. He has 8 years' professional experience programming in C/C++, distributed programming, and J2EE architectures. 1-k also loves his dogs.
Read an Excerpt
Excerpt from
Part 1: JSP Foundations
Module 1:Introduction to Internet Technologies
Common Platform HTML provides a simple way to program applications within the browser page itself, thereby transforming it from a single application into an application platform.
Ease of Application Installation, Deployment, and Training
Web applications require no installation beyond installation of the browser. (And these days, the browser is often bundled with the operating system.) The popularity of the Web browser has also achieved a kind of critical mass-so many applications use a browser that people understand and feel comfortable with the browser as their platform. People rarely need much training in the mechanics of using a Web browser.
The popularity of browser applications does not mean that users are completely happy with their limitations. Most recent developments in the browser and the Web server aim to overcome the limits of the basic Web technology. Although this book describes JavaServer Pages, a server technology, let us briefly address browser technologies.
Extending the Web Browser
In recent years, various vendors have spent great effort extending the capabilities of the browser as an application interface. This usually happened under the auspices of making browser pages "more dynamic." The most important of these client-side extensions have been these:- Helper applications
- Browser plug-ins
- JavaScript
- VBScript
- Dynamic HTML
- Java applets
TIP
The MIME standard that provides the basic scheme for HTTP request formatting also provides the basis for launching helper applications. The idea is that the browser passes MIME format types that it cannot handle to helper applications.
Recently, helper application functionality has tended to migrate into browser plug-ins. We discuss plug-ins next.
Browser Plug-Ins
Browser plug-ins seamlessly extend browser functionality so that they appear to be part of the browser itself. For example, Adobe Software provides a plug-in for viewing Adobe's Portable Document Format (PDF). Other plug-ins support audio and video formats. Real Networks, for example, has plug-ins to play RealAudio and RealVideo files directly in the browser. Dozens of such plug-in programs now exist for both Netscape and Internet Explorer. Such plug-ins are loaded into the browser's own address space for execution. Vendors deploy plug-ins in browsers as shared libraries.
Note
Shared libraries are specially packaged units of code (usually written in C or C++) that can be loaded and executed in an application at runtime. On Microsoft Windows platforms, shared libraries use Microsoft's Dynamic Link Library (DLL) format that has a All file extension. On UNIX platforms, shared libraries use the Dynamic Shared Object (DSO) format that has a .so file extension.
Both helper applications and plug-ins suffer from the limitation that they are not general purpose programming languages. They provide one proprietary function and only that function. JavaScript, on the other hand, provides a truly flexible programming language for browsers.
JavaScript
JavaScript was the first general purpose, "dynamic" client-side scripting language for browsers. Netscape first delivered JavaScript in 1995 but called it LiveScript. (See Steenson's article, "JavaScript: Past, Present, and Future," athttp://home.netscape.com/computing/webbuilding/ studio/feature19981111-1.html.)
Netscape quickly renamed LiveScript to JavaScript, thereby confusing many people who had just started to hear about Java. The confusion was somewhat lessened by Sun, the developer of Java, when it issued a joint press release with Netscape that same year. The press release proclaimed Java and javaScript to be complementary but very different technologies. (See http : / / home.netscape.com/newsref/pr/newsrelease67.html.)
JavaScript provides a scripting language for creating user interface controls. In effect, JavaScript inserts code logic into the browser. It supports such effects as validation of user input and image swapping as the mouse cursor rolls over a spot on a Web page.
Microsoft almost immediately wrote its own version of JavaScript and called it JScript. Both Microsoft and Netscape supported a scripting language standard encompassing the core features of JavaScript and JScript and controlled by the European Computer Manufacturers Association (ECMA) standards organization. ECMA named this scripting language ECMAScript. (See http : / /www. ecma. ch/.) Despite the respective commitments by Microsoft and Netscape to the ECMAScript standard, they continue their separate, proprietary and divergent enhancements to JavaScript. This means heavy dependence on JavaScript often requires separate code bases for different browsers.
VBScript
Alongside JavaScript, Microsoft also developed VBScript as an interpreted subset of its Visual Basic programming language. Microsoft developed VBScript specifically for use in Microsoft's Internet Explorer to support ActiveX controls. ActiveX is a proprietary Microsoft object-oriented software component model. Like JavaScript, VBScript requires interpreter support in the Web browser. Microsoft positions VBScript as an alternative to JavaScript for those programmers who already know Visual Basic. Only Microsoft's browser, Internet Explorer, and Microsoft's Web server, the Internet Information Service (IIS), support VBScript.
Dynamic HTML
Dynamic HTML (DHTML) supports multiple technologies such as JavaScript and Java, but it is most strongly identified with Cascading Style Sheets (CSS), a W3C specification. (See http: //www.w3 . org/TR/REC-CSS1.) Cascading Style Sheets help page developers separate presentation elements from content elements. For example, exact pixel layout, similar to page layout for books or magazines, requires Cascading Style Sheets. Cascading Style Sheets also support such page element traits as colors, font specifications, display layers, and page margins.Dynamic HTML also provides access to a browser page's Document Object Model (DOM). DOM is the internal representation of the elements of a page, along with their attributes. Dynamic HTML supports runtime access to some of these elements and in some cases, enables runtime modifications. For example, suppose we have this page element:
...Both JavaScript and VBScript can dynamically set the color of this element. Here is the JavaScript:
...HTML has a low level of standardization. Microsoft added support for its proprietary technologies, ActiveX and VBScript, which Netscape does not support. Both Netscape and Internet Explorer support CSS, but to different degrees for different features. Both the event model and DOM for Internet Explorer and Netscape differ, making cross-platform use of DHTML quirky. (See http : / /www. dhtml zone. com/.)
Java Applets Java was announced by Sun Microsystems in February of 1995, the same year that Netscape announced JavaScript. (See Richard Morin's article "Oak and WebRunner" in Sun Expert Magazine, 1995, Vol. 6, No. 2. Also see http://java.sun.com/pr/1995/02/pr950201-Ol.html.) Its original name was Oak. Sun described Oak as a simplified derivative of C++ and described its features as including the following:
- Dynamic linking of program functionality into a running application using a network download
- Independence from any CPU platform
- Guaranteed security from viruses
From that quiet beginning as Oak, Java has captured unprecedented mindshare among programmers. Initially, this popularity focused on the client side, especially Java applets.
The idea behind applets was to provide full-featured programming capabilities to browser applications without sacrificing security. Both Netscape and Microsoft licensed Java and integrated it into their respective browsers. Today, Sun provides a Java plug-in for both browser platforms. Special HTML tags invoke the plug-in to load applets into a Java virtual machine (JVM). This plug-in bridges the browser and an external JVM. The Sun Java plug-in removes developer dependence on the "out-of-the-box" versions of the Java Virtual MaclAne supported by browser vendors. This allows developers to remain current with the Java releases. For example, at this time you must use the Sun plug-in to run Java 2 applets in a browser....
Table of Contents
| Acknowledgments | xiii | |
| Introduction | xv | |
| Part I | JSP Foundations | |
| 1 | Introduction to Internet Technologies | 3 |
| The Internet as a Client-Server Architecture | 4 | |
| Network Transparency Issues | 5 | |
| Stateful Servers | 7 | |
| HTTP Servers Are Stateless | 8 | |
| HTTP Requests | 9 | |
| The Request Line | 9 | |
| Message Headers | 14 | |
| Message Body | 14 | |
| HTTP Responses | 15 | |
| The Status Line | 15 | |
| Message Headers | 16 | |
| Message Body | 17 | |
| The Rest of the Story | 17 | |
| Project 1-1 | Echoing the HTTP Protocol | 18 |
| Client-Side Web Programming | 23 | |
| Extending the Web Browser | 25 | |
| The Role and Limits of Browser Technologies | 30 | |
| Server-Side Web Programming | 31 | |
| Extending the Web Server | 34 | |
| The Role of Java Servlets and JavaServer Pages | 38 | |
| Project 1-2 | Running Your First JSP Program | 39 |
| Mastery Check | 41 | |
| 2 | JSP Elements: Comments and Directives | 43 |
| The JSP Container | 44 | |
| JSP Stages | 45 | |
| JSP Scope | 46 | |
| JSP Constructs | 48 | |
| Bird's-Eye View of a Complete JSP Page | 49 | |
| JSP Comments | 50 | |
| Using Comments | 50 | |
| JSP Comment Types | 52 | |
| JSP Directives | 54 | |
| The include Directive | 55 | |
| Project 2-1 | Include Directive Test | 60 |
| The page Directive | 62 | |
| Project 2-2 | Page Directive Test | 69 |
| The taglib Directive | 70 | |
| Mastery Check | 73 | |
| 3 | JSP Elements: Scripting Elements | 75 |
| The Three Scripting Elements | 76 | |
| How the Container Translates JSP Scripting Elements | 77 | |
| JSP Declarations | 81 | |
| Variables in a JSP Declaration | 82 | |
| Methods in a JSP Declaration | 82 | |
| Declarations of Advanced Java Features | 83 | |
| More About JSP Declarations | 84 | |
| JSP Expressions | 87 | |
| More About JSP Expressions | 90 | |
| JSP Scriptlets | 91 | |
| Variables in Scriptlets | 91 | |
| Expressions in Scriptlets | 92 | |
| Conditionals in Scriptlets | 92 | |
| Iteration in Scriptlets | 94 | |
| Advanced Java Features in Scriptlets | 95 | |
| Exceptions in Scriptlets | 97 | |
| More About JSP Scriptlets | 98 | |
| Project 3-1 | Scripting Elements | 100 |
| Mastery Check | 104 | |
| 4 | Implicit Objects | 107 |
| The request Variable | 109 | |
| Request Services | 110 | |
| The response Variable | 119 | |
| Response Services | 120 | |
| Project 4-1 | Streaming the Contents of a File | 126 |
| The pageContext Variable | 129 | |
| PageContext Services | 130 | |
| The session Variable | 134 | |
| Session Services | 135 | |
| Project 4-2 | URL Redirection and URL Includes | 137 |
| The out Variable | 140 | |
| Out Services | 141 | |
| The application Variable | 145 | |
| Application Services | 146 | |
| The config Variable | 155 | |
| The page Variable | 156 | |
| Page Services | 156 | |
| The exception Variable | 157 | |
| Exception Services | 158 | |
| Mastery Check | 159 | |
| 5 | Standard Actions | 161 |
| JSP Actions | 162 | |
| Standard Actions Versus Custom Actions | 162 | |
| Tag Attributes | 163 | |
| The id Attribute | 164 | |
| The scope Attribute | 165 | |
| The [left angle bracket]jsp:useBean[right angle bracket] Action | 166 | |
| Attributes and Usage Rules | 167 | |
| Processing Steps | 167 | |
| Using [left angle bracket]jsp:useBean[right angle bracket] | 170 | |
| The [left angle bracket]jsp:setProperty[right angle bracket] Action | 173 | |
| Attributes and Usage Rules | 174 | |
| The Two Variants of [left angle bracket]jsp:setProperty[right angle bracket] | 175 | |
| The [left angle bracket]jsp:getProperty[right angle bracket] Action | 178 | |
| Attributes and Usage Rules | 178 | |
| Using [left angle bracket]jsp:getProperty[right angle bracket] | 179 | |
| The [left angle bracket]jsp:include[right angle bracket] Action | 180 | |
| Attributes and Usage Rules | 181 | |
| Using [left angle bracket]jsp:include[right angle bracket] | 181 | |
| The [left angle bracket]jsp:forward[right angle bracket] Action | 182 | |
| Attributes and Usage Rules | 183 | |
| Using [left angle bracket]jsp:forward[right angle bracket] | 183 | |
| The [left angle bracket]jsp:param[right angle bracket] Action | 184 | |
| Attributes and Usage Rules | 184 | |
| Project 5-1 | A Simple Shopping Cart | 185 |
| The [left angle bracket]jsp:plugin[right angle bracket] Action | 190 | |
| Attributes and Usage Rules | 191 | |
| Mapping an Applet to a [left angle bracket]jsp:plugin[right angle bracket] | 192 | |
| Project 5-2 | Inserting a Menu Applet | 193 |
| Mastery Check | 196 | |
| 6 | Tag Libraries | 199 |
| Why Define Custom Tags? | 200 | |
| Elements of a Tag Library | 206 | |
| Tag Library Formats | 206 | |
| The taglib Directive | 207 | |
| The Tag Library Descriptor | 207 | |
| Tag Handlers | 212 | |
| Life Cycle of a Tag Handler | 225 | |
| Defining Scripting Variables | 227 | |
| The TagExtraInfo Class | 227 | |
| Defining the Scripting Variables | 230 | |
| The Recommended Convention for Defining Implicit Objects | 233 | |
| Project 6-1 | Defining Implicit Objects | 234 |
| Exchanging Data Between Actions and Tag Libraries | 239 | |
| Ids and the PageContext Object | 239 | |
| The Runtime Stack | 240 | |
| Project 6-2 | A Template Using a Tag Library | 242 |
| Mastery Check | 251 | |
| Part II | Building Real-World Applications | |
| 7 | JSP Architectures | 255 |
| Patterns in Application Development | 256 | |
| The Idea of Patterns | 256 | |
| The Utility of Patterns | 258 | |
| Architectural Patterns | 259 | |
| Application Tiers | 260 | |
| Splitting the Presentation Tier | 264 | |
| Web Application Architectures | 264 | |
| Object-Oriented Software Design Patterns | 267 | |
| Model-View-Controller | 268 | |
| Mediator | 270 | |
| Command | 271 | |
| Strategy | 273 | |
| Bridge | 274 | |
| Project 7-1 | Gallery Viewer | 277 |
| The Application: A Family Center | 285 | |
| Security | 286 | |
| Web-Flow | 286 | |
| Repository | 286 | |
| Mastery Check | 287 | |
| 8 | JSP Security | 289 |
| Basic Application Security | 290 | |
| Authentication | 290 | |
| Authorization | 294 | |
| Integrity | 295 | |
| Confidentiality | 297 | |
| Availability | 297 | |
| Auditing | 298 | |
| Web Authentication | 299 | |
| LDAP Authentication | 299 | |
| Certificate-Based Authentication | 300 | |
| Web Server-Based Authentication | 303 | |
| Configuring Apache Authentication | 305 | |
| Servlet Container Authentication | 310 | |
| Basic Authentication | 310 | |
| Digest Authentication | 313 | |
| HTTPS Client Authentication | 314 | |
| Form-Based Authentication | 314 | |
| Tomcat Security Interceptors | 317 | |
| Project 8-1 | A Custom Tomcat Security Interceptor | 319 |
| Project 8-2 | Enhancing Our Login Pages | 323 |
| The Elements of Our Security Solution | 326 | |
| The Login and Login Error Pages | 326 | |
| The web.xml File | 327 | |
| The CustomRealm Security Interceptor | 328 | |
| The server.xml Configuration File | 332 | |
| Mastery Check | 333 | |
| 9 | Controller and Flow Control in Web Applications | 335 |
| Controller | 336 | |
| User Input Processing | 336 | |
| Interaction with the Model | 339 | |
| Web Application Workflow and Flow Control | 339 | |
| Simple Flow Control | 348 | |
| Project 9-1 | Address Book Search | 354 |
| Advanced Flow Control: The Struts MVC Framework | 372 | |
| Final Thoughts | 374 | |
| Mastery Check | 376 | |
| 10 | Integrating a Database | 377 |
| The Role of External Content Sources | 378 | |
| Managing Large Amounts of Content | 379 | |
| Centralizing, Securing, and Sharing Content | 380 | |
| Providing Dynamic Content | 381 | |
| Accessing Legacy Information Systems | 382 | |
| The JDBC Data Access API | 385 | |
| The JDBC Architecture | 385 | |
| JDBC Basics | 387 | |
| JavaServer Pages and the JDBC API | 398 | |
| Project 10-1 | Using Jakarta DBTags | 401 |
| The Family Center Data Model | 405 | |
| Entity Types | 405 | |
| Attributes | 407 | |
| Relationships | 408 | |
| Project 10-2 | Adding Security to the Family Center | 411 |
| The Family Center Data Access Approach | 413 | |
| The Bridge Pattern | 413 | |
| Mastery Check | 426 | |
| Part III | Appendices | |
| A | Mastery Check Answers | 429 |
| Module 1 | Introduction to Internet Technologies | 430 |
| Module 2 | JSP Elements: Comments and Directives | 431 |
| Module 3 | JSP Elements: Scripting Elements | 432 |
| Module 4 | Implicit Objects | 435 |
| Module 5 | Standard Actions | 437 |
| Module 6 | Tag Libraries | 440 |
| Module 7 | JSP Architectures | 442 |
| Module 8 | JSP Security | 445 |
| Module 9 | Controller and Flow Control in Web Applications | 448 |
| Module 10 | Integrating a Database | 449 |
| B | Creating a Development and Deployment Environment | 451 |
| Web Servers and Containers | 452 | |
| Apache and Tomcat | 453 | |
| Installing Tomcat | 454 | |
| Starting and Stopping Tomcat | 455 | |
| Web Applications and the WAR Format | 456 | |
| The WAR Directory Structure | 458 | |
| Creating a WAR File | 459 | |
| The Web Application Deployment Descriptor | 459 | |
| Web Applications in Tomcat | 461 | |
| Installing Apache | 461 | |
| Connecting Apache and Tomcat | 464 | |
| Configuring Tomcat (Answer to Question 3) | 465 | |
| Installing the Adapter (Answer to Question 2) | 467 | |
| Configuring Apache (Answer to Question 1) | 468 | |
| C | Creating a MySQL Database | 471 |
| Downloading MySQL | 472 | |
| Downloading a JDBC Driver for MySQL | 473 | |
| Installing MySQL | 474 | |
| MySQL Administration | 475 | |
| The mysqladmin Tool | 476 | |
| MySQL Structured Query Language | 477 | |
| MySQL Documentation | 479 | |
| D | New Features in JSP 1.2 | 481 |
| The Java 2 Platform | 482 | |
| The Servlet 2.3 Specification | 482 | |
| The XML Syntax | 483 | |
| Validation of JavaServer Pages | 484 | |
| Enhanced Tag Library Support | 484 | |
| Improved Support for Page Authoring | 486 | |
| Better Localization Support | 486 | |
| Fixing the "Flush Before You Include" | 487 | |
| Backward Compatibility | 487 | |
| Index | 489 |
Introduction
Introduction
Are you a student trying to understand the fundamentals of modern Web development? Do you wonder how JavaServer Pages (JSP) work together with HTML, Java servlets, and databases to build scalable Web architectures? Have you been looking for a clear, structured introduction to JavaServer Pages?Do you develop Web sites and wish you could improve the performance of your CGI scripts? Have you ever wanted to use program loops or variables directly in your Web pages? Do you grow weary of writing obscure Perl programs that exert much of their effort printing out static HTML?
Do you develop Java servlets to generate Web pages? Do you yearn for a more natural way to write dynamic pages? Do you seek a clean way to separate programming language constructs from HTML elements?
Do you develop Active Server Pages (ASP) and hope to create Web sites on non-Microsoft platforms? Do you think there is a market for your skills on UNIX?
Are you interested in design patterns and wonder how you should apply them to Web architectures?
If you answered yes to any of these questions, this book is for you! The JavaServer Pages technology was developed by Sun Microsystems, Inc. Most obviously, the technology provides a better way to write dynamic Web pages. Web page development must often include both static HTML and dynamic content in its pages. Suppose, for example, you want to target the content of a page specifically for the person accessing the page. Most of the page provides the same look-and-feel for every person who accesses it. But some part of the page pulls content from a database tailored by user demographics or a pre-established login identity. Amazon.com, for example, provides a welcome message with a user's name and targeted advertisements. How might we imitate Amazon.com?
Traditional CGI development uses a programming language, probably Perl or C/C++, to create a program that prints out large amounts of static HTML interleaved with responses from database queries. Even Java servlets (a companion Java technology) follow this basic paradigm; the only difference is that servlets live in a process thread, while Perl scripts execute as standalone processes. JavaServer Pages invert this approach, starting with static HTML and interleaving "tagged" Java code into the static HTML. The fact that the Java code is "tagged" is important-it means there is a clear separation between HTML and code. Consider the following JSP fragment (don't worry about the details right now): This JSP fragment consists of two Java code sections and an HTML section. The point to notice is that we insert both HTML and Java using tags. Of course, what goes between the Java tags is more complicated than what goes between the HTML tags, but we will show later on in Modules 5 and 6 how even Java scripting can be simplified using JSP.
Now look at this servlet code fragment doing the same job performed by the JSP fragment: This servlet fragment buries static HTML in a Java println function call. The little piece of HTML shown here is comprehensible, but it is easy to see how confusing such statements can become. The problem lies with the inability of servlets to separate Java code from static HTML. It is the same problem when using Perl or C/C++ CGI scripts. JavaServer Pages solve this problem.
Prerequisites
We target this book at students and beginning Web and Java developers who seek a clear introduction to fundamental JSP concepts and techniques. While some of the material is difficult, we fill the book with examples, tips, and explanations that make it accessible to Web developers and programmers with modest experience. We address Java servlet programming in the context of JSP application architectures and in general provide what we believe is the necessary background information to use javaServer Pages effectively. Still, we assume and require some familiarity and experience with programming languages, preferably Java. We also assume some familiarity with the Internet.Structure of the Book
We divide the book into three parts:Part I lays the technical foundations for building JavaServer Pages, focusing on syntax elements and their appropriate use. We divide Part I into six modules addressing the foundations of Internet technologies and each of the specific elements of JavaServer Pages.
Part II introduces fundamental aspects of practical JSP development and focuses on the issues and techniques necessary to build "real-world" JSP applications. We divide Part II into four modules addressing common software patterns in Web architectures, Web security, application workflow, Ind integration of databases. By using such patterns, Web developers can create Web applications more quickly with fewer errors.
Part III provides four appendices supplying ancillary information supporting our basic discussion.
Part I-JSP Foundations
Module 1 presents the broader world of Web technologies. It first describes the core architectural elements of Web application development, the Hypertext Transport Protocol (HTTP) and basic client-server issues. Then it provides an overview of the client and server technologies that extend the functionality of Web browsers and Web servers to support "real-world" applications. At the end of Module 1, you will understand the general universe of Web technologies.Module 2 narrows the focus to two JSP syntax elements, comments and directives, and their appropriate use in Web applications. Module 2 also describes the basics of a JSP page and lays the foundations for good programming style. At the end of Module 2, you will have built and displayed your first simple JSP page.
Module 3 describes JSP scripting elements. We showed a few examples earlier in this Introduction. In Module 3 we describe scripting elements in detail and begin to build more complex JSP application elements. At the end of Module 3 you will be able to build complete JSP applications that exploit Java to script dynamic content.
Module 4 describes implicit objects in JavaServer Pages. These objects provide a framework for passing and using information between the parts of a JSP application. At the end of Module 4 you will have built a JSP page that interactively responds to an HTML form.
Module 5 describes standard JSP actions. JSP actions function as callouts (external references) to Java functionality. Among other things, standard actions provide a simple mechanism for incorporating helper JavaBeans in one's application. At the end of Module 5 you will be able to incorporate JavaBeans into your JSP application, thereby improving its style and professionalism.
Module 6 presents custom JSP actions. Such actions provide one of the most powerful features of the JSP architecture. When writing custom JSP actions one is really extending the JSP engine itself. At the end of Module 6 you will have built your first such extension to the JSP engine.
Part II-Building Real-World Applications
Module 7 begins our discussion of some major aspects of "real-world" application development using JavaServer Pages. It introduces software patterns and their application to JSP architectures. We pay special attention to these patterns:- Model-View-Controller (MVC)
- Mediator
- Command
- Strategy
- Bridge
Module 8 addresses security issues. We describe some of the common security techniques used in Web architectures, including those required by the Servlet 2.2 specification. Module 9 describes issues surrounding application workflow-the control and movement from page to page in a JSP application.
Module 10 addresses the role of databases in JSP architectures. We describe the JDBC data access API. Then we describe various techniques required to integrate a database into a JSP application.
Part III-Appendices
The appendices provide ancillary information supporting the rest of the book. Appendix A provides answers to special Mastery Check questions posed at the end of each module. Appendix B explains how to create and deploy a Web server and JSP environment. We concentrate on the Tomcat implementation of the Servlet and JSP containers and on the Apache Web Server.Appendix C describes how to set up and configure a MySQL database. This database engine is free and provides a fine platform for personal development projects.
Finally, Appendix D describes the changes that occur between the current JSP specification JSP 1.1) and the proposed final daft of the JavaServer Pages 1.2 specification.
Special Features
Each module includes Hints, Tips, Cautions, and Notes to provide additional reference information wherever needed. Detailed code listings are included in gray boxes, many times with certain tags or features highlighted with further explanation.Most modules contain Ask the Expert question-and-answer sections to address potentially confusing issues. Each module contains step-by-step Projects to give you a chance to practice the concepts taught thus far. You can download the content for the projects from Osborne's Web site (www. osborne. com).
Mastery Checks are included at the end of all modules to give you another chance to review the concepts taught in the module. The answers to the Mastery Checks are in Appendix A.
Notational Conventions
At several points, we present formats derived from formal specifications. When we do so, we use the following conventions:- We display all literals in courier font: literal.
- When we treat collections of elements as a single unit, we display them in parentheses: (elementl element2).
- We indicate zero or more instances of an element using an asterisk: (elementl element2)*.
- We indicate an optional term between brackets: [element].
- We indicate a carriage return character followed by a line feed character using the hyphenated sequence: CR-LF.
- We indicate symbolic elements such as variables or placeholder names using italics: element.
- We indicate environment variables in courier font, capitalized with `%' signs around the variable (Windows notation): %TOMCAT HOME%.
- We indicate directory names, relative paths, and file names in courier font using the backward-slash character for a file separator (Windows syntax): %TOMCAT HOME%\webapps\Book.
- We indicate Java Class names, interface names, and method names using italics: HelperBean.getProperty.
Other Readings
- 1. Alexander, C., S. Ishikawa, and M. Silverstein. A Pattern Language. Oxford University Press, 1977.
2. Alexander, C. The Timeless Way of Building. Oxford University Press, 1979.
3. Alur, Deepak, John Crupi, and Dan Malks. Core J2EE Patterns: Best Practices and Design Strategies. Sun Microsystems Press, Prentice Hall, 2001.
4. Berners-Lee, Tim, with Mark Fischetti. Weaving the Web: The Original Design and Ultimate Destiny of the World Wide Web by Its Inventor. Harper San Francisco, 1999.
5. [DBTags] http://jakarta.apache.org/taglibs/doc/dbtags-doc/l*ntro.html
6. Gamma, Erich, Richard Helm, Ralph Johnson, and John Vlissides. Design Patterns: Elements of Reusable Object-Oriented Software. Addison-Wesley Publishing Company, 1995.
7. Geary, David. "JSP Templates." Java World, September, 2000. http://www.javaworld.com/javaworld/jw-09-2000/jw-0915-jspweb_p.html
8. Lea, Doug. "Christopher Alexander: An Introduction for Object-Oriented Designers." SUNY Oswego/NY CASE Center, December, 1993. http://g.oswego.edu/dl/ca/ca/ca.html
9. [MySQL] http://www.mysql.com
10. [Struts] http://jakarta.apache.org/struts/index.html
11. [Taglibs] http://jakarta.apache.org/taglibs/index.html
12. [Tomcat] http://jakarta.apache.org/tomcat/index.html