Customer Reviews

JavaServer Pages, 3rd Edition

5 star:		(7)
4 star:		(2)
3 star:		(2)
2 star:		(6)
1 star:		(1)

 

 

I bought this book hoping to learn enough of JSP/Servlets to create an e-commerce website.

My impression after reading this book is that the author tries very hard to please both beginners and intermediate developers. To this extent, he winds up pleasing no one.

Quite often he tells "advanced programmers" to jump ahead and read a later chapter. This didn't make the book flow very well. This book gives a lot of JSP code, but skimps on the code when it comes to Beans, which are critical elements to the examples. I assume the author expects the reader to download the Bean code from O'Reilly's website and decipher the code by themselves. Because of this incompleteness, I was not able to completely grasp the ideas behind the examples. It would've been better if the author included the Bean code along with the supporting JSP code. By not providing code for them, Beans are treated like a "black box" throughout this book.

The last gripe I have about this book is the author's inordinate amount of use of "..." in the code examples. Quite often in listing the codes, he would throw the three dots. Again, this renders the examples in the book almost useless to those trying to type in the code for themselves to learn.

A more thorough and coherent book for learning about JSP and Servlets would be "Core Servlets and JavaServer Pages" by Marty Hall and Larry Brown.

Coverage is okay, but the book assumes so little knowledge that it is very frustrating for an experienced web developer who just wants to add JSP to his toolbox. It spends quite a while in the middle of chapters on such basic programming knowledge as using parentheses to change the order of mathermatical operations and using "!" as a logical negator. It also explains from scratch HTML concepts like relative and absolute links, and basic form elements.

If the book were better organized, these basic concepts might have been explained in introductory chapters which one could skip (if they were even included in the first place - it seems to me that anyone who needs these things explained isn't ready to be learning JSP, though I could be wrong). But since they're embedded in the middle of JSP discussion it is hard to just skip them - and I often find myself skimming over new material simply because I've gotten into the habit.

It's not a bad book, but it needs to be better targeted at an audience of a specific skill level. For an O'Reilly book it's very disappointing.

O'Reilly falls down on its usual excellent editorial job and delivers an undisciplined unstructured mess that is useless as a reference. The JSTL examples are so incomplete as to be virtually worthless. As an experienced developer, I spent my 45 bucks expecting a useful reference and practical guide, instead getting a beginner's tour and some appendices of jstl syntax spec.

There is some really good information in this book. The problem is, you have to wade through a mess to find it. The author is constantly referencing chapters later in the book, suggesting that the reader look ahead for information on the subject currently being talked about. Much of the information in later chapters should have been included earlier on. Besides the annoyance of having to read ahead to keep up with the current subject, the author goes back on himself constantly. Examples are shown as a functional way to do things, and then later on, I found myself being told not to follow the methods explained previously because they arent an efficient way to work. On top of this, the language of the book seems overcomplicated. Simple concepts are explained in a long drawn out fashion left me wondering where I had lost my way.

I am picking things up that I wouldn't have figured out without the book, but I'm quite convinced that another book would have had me writing applications already.

Perhaps this is as good a user guide as is possible for JSP, which is a good, but not great techology.

JSP integrates between web markup user interfaces (usually HTML) and back-end java technology (usually servlets), and best practices have most of the interesting work done in these technologies, not in JSP. JSP's flaws come from too many spurious features that lead the unsuspecting user far away from best practices.

JSP's strengths as a template technology for web view markup come in its 2.0 version with its addition of programmatic logic to markup (JSTL for logical branches and loops, and tags for subroutines) which allow for development of markup without repeated code. This is a great benefit of JSP, and this book does a fairly good job of explaining it for JSTL/logic, but talks around it with confusing examples for tags/subroutines. To this book's credit, it is the only decent reference I have found for JSP 2.0 tag library development.

Best practices with JSP as an integration technology involve what is called "Model 2 MVC" where the JSP page is strictly used only as a template for markup (the "view" which is the "V" from "MVC"), a JavaBean is used for the M-"model" and a single servlet is used for the C-"controller". This concept is mentioned in this book, but its up to you to figure out how to implement it, and the book is full of examples that show off unrealistic uses of JSP's spurious features and are anything but best practices. At some point in using JSP's and servlets, you are going to have to go head-to-head (actually, head-to-confusing-XML) with a real deployment descriptor, and this book will give you little help as to why it doesn't work.

Until someone writes a truly useful reference for JSP and servlets, you will have to follow the time-honored tradition of finding an example that works and cut-and-pasting it into your web application. Poring over this book will help some, as will poring over Craig McClanahan's online doc that comes with Tomcat. The best book I've found so far for explaining best practice design with JSP is Rod Johnson's "expert one-on-one J2EE Design and Development" (read the chapters on web-tier MVC design and views in the web tier) though it's description of JSP is somewhat dated, and it won't help you out with implementation details.

I started reading "JavaServer Pages, 3rd Edition" hoping to get a good grasp of JSP.
After 3 days I was wondering why I was still confused about JSP.
Then I started reading the JSP chapter in "Java Servlet Programming, 2nd Edition by Jason Hunter" and suddenly everything made sense. I am *much* more comfortable with the coverage of JSP in "Java Servlet Programming, 2nd Edition". The JSP chapter in "Java Servlet Programming, 2nd Edition" is much more logically organized, and easy to follow.
"JavaServer Pages, 3rd Edition" may have all the correct information, but I found the organization of the book to be confusing.

Contents
This book covers JavaServer Pages (JSP) technology and standards. The chapters are as follows:
Part 1 - JSP Application Basics - Introducing JavaServer Pages; HTTP and Servlet Basics; JSP Overview; Setting Up The JSP Environment;
Part 2 - JSP Application Development - Generating Dynamic Content; Using JavaBeans Components In JSP Pages; Using Custom Tag Libraries And The JSP Standard Tag Library; Processing Input And Output; Error Handling And Debugging; Sharing Data Between JSP Pages, Requests, and Users; Developing Custom Tag Libraries As Tag Files; Accessing A Database; Authentication And Personalization; Internationalization; Working With XML Data; Using Scripting Elements; Bits And Pieces;
Part 3 - JSP In J2EE And JSP Component Developments - Web Application Models; Combining JSP And Servlets; Developing JavaBeans Components For JSP; Developing Custom Tag Libraries Using Java; Advanced Custom Tag Library Features; Integrating Custom Code With JSTL; Data Access Strategies;
Part 4 - Appendixes - JSP Elements References; JSTL Actions And API Reference; JSP Expression Language Reference; JSP API Reference; Book Example Custom Actions And API Reference; Web Application Structure And Deployment Descriptor Reference;

Review
So, you're surfing a web site and hit a web page that ends with the extension .jsp. Looks like a regular web page to you, and if you view the source, it still looks like regular HTML. So what is a .jsp page, anyway? This book will tell you everything you need to know, both as to what they are, how they work, and how you can start using the technology in your development projects. Provided you have a basic understanding of Java, this book will work well for you.

The book starts off with an explanation of what JSPs are and why you would use them. Basically, it provides a way to generate dynamic web pages using snippets of Java code. Logically, it's much like ActiveServer Pages (ASP) code as provided by Microsoft, only using Java instead of Visual Basic. It then goes into the benefits of generating content in this fashion, and how it's a superior method to other technologies such as CGI and ASP coding. The rest of the book then goes into great detail (with a large number of examples) on the specifics of JSP syntax. The author does an excellent job of meshing the approach of a tutorial with actual detail that can be referenced after you start developing applications.

The author assumes the use of the Tomcat J2EE server package to learn JSP technology. Tomcat is a free download from www.apache.org, and it's easy to load and configure. But don't despair if you are using a different web server. The examples are very generic and portable, and with very little effort you can adapt the information to whatever platform you use. In my case, I was using the Websphere platform and had no problems using that server to work my way through the book.

By getting the 3rd edition of the book, you'll learn about the latest versions of the JSP 2.0 specification, as well as the JSTL specification (version 1.1). These were both released in late 2003, so you are getting the latest and greatest as far as the information goes. Since the author was involved in developing the JSTL standards, he has replaced many of his custom examples with the new standard components that are now part of the language. This is extremely important in that you will be learning core language features as you work your way through the book, instead of how the author had to work around deficiencies in the spec.

Conclusion
If you want to keep moving along in the Java-based IBM/Lotus world, servlet and JSP technologies are in your future. While you may not need it right now, you WILL need it. I highly recommend this book as a great starter text on the subject that will grow with you as you learn and work with JSPs.

If you are looking for a quick cookbook this should not be your choice. If you want to learn JSP in depth, buy it right now. Hans guides you from the basics to comprehensive details of JSP technology in a very structured way.

In any case, (from my point of view) JSP is not the whole jigsaw for building web applications, it's just a piece of it. So don't expect to be able to build real web applications if you just have read this book. At least, consider reading also Java, Struts/MVC and SQL.

Very recently (late 2003), Java Server Pages underwent a major official upgrade to Version 2. In part, this was driven by success. The sheer popularity of Version 1, which dates from 1997, also let to many ideas for improvements. Bergsten devotes the bulk of this book to explaining these. Some of you who coded with Version 1 and used earlier texts may notice the heft of this, compared to those.

Look, there is one immediate reason, as explained by Bergsten, why Version 2 is better than Version 1, and why you should migrate, presumably with the help of this book! If you wrote JSPs, like me, then your java code is generously littered with out.println(), wherein are strings with HTML tags. We can all appreciate Version 1 for its power and ingenuity in making dynamic web pages. But that interleaving of java and embedded HTML looks kludgy. (It is!) But aside from aesthetics, it scales badly with the size of the website you are supporting. And it is hard for you, the developer, and the HTML page designer to interact.

The key innovation is how Version 2 lets you separate the java and HTML far more cleanly. Not a complete refactoring, perhaps. But close enough to justify you investing some time in moving to it. The payoff should be considerable.

How does Version 2 do this? Well, you should read the book to find out.

This is one of the best technical books I have read. Bergsten wrote an in-depth, exhaustive tour of JavaServer Pages and the MANY related technologies, and it never once put me to sleep. It actually kept me up a few nights, but I'm a nerd like that.

For those of you new to web development, this book takes a slow and gentle approach to teaching you JSP. You will not only learn how to setup an environment and use JSP to build simple to moderately complex web applications; Bergsten filled his book with more best practices, pitfalls, supporting information, and general wisdom than I could have possibly hoped for. Taking his words to heart will set you well on your way to being a more solid, knowledgeable developer than most developers I've ever met.

For experienced developers, this book is a very fast read with a flowing style. Bergsten attacks every concept from a handful of angles to ensure complete coverage of the subject matter, so if you understand his meaning quickly, you can generally fly right by. I enjoyed reading this book so much that I rarely found myself flying over anything. The appendices are very useful as a reference, and if you're anything like myself, your copy will be filled with dog ears and highlighter.

In general, I don't hold high opinions for recent technical books. They are, in my experience, mostly superficial and lack any measure of depth. This book has set the bar as far as I'm concerned, being packed with content and wisdom without reading like an encyclopedia. Having said that, it's not without its faults.

To begin with, nobody should be fooled into thinking that using any of the JSP technology stack is NOT programming, and Bergsten tried to fool the reader far too many times. Using JSP, JSTL, and building tag libraries with either method is very much programming, and should be thought of as such. I think it does a disservice to reassure non-programmers that they don't have to learn Java or programming in general to work with JSP. That is how horrible code gets written, folks. Suffice it to say, if you're new to programming, accept that you're learning to program and absorb what you can!

In the later chapters, Bergsten's treatment of MVC was a bit off on a number of points. Views (the V in MVC [Model View Controller]) are defined as having direct access to Model objects, which creates a "template" with a lot more power and responsibility than the spirit of MVC denotes, if not eschewing the definition entirely. However, this idea of MVC fits very well with the power-hungry nature of JSP as a templating language, so I understand why it was stated that way. Just be aware, Bergsten / JSP's definition of MVC is not the same MVC you're likely to find in common MVC frameworks today. Also, the few MVC examples used bits of Struts, and I wished they wouldn't have. MVC is not that difficult; an extra page of code could have done a lot to illustrate and demystify the concept.

Another issue, albeit a small one, is that the editor appears to have taken a nap between pages 100 and 200. The code and spelling issues are slight, but there are a mess of them. (Cue Muphry's Law)

Finally, having said all that: I don't recommend this book. I have come to believe that JSP is a very confused technology, and should be avoided if you have a choice in the matter. Learn a nice framework like Rails, Cake, Django, CodeIgniter, Pylons, etc. instead, and save yourself a few hundred headaches and finger cramps. If you HAVE TO learn JSP as I did, then this is definitely a great book that will significantly help you on your way.

Even though I have such a strong distaste for JSP, I still give this book 5 stars. It was incredibly written and compiled. If I am ever in the position to write a tome on some technology, I will plan to model it after this book. It is that good (in my humble opinion).