Customer Reviews

JavaServer Faces: The Complete Reference (Complete Reference Series)

5 star:		(9)
4 star:		(0)
3 star:		(4)
2 star:		(4)
1 star:		(2)

 

 

JavaServer Faces: The Complete Reference, by Chris Schalk and Ed Burns, is a once-and-for-all reference to JSF 1.1 and 1.2, covering almost anything and everything JSF-related.

Differences between JSF 1.1 and 1.2 are noted whenever they might occur. The book also has some very helpful and interesting design notes from the specification group to enlighten readers of why some choices were made or not made, so that the reasoning behind decisions is exposed.

The book has five sections: an introduction to the framework, extending JavaServer Faces, applying JSF (which addresses security, i18n, and testing/debugging), JSF tools and libraries (with coverage of the standard component library, the MyFaces JSF implementation, and configuration files), and a set of appendices covering the Faces Console (a third-party tool to help configure JSF), Shale, migration from Struts, and a set of third-party component libraries.

The first section starts off with a history of JSF, and quickly launches into an application - a simple registration application, complete with error checking, data validation, navigation, and a working UI. Along the way, the authors explain the concepts used so that readers don't get confused. The details are explained in enough depth that readers can see why something is being done without drowning them in excess detail about what's actually happening.

Each chapter builds on the previous one, and in this reviewer's opinion, most readers would be able to actually start applying JSF almost from the very beginning. An idea is hardly ever presented without a clear explanation of why readers would want to understand it, although the request lifecycle is explained in the third chapter. That said, the request lifecycle is very clearly explained and justified, so while it's not clear why it's presented so early at first glance, a quick scan reveals how important it is to JSF, and why understanding it is a core concept JSF developers should be aware of.

The section on extending JSF covers custom UI components, custom components without a user interface, AJAX components, and the use of alternative display technologies like Facelets. Having this information clearly expressed in print is very useful, and it's also fairly complete, with hardly any core functionality left unexplained or without examples.

The section on security is also useful, especially since it does a good job of explaining the servlet security model by design and then cleanly integrates it with JSF, through both container-managed security and application-managed security.

The only complaint I had about the book was that it was too short: the examples of the components in the various reference sections were not complete enough. In particular, the Tomahawk references (the MyFaces AJAX extensions) were slightly out of date (hardly the fault of the book authors) but also incomplete, which made using some of the Tomahawk extensions less pleasant. It doesn't help that the MyFaces documentation itself is not as complete as one would like.

It's a credit to the authors that, at the book's weakest, it's as useful as the official documentation, and at its strongest, is easily becoming the first reference reached for.

[...]

I really enjoyed reading this book. I have several JSF books, and I feel that most of them were rushed to the market. This one is an exception. The coverage is very comprehensive (the book is written by the spec lead), JSF 1.2 is extensively discussed. The book covers multiple open-source "sub-frameworks" for JSF such as Shale and Facelets as well as various component libraries.

JSF is a relatively complex framework, and one does need a good reference to be able to master it. I think this book is it.

The book goes over all the stuff in JSF and explains in a very clear language exactly whats happening under the hood of JSF. I have also some other JSF books and this is by far the best.

This was a good book, but it is now outdated. JSF 1.2 is now prevalent, and this book spends much of its time focused on JSF 1.1. It claims full coverage of both JSF 1.1 and JSF 1.2, but in many chapters (such as building a custom UIComponent), it describes the entire process for JSF 1.1, and then spends a page or two saying how it would have been different with JSF 1.2. Since JSF 1.2 is now prevalent, ideally this book would have been organized the other way around.

This is not the fault of the book - it is pretty well written and has good examples; technology has simply marched on and this book is now out of date. My low rating is not due to the books poor quality, it is due to the fact that people should probably look for alternatives that focus exclusively on JSF 1.2.

Beware - Kindle version has an index (which is more than I can say for other Kindle books I own!), but no page numbers and no links - not very useful in a technical book. Book is very readable and informative... I recommend the content - but am not happy about the index issue.

This book is only worth the first 166 pages (Chapter 1 to 8). You could just literally tear off the rest 650 or so pages and save yourself the burden of carrying the weight.

Chapter 1 to 8 provides a brief walk through of some of JSF features. I say brief because the content lacks matter. The author spends too much time and text on stuff that are so obvious and wisely evades concepts that are important and difficult for JSF beginners to grasp. Most of the prose is vague and lacks rigor.

Chapter 10, 11 & 12 that deal with building custom components are very poorly done as well. Again, the author eludes explaining the 'whys' rather writes 'this is what we should code'. This leaves the reader baffled understanding why this needs to be done this way. It would have been easier if the author had explained the custom components, its parts & methods by putting the JSF lifecycle into perspective instead of pages and pages of prose. If you are a copy-paste type you are probably benefitted with this approach but if you want to understand 'how & why this works' it doesn't help at all.

Chapter 13 is about Facelets. Probably the worst part of the book. Pages wasted. No clear explanation on how facelets differ from JSPs, no working examples and a quick & fast-paced (mere 4 or 5 lines of text) run through of facelet features.

Chapter 14 & 15 gives an overview of Localization & Securing JSF applications.

Chapter 16 & rest of the book (~400 pages) is just a printed copy of faces-config DTD and the Tag lib descriptor file. The examples are so terse and hard to understand and of no practical use. The examples at jsf tool box dot com are way better and illustrative.

Also, this book was written for JSF 1.1 and parts of JSF 1.2 were 'injected' into the prose that doesn't fit or go well with the context.

This book doesn't cover the basics well enough. Concepts that deserve rigor and more examples and prose are smartly evaded (or the author lacks the knowledge). You will have to constantly refer to JSF documentation and online resources to fill the gap. If all you need is a printed copy of the JSF Javadoc, its XMLs' DTDs and TLDs, buy this book. I do not recommend this book to anyone at any level. I'm using this book to train my biceps.

The most boring book I have ever read. A good deal of info is there, but staying awake while getting it is the difficult part!

As background, before reading this book I had many years of web development experience, including a few years of Struts and ASP.NET development.

This book is not simply a reference, as it starts off as a programmers' guide. The book begins with a "hello, world" type of application. Where it shines is in giving very specific instructions for getting that simple application up and running - such as what jar files to download and where to put them. From there, trying out the examples on your own is very simple.

The book is very well organized, and thorough. After covering the basics of JSF, it gets into the gory details of writing your own JSF components. It then provides a reference of the standard JSF components and the MyFaces components.

One minor complaint is that some of the text covering the basics is verbose and somewhat redundant. But, if you are new to web development and the Model-View-Controller pattern, the wordiness might be helpful.

Very well done.

This book has the worst index of any technical book I have ever used. Six pages for an 834 page book. It has a lot in it, but you will have to skim through topics to find what you are looking for.

Added later, because of a comment:

I gave it three stars because, when I could find what I was looking for, the book gave me what I needed to continue my work. It's just that I had a lot of trouble finding anything! I have since turned to a less "complete" book on the subject that covers the core information that I need and use this book only if I can't find that bit of knowledge in the core reference.

In my opinion this is a pretty good book on JSF 1.1. I have learned a lot from it by doing the the examples in the first few chapters. However, the website that the author users, [...], which is needed to use the scroller component is out of date or no longer available. I will have to comment out this portion of the code in order to make this work.