Customer Reviews

JavaServer Faces

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

 

 

Okay... if you have any modicum of experience with Java web technologies, but are looking at expanding your horizons, DO NOT BUY THIS BOOK! It will frustrate you beyond belief.

1. The author spends over 60 pages just introducing JSP: If I wanted a book on JSP there are already plenty available, and much better at explaining it since the author does a very sparse job of it.

2. The author spends 7 pages just discussing HTTP! If you don't know what HTTP is, once again there are better introductory books on web technologies.

3. The author's examples are rarely fully explained, but instead he continuously uses mere 'snippets' without ever giving the entire code. I understand that the code is available online, but I don't want to toggle between reading code on my computer and then having to flip through pages in a book: Keep it all in one place.

4. The author also spends a fair portion of the book talking about other non-JSF related issues: Internationalization, CSS, Tabular data???? (which, by the way, is a horrible example that does not model anything close to a real-world example.)

5. Over 200 pages of the book are simply reference pages which are available to anyone online (which is when you want them since that's when you're coding!)

6. He has 36 pages (in appendix C pp. 444-476) on the HTML-Specific Component classes... read through these and see exactly how useful this reference is: It only lists the components and the litany of methods with absolutely no explanation.

7. He never really adequately puts all the pieces together and shows the JSF novice how to create anything that resembles something that would be a good starting point for real-world development.

These are just some of the incredible deficiencies of this book. My opinion of O'Reilly has been tainted as of late and this book certainly doesn't do O'Reilly any favors. Overall, this is by far the very worst Java book I've ever read and a definite waste of my money and time.

This book is an "OK" starting point for someone learning JSF.

Here are some things to be aware of:
1) Does a poor job explaining the lifecycle of a JSF component; he writes the sequence of events out in paragraph style and does not provide diagrams (UML or otherwise) to help with the illustration

2) Constantly switches metaphors as he is explaining JSF; sometimes he will be talking about the implementation view of a JSF component and then other times he will be talking about the application view of a component. It would be better if there were one or two chapters that focused on the "how the heck does this work behind the scenes" and the rest of the book focused on applying JSF.

3) There are syntax errors throughout the examples; this includes the code examples (.jsp examples) and the configuration examples (web.xml and faces-config.xml). To his credit, he constantly references the appendix section for a more complete example. As a reader, I personally don't like flipping back and forth all the time.

4) His coverage of the application (using JSF actions) is very basic (academic). He doesn't go through the academically classified edge-cases, which is disapppointing because those are typically classified as real-world.

5) He forward references way too much; for example he will talk about / use something in say chapter 4, and then states something to the effect "oh, we'll come back to that later, don't worry about it now". From a learning perspective this is terrible. It causes your train of thought to be derailed and you end up asking yourself the question "what does that do?".

On the positive side, the flow does seem to make some sense from a learning perspective. He builds on the foundational concepts and frames the learning in the context of creating a "real-world" application.

I understand this book is a bit out of date (suprises me O'R hasn't encouraged an update). My suggestion is to buy this book used.

1/4 of the book goes explains how to use JSP, JSTL
2/4 of the book API reprint
1/4 of the book actual JSF stuff - not real world related - unless you know exactly what you are looking for you'll never find it...
i'm surprised this book went into print - probably somebody upstairs decided to have at least something rather than nothing.
waste of time and money.

There is no reason to buy this book. I am not saying that it's totally useless - but information in this book can be easily obtained for free in other places. One of them is the Sun's j2ee 1.4 tutorial updated for JSF final release.

The book borrows a lot from JSF specs - well, just go and read specs. As an example, the book has custom tree component - you can find open source JSF tree components on the Web as well. In fact, out of 590 pages in the book, 260 pages (!) are various appendices with what can be considered an official JSF information (APIs, tag description, etc.).

The language is good, but what's in the book, in essence, does not go beyond regular blurb about JSF now in abundance in various articles, Sun's site, etc. However, there are few insights about what is called JSF infrastructure and its API. And that's where the tricky part with the JSF is - you can learn without this book about JSF "phases" and how to use components for presentation purposes - but this is not enough for real world Web applications. The author, as far as I understand, is the member of the original JSF team - it would be nice to hear from such person more about areas of JSF weaknesses and how to deal with them vs. other frameworks which put a stress on the controller aspects in building applications (such as Struts).

Unfortunately, from this perspective this book is not more useful than other sources (available though for free).

This was a useful book. however within 6 hours I had gotten everything I could out of it. 2 whole chapters are devoted to things that are not directly related to JSF (Servlets and JSP Basics and Setting Up JSF-Mostly just setting up tomcat)

I really liked the book...but it was not very deep. Understandable becasue of the relative newness of JSF. I can imagine not many projects have been done with JSF yet...but there needs to be more on integrating with J2EE and how to really use this technology in a meaningful way. Right now all I can do with it is make a simple little example and not really a whole production application. The book only spends 3 paragraphs talking bout JSF and databases. Then says "That is all I am going to say about databases, because that is all there is to say about databases that is database specific"--That was very dissapointing. The entire chapter about Servlets/JSP would have been much better used showing examples of "best practices" implementing databases.

That said I really appreciate the section on integrating JSF and Struts with Struts-Faces. I can imagine that I will most definately be using this technology as I do a lot of struts development. Thanks Hans.

Also I would have really appreciated a comparison of JSF and ASP.NET. the book pretends like this technology doesn't exist. When in reality JSF is the response from the JCP that was necessitated by ASP.NET.

This is the best intro to JavaServer Faces for someone with experience in developing Java web applications. I started out with Core JavaServer Faces based on recommendations here, but I was disappointed. JavaServer Faces does a much better job of explaining the implementation of JSF components, converters, validators, events, renderers, etc. And the author does so with a lot fewer pages, and fewer code listings.

The book is about half "how to and why to" and half reference material. The first half of the book does a good job of explaining how everything works, and I actually find myself using the reference material once in a while.

If you want to learn JavaServer Faces, this is the book to choose. As an active member of three important JCP expert groups (JSF, JSP, and JSTL), Hans can share insights into JSF and its use that few other authors can. Notably, Hans is also the author of three editions of the popular O'Reilly book, JavaServer Pages. Like his other books, this book contains clear explanations and best practices based on his experience.

Unlike many other JSF books, this book includes accurate, up-to-date information since it was intentionally published AFTER the JSF 1.0 final specification was released. Hans clearly explains the JSF UI framework, how events are handled, authentication, navigation, how to work with tabular data, how to use JSF with Struts, internationalization, and input validation. I particularly like how Hans clearly explains the relationship between the JSF custom tag libraries and the JSF Java API. Hans' book also explains how to extend existing JSF components and build your own custom components.

On various mailing lists, Hans regularly answers questions for those who are stumbling on learning JSP, JSTL, and now JSF. Hans' passion to teach is evident in his efforts to clearly explain important concepts and how they can be applied using best practices. Over the past few years, Hans has helped me immeasurably in learning JSP, JSTL, and now JSF. If you can't find an answer in his book, you can post your questions online and Hans is likely to answer. Buy this book - you can't go wrong.

I have this book and Core Javaserver Faces; this is the book that lies open on the desk, is dog eared, and has coffee spills on it. It's not perfect, but it's the best there is in this space.

In this book, Hans has provided us with a good starting point to using JSF, including the Servlet and JSP systems on which it is built. This is of particular value to those of us coming from an ASP.Net background who so often are given a book that looks at just one small piece of the J2EE picture, leaving us to feverishly google for answers to questions regarding underlying java technologies.

What you should bear in mind with this book is that it is all-inclusive: a lot of the book's documentation can be readily found online--as long as you know where to look (and, believe me, coming from a Microsoft background it takes a while to know where to look--eg. "sourceforge, what?"). Including all documentation for JSF gives the benefit of not having to look for it yourself.

Remember also that JSF is a very new technology and not all of the details have been fleshed out about it (generating custom errors for validation is sorely lacking). As such, I would imagine it to be hard to write a book full of those "watch out" tips when the framework hasn't been widely deployed on various environments and in divergent situations. Hans' book reflects this by appearing to some to be overly general.

I really appreciated the chapter showing how to plug in custom renderer code into JSF, it shows that Hans recognizes the shortcomings of JSF and points the way to fixing them.

Overall, if you are a top-notch Java web app builder familiar with Struts or Tapestry, okay, you would get just as much benefit downloading the spec and reading it. If, however, you are a relative newcomer to java-based web apps--or just someone who wants to have it all in front of you--, especially if you're coming from the Microsoft world, I would recommend this for you.

A final note: I'm an average guy who picked up this book. I have no affiliations with Hans and yet, when I sent emails asking him questions on hang ups I found using JSF, he responded to me with detailed information about my issue. Not only that but Hans has been very vocal in pushing to make JSF better by publishing articles (...) and trying to get the Tapestry folks to help.

This is one of the best O'Reilly Java books I have read in some time. The use of graphics is very effectively coupled with tightly written and interesting exposition. Nowhere is this more evident than in chapter four which works through an entire web transaction both on the client and the server.

About two thirds of the book covers JSF in-depth. The last third, in the appendices, gives an O'Reilly style reference for the components. Before the reference section the book covers the basics, like forms. Then goes into advanced topics like internationalization and finished off by covering the creation of custom components and layout systems.

This is a must read for anyone using or evaluating JSF. It's well written, and teaches the topic, as opposed to just translating the documentation.