Core JavaServer Faces

Rating:
Summary: The best book on JavaServer Faces
Review: This is the best book on the market to date on JSF. This book is all about getting you up to speed with this new Java technology and being productive. If you are a J2EE web developer, you will be able to use and reuse Java components off the shelf in your Java application. The book clearly shows you how to employ JSF user interface components and also explains why and how to employ these new JSF features compared to using JSP. I strongly recommend that you do all the JSF examples in each chapter. It's a very good book on a great subject.

Rating:
Summary: good intro to JSF
Review: "Core JavaServer Faces" introduces JSF to programmers only requiring HTML and Java knowledge. The first chapter explains how to setup the examples using Tomcat and Ant. The authors show everything needed to run all the examples, including the directory structure.

Most of the book is also appropriate for experienced web developers. The second half has involved topics. The authors include a few comparisons to Struts and comment on how to combine the two frameworks. The authors keep most of the technical/advanced concepts at the end of the chapters and mark them clearly.

The first half of the book explains JSF. It includes everything you should know to use a framework, such as lifecycle and tags. The second half of the book shows how to use JSF with longer examples. This includes Tiles, custom components, JDBC and LDAP. There is even a chapter of wireless devices and combining JSF with MIDP. The last chapter is 25 "How do I ___" questions, like those at JavaRanch.

The book highlights best practices where possible. It uses some, such as style sheets and message bundles, through the examples. It even mentions cross-site scripting attacks and how JSF can assist in preventing them.

I had a copy of the first edition first printing. There were some minor typos and a missing reference, but the authors promise this will be corrected in the next printing. The reference is also on the book's website. Overall, I would definitely recommend this book.

Rating:
Summary: It tells you how, but not why
Review: Core JavaServer Faces, by David Geary and Cay Horstmann, is a decent introduction to JavaServer Faces. But it's really just a "how-to" book: probably half the book is simply code listings, which are available online. Why waste the paper?

Once you get JSF installed into your servlet container, the book does an acceptable job of explaining how to perform most tasks. But it doesn't go into enough detail on the background behind JSF and comparisons to other technologies (raw JSPs, struts, etc.). It needs more "why", not just "how to".

If you want to know what to do, and why you should do it, read JavaServer Faces by Hans Bergsten (one of the Apache Tomcat developers, and contributor to JSP 2.0, JSTL, and JSF).

Rating:
Summary: Best JSF Book
Review: Dont waste your time reading about JSF from others sources, buy this BOOK, this is the best book ever written on JSF.

Rating:
Summary: good intro for JSF but...
Review: I am currently reading David Geary�s Core JavaServer Faces book. I have read Chapters 1-9 and Chapter 12 (Ch 10 talks about JSF/ external service, Ch 11 about JSF/wireless clients).

One thing that annoyed me right away was he starts talking about the core JSF classes (UIInput, FacesContext etc) in early chapters without a formal introduction to the JSF class hierarchy. He does do a good job in laying out the JSF and HTML tags, but he never does the same for the classes. Well, I think that maybe the class hierarchy will come soon, but as I finished chapter 9 (custom components), I realized he never did that. As a programmer, I feel that this is a serious lacking in a book.Again, as a programmer, I managed to overcome this lacking by referring to the JSF Javadocs for the class hierarchy as I was reading thru the chapters. David Geary's own article on JSF does a good job of introducing the classes (although the names are a little outdated).

His examples are very good (the downloaded code builds/works great), but I did not find any that "pushed the envelope" of JSF. For example, in the custom components chapter, he talks about building a custom spinner :roll:; yes, this is a good intro to howto, but I would like to see something more complicated and exciting, like a tree or a list component. After all, the ability to plugin custom components as tags is one of the enticing features of the JSF specification. It would have also been nice if he had talked more about JavaScript/JSF interaction.

The book is about 600+ pages long, but I think half the pages are just code printed (a lot of the code is also repeated in the discussion within the chapters). I dont know if this is good (lot of printed code) or bad (lot of wasted trees). The longer chapters kind of meander between discussion of code and printed code, and by the time I was with the chapter, I had to go back and put the pieces together myself. It would have been nice if he summarized the concepts in the end. (I plan to summarize the `Custom Components' chapter soon)

I did find the chapter on Tiles and the `How do I' section on using the Commons Validator for client-side validation, quite interesting and informative :cool: (although, I think he should have delved more into these topics instead of a whole chapter on the JSF dataTable tag!)

Bottomline, Core JSF is a good introduction to JSF with some advanced discussion too. I recommend it to get started on JSF, but with a healthy dose of JSF JavaDocs and/or another book.

read the full review here ( http://www.browngeek.com/index.php?p=27 )

Rating:
Summary: Certainly not as good as authors other books
Review: I purchased this book, in part due to the reputation of
the Sun "Core" book series; and in part due to the
reputation and work of the authors previous titles.

The book is not at all intuitive, and seems to jump right
into deploying JSF. If you are a HIGHLY experienced
J2EE programer, Apache/Tomcat application administrator,
then maybe this book is for you. If not, then I would
recommend looking elsewhere.

Not only is the book lacking in context, but what is worse,
is that the JSF 1.1 specification documents (available on-line
for free from http java dot sun dot com / j2ee / javaserverfaces)
are better written, and more complete.

Again, I would recommend another title (none of which
I have read), or the JSF specification itself. If you
are like me, and hate reading 800 + pages on-line,
then I would recommend downloading and printing out the
JSF documentation.

Rating:
Summary: Drag and drop development
Review: Java Server Pages (JSPs) and servlets are at the core of many J2EE web applications. But thus far, building the code to implement a particular HTML front end has been totally manual. In spite of this, many Java programmers have successfully taken up the approach. Geary and Horstmann show how this can be replaced by JSF, promising potentially far greater productivity at assembling the UI. Necessary if J2EE is to better compete against powerful UI builders in the .NET environment.

There is a slight awkwardness in this book, born of necessity. The authors show how to write JSF code by hand, using just a text editor. This can still offer advantages over the previous JSP/servlets. But the full promise of JSF has to await the emergence of visual development environments (VDEs) that can graphically represent components. Then you can drag and drop an instance of a component onto a central window and customise it. The VDE can then autogenerate the JSF tag code. Very early in the book, the authors show a simulated illustration of this. Hopefully, by the time you read the book, at least one such VDE will be available.

This promise of incipiently greater productivity should be clear. It mimics what happened in circuit design in the 1980s. Spice programs could simulate a circuit. But the input that defined a circuit was a text netlist file, which had to be written by hand, from a handdrawn circuit diagram. As PCs came on the scene, MicroSim came out with a version of Spice where the UI let you drag and drop elements to make a circuit. Far easiere and less error prone. Hopefully, JSF will give us a similar gain.

Rating:
Summary: Good for beginners
Review: Other reviews have covered most of the good things of this book. I want to point out a few other facts: It is more "textbook" like. Very good for beginners, but may not very useful for advanced. If you are building a real web application, you will find that you cannot find answers for some common questions.

Rating:
Summary: By Far the Best
Review: Over the last few months I have read four different books on Java Server Faces (JSF) and been through the Sun JSF - J2EE Tutorial. If you are going to start a new project using JSF and have a budget for just two books on the topic, I'd recommend that you buy two copies for Geary's book. One copy for your reference and one to loan out to the rest of the staff.

This book starts simple and builds and builds until you have a complete picture of JSF. The 600+ pages talk about everything from building web applications to using JSF with wireless devices. This is definitely the one to buy.

Hale Ed.D.

Rating:
Summary: Perfect Cure for Misunderstood New Standard
Review: Struts spread like wildfire in part due to the fact that it was simple. JSF is very ambitious and defies a very simple explanation followed by a bugle blast to commence hacking. Nevermind the history of designing circuits, in software, generally the complex APIs don't get a following until a great book ships (e.g. Petzold, Roman's book on EJB, etc.). This is that book for JSF, and it is just on time. I would also like to differ with the opinion about the book being awkward because it makes you do things by hand that will soon be automated. That is a small part of the book, and doing by hand those early things helps immensely to understand the bigger picture (e.g. custom components, web services, etc.).

The reasons this book deserves a 5:

1. Its score for comprehensiveness alongside similar offerings is orders of magnitude higher.

2. Tool support for web dev is unfortunately still in its infancy for Java. The webtools project in eclipse just dropped its first version of a JSP editor for bloomin' sakes. That puts more pressure on the writers to have to painstakingly describe setup and configuration issues. They do an excellent job.

3. The examples are very good and get worked from different angles to great effect.

4. There are many useful diagrams as well, for example of the processing flow, which is crucial to understanding what the framework is doing for you. I had a case where I was debugging a problem and the error message looked spurious until I consulted the flow and saw that it was repopulating the page automatically.

JSF is not perfect, but this book shows that guidance can make all the difference in pain of adoption.