JavaServer Faces in Action

Kito D. Mann

2004 | 744 pages | B&W
ISBN: 1932394125

Out of Print $49.95 Softbound print
$39.99 eBook edition (PDF only)


Look Inside Resources Downloads


Exclusive to the owners of this book: free online access to over 300 additional pages of substantial content. That's over 1,000 pages of JavaServer Faces in Action!

Register for the OE now.


JavaServer Faces helps streamline your web development through the use of UI components and events (instead of HTTP requests and responses). JSF components (buttons, text boxes, checkboxes, data grids, etc.) live between user requests, which eliminates the hassle of maintaining state. JSF also synchronizes user input with application objects, automating another tedious aspect of web development.

JavaServer Faces in Action is an introduction, a tutorial, and a handy reference. With the help of many examples, the book explains what JSF is, how it works, and how it relates to other frameworks and technologies like Struts, Servlets, Portlets, JSP, and JSTL. It provides detailed coverage of standard components, renderers, converters, and validators, and how to use them to create solid applications. This book will help you start building JSF solutions today.

What's Inside

How to


"can't wait to make it available to the people I teach."
- Sang Shin, Sun Microsystems Inc.

"This book unlocks the full power of JSF ... It's a necessity."
- Jonas Jacobi, Oracle

"... explains advanced topics in detail. Well-written and a quick read."
- Matthew Schmidt, Javalobby

"... by a programmer who knows what programmers need."
- Alex Kolundzija, Columbia House

"A great reference and tutorial!"
- Mike Nash, JSF Expert Group Member

"I'm new to JSF and Java but this book has been a great help. I was searching all over the net to get info on JSF and really didn't find documentation that cleared everything up...Well, your book did ! I love the way it's structured, taking the reader one step at a time into the world of JSF and explaining WHY and HOW things are done."
-- Ben


An independent enterprise architect and developer, Kito D. Mann runs the community site and is a member of the JSF 1.2 and JSP 2.1 Expert Groups. He lives in Stamford, Connecticut with his wife, two parrots, and four cats.


As I write this foreword, I am collaborating with four leading user interface (UI) component vendors on a presentation for the 2004 JavaOneSM conference. In our presentation, the vendors will show how they leverage JavaServerTM Faces technology in their products. While developing the presentation, I am learning some things about the work we’ve been doing on JavaServer Faces for the past three years. The vendors have their own set of concerns unique to adapting their product for JavaServer Faces, but they all voice one opinion loud and clear: they are very relieved to finally have a standard for web-based user interfaces.

The absence of a standard for web-based UIs forced these component vendors to write special case code for every integrated development environment (IDE) into which they wanted to plug. Now that we have the JavaServer Faces standard, any IDE can declare compliance to that standard, and any vendor that also complies with the standard can plug components into the IDE with much less work. Of course, this means that any components you develop will also be able to plug into tools without too much additional work.

The JavaServer Faces specification was developed by a community of leading minds in the field of web UI development. We took the best ideas from many different approaches to UI frameworks and assembled them into one coherent whole. The trouble with standards is that they get rather complex in order to solve the problems they are addressing. For JavaServer Faces, that problem is providing an easy-to-use UI framework built on top of a collection of technologies not well suited to UIs at all. This has led to a particularly complex specification to implement. Thankfully, the number of people actually implementing the spec is relatively small compared to those using those implementations, but as it turns out, knowing the specification in detail is still helpful in order to use it.

As a member of the expert group developing the next version of JavaServer Pages, Kito is no stranger to technology standards. Kito grasps the key value-adds of JavaServer Faces and has explained them in a book that is accessible and in-depth. You will see what sets JavaServer Faces apart from other web UI frameworks, including its first-class component model, its well-defined state management system, and its conceptual similarity to JavaBeans. Kito is familiar with the abstractions being used by the specification, and, more important, he understands why we used those abstractions. Understanding the why of the specification leads to a superior explanation for you, the reader. For example, look at the “relationship of concepts” diagram in chapter 2. This is a great way to understand the rationale for the design of JavaServer Faces.

Kito also understands the marketplace into which this technology fits. This means you get the most important information first, so you can get your job done quickly and completely. He spends just enough time building a firm foundation of the technology underlying JavaServer Faces, making the book ideal for getting started from scratch.

Finally, the book has all the things you’ve come to expect from a top-quality software technology book: a descriptive table of contents that can serve as a framework for understanding, chapter goals and summaries to save you time, and lots of working examples that you can use in your own projects. One thing I’ve seen in this book that I haven’t seen in others is an in-depth look at the currently shipping IDEs that support JavaServer Faces. This is especially valuable because such tools can save you time, once you understand the underlying technology they support.

In addition to the unique insight this book offers on shipping IDEs, Kito brings to bear his experience as the principal of to inform the entire book. This site is a high-quality aggregation of articles, interviews, and, most important, an up-to-the-minute picture of the state of industry and community offerings related to JavaServer Faces. Kito has separate sections that cover components, render kits, implementations, and more. I think you’ll find this site—and this book—extremely valuable as you explore JavaServer Faces programming.


JavaServer Faces Specification Lead


"Provides a well-distributed focus on the what/why/how of JSF... After I saw the Struts + JSF diagram I had an 'aha' experience, and a sense of relief that I won't have to struggle with learning this topic...Superb."
-- JSF Developers' Mailing list

"One of the important features of this book, as indicated by the phrase "in action" in the title, is its devotion, not only to the discussions of the definitions and concepts of JSF, but also to the detailed actions of how to develop real-world examples and applications using JSF. With about 1,000 pages (700 pages of text, plus 300 pages of online extension), this book serves both as a tutorial for JSF beginners, and as a valuable reference for seasoned developers."
-- Computing Reviews

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

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."
-- Books-On-Line

I purchased your JSF In Action ebook from Manning and am so far loving it on Chapter 2). I like knowing that what I am learning are the 'tried and true' practices by a JSF guru instead of someone that JUST learned it and wants to write a book to make some money.

Your book has actually turned around my view of JSF as before I was quite befuddled by it. Also I have to say that the diagram of framework coverages on page 18 is absolutely excellent. This diagram alone answers so many questions that so many people will have that I think it should be added to the J2EE tutorial in the JSF section introduction. There is such a general confusion about Struts/JSF and the role they play. For example I had been flip flopping for a while trying to figure out if I wanted to do both Struts and JSF, letting Struts handle navigation, but at the same time I only want to worry about one framework in my apps, your diagram helped me realize that the facilities Struts provides over JSF are not things I currently use or will need to use, so I was able to make an informed decision to go with JSF-only apps.

Thanks for the great book!