Customer Reviews

JavaServer Faces in Action (In Action series)

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

 

 

What I enjoyed so much about Kito's book was the fact that he doesn't just present the entire gamut of JSF to you in this book, he also uses it for about 6 chapters to take you (step-by-step) on a journey building a full fledged project tracking application complete with nicely laid out user interface (using JSF technologies and CSS... not just plain HTML), comprehensive feature sets, user role and security logic, database interactions... pretty much the works. I always think this is important because no matter how many API docs or Developer Guides you read, you still have questions about how XYZ component will behave in the "wild" or how you can make it do something that wasn't covered in the docs. After Kito's book I not only find it to be an excellent resource when trying to remember how a certain component worked but also a truely comprehensive proof-of-concept for JSF... the tracking system developed in the book actually struck me as something that would be much appreciated if I were to deploy it at work.

You definately get the sense from this book that it was written by someone that loves developing and is extremely versed with JSF; not someone that wanted to make some money and picked up a few tutorials on it before writing a book. Also to his credit, Kito runs the immensly helpful jsfcentral.com site that supplements the book beautifully with more resources, articles and applications (even components) for your picking after you are up and running with JSF.

A little information on me: I am a JSP/Servlet web application developer, I've done Java client side for about 5 years and server side for 3. I've played with EJBs, done a lot of Struts applications, and attempted to learn Tapestry. I wanted to learn JSF and wanted a good paced yet deeply informative book that would teach me best practices right off the bat with JSF and also talk about WHY they were best practices... this is exactly what I found this book to be. 5/5 stars from me.

Kito Mann's JSF book is superb. In addition to the twenty book chapters there are also five on-line chapters (which I haven't read yet), for a total of 1,000 pages.

Before reading this book, I had read the Wiley book and part of the OReilly JSF book. There's a great deal of information in Kito's book, and absolute neophytes will probably need to re-read the material (it obviously depends on how fast they learn).

I also liked the discussion on integrating JSF with Struts, which (AFAIK) is the only place where I've seen such a discussion. After I saw the Struts+JSF diagram I had an "aha" experience, and I'm sure it has saved me hours of effort trying to cull the same information from a variety of other sources.

One of the book's primary strengths is its even-handed focus on the what/why/how of JSF, along with examples that are incremental developed and presented in a lucid manner. I'm planning to develop some custom JSF components, and I'll definitely have Kito's book within arm's reach!

JavaServer Faces (JSF) is one of the newest technologies in the Java toolbox and is designed to make developing web applications as easy in Java as it is in .Net. JSF is designed mainly to be used inside of an IDE by dropping JSF components onto a screen from a palette. This book is an introduction to JSF and although it is far from perfect, it is still a worthwhile read.

The book starts with an introduction to JSF with a good overview of the component technology and how it works as well as a brief discussion of some of the IDEs that support JSF. The next few chapters discuss the components in depth and the book bogs down. There is too much detail with very little in the way of code samples. To some extent this might make sense since the components are meant to be dropped from a palette, but at the same time it makes it very difficult to follow along without some understanding of how the components would be used in an application. Starting with chapter 8, the author tries to put it all together with a sample application. Unfortunately, it is presented as a development case study instead of a JSF case study. We get three chapters of screens with no code behind it that includes prototype versions and final versions. This seemed very unnecessary and helped to inflate the page count. It isn't until chapters 12 and 13 that we finally get to see some detail code but by then I had forgotten what the screens introduced four chapters earlier were supposed to be doing. The book ends with a chapter on Struts integration and a chapter on developing your own custom components.

There are bonus chapters available on the Manning web site, but since some of the bonus chapters are important to understanding the material in the book, unless you are reading the book while sitting at your computer, this isn't very helpful. The book would have been much better with some serious editing and rearranging of topics. The sample application should have been simplified and combined with the component reference material presented earlier. Code and screens should have been discussed together. The bonus chapters should have been incorporated into the printed version of the book.

I don't want you to get the impression that this is a poorly written or useless book. In fact, there is a lot of good material here and after reading this book you will have a thorough understanding of JSF. The author gives very clear (if not concise) explanations but the book is too long and parts are difficult to wade through.

I purchased this book based on my previously great experience with Manning Press books. I've found other books by this publisher to be easy to read and easy to comprehend. They usually give you just enough background information and then details on different aspects of the subject matter. This book just goes on and on and on about background information and implementation details that are of little use to anyone after they configure their first application. It takes too long to get to the meat of writing JSF applications. And once you get to where the meat is supposed to be, most of that has to be downloaded as a 300 page PDF from their web site. Not very useful at all.

If you are looking for good JSF information, I now use the Core book for information and the O'Reilly book for a quick API reference. If you want examples of great Manning Press books, please check out their "Spring In Action" and "JSTL In Action" books. Both are fantastic reads and full of great information.

Sadly, this particular book left a lot to be desired both as an instructional text or as an API reference.

I bought this book because it was the most recently published title on JSF, even though I like Horstmann's writing style and would have bought the Geary and Horstmann book if it hadn't seemed likely to be a little out of date. After trying to work my way through disorganized discussions of individual points that were not tied to any clear examples or to other aspects of JSF, shifting forwards and backs trying to string information together into simple working examples, I read a few sample chapters of the Horstmann book online, and was reminded of what a pleasure a well-written book can be. Coming from a Struts programming background, I had expected learning JSF to be rather straightforward. I expect it to be after I replace this book.

I have been coding JSF applications for about a year now. At first, all of my JSF knowledge came from online material. I decided to purchase this book because I wanted to have a good reference for JSF on hand. I am glad that I made the purchase because even as an experienced JSF developer, this book taught me many new things. This book takes you through the development of an entire project from start to finish using JSF...it really details how JSF works and the correct way to use it. I definitely recommend this book to anyone who uses or is interested in using JSF!

This book is particularly interesting in it's layout. It's part tutorial, part reference book, and 30% on line, not printed on dead trees. The book is designed to lead you through the maze of learning the material while allowing you to discover for yourself by exploring. It is also designed to allow the reader who needs to know some little point to get in, find that point, and go back to work on the real life project.

Using tutorials are the best tay to get a person up and running on a software package. You kind of blindly follow the instructions from page to page and at the end you've accomplished a few tasks that give you the introduction you need to really start learning. ==After finishing the tutorial you need a reference book that is organized so that you can rapidly find what you need for a specific task.

First the book starts with a general introduction to Faces. It shows the screen from IBM's WebSphere Application Developer, Oracle's JDeveloper, and Sun's Java Studio Creator, that's all the big IDE's and a good introduction to the kinds of support that you can find for Faces out in the real world.

It then goes on to the mandatory "Hello World" application (it presumes here that you have some experience with Java and JSP) just to get your feet a bit damp, not wet yet, but damp. After a few chapters about the architecture and standard components of Faces, the real tutorial begins with an application called ProjectTrack. Here your feet get really, really wet with web pages that combine CSS, JavaScript and of course Faces.

This concept of how to do a book really worked well for me.

Ok, I've had this book on early e-release from Manning since the first couple chapters were done. If you are going to get one book on JSF, this ain't the one to choose (get Core JSF by Geary and Horstmann). However, there are some really good things in this book. For instance, the custom controls examples in Core are ok, but they consist of a spinner straight to a huge tabbed pane thing (that they should have spent more time making look good). This book has an example of doing a custom component for entering dates from dropdowns which is more immediately useful than any of the other things I've seen out there for a number of reasons: binding to objects, handling a type (Date) using multiple components. (That said, the code is kind of funny in that it is very thorough in some ways and lacking in some nutty ways, for instance, if you want to present a field for a user to put a date into, it will set the dropdowns to today's date (even though the field is null); changing this behavior to having blank dates for nulls is kind of a nuisance (though a good exercise).

Wonder what the editors were thinking w/this book: if you look at the table of contents (and you have any exp at all w/JSF), you will notice that there is no real effort to be at all comprehensive. If you search in the book, many core terms and concepts don't even appear anywhere in the text.

One final note: I didn't think it could happen, but I actually am starting to prefer the PDF versions of these books. Makes searching a snap and if you have a decent size monitor, it's easy reading.

Reprise: I've changed my mind about this book. There is a lot more in here than there was in the preview. And I've come to appreciate some of the things this has that Core is not so great on. Still deserves a 4 though because of some of the other comments and the fact that some of the code really should be better; the dates custom control is kind of a mess: methods w/5 or 6 params, sloppy genericity that should have just been done as classes (even inner ones).

Without exaggeration, this is the most poorly edited, sloppily written technical book I have ever paid money for. I can find a typo on almost every page. Some are merely distractions (such as an extra "on") but others are inexcusable. There are several occurrences of badly formed XML, with elements that open with one tag (tree-id) and close with another tag (view-id). Which is it? I shouldn't have to reverse engineer the sample code in a professionally edited book.
Furthermore, this book is not even complete! It ships with 15 chapters and the rest of the book is to be downloaded as a pdf. The pdf has no less typos than the hard copy and astonishingly, there are errors that should have been caught by the most elementary spell checker. (Apparently, the editors did not have time to run one).
The content of this book is superficial and you won't learn anything that you couldn't find in a free web tutorial. This book is wordy and would only be half as long is it is if the fluff were removed. The author's annoying attempts at wit only served to remind me of how little substance this book really has. The "real world" examples would be appropriate for an introductory undergraduate computer class and do not correspond to any "real world" that I've lived in. All in all, this book put me in a bad mood almost every time I picked it up (and believe it or not, I am usually a very forgiving reader). From the In Action series, I've read the books on Struts, Hibernate, Spring, Ajax and this one. This is the only that has disappointed. I highly recommend the others and I highly recommend O'Reilly's Java Server Faces and Core Java Server Faces from Prentice Hall.

Let me start by pointing out that his target audience includes people who currently develop Java web applications. So its fair then to say that if you are new to JSP and servlets, this isn't quite the book for you. So forget about getting any hand holding with setting up a servlet container or a gentle introduction to JSP actions.

That said, if you know the top end of a web application from its bottom one, and you want to get up to speed on JSF, you're in for a good ride.

1. Architecture (5 out of 5)
--------------------------------
This book shines in the area of general architecture. And, I can't say enough good things about Kito's diagrams.

The first diagram of note provides a birds eye view of a JSF application. If you take the time to read through each textual element in the diagram, you'll get a very comprehensive view of your application's place in the world, when implemented using JSF.

His basic introduction to HTTP and Servlets is just that - basic. But his discussion on what frameworks bring to the table is a must read for web developers. That section culminates in another worthwhile diagram - this time a depiction of web application infrastructure as a stack of services. You can clearly see the benefit you accrue from using JSF, vs. say coding using the servlet API. It overlays Struts on there as well, so you get a nice comparison of the two frameworks.

His first application requires a leap of faith. There's a lot of code here just for a simple Hello World application, and its hard to follow along without a reasonable knowledge of what a standard JSP might look like, so you can spot the differences introduced by JSF. It doesn't help that this basic application starts out of the gate with a roar - you're dynamically adding controls to a component using an action listener! Not good.

His class model of the various JSF components is another must see. Its a very informative overview with the UI Component as the center of attention, surrounded by its minions.

The second chapter is another gem - it provides a detailed description of the various classes that comprise JSF. There's a lot to take in, so you'll find yourself returning here after you've read the rest of the book, to help everything fall in place in your mind.

One thing I had difficulty with was that the topics seemed to jump from low level to high level and back again, leaving me a bit winded. The net result is that I couldn't read this very linearly, and had to backtrack ever so often to find my bearings.

For e.g., the first time you get to building a JSF web application is over 100 pages into the book. Fortunately the structure of a WAR is well known, especially to the target audience of this book, so there's no surprises here, other than to note the specific JARs that are required by your JSF implementation.

In the spirit of the topic organization of this book, one of the most engaging chapters on high level architecture is placed right at the end (chapter 11). There again you find a diagram that maps all of JSF's application classes, grouped as component classes, context classes, application classes, and event handling classes. This chapter is a must read as it provides in depth coverage of the APIs that underpin the JSF classes.

The UI Component's singular importance in JSF is honored by an entire chapter. A table classifies components by family (input, output, etc.), JSF implementation class (UIInput, UIOutput), and HTML subclass (HtmlInputText, HtmlOutputLabel).

The components are treated well with the standard components described in sufficient detail. In a rare fashion, he provides examples of how a component tag is rendered as HTML, and presented in a browser. This gives you a clear picture of the additional scripting that is added for a <h:commandLink> component.

This includes single- and multi- select controls, and their data models set via UISelectItem instances and UISelectItems.

2. Request Processing (5 out of 5)
--------------------------------------
The life cycle stages are defined clearly and precisely. Its hard to think of any information that might have been missed.

A key concept is that of component and client identifiers - which defines how naming containers influence the name of a child component in the rendered HTML code. This is very clearly portrayed, by yet another diagram that maps the component tree on the server to form components on the client.

All in all, a very satisfying tour of the life cycle.

The coverage of converters and validators is just as complete - including creating custom converters and customizing error messages using message bundles.

3. Templating (4 out of 5)
------------------------------
JSF implementations must support JSP as a templating technology. It's a rare book that doesn't cover the use of JSP actions, custom actions, and JSTL within a JSP page adequately - and this one doesn't disappoint. A key issue with JSP/JSF is that there are certain constraints with using JSF/JSTL tags (such as the <c:forEach> tag) - and these are called out adequately. While the coverage is decent, this is not a book on JSP, and it shows.

4. Navigation and Event Handling (3 out of 5)
-------------------------------------------------
This information is spread out across multiple chapters - not something that I prefer. While no details are lost its still a bit of work to piece together the whole story. For example, the default ActionListener is covered a number of chapters away from the topic on declaring an action listener.

5. Miscellaneous (5 out of 5)
--------------------------------
Interestingly, this is one of the rare books that addresses a rarely considered concept - which JSF implementation should you choose. The RI is a reasonable choice, but the larger question is when an alternative implementation such as MyFaces would be preferable.

The Managed Bean Creation Facility is an interesting implementation of inversion of control - much like Spring - where a configuration file drives the creation and initialization of beans. He actually provides guidelines as to which objects should be constructed using this facility, and which ones would be better served by initialization at web application startup - say using a ServletContextListener, so as not to incur inordinate delays in the middle of a user's interaction. And there's even an example later on in the book, if you didn't get the hint.

Internationalization coverage is pretty complete - in terms of configuration in faces-config.xml (and a warning that without these locale-config elements, the JSF implementation may only support the default locale of the application's JVM); determining the user's locale (using the <f:view> tag, Java code, or the browser's locale settings); and creating resource bundles to house your locale specific properties.

This book is peppered with relevant tips such as the warning here that you can't use the "." character in resource bundle keys.

On the client side it describes the use of <f:loadBundle>, especially the use of the basename attribute and how it is set based on where in the classpath the resource bundle is located. For bundles located in WEB-INF/classes no prefix is necessary - since that's the root of the classpath. However, bundles any deeper than that require to be prefixed appropriately.

Another rare topic for a JSF book is the creation of a global error page and registering it in web.xml and as a global navigation rule.

Finally, there's an example of the use of a servlet filter for security.

6. Examples (3 out of 5)
----------------------------
While I typically don't favor overblown monolithic projects that require you to follow along across multiple chapters, the provided example has all the bells and whistles of a typical application you might encounter - including user roles, workflows, and a common toolbar component.

In addition, Kito provides a really interesting approach to application development - by starting out with a dummy user interface using hard coded beans and static navigation outcomes, and slowly evolving the application.

The result is a bit mixed - the first couple of chapters flow wonderfully. However the latter chapters of the examples felt a bit hurried in their execution, especially once we're into the more difficult aspects of JSF development, such as backing bean design.

7. Conclusion (overall score: 4.5 out of 5)
-----------------------------------------------
You'll be hard pressed to find a book that has such excellent coverage of so many diverse topics - many that are not JSF specific.

You'll also find gems of practical advice throughout the book - for e.g., that you have 3 alternatives as to where to place your action methods (in your backing beans, within independent action classes, or within service classes) along with the tradeoffs associated with each.

A couple of reservations (albeit subjective):

I'm not a big fan on how the topics are organized. As I read this book, I had to keep jumping back and forth - many many times, and that got to be very tiresome.

I typically like related information to be as physically close as possible, preferably within the same chapter. It is hard to use this as a reference book given the geographical distance between related concepts. This may actually fare better as a search-able e-book.

The example application is very comprehensive and well thought through. However, the example is built over multiple chapters, and the latter chapters are not as coherent as the initial ones. I found the change of pace a bit unsettling.

On the whole, though, its been a satisfying read.

Damodar Chetty (swengsol.com)