Rating: 
Summary: OK intro to JSP, but not for serious developers
Review: As noted in other reviews, this book provides a well-written, quick-read introduction to JSP, covering most of the basics. It doesn't go very deep on any topic. If you're just starting to explore JSP technology, this is a useful read. If you're a serious JSP developer (or about to be one!), this book isn't for you.
Rating: 
Summary: Excellent JSP book
Review: I at first bought the PDF version of this book, but I loved it so much that I also bought the printed version. It is an excellent book to use both as a learning tool and as a daily reference for the JSP programmer.
Rating: 
Summary: Gets at the heart of JSP's Philosophy
Review: This book really does a wonderful job of explaining the problems with JSP development (too tempting to put the code in the .jsp file) and emphasizes the solution: servlets + beans.It starts with a thorough introduction to the general JSP architecture and how the different objects relate to each other. There are lots of wonderful tables that help clarify things; I found myself flipping back to them quite often to get the relationships between all the implicit objects straight when I first started out. Once the authors have introduced you to what JSP is, they get to the real concept that makes JSP work: beans. The two chapters that focus on beans provide an excellent introduction and grounding for those unfamiliar with beans, and they make an excellent argument for using beans to cleanly separate the business logic from the presentation. They present the idea of building JSP components from beans quite clearly, and make it simple to udnerstand the power behind the approach. The middle chapters also argue for using a central controlling servlet to centralize the transition logic, and the FAQ example is a complete one that illustrates many of the littler details encountered with implement a tool in JSP that get missed in the overview chapters. I found myself referring back to it quite a lot, especially the discussion of centralizing the control transition logic in a servlet and utilizing the command pattern effectively. THe later chapters are a sort of hodgepodge of useful items. Chapter 10 give some helpful hints at understanding the WAR format, which is something I found quite confusing coming from a strong Perl CGI background. This chapter was a real benefit the first time I put together a complete appliation, as the examples answered many of the questions I had. The next two chapters are full of small examples of doing common tasks, and illustrating other subtleties of the JSP platform. They have a number of useful tidbits, but the overall usefulness of these chapters mostly depends on how often you will need to accomplish things like mailing from a JSP. Naturally, a lot of these examples that weren't necessarily JSP-specific could be found in other books, but it was definitely nice to have an example of one way to implement it in JSP ready and waiting. The last two chapters deal with the tag libraries. This is a very powerful mechanism of JSP, and these chapters require considerable study and tinkering to fully understand. The authors note that correctly used, JSP+beans+tags+servlets can make for an exceptionally-compartmentalized design. However, it does take some time to master and apply well. The appendices were mediocre. The one which deals with running Tomcat is already out of date (as can be expected). It is still somewhat useful, but the Tomcat manals are still an invaluable resource to getting an installation up and running. The applet appendix was a little short, but it is admittedly a short topic that is of little use to many developers. The resources & reference appendices were fair. The biggest problem with the reference section was the organization made it difficult to find items at times, and there wasn't quite enough information. As a result, I usually just resorted to looking things up in the chapters. It's worth noting the Index is pretty nice; I almost always find what I am looking for fast, and the extensive cross-referencing helped me find out all the information on a given topic. The most annoying problem with this book is the number of mistakes in it. Some of the chapters are littered with errors, though lots of them are merely English errors that don't affect the code. I could always figure out what was meant, however, it would have been nice for the editors to have spent more time on it. My only other complaint is that that tag library chapters weren't as clear to me as others were. YMMV. My favorite thing about this book was its lack of preaching about XML and patterns. They mentioned both, but the authors wisely refrained from lecturing the reader on the virtues of the two. Nearly every other Java book written these days makes it a point to show the patterns being used, and how XML is over-used here and here and here, as if the usage of XML and patterns in the software were a feature. Instead, the authors recognize that these are **implementation details** that can sometimes make for a cleaner implementation. It was refreshing to be able to read about and understand JSP, and not JSP & XML & Patterns all the time. Kudos to Fields & Kolb for writing an excellent text for beginners and intermediate JSP developers that still has some appeal to the advanced members of the crowd. The discussion of using the various parts of the JSP architecture (pages+beans+servlets+tag libraries, ESPECIALLY the discussion of beans) is the real shining star of this book.
Rating:
Summary: Clear explanations, sufficient examples
Review: The authors do a good job of maintaining a balance between using code listings and explaining topics. I find this writing style to be compatible with how I learn new technology. Specifically, they systematically provide the big picture by explaining JSP's overall relevance in Java technology. Then they break it down by going over the main parts of JSP architecture. If you're in a hurry to bang out some code to make your content more dynamic, reading the first four to seven chapters will get you going, depending on your specific needs. They're not big chapters. Starting with Chapter 8, the authors provide you with techniques and example applications. I haven't gotten all the way through the latter chapters, but it appears that you can refine your application of the technology here. I find the book's organization to be well thought out, which makes for more enjoyable reading.
Rating:
Summary: This book has helped me immensely in my work
Review: As a Java developer needing to get up to speed with JSPs, this book has helped me immensely. This book hits the perfect sweet spot of using thorough examples and explaining the technology to an audience that is presumed to be familiar with java technology. In addition, they do a wonderful job of explaining the overall picture of how JSPs, servlets, JavaBeans and even EJBs can all work together. This kind of attention to the big picture, while focusing effectively on JSPs is just amazingly well done. I'll stop raving about this book. In addition. I think that the Manning series of books are some of the best technical books out there and have replaced O'Reilly in my estimation.
Rating:
Summary: Good for beginner to Advanced
Review: Good book with lots of good information. I thought it covered the basics extremely well. Although, I think it is somewhat scattered for any kind of reference manual. The book gives you a good understanding of what JSP is about.
Rating:
Summary: Solid and easy to use guide makes JSP easier to do.
Review: This guide from Duane Fields and Mark Kolb is concise, to the point, and easy to read. They have excellent coverage of Custom Tags, which can be a tricky subject to cover. If you need to grasp JSP quickly, start here, and you won't be disappointed.
Rating:
Summary: Very nicely done
Review: A very good introduction to JSP. Very good examples of how to implement JSP with an emphasis on using good design patterns. I wish I would see that in more books.
Rating:
Summary: An excellent, in-depth book that covers more than the basics
Review: I'm going to start off with the summary paragraph. Those who just want this will be happy, and those who want my reasoning behind it can read on. As the title indicates, this is an excellent book. Just how good? I've ordered a copy for every member in my development team to use as a reference. The authors cover not just the basics, but all of the related material necessary to let you develop a fully functioning web application. They give lots of excellent, real-world examples that show how each element works, and show you how to put everything together in a clear and well thought-out manner. I've been coding JavaServer Pages for over six months now, but I was doing it by figuring out what I needed to know as the need arose. I happened upon this book at a conference I was attending, and after a quick check of the other reviews here, I bought it. I spent a week reading it from cover to cover, and I've learned far more than I had hoped to. The first few chapters of the book are devoted to covering the main elements of JSP -- the various tags, their parameters, and how each one works and how they can be combined. If that was all this book was, it would still be pretty good. What makes it excellent in my book and earns it the five-star rating is what comes in the following ten chapters. First there's a discussion of JavaBeans and the JSP bean tags. The authors give excellent examples of how beans can be used, what their limitations are in JSP, and why you don't have to strictly follow the JavaBeans specification when you're designing a bean for JSP use. Then the authors get into what I consider the real and most-important meat of the book -- how you use JSPs to build a web application. They provide several very useful and detailed examples that show the various ways in which JSP's can be combined with Java servlets and JavaBeans to create fully functional applications. The examples are real-world ones, based on work the authors did themselves, so you get to see practical application of the technology. Once the application is built, there is a brief (one chapter) discussion on the deployment of web applications using the new WAR (web application archive) packaging standard and the elements involved. They also go into an intro-level discussion of design patterns and how they can be used to fully realize the goal of JSP's -- the separation of business logic from presentation details. This discussion alone was worth its weight in gold to me, as I had heard about design patterns before but never really understood what they were or how they were used in relation to programming. The last two chapters of the book cover creating custom tag libraries. Because this technology is still somewhat in its infancy, there were only a couple of examples the authors could give, but again they do an excellent job and make very clear the limitations and obstacles that have to be overcome. We're getting ready to start trying to build a custom library for our web apps at work, and these two chapters are going to be very useful. As noted above, this book is a fantastic resource that anyone doing JSP development should have in their library.
Rating:
Summary: Awesome Book
Review: Easy to understand. I thought it was a great book on JSP. Great for Beginners too.
| 
