Ten JSP technology books compared

Document options Document options requiring JavaScript are not displayed Rate this page Help us improve this content

Level: Introductory

John Zukowski (jaz@zukowski.net), President, JZ Ventures, Inc.

01 Jun 2001

Back in September 2000, Java guru (and book author) John Zukowski reviewed six of the early JSP technology books to hit the shelves. Now, he revisits the review with 10 new offerings -- fresh volumes that explore JSP development -- all to ask the question, "Are the original favorites still the best way to learn JSP or do the new guides deliver a better lesson?"

JavaServer Pages (JSP) technology is closing in on its third major release (not counting those versions widely used before number 1.0), and the instructional guides to help you past the learning curve just keep on coming. The number of books on JSP technology is pushing 30.

It has been about nine months since my initial review (see Resources) -- an eternity in the technology arena -- and the importance of JSP technology has grown. Many developers have asked me for an update to the review, so here it is.

The methodology

Given the large number of books available, I had to limit the number of books to review. I got the total down to 10 by employing the following guidelines:

• I did not include books I have already reviewed.
  
  
• I chose only one book per publisher imprint. For instance, JSP: JavaServer Pages and JSP, Servlets, and MySQL are both from M&T Books. When multiple books were available from an imprint, I picked the more introductory book.
  
  
• When there were multiple books from the same publisher, but with different imprints, like JavaServer Pages Application Development from Sams and Special Edition Using Java Server Pages and Servlets from Que, I reviewed both, even though they were both coming out of the Macmillan family of imprints.

The 10 books that made the cut are (in alphabetical order):

1. Core JSP by Damon Hougland and Aaron Tavistock (Prentice Hall, 2000)
   
   
2. Java Developer's Guide to Servlets and JSP by Bill Brogden (Sybex, 2000)
   
   
3. JavaServer Pages: Fast & Easy Web Development by Aneesha Bakharia (Prima, 2001)
   
   
4. JavaServer Pages by Hans Bergsten (O'Reilly, 2000)
   
   
5. JavaServer Pages: Your Visual Blueprint to Designing Dynamic Content with JSP by Paul Whitehead (Hungry Minds, 2001)
   
   
6. JavaServer Pages Application Development by Ben Forta, et al. (Sams, 2000)
   
   
7. JSP: JavaServer Pages by Barry Burd (M&T, 2001)
   
   
8. JSP: The Complete Reference by Phil Hanna (McGraw Hill, 2001)
   
   
9. Professional JSP (2nd ed.) by Simon Brown, et al. (Wrox Press, 2001)
   
   
10. Special Edition Using Java Server Pages and Servlets by Mark Wutka (Que, 2000)

In the next section of this article, I'll review each book individually. For an at-a-glance comparison of the books, see the quick comparison guide.

Fast-track to the reviews The following books are listed in descending order based on my rating of a possible five stars. JavaServer Pages (* * * * 1/2) Intro/intermediate. Targets page designers and Java developers with appropriate modes of presentation for each. Professional JSP (* * * * 1/2) Intermediate/advanced. This second edition is 33 percent larger, well updated with coverage of both JSP 1.2 and Servlet 2.3 additions. Coverage of JSP and servlets concepts is exemplary. Special Edition Using Java Server Pages and Servlets (* * * * 1/2) Intermediate/advanced. Focuses on building large-scale, multi-tier business applications by mixing JSP and servlets with EJB, CORBA, and RMI. Excellent for taking you into the realm of creating real-world applications. JavaServer Pages: Fast & Easy Web Development (* * * *) Introductory. For Java and JSP development, this book takes a visual approach with screen dumps. Some example mismatches. JavaServer Pages: Your Visual Blueprint to Designing Dynamic Content with JSP (* * * *) Introductory. A well-structured visual presentation for the neophyte. Good references; servlets sections are a bit disappointing. JSP: The Complete Reference (* * * *) Introductory/intermediate. A thorough, large book with some in-depth examples. code, tables, and flow charts. JavaServer Pages Application Development (* * * 1/2) Introductory/intermediate. Insufficient to teach HTML developers enough to use JSPs; fairly good for Java programmers. No JSP 1.2 coverage (as implied on cover). JSP: JavaServer Pages (* * * 1/2) Introductory/intermediate. Full of source code, it teaches by example with a little language basics. Higher level than basics, but short of servlet and J2EE usage examples. Core JSP (* * *) Introductory. Somewhat unclear and some coding errors. Java Developer's Guide to Servlets and JSP (no rating) Intermediate. Designed to demonstrate how to use servlets and JSPs; not meant to teach JSPs.

Back to top

The reviews

Beside each book's title is a star rating, based on the book's overall coverage of JavaServer Pages technology. One star equals a poor rating, while five stars indicate exceptional coverage. The books are arranged in alphabetical order in this section; if you want to view the books arranged by ratings, see the sidebar "Fast track to the reviews." Links to more information on all the titles are located in Resources.

Core JSP

Damon Hougland and Aaron Tavistock, Prentice Hall, 2001
$42.99, 416 pp., ISBN 0-1308-8248-8
The Core JSP book by Hougland and Tavistock is an introductory book that walks you through the basics of JSP development. Roughly the first half of the book explores such JSP fundamentals as scripting elements, actions, directives, sessions, and JavaBean connectivity. The second half explores J2EE aspects and custom tag extensions.

The explanation of fundamentals isn't bad, but there are some problems. Reading through the book, I'm not sure what to believe. In some places they state one thing (like all action elements have two attributes, id and scope), which they later contradict (a few pages later they talk about the include action, which uses neither).

The book also contains capitalization errors. For example, four times on one page the authors talk about the serializable interface, written with a small s. Had I not known the difference, I'd have been confused.

The coverage of some topics, such as error pages, is rather lacking (approximately one page long in this case). I'm curious what the technical editor did while reviewing, as there are the occasional coding errors, too -- even in the second printing.

The second half of the book moves into J2EE coverage beyond JSP and servlets. The JDBC coverage isn't bad, describing (Oracle) connection pools and how to create a JavaBeans component to generate HTML tables from queries, among other tasks.

The XML chapter has the reader generate XML from JSP through a JDBC query, then combine it with an XSLT style sheet to generate the HTML output.

Beyond this level of coverage though, there's only a page or two mentioning EJBs, a quick JavaMail introduction, and a minimal JNDI bean with little setup information on how to add a user for the authentication page created. I'm still looking for the dozens of non-trivial programs mentioned on the cover.

One thing different about most of the examples in Core JSP is that the authors used Cascading Style Sheets (CSS). While there is nothing wrong with using them in JSP pages, I think their usage in the book detracts from the JSP explanation. Sure, there is the one- or two-page explanation of CSS in the book, but picking up on the CSS details won't teach you JSP. Had the target audience been identified earlier I wouldn't complain, but the gist of the book seems more for the Java developer interested in JSP development, than the Web designer who wants to add JSP to their toolkit.

Likes: Fundamentals explanations; JDBC coverage.
Dislikes: Conflicting descriptions and definitions; capitalization inconsistencies; some topic coverage insufficient; occasional coding errors; too much CSS.

Java Developer's Guide to Servlets and JSP

(No rating)
William Brogden, Sybex, 2000
$49.99, 432 pp., ISBN 0-7821-2809-2
Bill Brogden's Java Developer's Guide to Servlets and JSP is one of three books included here that are meant more to demonstrate the proper usage of servlets and JSP together instead of focusing on using JSP alone. Because this book isn't really meant to teach you JSP, I didn't give it a rating.

Brogden's book takes a servlets-first approach to Web site development, before introducing JSP, revealing the main focus of the book early.

The JSP introduction covers the basic syntax and implicit variables in about 30 pages. The introduction includes the history of JSP versions, JavaBean connectivity, error page handling, and the XML version of the JSP tags. I didn't notice anything wrong with the content, but for someone new to JSP development, I found the coverage a little light.

Moving beyond the JSP introduction, the book examines several concepts in the context of servlets, with limited JSP coverage. First is cookies and session tracking. There is a JSP example, but there is more HTML in quoted strings within JSP expressions than good design calls for. The chapter on generating dynamic content talks about dynamic image and sound generation, but the JSP aspects are limited to doing little more than what a JavaScript page can do, leaving the bulk of the work to the servlets.

The J2EE aspects covered beyond JSP and servlets are light and somewhat focused on using them from servlets with little mention of JSP. The XML usage introduces SAX and DOM, but doesn't touch XSL. The EJB coverage has no source whatsoever, just essentially introducing the terminology.

The JDBC chapter has a nice SQL and JDBC introduction, talks about JDBC and servlets, but has no example to help clarify the discussion. There's even an RMI example for a chat servlet server.

The only other chapter that provides JSP-specific coverage is on custom tag libraries. This chapter covers the necessary skills for creating custom libraries, even going so far as to include a JSP page that demonstrates XSLT processing of a JDBC query result. Overall, not too shabby, though it could have used a little more descriptive text.

This book isn't intended to teach you JSP. Yes, the basics are there, but you'll be disappointed if you get this book solely to learn about JavaServer Pages development.

Likes: The chapter on custom tag libraries.
Dislikes: JSP coverage light; too much HTML in quoted strings within JSP expressions; servlet-heavy instructions.

JavaServer Pages: Fast & Easy Web Development

Aneesha Bakharia, Prima, 2001
$29.99, 480 pp., ISBN 0-7615-3428-8
Bakharia's JavaServer Pages: Fast & Easy Web Development is certainly not your typical JSP book. First, its aim is to teach you Java programming, not just JSP development. Second, you will not see page after page of text with code blocks. Instead, most pages are full of screen dumps (usually of an editor) with numbered callouts designed to walk you through the important aspects of either the source or screen dump. This type of visual approach is definitely a welcome change to the typical book flow, though it isn't as well structured as the JavaServer Pages: Your Visual Blueprint to Designing Dynamic Content with JSP book I review later on.

Because the book introduces Java programming in addition to JavaServer Pages technology, Web designers or programmers new to Java development are in luck. (You do need some programming background to get through the book.) There are even step-by-step instructions for setting up the Java 2 SDK (JDK), your CLASSPATH, and Web server (JRun).

The first 125-or-so pages introduce you to JSP concepts, but are primarily about teaching the basics of the Java programming language -- elements such as methods, classes, operator precedence, and exception handling.

After the Java language introduction, the chapters change to more JSP-specific content, though Java programming basics, like file I/O for the guestbook, are mixed in. The form-handling section has you send JavaMail, and the creating dynamic images discussion with the JPEG codec talks about the coordinate system, how to draw shapes, and the different color constants. Bakharia does everything she can to properly set the stage.

The JDBC coverage is surprisingly deep and detailed. While definitely Windows-centric, with the step-by-step System DSN setup for Access, it goes all the way though connecting, querying, and updating to using the CachedRowSet in the JDBC Optional package to spread query results over multiple pages. And, if you're not 100 percent familiar with SQL, you'll get a reasonable SQL introduction, too.

The book also explores XML, basic Servlet-JSP integration, and creating custom tag libraries. The servlet integration content is on the light side, but the XML and tag library chapters are better. For instance, the XML chapter has you generate an XML document from a database query and throw the results through XSL, while the tag library chapter also includes coverage of some of the JRun-specific tags. The book ends with two complete examples of an employee phone directory and an online store.

One noticeable problem is the occasional misplaced image. I had to stop and scratch my head a few times before realizing the problem. Also, there is the occasional mismatch between screen dump and text, like the wrong content type for the generated Excel spreadsheet.

Likes: Takes a shot at a visual approach; introduces the overall concepts of Java programming; mixes JSP with Java basics; deep JDBC coverage; reasonable introduction to SQL; good coverage on XML and custom tag libraries.
Dislikes: Visual instruction approach unstructured; Windows-centric; servlet-integration instruction light; misplaced image and screen dump examples.

JavaServer Pages

Hans Bergsten, O'Reilly, 2000
$39.95, 572 pp., ISBN 1-5659-2746-X
The aptly named JavaServer Pages book by Hans Bergsten tries to target both Web-page designers and Java developers. It does this by recommending that most of the Java code go into components and tag libraries, leaving the page designer with little Java code in the pages.

The book is divided into three parts (with five appendices). The first part is meant to provide an introduction to the basics of JSP development, and while it explores some JSP code, you don't learn how to apply it. By the end of the section, you'll have a working development environment, with a Java Development Kit and Tomcat installed, including instructions for both UNIX and Windows platforms.

In the second part, you'll immediately notice the author's different approach to explaining the technology. The first example showing the current date and time treats the java.util.Date class as a bean, instead of just displaying the results of new java.util.Date(), which is the way it's done in many of the other books.

The second example uses a bean component again, getting all the attributes into a bean with the * property. The remainder of the section uses a similar approach, minimizing the raw Java code in the .jsp files. This is most obvious in the book's database connectivity chapter where there is no JDBC introduction and all the JDBC code is hidden in a tag library.

I also appreciated (as I'm sure you will, too) the coverage of internationalization (dealing with Shift-JIS input and display), application-controlled authentication, and transforming XML to HTML through XSLT (though no parsing with SAX or DOM parsers).

In the third part, the book shifts to programmer mode. Page designers can get the source for the components used earlier, but I suspect they'll prefer to just download them and not bother compiling each themselves. The Java developer, however, will get a good grasp of the basic Web-application model, will learn about combining JSP pages with servlets, and will develop JavaBeans and custom tag libraries.

Part 3 is also where you get the JDBC introduction, with the development of the database access tag library.

Overall, this book provides good instruction of JSP technology; it just presents the concepts in a different -- and in my opinion, a better -- way.

Likes: Designed for both the Web designer and the Java developer; promotes good code-placement design practices; multi-platform coverage; well-structured, starting slow and building on earlier lessons; some unique approaches to characterizing JSPs, minimizing raw Java code in .jsp files; good coverage of internationalization, authentication, and XSLT.
Dislikes: None of mention.

JavaServer Pages: Your Visual Blueprint to Designing Dynamic Content with JSP

Paul Whitehead, Hungry Minds, 2001
$26.99, 290 pp., ISBN 0-7645-3542-0
This book provides a nearly unique approach to teaching JavaServer Pages technology to the neophyte. Like Bakharia's JavaServer Pages: Fast & Easy Web Development book, you get a visual introduction to JavaServer Pages.

Unlike the Bakharia book, the visual presentation of this Hungry Minds title is well structured. The majority of the content is explained in two-page spreads where the bottom half has four screen dumps, with numbered callouts pointing out the featured concept. Above the left two figures, the specific concept is described in about 200 words. Above the right two figures are either code fragments or extra tips to explore the concept in a little more depth.

The first two chapters (about 50 pages worth) introduce you to object-oriented programming, have you install a Java Development Kit, and help you get started with the Java programming language. You won't become a Java programming expert from the introduction, but if you are completely new to Java programming, you'll get a better grasp of the Java constructs before jumping into JSP development.

The remainder of the book covers JSP essentials, starting with installation of the Tomcat Web server. Concepts like expressions, declarations, and directives are each explained in a two-page spread. Implicit objects are also explored in a similar way, listing all of them at once, then examining each one separately, usually over a two-page spread. Some steps take only one page, and others jump to four if you consider creating and reading as one task.

Like the other concepts in the book, the JavaBeans coverage starts with the basics. Not only are you taught how to use JavaBeans within JSP pages, but the author also explains what properties are and how to create them. There is coverage of indexed properties, too, but, unfortunately, it's wrong. An indexed property's basic getter method needs to return an array, not a single element. And that single element shouldn't have converted the array of elements into HTML; that's the job of the JSP page.

The book's JDBC coverage ranges from setting up the Access DSN to basic connection, retrieval, and updates. You even get to work with scrollable result sets, stored procedures, and batch updates. I had two disappointments here, though. The book did not clearly explain how to fill the initial database, and there was no coverage on splitting results over multiple pages.

The remainder of the book describes using error pages and creating a tag library, and introduces servlets. The servlets content was a real disappointment -- 10 pages of isolated usage, not connecting to JSP technology at all.

One other worthwhile feature was the eight-page reference illustrating the differences between JSP and Active Server Pages (ASP) features -- a useful addition for anyone transitioning to JSP development from ASP.

Likes: Well-structured visual-presentation approach; encourages user to explore concepts in as much depth as they prefer; delivers good introduction to Java constructs for beginners; eight-page ASP-to-JSP transition reference.
Dislikes: Error in indexed properties entry; servlets coverage limited.

JavaServer Pages Application Development

Ben Forta, Sams, 2000
$49.99, 416 pp., ISBN 0-6723-1939-X
According to the introduction of JavaServer Pages Application Development, this book will teach you JSP technology "even if you have no Java experience whatsoever." If the target audience of the book is the HTML developer, as the introduction claims, the book is an utter failure when compared to the other books in this review that target that same audience.

This book's attempt to introduce the Java programming language to HTML developers is insufficient; a non-programmer would not develop adequate skills to use the Java language within JSP pages. For instance, the first exposure to Java programming is three versions of the generated Java source behind a JSP page. Having never seen Java code before, the HTML developer doesn't care what it looks like behind the JSP pages and will more likely than not find this information confusing and irrelevant.

The second exposure to Java coding talks about importing classes and packages. The typical HTML developer doesn't have sufficient proficiency in Java programming to understand these concepts. There's even a note about using an asterisk to import all the classes in the package, but again, this is information that will probably slip right over the head of non-programmers. Yet another challenge is requiring the reader to install the JDK and Web server sans instruction.

Target audience aside, this book can teach you about JSP development, if you're already comfortable with basic Java programming. You'll get the typical explanation of JSP syntax and implicit objects, and details on working with sessions, connecting JavaBeans components to JSP, and using JDBC (though there is no mention of JDBC 2.0 capabilities). There's even a chapter on securing your application with LDAP and the capabilities introduced with the Servlet 2.2 API (using the web.xml file). You also learn about the JavaMail API, create a custom tag library, and explore (in a surprisingly good introduction) Enterprise JavaBeans technology.

Two other items are worth mentioning, one positive and one negative. The authors use CSS and JavaScript in a manner that keeps the JSP pages uncluttered, in included files. This is a nice feature that keeps the focus on the JSP aspects of the examples. Also, don't be fooled by the cover's mention of JSP 1.2 coverage. It's a mistake.

Likes: Fairly good JSP reference for those comfortable with basic Java programming; author use of CSS and JavaScript follows good coding practices.
Dislikes: Insufficient coverage to teach non-programmers (the book's target); erroneous claim of JSP 1.2 coverage.

JSP: JavaServer Pages

Barry Burd , M&T, 2001
$29.99, 425 pp., ISBN 0-7645-3535-8
This book provides an introductory look at JSP development a level higher than the visual books discussed earlier, but not quite at the level of the books that show you how to use JSP with servlets and other J2EE technologies. Full of source code, JSP: JavaServer Pages teaches you JSP development by example with some language basics thrown in.

The book is divided into four parts. Part one covers the basics of JSP scripting, with reasonable coverage of scripting elements, implicit objects, directives, and actions.

The beans chapter in part two isn't bad either; though it, too (like the Hungry Minds title reviewed earlier), has an incorrect description of indexed properties.

The JDBC coverage in part three includes a description of the basics of JDBC and using a scrollable result set, but doesn't bother with displaying paginated results.

Finally, in part four there is a chapter on deployment and another on creating customized tags, which is probably what I liked best.

The book also includes four case studies -- full-blown working code examples -- one for each of the above-mentioned sections. You get a simple Web portal built on basic scripting code, a multi-player tic-tac-toe game for JavaBeans, an online message board for JDBC, and a Web shopping cart based on custom tags. In general, the examples are good, though in a more typical environment servlets would be doing more of the work.

Likes: Basics and beans coverage satisfactory; good coverage of deployment and creating customized tags; examples are satisfactory.
Dislikes: Level of instruction between that of basic and higher levels; incorrect description of indexed properties.

JSP: The Complete Reference

Phillip Hanna, Osborne-McGraw Hill, 2001
$49.99, 876 pp., ISBN 0-0721-2768-6
At more than 800 pages, Phil Hanna's JSP: The Complete Reference is one of the larger JSP books reviewed here. If you consider books written by a single author, it is the largest. And it's quite an accomplishment.

The book takes you through the birth of The Lyric Note Web site, starting with an introduction to servlets before moving into the inner workings of JSP development. You'll find the content full of lengthy tables, code blocks, and figures -- including flow charts.

The JSP coverage starts off with a conversion of the servlet example, before changing focus to describe the syntax and semantics of JSP technology. The concepts are described one-by-one along with the generated Java servlet source. The concept of showing the generated source is nice, but gets old after awhile. All the standard elements, including session tracking, are described reasonably well without going into too much depth on any one part.

Of the more advanced concepts, JSP tag extensions are explored first, followed by JDBC a few chapters later. I mention the order primarily because the tag library created deals with JDBC queries and displaying the results. If you hadn't seen JDBC before, you'd probably want to swap the order of the chapters to follow the discussion. The JDBC coverage includes JDBC 2.0 features like scrollable result sets, batch updates, and updatable result sets. Unfortunately, the row set coverage is limited to a half page description, instead of a working example.

The XML coverage is without a database, but does have you parse input with SAX and DOM as well as use XSL transformations.

A large chunk of the book is a case study of a product support center for the hypothetical Internet music store. No shopping cart example here, but a rather in-depth problem-submission system, with lots of code.

The book's main body covers the Servlets 2.2 and JSP 1.1 APIs. However, there are appendices that cover the newer 2.3/1.2 APIs. The appendices are, unfortunately, only an API reference though, with no descriptive text on what they are and how to use the new features.

Likes: Concepts defined with generated source running alongside; standard elements described well; lots of code; in-depth description of product-support system for online store.
Dislikes: Too many generated-source examples get tiring; chapters describing advanced JSP tag extensions and JDBC would have made better sense if swapped in order; no database with XML coverage.

Professional JSP

(2nd ed.)
Wrox Press, 2001
$59.99, 891 pp., ISBN 1-8610-0495-8
The shelf life of Java technology books is decreasing rapidly. The second edition of this book is 33 percent larger than the first and with only six of the original authors.

The book is updated with new content on the preliminary Servlet 2.3 and JSP 1.2 specifications, and seems to give both technologies equal billing, even though the title only mentions JSP.

The introductory content is available for servlets as well as JSPs. Starting with installation instructions for Tomcat 4.0 (beta), the reader is given an extended view of the basics of both technologies with information on nearly everything including pre-loading servlets, internationalization, and pre-compilation of JSP files.

The one topic noticeably lacking coverage is the servlets/JSP threading model; there's no discussion of what happens when you implement SingleThreadModel or set the isThreadSafe page directive.

The book, however, really shines in its coverage of the more advanced JSP concepts. For instance, approximately 150 pages focus on creating custom tag libraries, including coverage of the new InsertionTag. The XML coverage includes a little bit of everything, from SAX, DOM, JAXP, XSL, XSLT, and XPath, explored in many of the examples, not just the XML chapter. The JDBC coverage provides a reasonable JDBC introduction and adds JDBC 2.0 information on connection pooling and distributed transactions. There's even a WAP example, an EJB-based shopping example, and coverage of generating binary content, like PDF files and SVG images. The JSP for ASP developers appendix also is in this edition.

Topics unique to this book include the Servlets 2.3 capabilities like filtering and application events. There's also a chapter on the Jakarta Struts Framework.

Likes: Equal, bonus coverage of Servlet 2.3, as well as JSP 1.2, technology; excellent, complete, extended views of technology basics; coverage of advanced concepts just as comprehensive.
Dislikes: Lacks coverage of servlet and JSP threading model.

Special Edition Using Java Server Pages and Servlets

Mark Wutka, Que, 2000
$39.99, 768 pp., ISBN 0-7897-2441-3
The Special Edition Using Java Server Pages and Servlets book is the only one of the bunch that consistently, and incorrectly, expands the JSP acronym. Given that in the first review article, one of the six books had it wrong, you might think that one in ten isn't bad, unless you're that one.

Assuming you can get past the acronym problem, the book itself is pretty good. Divided into five sections, the book's focus is on creating large-scale business applications by mixing JSP development and servlets with EJB, CORBA, and RMI to create multi-tiered applications.

Sure, the first 275 pages introduce JSP basics like directives, interacting with JavaBean components, and communicating with servlets. However, the remaining 335 pages (excluding appendices) are what sets this book apart from most others.

Similar to Marty Hall's Core Servlets and JavaServer Pages, this book takes you into the realm of creating real-world applications, using the cooperating technologies of JSP and servlets where necessary.

If you're new to JavaServer Pages, you'll appreciate the introductory JSP coverage mixed with introductory servlets material. The two concepts are described in pieces, as you need them, instead of lumped together in one place. However, if you are looking for a quick API and syntax reference, see Appendix A for JSP and Appendix B for servlets.

Despite the basic level of the introductory material, I get the impression that the book is meant for someone interested in moving beyond the basics of JSP (and servlets). For instance, not only do you get the standard shopping-cart example, but you get an extra example application for communicating with wireless devices. There are some internationalization issues explored, too, as well as a discussion dealing with role-based security.

Also, if you're into generating dynamic images from servlets and JSP, you'll find some useful coding techniques, from changing the width of a simple image to generate a bar chart, to dynamically generating JPEG images with the com.sun.image.codec.jpeg package.

All in all, this book is a nice resource for the serious Java developer interested in developing with the full J2EE architecture.

Likes: Demonstrates how JSP technology plays in real-world systems with a host of other technologies; coverage of advanced servlet and JSP issues is complete.
Dislikes: The introductory section and the following sections seem like two separate books.

Back to top

The quick comparison

Tables 1 and 2 offer a quick overview and comparison of the characteristics of the 10 books.

Table 1. Comparison/overview of JSP books (the first five)

Table 2. Comparison/overview of JSP books (the second five)

Back to top

The last page

The overall quality of JSP books seems to be improving. There are so many of them out there, though, it's hard to pick just one book for everyone. It depends on your specific needs and how much money you want to spend.

For those who already know Java programming and are looking for a pure-play JSP book, the M&T book ( JSP: JavaServer Pages by Barry Burd) isn't a bad choice if you like to learn mostly from code. O'Reilly's originally named JavaServer Pages book is probably your best bet. At only $39.95, it adds in a little bit of XML and servlet coverage, but focuses on the JSP tasks at hand, without trying to forcibly teach you by putting too much Java code in the JSP pages.

For the visual learner, the choices of JavaServer Pages: Fast & Easy Web Development and JavaServer Pages: Your Visual Blueprint to Designing Dynamic Content with JSP are both good. They work out well for those new to Java development and those interested in including Java source in the JSP pages. It is hard to say which of the two is better, but for only $3.00 more, I'd be inclined to take the Fast & Easy book.

If you want to learn how to work with JSP and servlets together, both Professional JSP and Special Edition Using Java Server Pages and Servlets work out well. While neither provides the depth of a JSP-specific book like the Web Development with JavaServer Pages favorite from the first review article, both should give Marty Hall's Core Servlets and JavaServer Pages book a run for the money on the cooperative technologies side. The Wrox book takes the approach of exploring more of the newer capabilities, while the Que book is heavier on integrating the J2EE technologies with the current release. You shouldn't be disappointed with either.

Resources

• Read the original JSP book review article (JavaWorld, September 2000).
  
  
  
  
• Get more information, including purchasing information, on all the books reviewed in this article:
  • Core JSP by Damon Hougland and Aaron Tavistock
  • Java Developer's Guide to Servlets and JSP by Bill Brogden
  • JavaServer Pages: Fast & Easy Web Development by Aneesha Bakharia
  • JavaServer Pages by Hans Bergsten
  • JavaServer Pages Application Development by Ben Forta
  • Special Edition Using JavaServer Pages and Servlets by Mark Wutka
  
  
  
• Get the source code for the following books in this review:
  • JavaServer Pages
  • JSP: The Complete Reference
  
  
  
• The jGuru JSP FAQ is an excellent JSP resource.
  
  
  
  
• This reference document on JSP provides a good basic look at the technology.
  
  
  
  
• This InfoCenter report explains the JSP life cycle, access models, file content, and support and delivers examples of the technology for the WebSphere application server.
  
  
  
  
• You can find the latest on JSP at the JavaServer Pages site.
  
  
  
  
• In "Generate dynamic XML using JavaServer Pages technology" (developerWorks, December 2000), Marshall Lamb shows how to build a JSP page as an XML document template that is "filled in" at request time using Java code embedded in the page.
  
  
  
  
• "Filtering tricks for your Tomcat" (developerWorks, June 2001) introduces you to filtering in Tomcat 4.
  
  
  
  
• Paul Monday takes a look at JSP 1.2 and outlines JSP technology's place in the coming Web services revolution in "JSP pages, evolving and contributing to Web services" (developerWorks, June 2001).
  
  
  
  
• Find more Java resources on the developerWorks Java technology zone. And if you're interested in finding more about XML, try the developerWorks XML zone.
  

About the author

		John Zukowski conducts strategic Java consulting with JZ Ventures, Inc. His latest books are Java Collections and Definitive Guide to Swing for Java 2 (2nd ed) from Apress. Contact John at jaz@zukowski.net.

Rate this page

Please take a moment to complete this form to help us better serve you. Did the information help you to achieve your goal? Yes No Don't know   Please provide us with comments to help improve this page:   How useful is the information? 1 2 3 4 5 Not useful Extremely useful

Back to top