Core JavaServer Faces (Core Series)
  • Alternative view 1 of Core JavaServer Faces (Core Series)
  • Alternative view 2 of Core JavaServer Faces (Core Series)

Core JavaServer Faces (Core Series)

4.5 2
by David Geary, Cay Horstmann

View All Available Formats & Editions

JavaServer Faces (JSF) is quickly emerging as the leading solution for rapid user interface development in Java-based server-side applications. Now, Core JavaServer™ Faces–the #1 guide to JSF–has been thoroughly updated in this second edition, covering the latest feature enhancements, the powerful Ajax development techniques, and


JavaServer Faces (JSF) is quickly emerging as the leading solution for rapid user interface development in Java-based server-side applications. Now, Core JavaServer™ Faces–the #1 guide to JSF–has been thoroughly updated in this second edition, covering the latest feature enhancements, the powerful Ajax development techniques, and open source innovations that make JSF even more valuable.

Authors David Geary and Cay Horstmann delve into all facets of JSF 1.2 development, offering systematic best practices for building robust applications, minimizing handcoding, and maximizing productivity. Drawing on unsurpassed insider knowledge of the Java platform, they present solutions, hints, tips, and “how-tos” for writing superior JSF 1.2 production code, even if you’re new to JSF, JavaServer Pages™, or servlets.

The second edition’s extensive new coverage includes: JSF 1.2’s improved alignment with the broader Java EE 5 platform; enhancements to the JSF APIs; controlling Web flow with Shale; and using Facelets to replace JSP with XHTML markup. The authors also introduce Ajax development with JSF–from real-time validation and Direct Web Remoting to wrapping Ajax in JSF components and using the popular Ajax4jsf framework.

This book will help you

  • Automate low-level details and eliminate unnecessary complexity in server-side development
  • Discover JSF best practices, ranging from effective UI design and style sheets to internationalization
  • Use JSF with Tiles to build consistent, reusable user interfaces
  • Leverage external services such as databases, LDAP directories, authentication/authorization, and Web services
  • Use JBoss Seam to greatly simplify development of database-backed applications
  • Implement custom components, converters, and validators
  • Master the JSF 1.2 tag libararies, and extend JSF with additional tag libraries


Chapter 1: Getting Started Chapter 2: Managed Beans Chapter 3: Navigation Chapter 4: Standard JSF Tags Chapter 5: Data Tables Chapter 6: Conversion and Validation Chapter 7: Event Handling Chapter 8: Subviews and Tiles Chapter 9: Custom Components, Converters, and Validators Chapter 10: External Services Chapter 11: Ajax Chapter 12: Open Source Chapter 13: How Do I . . .

Product Details

Prentice Hall
Publication date:
Sun Core Series
Product dimensions:
6.92(w) x 9.24(h) x 1.40(d)

Read an Excerpt

When we heard about JavaServer Faces (JSF) at the 2002 JavaOne conference, we were very excited. Both of us had extensive experience with client-side Java programming, and had lived to tell the tale—David in Graphic Java, and Cay in Core Java, both published by Sun Microsystems Press. When we first tried web programming with servlets and JavaServer Pages (JSP), we found it to be rather unintuitive and tedious. JavaServer Faces promised to put a friendly face in front of a web application, allowing programmers to think about text fields and menus instead of fretting over page flips and request parameters. Each of us proposed a book project to the publisher, who promptly suggested that we should jointly write the Sun Microsystems Press book on this technology.

It took the JSF Expert Group (of which David was a member) until 2004 to release the JSF 1.0 specification and reference implementation. A bug fix 1.1 release emerged shortly afterwards, and an incremental 1.2 release added a number of cleanups and convenience features in 2006.

JSF is now the preeminent server-side Java web framework, and it has fulfilled most of its promises. You really can design web user interfaces by putting components on a form and linking them to Java objects, without having to mix code and markup. A strong point of JSF is its extensible component model, and a large number of third-party components have become available. The flexible design of the framework has allowed it to grow well and accommodate new technologies such as Ajax. The framework was designed for tool support, and usable drag-and-drop GUI builders have finallyemerged. And finally, unlike competing technologies that let you tumble down a deep cliff once you step beyond the glitz, JSF supports the hard stuff—separation of presentation and business logic, navigation, connections with external services, and configuration management.

We are still excited about JSF, and we hope you will share this excitement when you learn how this technology makes you a more effective web application developer. About This Book

This book is suitable for web developers whose main focus is user interface design, as well as for programmers who implement reusable components for web applications. This is in stark contrast to the official JSF specification, a dense and pompously worded document whose principal audience is framework implementors, as well as long-suffering book authors.

The first half of the book, extending through Chapter 6, focuses on the JSF tags. These tags are similar to HTML form tags. They are the basic building blocks for JSF user interfaces. No programming is required for use of the tags. We assume only basic HTML skills for web pages and standard Java programming for the business logic.

The first part of the book covers these topics:

  • Setting up your programming environment (Chapter 1)
  • Connecting JSF tags to application logic (Chapter 2)
  • Navigating between pages (Chapter 3)
  • Using the standard JSF tags (Chapters 4 and 5)
  • Converting and validating input (Chapter 6)

Starting with Chapter 7, we begin JSF programming in earnest. You will learn how to perform advanced tasks, and how to extend the JSF framework. Here are the main topics of the second part:

  • Event handling (Chapter 7)
  • Including common content among multiple pages (Chapter 8)
  • Implementing custom components, converters, and validators
  • (Chapter 9)
  • Connecting to databases and other external services (Chapter 10)
  • Ajax (Chapter 11)
  • Open source technologies, with a focus on Facelets, Seam, and Shale (Chapter 12)

We end the book with a chapter that aims to answer common questions of the form “How do I . . . ” (see Chapter 13). We encourage you to have a peek at that chapter as soon as you become comfortable with the basics of JSF. There are helpful notes on debugging and logging, and we also give you implementation details and working code for features that are missing from JSF, such as file uploads, pop-up menus, and a pager component for long tables.

JSF is built on top of servlets and JSP, but from the point of view of the JSF developer, these technologies merely form the low-level plumbing. While it can’t hurt to be familiar with other web technologies such as servlets, JSP, or Struts, we do not assume any such knowledge. Required Software

All software that you need for this book is freely available. You need the Java Software Development Kit from Sun Microsystems and an application server that supports JSF, such as the excellent open source GlassFish project. The software runs identically on Linux, Mac OS X, Solaris, and Windows. We used Java 5 and GlassFish on both Linux and Mac OS X to develop the code examples in the book.

If you are looking for a development environment that supports JSF development, we can heartily recommend the freely available NetBeans IDE. Good JSF support for Eclipse is available from several vendors that sell Eclipse enhancements. Web Support

The web page for this book is It contains

  • The source code for all examples in this book
  • Useful reference material that we felt is more effective in browseable form than in print
  • A list of known errors in the book and the code
  • A form for submitting corrections and suggestions

Meet the Author

David Geary, who worked at Sun Microsystems from 1994 through 1997, was a member of the JSF 1.0 Expert Group. He is president of Clarity Training Inc., a training and consulting company focusing on server-side Java technology, and is the author of eight books on Java technology, including the best-selling Graphic Java 2 series, Advanced JavaServer Pages, and Google Web Toolkit Solutions (all from Prentice Hall). David was also a member of the JSTL Expert Group, was the Second Apache Struts committer, and wrote questions for Sun's Web Developer Certification Exam. David is a regular speaker on the popular No Fluff Just Stuff tour and is a JavaOne Rock Star, by virtue of his Shale Presentation with Craig McClanahan in 2005.

Cay S. Horstmann is a professor of computer science at San Jose State University. He has served as vice president and chief technology officer of Preview Systems Inc., and as a consultant on C++, Java, and Internet programming for major corporations, universities, and organizations. Cay is also the author of the classic Core Java books.

Customer Reviews

Average Review:

Write a Review

and post it to your social network


Most Helpful Customer Reviews

See all customer reviews >

Core JavaServer Faces 4.5 out of 5 based on 0 ratings. 2 reviews.
Guest More than 1 year ago
[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. 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.
Guest More than 1 year ago
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.