JSP: A Beginner's Guide

JSP: A Beginner's Guide

by Gary Bollinger (Conducted by)


Choose Expedited Shipping at checkout for delivery by Thursday, December 2


Learn to deliver dynamic content to Web pages using JavaServer Pages. The ideal introduction to this server-side scripting language, JSP: A Beginner's Guide first covers the building blocks, such as JSP syntax, scripting elements, implicit objects, and tag libraries. You'll then learn how to build solid JSP architectures, create real-world Web applications, implement application security measures. and integrate a database into your JSP architecture. Get started working with JSP right away with this self-paced, step-by-step learning solution.

Related collections and offers

Product Details

ISBN-13: 9780072133196
Publisher: McGraw-Hill Companies, The
Publication date: 09/01/2001
Series: Beginner's Guides Series
Pages: 532
Product dimensions: 7.50(w) x 9.25(h) x 1.07(d)

About the Author

Gary Bollinger is Chief Product Architect and co-founder of Artesia Technologies. He is the author of several articles appearing in JavaPro and JavaReport magazines. He has several undergraduate and graduate degrees in literature, computer science, theology, and a Ph.D. in philosophy. He also has 15 years' professional experience programming RPC, CORBA, and J2EE architectures. He loves his dogs.

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
Helper Applications Browsers do not know how to handle most format types they encounter on the Web. This is partly because so many format types exist and partly because new format types keep appearing. Browsers compensate by launching other applications based on media format. For example, a browser may not handle Real Video files but can be configured to launch the Real Player application to handle a Real Video download.

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.

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 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.

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
Oak was renamed Java by April of 1995. (See Chris Rose's article, "It's the World Wide Web, But Not as We Know It," in PowerPC News: Apt Data News Ltd, 1995, Issue Number 534, UG534-17. Also see http : / / j ava. sun. com/ pr/1995/04/pr950417-01.htm1.)

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

Part IJSP Foundations
1Introduction to Internet Technologies3
The Internet as a Client-Server Architecture4
Network Transparency Issues5
Stateful Servers7
HTTP Servers Are Stateless8
HTTP Requests9
The Request Line9
Message Headers14
Message Body14
HTTP Responses15
The Status Line15
Message Headers16
Message Body17
The Rest of the Story17
Project 1-1Echoing the HTTP Protocol18
Client-Side Web Programming23
Extending the Web Browser25
The Role and Limits of Browser Technologies30
Server-Side Web Programming31
Extending the Web Server34
The Role of Java Servlets and JavaServer Pages38
Project 1-2Running Your First JSP Program39
Mastery Check41
2JSP Elements: Comments and Directives43
The JSP Container44
JSP Stages45
JSP Scope46
JSP Constructs48
Bird's-Eye View of a Complete JSP Page49
JSP Comments50
Using Comments50
JSP Comment Types52
JSP Directives54
The include Directive55
Project 2-1Include Directive Test60
The page Directive62
Project 2-2Page Directive Test69
The taglib Directive70
Mastery Check73
3JSP Elements: Scripting Elements75
The Three Scripting Elements76
How the Container Translates JSP Scripting Elements77
JSP Declarations81
Variables in a JSP Declaration82
Methods in a JSP Declaration82
Declarations of Advanced Java Features83
More About JSP Declarations84
JSP Expressions87
More About JSP Expressions90
JSP Scriptlets91
Variables in Scriptlets91
Expressions in Scriptlets92
Conditionals in Scriptlets92
Iteration in Scriptlets94
Advanced Java Features in Scriptlets95
Exceptions in Scriptlets97
More About JSP Scriptlets98
Project 3-1Scripting Elements100
Mastery Check104
4Implicit Objects107
The request Variable109
Request Services110
The response Variable119
Response Services120
Project 4-1Streaming the Contents of a File126
The pageContext Variable129
PageContext Services130
The session Variable134
Session Services135
Project 4-2URL Redirection and URL Includes137
The out Variable140
Out Services141
The application Variable145
Application Services146
The config Variable155
The page Variable156
Page Services156
The exception Variable157
Exception Services158
Mastery Check159
5Standard Actions161
JSP Actions162
Standard Actions Versus Custom Actions162
Tag Attributes163
The id Attribute164
The scope Attribute165
The [left angle bracket]jsp:useBean[right angle bracket] Action166
Attributes and Usage Rules167
Processing Steps167
Using [left angle bracket]jsp:useBean[right angle bracket]170
The [left angle bracket]jsp:setProperty[right angle bracket] Action173
Attributes and Usage Rules174
The Two Variants of [left angle bracket]jsp:setProperty[right angle bracket]175
The [left angle bracket]jsp:getProperty[right angle bracket] Action178
Attributes and Usage Rules178
Using [left angle bracket]jsp:getProperty[right angle bracket]179
The [left angle bracket]jsp:include[right angle bracket] Action180
Attributes and Usage Rules181
Using [left angle bracket]jsp:include[right angle bracket]181
The [left angle bracket]jsp:forward[right angle bracket] Action182
Attributes and Usage Rules183
Using [left angle bracket]jsp:forward[right angle bracket]183
The [left angle bracket]jsp:param[right angle bracket] Action184
Attributes and Usage Rules184
Project 5-1A Simple Shopping Cart185
The [left angle bracket]jsp:plugin[right angle bracket] Action190
Attributes and Usage Rules191
Mapping an Applet to a [left angle bracket]jsp:plugin[right angle bracket]192
Project 5-2Inserting a Menu Applet193
Mastery Check196
6Tag Libraries199
Why Define Custom Tags?200
Elements of a Tag Library206
Tag Library Formats206
The taglib Directive207
The Tag Library Descriptor207
Tag Handlers212
Life Cycle of a Tag Handler225
Defining Scripting Variables227
The TagExtraInfo Class227
Defining the Scripting Variables230
The Recommended Convention for Defining Implicit Objects233
Project 6-1Defining Implicit Objects234
Exchanging Data Between Actions and Tag Libraries239
Ids and the PageContext Object239
The Runtime Stack240
Project 6-2A Template Using a Tag Library242
Mastery Check251
Part IIBuilding Real-World Applications
7JSP Architectures255
Patterns in Application Development256
The Idea of Patterns256
The Utility of Patterns258
Architectural Patterns259
Application Tiers260
Splitting the Presentation Tier264
Web Application Architectures264
Object-Oriented Software Design Patterns267
Project 7-1Gallery Viewer277
The Application: A Family Center285
Mastery Check287
8JSP Security289
Basic Application Security290
Web Authentication299
LDAP Authentication299
Certificate-Based Authentication300
Web Server-Based Authentication303
Configuring Apache Authentication305
Servlet Container Authentication310
Basic Authentication310
Digest Authentication313
HTTPS Client Authentication314
Form-Based Authentication314
Tomcat Security Interceptors317
Project 8-1A Custom Tomcat Security Interceptor319
Project 8-2Enhancing Our Login Pages323
The Elements of Our Security Solution326
The Login and Login Error Pages326
The web.xml File327
The CustomRealm Security Interceptor328
The server.xml Configuration File332
Mastery Check333
9Controller and Flow Control in Web Applications335
User Input Processing336
Interaction with the Model339
Web Application Workflow and Flow Control339
Simple Flow Control348
Project 9-1Address Book Search354
Advanced Flow Control: The Struts MVC Framework372
Final Thoughts374
Mastery Check376
10Integrating a Database377
The Role of External Content Sources378
Managing Large Amounts of Content379
Centralizing, Securing, and Sharing Content380
Providing Dynamic Content381
Accessing Legacy Information Systems382
The JDBC Data Access API385
The JDBC Architecture385
JDBC Basics387
JavaServer Pages and the JDBC API398
Project 10-1Using Jakarta DBTags401
The Family Center Data Model405
Entity Types405
Project 10-2Adding Security to the Family Center411
The Family Center Data Access Approach413
The Bridge Pattern413
Mastery Check426
Part IIIAppendices
AMastery Check Answers429
Module 1Introduction to Internet Technologies430
Module 2JSP Elements: Comments and Directives431
Module 3JSP Elements: Scripting Elements432
Module 4Implicit Objects435
Module 5Standard Actions437
Module 6Tag Libraries440
Module 7JSP Architectures442
Module 8JSP Security445
Module 9Controller and Flow Control in Web Applications448
Module 10Integrating a Database449
BCreating a Development and Deployment Environment451
Web Servers and Containers452
Apache and Tomcat453
Installing Tomcat454
Starting and Stopping Tomcat455
Web Applications and the WAR Format456
The WAR Directory Structure458
Creating a WAR File459
The Web Application Deployment Descriptor459
Web Applications in Tomcat461
Installing Apache461
Connecting Apache and Tomcat464
Configuring Tomcat (Answer to Question 3)465
Installing the Adapter (Answer to Question 2)467
Configuring Apache (Answer to Question 1)468
CCreating a MySQL Database471
Downloading MySQL472
Downloading a JDBC Driver for MySQL473
Installing MySQL474
MySQL Administration475
The mysqladmin Tool476
MySQL Structured Query Language477
MySQL Documentation479
DNew Features in JSP 1.2481
The Java 2 Platform482
The Servlet 2.3 Specification482
The XML Syntax483
Validation of JavaServer Pages484
Enhanced Tag Library Support484
Improved Support for Page Authoring486
Better Localization Support486
Fixing the "Flush Before You Include"487
Backward Compatibility487



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.


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
We also mention other patterns, but spend less time on them. These include factory, interceptor/filter, and callback.

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.
Throughout the development of this book, our objective has always been to provide you with a cohesive, easy-to-understand guide for coding JavaServer Pages that helps you get up and running in no time. We applaud your decision to learn JavaServer Pages and encourage you to use the Internet to its fullest potential, both during the learning process and in your ensuing Web application development. Have fun and good luck!

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

Customer Reviews