Customer Reviews

Web Development with Java Server Pages

5 star:		(53)
4 star:		(19)
3 star:		(7)
2 star:		(4)
1 star:		(3)

 

 

This is presently, one of two better books on JSP. The other book is "core servlets & jsp" by M. Hall. Hereby, I will compare these two books:

1. I like the clarity of Hall's book. Hall expained everything very well although he did not touch as much depth as Fields & Kolb. Fields & Kolb's book was also well written, although a little on the verbose side; but it has the advantage of reaching further in depth: for example, the use of token handling to prevent re-execution of critical requests when the users push refresh...

2. The code examples in both books are excellent and worked very well. Again, Hall's examples lack some depth. For example, the databases examples are pretty poor and another key examples such as the Travel Agency examples are not as nearly as complete. Fields & Kolb's examples, some of them probably require more of your attention, reach far more in depth. I particularly like the examples on databases and customtags, expecially the examples on FAQ which is really outstanding.

My conclusion is the two books complement each other pretty well and you should buy both. And forget about those wrox books which are often an horror when it comes to testing the code examples. And you know, in programming, without good codes, you don't learn much!

If you are new to Java Server Pages this is the book to start with. It covers the basics on JSP construction, bean creation and connection and how work with data bases. There is a section on how to architect JSP applications to make their construction easier.

The book is full of easy to understand examples. They range from the simple "hello world" to the complex (and useful) FAQ manager.

There is also in-depth coverage on how to build your own custom tag libraries. Until now you needed to wade into the Sun Java docs, this book makes custom tags painless.

If you are serious about JSP / XML combinations, this is the book to get started with.

Just finished reading this excellent book. I believe this is one of the best well-written books ever since Java came into existence. The things I liked about this book are:

- The authors spent a lot of time explaining the fundamentals of JSP in detail, thereby providing a very good foundation.

- The chapters "Architecting JSP application" and "An example JSP project" have been very useful for me. In fact, I am using the concepts and examples presented in these chapters for a project that I am working on.

- The tips, notes, and warnings throughout the book are very useful in applying JSP technology in the real world.

- The support sites, author-online at the Manning web site are available for us to ask questions to the authors and also for discussion on JSP. I have personally found these sites to be extremely useful.

I hope to see the following things in the next version of the book:

- An exclusive chapter on the fundamentals of servlets and how it ties with JSP.

- An exclusive chapter on how JSP and EJB can work together - A real world "non-trivial" example will certainly help.

- I would also like the authors to address some of the concerns that Jason Hunter (Author of JAVA servlet programming, by O'Reilly) listed on his site,

I read through this book in a week and I must say it is very well written. The concepts of JSP are well explained with an appropriate depth for a JSP application developer. I especially like the part when it explains the servlet-centric design. With this design model we shall be able to create large Web application with complex workflow, because we can implement an automata in the center servlet and use multiple JSPs to provide interaction with end-users. Personally I feel it very hard to understand JSP before you understand servlet. Thus I will advise any reader of this book to read some Java servlet documentation or code some Java servlets before you touch JSP or this book. It will be even better if the example in this book has a login page, a necessary component in a lot of JSP applications. Fortunately, you can find some solutions for that from the Net, so don't worry.

I can't say enough good things about this book.

We were given the task of building a JSP project and knew nothing about the technology. This one book gave us everything we needed to understand the JSP specification from Sun. It was truly all we needed.

The book is very well written and easy to follow. The authors have done an excellent job of explaining peripheral issues associated with JSP (i.e. Servlets, EJBs, etc.).

The book also contains a ton of code samples that covers a variety of different solutions.

If you're getting ready to start a JSP project or want to master the JSP technology from Sun, look no further than this book. You won't be disappointed!

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.

It's very hard to find a book that covers the most current technology accurately. This book is the only one that focus 100% on JSP and the latest 1.1 specifications. The chapters on writing custom tag libraries are worth the price alone. It also covers the basics of JSP development for beginners too.

JSP tutorials come mostly in books dedicated to other broader subjects such as Java on the server. With this book, a concise and clear treatment of this new technology makes it possible to see why there is so much potential in JSP. It shows how to greatly benefit from it.

This book covers JSP very well. My only gripe as with all Servlet/JSP books is that it does not cover MVC and the database access architecture in enough detail. The book provided a decent example, but I am waiting for a book that solely focuses on designing and implementing large scale JSP/Servlet/JDBC systems.

This is not just another JSP book. Rather, it is a complete presentation tier design book covering JSP architecture, JSP design, Servlets, and JavaBeans. As with other Manning books I have read and reviewed, this book is complete, and leaves no stone unturned. This book is very well written, and easy to understand. The authors have added tips and tricks, and they interject "real-world" notes throughout the book. The coding examples are clear, concise, and fit well with the concepts described. I found so much useful information in this book I was marking almost every other page.

The book starts out with a review of other dynamic content techniques (CGI, ASP, Cold Fusion, etc.), which gives the reader a context in which to place the JSP technology. After a somewhat slow start, the book really picks up speed and gets into the guts of JSP and Servlet architecture. Topics such as session management, buffering, and exception handling are covered in great detail, with issues and alternatives introduced. I was very impressed with how the authors introduced these concepts and applied them to the technology in a clear and concise manner. There is an entire chapter devoted to the JSP directives and scripting elements, which I also found very complete and full of clear and relevant examples. The treatment of JSP implicit objects (request, response, session, out, page, etc.) was also very clear and easy to understand. It is here that you will see a big difference between this book and others; in this book the authors not only explain these concepts, but also illustrate how and why they are used in the overall picture.

One recommendation I would make is to read chapter 8 on JavaBeans before reading chapter 7 on the JSP component model. It seemed to me that these chapters are somewhat out of order. I thought that the chapter on JavaBeans (chapter 8) was the best chapter in the book, and gave the cleanest explanation of the role of JavaBeans within the overall presentation tier architecture I have read to date. The scope of this chapter was perfect for the context of the book, and the examples were very clear and understandable. For me, this chapter cleared up questions I had regarding the difference between JavaBean components and value objects.

One thing that impressed me about the JDBC section was that the authors presented and discussed many real-world issues such as techniques for handling large result sets and creating persistent result sets. The following chapter then discussed the overall presentation tier architecture, including page-centric design and Servlet-centric design (dispatcher design). Within this section the authors once again presented real-world issues, limitations, and design considerations within each of these two presentation tier designs.

Chapter 11 is devoted exclusively to building a sample app from the information learned in the previous chapters. I went through the example, and thought it was clear, and in sync with the information and content previously presented. I saw this chapter as ending what I call "part 1" of the book. The chapters following this one were more advanced, and a little more difficult to follow. For example, I felt that the treatment of listeners and filters, which covered several chapters in the book, was useful material, but the authors dove straight into code rather than spending enough time on the concepts. However, the chapter on JSP deployment with WAR files was extremely thorough, and covered all aspects of WAR files and JSP deployment.

The section on cookies, error handling, and shopping cart processing was great. However, the chapters after that (Chapters 17 and 18) seemed very out of place in the book. I did not find these particular chapters useful at all. However, the treatment of JSP custom tags, which spanned 3 entire chapters of the book, was the best coverage of this topic I have seen.

The book is full of all sorts of goodies at the end, including changes in the JSP specification, installing and configuring Tomcat, a very extensive JSP reference listing, and a JSP syntax and API reference.

Whether you are a JSP novice or a presentation tier architect, I would highly recommend this book. After reading it I found it is valuable as a learning tool and a quick reference. Without hesitation I give this book a big thumbs up.