Yes, this book will answer most of beginners' questions about how JSF works. No, after it answers them you'll still be looking for answers why.
Yes, if you need to know *how* to program JSF then book's long examples will benefit you. No, if you want to understand *why* things are done that way then a lot of pages could be skipped.
This book is much closer to being specification than it needs to be, but beginner will get good understanding of JSF foundation topics. So for every 'yes' - it's good, there is almost always 'no' - it was not enough.

It's an excellent introduction text to JSF. I like the examples which you can try and learn from the coding experience. It however, is a bit weak on theory, like for instance lifecycles details etc. which isn't a big deficit considering that can be looked up easily. However, I do think a bit more theory in the first couple of chapter would make this book a stronger offering. As for rest of the chapters, the examples are clear and well suited for learning the material and the author's logic/explanations clear and succinct. The chapters are arranged logically, which means by following its order it build you knowledge up nicely. You probably should pickup a book that explains the h: f: tags in more details after this. But this book has the skeletons of everything which wets your appetite for digging deeper into JSF. Overall, a very good introduction.

I got the first and second edition of this book. From the first to the second the book does not get better in knowledge even though Java Server Faces for Java 5 EE gets a lot of powerful components. They are not covered. I was expecting a more deep explanation of how to get the best from Java Server Faces to build Web Applications. For first time purchasers this is a "must have book", but do not expect too much if you have the first edition.

Hi, this is the best book you can get.
But I hope in their future version:

1. There should be a new chapter called Managed Bean Environment or something like that. One managed bean cannot do much if it knows nothing about its environment. How to access other managed beans in scopes. How to access objects in scopes. How to access the parameters in the environment. We need to know how several managed beans communicate each other and communicate with their environment to complish a real project. We also need you to provide a concret example like in J2EE5 tutorial bookstore6. I am so pity you missing this crucial part.

2. There should be a new chapter called JSF and Enterprise Bean. This is an important issue to put JSF into a meaningful environment. JSF is for J2EE application. Managed bean need to link to session bean and session bean link to JPA. We need a such example how it works.

3. The chapter 8 to chapter 12 do not realy need to know for CORE JSF and therefore should be dropped to give book space for the above content.

4. In the chapter 5 Data Tables : Editing Table Cells. It is very inconvinient to click a checkbox to active editing mode. I suggest to remove all checkbox because in practise people will edit seveal cell content and click a save button. Also you do not need one inputText and one outputText for one cell. Remove outputText and add readonly in the inputText. Can you tell how to freez header when scroll a table?

5. There should be a chapter to talk about JSTL. It seems my request is out of the topic but it is not. JSTL is hard to stand out for an independent book. It will live with JSF. In real project, JSF is always mixed with JSTL to make a web page. We need to know when and how to use JSTL in a JSF page. I would say, the technique you learned from this book is not enough fro you to make a real web page.

Regards

Java programmers will find essential this second updated edition CORE JAVASERVER FACES, which examines all elements of JSF 1.2 development and offers up a set of 'best practices' for automating functions, building consistent reusable user interfaces, and tweaking Java with JBoss Seam and custom components. There have been extensive updates and modifications to this edition, making it a solid 'must have' reference for any serious library catering to Java programmers.

Diane C. Donovan
California Bookwatch

I was excited when I first purchased this book, but I think my expectations were a bit too high. The Book covers the basics of JSF with aesthetic elegance, but more advanced topic's are not covered in as much depth.

That is not to say, however, that they are not covered. The book touches upon things like JSF used along side open source frameworks; which is an excellent place to start for the developer looking at the current options available for Object Relational / JSF / Alternate View Technology integration (Shale, Facelets, Seam, etc.)

But I would have liked to have seen a more thorough explanation on custom component creation. The example given in the book, e.g. the creation of a custom spinner component, is something that is somewhat useless in actual production environments. Usually, if a custom component needs to be created, it involves much more complicated functionality; such as a custom 'dataTable' component.

Even an explanation on how to create an advanced custom renderer would have been appreciated, for example, how to create a custom renderer for the 'dataTable' component.

Nevertheless, the book was useful and informative in many ways that I did not expect. The 'How do I...' section is an interesting approach, that was invaluable to me on numerous occasions.

Thus, overall, I would recommend this book to beginner and intermediate JSF developers looking to utilize JSF technology in their development pipelines. Unfortunately, for the most advanced JSF topics, looking at JSF implementation source code, and JavaDoc's still remains the best way to learn these advanced topics.

It's a great book, easy to understand, a lot of examples, could be used by people initiating on JSF, or like a reference book. It is not necessary any knowledge of servlets or JSP. Just install tomcat, jsdk a jsf lib and start to write yours first webapp!!

Reading the Amazon reviews I suspected this to be a good book. But how excellent it actually was, caught me by surprise.

You get introduced slowly. The authors do not even hesitate to make pedagogically motivated design shortcuts at the beginning and they comment what they will improve later on.
The code examples are complete. Though you rarely ever need all of it, it strongly helped me not to get lost in the later chapters.
The code quality is top notch with a slight taste of C. It just feels good to read the code and one learns for even completely different software contexts.
If you only want a thin book on JSF the first six chapters (270 pages) will do an excellent job on that too. In fact this would be even the better book.
The style is unpretentious and the intellectual muscle of the authors is just amazing.

Are there problems? Well I think yes, in the more advanced chapters. The authors are just too competent. The consequence: In the later chapters you learn how you could do much, and I mean really much more, than is directly covered by the JSF standard. This might be a life saver, if you really do have any of those specific problems. In a general purpose book this might encourage people to overstretch their own system.

This book focuses only on the development side of the issues. If you want to learn the visual or the usability part of web applications, you have to turn to other books.

In summary I do highly recommend this book to people interested in JSF, Web development and software in general.

I think this book is a good start to learn JSF.

The author's have done a nice job of intoducing JSF.
The examples are easy to follow.

Great book on JSF, the absolute best intro to JSF in the concise, terse, classical style of Horstmann & Geary. You can buy any book by these two dudes with your eyes shut. I would have loved to see more new material in this second edition, especially on Seam and EJB integration in general. The book being so similar to the first edition there is little need for you to buy it if you already own the previous one.
The chapter on custom JSF tag development will be well over your head if you are reading the book as a first intro to JSF, and the LDAP material is pretty brutal and useless for a newbie to the subject, the chapter on opens source miscellanous frameworks is way too sparse to be useful beyond a little inspiration to learn more, but the rest of the book is top notch and will greatly help you to understand the JSF framework deep down to the bone.
The monkey wrenching title is not really about the book but about my feelings towards the development of java web development (forgive the horrible pun). First there were servlets, then JSP then EJB then Struts then JSF then Seam then Facelets then Shale...Am I the only one who feels that stacking framework over framework is going definitely overboard and leading us to do "frankenstein programming"? (omg I think I am starting to blog.. pls stop me! ;)

Core JavaServer Faces in an introduction to JSF for experienced Java programmers. The beginning of the book explains that JSF is designed to support GUI development using visual tools and the hand coding as shown in the book will eventually go away. JSF includes an event model and server components sort of like Swing for web applications. One important feature of JSF is that JSF tags represent a component and rendered that generate HTML, which makes it easier to use a different display technology. The book begins with an explaining of managed beans, which are important in separating business logic from presentation, and then proceeds to show each part of JSF, event handling, validation, etc.

The examples in the book are well written and complete. The example code also demonstrates good coding practices, such as using message bundles, which are beyond using JSF. The book also explains how to build complete JSF applications, explaining complex user interface layouts and connecting with back end databases. The last chapter "How do I..." answered many questions you would want answered or wouldn't have thought of to ask.

This book starts with the basics of JSF and build to show the entire framework and a lot of advance features. This is an outstanding book on learning and using JSF and I would definitely recommend this book.

With JSP & Servlet in popular decline Sun comes out with a technology that has the potential to challenge ASP.NET.

By far this is the best book as an introduction to the new technology. Really appreciated the intro on how to make JSF work with Tomcat.

It will take 3-4 days to become confident with the technology.

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).

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 )

Dont waste your time reading about JSF from others sources, buy this BOOK, this is the best book ever written on JSF.

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.

[A review of the 2ND EDITION published in 2007.]

Respected Java authors Geary and Horstmann provide an update of the first edition of their book. The key theme is a faster and more robust coding of web servers using Java. From about 8 years ago, Java Server Pages and Java servlets were the recommended approach. But while doable, it proved quite grungy, with lots of low level code needed. Plus, Microsoft cranked up the competitive pressure with their .NET approach, that had a nice IDE. The collective response by Sun is given here, with JSF 1.2.

The book's code examples demonstrate a tight integration with XML configuration files. These files can encode things like navigation rules and action attributes. A file can be considered to define a server's state. Some files are lengthy. But the good thing is that you rarely have to edit these by hand. In the first edition of this book, much remained to be done, to improve the IDE. This second edition reveals impressive improvement.

The standard JSF tags are shown to lead to the building of sophisticated dynamic HTML pages. Much simpler than explicit coding of JSPs. Another bonus for the programmer is the existence of a comprehensive set of standard validators. These let you check user inputs and filter out invalid choices, before they get into your backend database.

Important recent topics like using Ajax or implementing a Web Service are also treated. Ajax and JSF are entirely compatible. This combination of improved client side abilities and server side functionality is easy to understand, from the text's examples. Some readers might wish for a lengthier discussion. Only 1 chapter is devoted to this. The treatment of Ajax itself is necessarily brief, as this is primarily a book on JSF, not Ajax. But there's enough to get you started.

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.

"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.

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.

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.

Designed for beginners. Walks you through details and have a lot of examples. A must for beginners.

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.

This is the official book by Sun Microsystems Press. I found it easy to read and very informative. The first part requires little Java programming, having a gentle introduction into beans, navigation, standard components and validators. This should get anyone up to speed right away. The later chapters have more meat for experts, custom validators and components, databases and web services (not strictly JSF but still great to see how the pieces fit together) and finally a "how do I" chapter that's filled with nuggets. Much better than the Orielly book.

This is the best book on JSF on the market today: (1) Authors are experts. (2) Tells you how to use the technology, not just how it was designed. (3) Doesn't require prior experience with JSP, servlets. (4) No pages wasted on reference material that is available online. Highly recommended!