Customer Reviews

Advanced JavaServer Pages

5 star:		(16)
4 star:		(4)
3 star:		(2)
2 star:		(1)
1 star:		(1)

 

 

I have several books on servlets and JSP, and while some of them are quite good (I would recommend Core Servlets and JSP or Web Development with JSP), none of them cover the advanced aspects of JSP that Geary's book does.

Geary starts with two excellent chapters on implementing custom tags, which includes a clear explanation of how body tags work, which was something I didn't really understand before reading this book. From there, Geary shows best practices for handling forms, implementing templates and the Model 2 architecture, event handling, internationalization, security, interacting with databases, and XML. The book concludes with a comprehensive case study that uses most of the concepts previously discussed in the book.

The best thing about this book, however, is that it shows you how to apply a number of design patterns discussed in the GOF book for servlets and JSPs. Those design patterns allow you to implement robust Web sites that are easy to maintain and modify. For example, Geary shows how to use the façade design pattern to handle forms and the memento pattern to retain form values. In what is arguably the most interesting chapter in the book (Templates) Geary shows how to use the Composite and Strategy design patterns to implement templates. Templates let you construct web sites with pluggable components, which makes those sites much easier to implement and, more importantly, modify. I have not seen templates covered in any other JSP book.

Finally, Geary's book is extremely well written -- it's authoritative and easy to read, contains a great deal of information that you won't find elsewhere, and unlike most technical books, does not contain a bunch of fluff. You won't find rambling discussions of things you already know, useless appendices that repeat what you can easily find in the javadocs, or long code listings that could be much shorter. Every page in Geary's book is packed with useful information that's presented clearly in a logical progression.

I've looked through probably every book under the sun (no pun intended) pertaining to the subject of JSP, and while there are some good things in many of them, I can't think of one that has as much useful information between the covers as Geary's book does. Unlike most of the books on the subject that describe what JSP can do, Geary's book is a thoughtful exposition of how best to do it.

His central theme is the use of custom tags to manage the complexity of JSP applications. His first 2 chapters describe how custom tags are built and used in web pages. But for my money, it is the 4 chapters following these that are the real highlight of the book, the ones dealing with HTML Forms, Templates, and the Model 2 Framework. These chapters provide really useful information for the architectural design of web sites using JSP technology. I found Geary's explanation of these subjects to be clear, concise, and complete - something I can't say about Sun's Blueprint book.

Finally, it was refreshing NOT to find the 'obligatory' appendixes with the entire Servlet and JSP APi at the end of Geary's book. Instead, there is just one lone appendix dealing with the subject of Servlet filters.

Advanced JSP is an incredibly useful book; it provides the essential design framework for implementing real-world JSP applications. Geary outlines three critical JSP architecture patterns: (1) a template-driven approach for structuring web page layouts; (2) a Model-View- Controller (MVC) framework to separate presentation and business logic; and (3) a custom-tag based pattern for controlling database access. The text and the examples are clearly written and illustrated; in explaining each concept, Geary starts with a straightforward example, and then effectively builds additional sophistication upon it.

As a project manager with my first JSP assignment, this book provided the key design principles. When I shared the book with my Java development team, they were even more enthusiastic; they shared the book with two other development teams who are going to incorporate his ideas. One senior Java developer indicated that if he had implemented Geary's framework on his previous JSP project, they could have written a much more robust application with 75% less code. Geary's design patterns take care of most of the application infrastructure; it will allow my development team to focus on coding business-specific components -- and not on the underlying "plumbing".

David Geary has written an excellent book on developing JSP websites with "modern" techniques. It explores the areas of JSP that are diverging from traditional web scripting environments: trends such as tag libraries and model 2 architecture (even providing an entire chapter devoted to developing a model 2 based framework, a perfect way to learn the concepts behind frameworks like Struts).

For those that want to develop large scale, maintainable web systems with J2EE and/or JSP, this is the book to reach for.

The basics of JSP are easy to learn for anyone familiar with HTML and Java but it is difficult to learn the many advanced features. This book covers the complexities of JSP very well and helps to make them simple and easy to understand.

The book starts with coverage of JSP custom tags, one of the most important features of JSP. HTML forms and JSP templates are covered next. The section on templates is extremely useful for those who wish to use pluggable components to build web sites. The best part of the book for me were the middle chapters which cover designing a Model 2 framework using servlets and JSP. The framework is generic and can be applied to any web site development effort. He then demonstrates how event handling can be used within the framework to provide internationalization, authentication, and form resubmission trapping. (Have your users ever created additional profiles by using the back button?) The next chapter demonstrates using custom tags to access databases. The author then shows different ways to process XML with JSP. The final chapter is a case study demonstrating all the techniques used throughout the book.

Code samples are found throughout the book and I had no trouble getting any of them to run in Tomcat. The tag libraries are provided as open source by the author and will be helpful for most developers. The book is very well written and will be useful for anyone interested in advancing their knowledge of JSP.

Excellent book. Once you know the basic fundamentals of servlets and jsps (highly recommend "Core Servlets and JavaServer Pages" by Hall and "Web Development with JavaServer Pages" by Fields, Kolb) you're ready for this book. Very in depth coverage of behind the scenes workings of jsp containers and how they interact with your jsps, beans, and custom tags. Covers life cycles of custom tags, which helped my understanding of them immensely. Great examples, and lots of coverage on how to use jsps effectively. Worth every penny. Between these three books, I've got everything I need to know about jsps covered.

Geary's book makes three key contributions: 1) explaining how application specific JSP tags enable a division of responsibilities between page designers and programmers; 2) demonstrating how to modularize page design and separate layout from content with his templates tag library; and 3) (most importantly) showing how to implement the Model-View-Controller architecture in a servlet environment. A must read if you plan on using Struts, the Apache MVC framework. Very well written and packed with great examples.

I would recommend this extremely well-written book to anyone who is seriously interested in J2EE architecture. If you have basic familiarity with server-side Java (servlets, JSP), Advanced JavaServer Pages will help you understand design patterns and strategies that are widely popular among experienced J2EE software developers, such as Model 2 Architecture or Composite View. The author provides a great tutorial on custom tags. The first two chapters: "Custom tag fundamentals" and "Custom tag advanced concepts" is all you need to start developing JSP custom tags. Whether you consider using an open source framework like Jakarta Struts, or writing your own, David Geary's book provides a great deal of insight and tons of carefully written source code. I am using his custom tags based implementation of the composite view pattern in my projects. By the way, the downloadable source code is very reliable. The book's case study, and all other examples, work "out of the box". It was very easy to switch the sample code from Cloudscape to MySQL and mmMySQL JDBC driver.

Geary states in the opening chapter that he was looking for another book to write, and this one was more "phoned in" than composed. Everything to extend you knowledge of Jsp is right here, except you need to download code that wasn't printed in the book, and the author spends but 5 paragraphs(!) on tag libraries out of more than 480 pages. For instance -- there are snippets of TLD info throughout the book, but then Geary refers to this absolutely emaciated section at the front as a guide to construction, or to review the downloads. For those of you (and this includes me) that like to work and code along with the book, creating workable pieces to a puzzle and then tackling an entire case history as you learn, this book will be a miserable failure. A little more coverage of the subject, more organization and a little more depth in areas such as modification of the WEB.xml files and TLD files would have been appreciated. I guess I'll buy the WROX JSP second edition book and hope that they did a better job than this book does.

What happened? David Geary’s books on the AWT and Swing are excellent and stand above all others. But this book was clearly rushed with numerous errors. For example, consider the EnforceLoginTag in Chapter 9. Geary's TLD defines the errorPage attribute as optional; however, if you don’t specify an error page, the custom tag fails miserable because Geary tries to set a null attribute on the session object (illegal by the API). This technical error is very hard to debug.

On the other hand, this book is full of great ideas. The material addresses how programmers are tackling real JSP issues in industry. The ideas alone will save you the... investment. Just be cautious of errors.