Core JavaServer(TM) Faces (2nd Edition) (Sun Core Series) (Paperback)

by David Geary (Author), Cay S. Horstmann (Author)
Key Phrases: custom components, external services, selection tags, Done Figure, Data Tables, Web User Interface Design (more...)

Editorial Reviews

Product Description

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

Preface
Acknowledgments
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 . . .
Index 


From the Back Cover

JavaServer Faces promises to bring rapid user-interface development to server-side Java. It allows developers to painlessly write server-side applications without worrying about the complexities of dealing with browsers and Web servers. It also automates low-level, boring details like control flow and moving code between web forms and business logic.

JavaServer Faces was designed to support drag and drop development of server-side applications," but you can also think of it as a conceptual layer on top of servlets and JavaServer Pages (JSP). Experienced JSP developers will find that JavaServer Faces provides much of the plumbing that they currently have to implement by hand. If you already use a server-side framework such as Struts, you will find that JavaServers Faces uses a similar architecture, but is more flexible and extensible. JavaServer Faces also comes with server-side components and an event model, which are fundamentally similar to the same concepts in Swing.

JavaServer Faces is quickly becoming the standard Web-application framework. Core JavaServer Faces is the one book you need to master this powerful and time-saving technology.

Without assuming knowledge of JSP and servlets, Core JavaServer Faces:

• shows how to build more robust applications and avoid tedious handcoding
• answers questions most developers don't even know to ask
• demonstrates how to use JSF with Tiles to build consistent user interfaces automatically
• provides hints, tips, and explicit "how-to" information that allows you to quickly become more productive
• explains how to integrate JSF with databases, use directory services, wireless apps, and Web services
• teaches best practices and good habits like using style sheets and message bundles
• covers all of the JSF tags and how to create new tag libraries

--This text refers to the Paperback edition.

See all Editorial Reviews

Product Details

• Paperback: 752 pages
• Publisher: Prentice Hall PTR; 2 edition (May 19, 2007)
• Language: English
• ISBN-10: 0131738860
• ISBN-13: 978-0131738867
• Product Dimensions: 9 x 6.9 x 1.5 inches
• Shipping Weight: 2.3 pounds (View shipping rates and policies)
• Average Customer Review: 3.9 out of 5 stars See all reviews (37 customer reviews)
• Amazon.com Sales Rank: #36,875 in Books (See Bestsellers in Books)

  Popular in these categories: (What's this?)

  #40 in	Books > Computers & Internet > Graphic Design > Website Architecture & Usability
  #57 in	Books > Computers & Internet > Programming > Java

Customer Reviews

Most Helpful Customer Reviews

47 of 49 people found the following review helpful:

5.0 out of 5 stars Perfect Cure for Misunderstood New Standard, September 10, 2004

By	R. Williams "code slubber" (Los Angeles, CA United States) - See all my reviews (REAL NAME)

This review is from: Core JavaServer Faces (Core Series) (Paperback)

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.

20 of 20 people found the following review helpful:

4.0 out of 5 stars good intro for JSF but..., October 8, 2004

By	S. Varadarajan "browngeek" (bay area) - See all my reviews (REAL NAME)

This review is from: Core JavaServer Faces (Core Series) (Paperback)

I am currently reading David Gearys 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 )

21 of 22 people found the following review helpful:

3.0 out of 5 stars It tells you how, but not why, October 24, 2004

By	Jeff Mackay "A woodworking geek" (Waukesha, WI USA) - See all my reviews (REAL NAME)

This review is from: Core JavaServer Faces (Core Series) (Paperback)

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