javaserver faces in action

Kito D. Mann
Foreword by Ed Burns
MANNING
J
AVA
S
ERVER
FACES
INACTION
www.it-ebooks.info

www.it-ebooks.info
JavaServer Faces
in Action
KITO D. MANN
MANNING
Greenwich
(74° w. long.)
Licensed to JOSE CARLOS ROMERO FIGUEROA <>
www.it-ebooks.info
For online information and ordering of this and other Manning books, please go to
www.manning.com. The publisher offers discounts on this book when ordered in quantity.
For more information, please contact:
Special Sales Department
Manning Publications Co.
209 Bruce Park Avenue Fax: (203) 661-9018
Greenwich, CT 06830 email:
©2005 by Manning Publications Co. All rights reserved.
No part of this publication may be reproduced, stored in a retrieval system, or transmitted,
in any form or by means electronic, mechanical, photocopying, or otherwise, without
prior written permission of the publisher.

Many of the designations used by manufacturers and sellers to distinguish their products
are claimed as trademarks. Where those designations appear in the book, and Manning
Publications was aware of a trademark claim, the designations have been printed in initial
caps or all caps.
Recognizing the importance of preserving what has been written, it is Manning’s policy
to have the books they publish printed on acid-free paper, and we exert our best efforts
to that end.
All screens shots of Oracle JDeveloper in appendix B are reproduced with
the permission of Oracle Corp. Copyright Oracle Corp, 2004.
All screens shots of WebSphere Studio in appendix B are reproduced with
the permission of IBM Corp. Copyright IBM Corp, 2004.
Manning Publications Co. Copyeditor: Liz Welch
209 Bruce Park Avenue Typesetter: Denis Dalinnik
Greenwich, CT 06830 Cover designer: Leslie Haimes
ISBN 1-932394-11-7
Printed in the United States of America
1 2 3 4 5 6 7 8 9 10 – VHG – 08 07 06 05 04
Licensed to JOSE CARLOS ROMERO FIGUEROA <>
www.it-ebooks.info
To my beautiful wife and best friend, Tracey.
This book would not exist without you, and I’m eternally grateful
for the positive influence you’ve had on my life,
always pushing me to be the best I can be.
Licensed to JOSE CARLOS ROMERO FIGUEROA <>
www.it-ebooks.info
Licensed to JOSE CARLOS ROMERO FIGUEROA <>
www.it-ebooks.info
vii
PART 1 EXPLORING JAVASERVER FACES 1
1

■
Introducing JavaServer Faces 3
2
■
JSF fundamentals 38
3
■
Warming up: getting around JSF 88
4
■
Getting started with the standard components 137
5
■
Using the input and data table components 185
6
■
Internationalization, validators, and converters 234
PART 2 BUILDING USER INTERFACES 275
7
■
Introducing ProjectTrack 277
8
■
Developing a user interface without Java code:
the Login page 287
9
■
Developing a user interface without Java code:
the other pages 316
10

■
Integrating application functionality 354
brief contents
Licensed to JOSE CARLOS ROMERO FIGUEROA <>
www.it-ebooks.info
viii BRIEF CONTENTS
PART 3 DEVELOPING APPLICATION LOGIC 407
11
■
The JSF environment 409
12
■
Building an application: design issues and
foundation classes 456
13
■
Building an application: backing beans, security,
and internationalization 499
14
■
Integrating JSF with Struts and
existing applications 568
PART 4 WRITING CUSTOM COMPONENTS, RENDERERS,
VALIDATORS, AND CONVERTERS 603
15
■
The JSF environment: a component
developer’s perspective 605
PART 5 WRITING CUSTOM COMPONENTS, RENDERERS,
VALIDATORS, AND CONVERTERS: EXAMPLES 703

16
■
UIInputDate: a simple input component 705
17
■
RolloverButton renderer: a renderer
with JavaScript support 727
18
■
UIHeadlineViewer: a composite,
data-aware component 756
19
■
UINavigator: a model-driven toolbar component 794
20
■
Validator and converter examples 839
ONLINE EXTENSION
The five chapters in part 5 (plus four additional
appendixes) are not included in the print edition.
They are available for download in PDF format from
the book’s web page to owners of this book. For free
access to the online extension please go to www.
manning.com/mann.
Licensed to JOSE CARLOS ROMERO FIGUEROA <>
www.it-ebooks.info
ix
foreword xxi
preface xxiii
acknowledgments xxv

about this book xxvii
about the title and cover xxxiii
PART 1 EXPLORING JAVASERVER FACES 1
1
Introducing JavaServer Faces 3
1.1 It’s a RAD-ical world 4
So, what is JavaServer Faces? 5
■
Industry support 10
1.2 The technology under the hood 10
Hypertext Transfer Protocol (HTTP) 11
■
Servlets 12
Portlets 13
■
JavaBeans 14
■
JSP and other display
technologies 15
1.3 Frameworks, frameworks, frameworks 16
Why do we need frameworks? 16
■
She’s a Model 2 17
JSF, Struts, and other frameworks 18
1.4 Components everywhere 19
contents
Licensed to JOSE CARLOS ROMERO FIGUEROA <>
www.it-ebooks.info
x CONTENTS
1.5 Hello, world! 22

Dissecting hello.jsp 24
■
Dissecting goodbye.jsp 31
Examining the HelloBean class 32
■
Configuration with

faces-config.xml 34
■
Configuration with web.xml 36
1.6 Summary 37
2
JSF fundamentals 38
2.1 The key pieces of the pie 39
User interface components 41
■
Renderers 43
Validators 44
■
Backing beans 45
■
Converters 48
Events and listeners 49
■
Messages 55
■
Navigation 56
2.2 The Request Processing Lifecycle 57
Phase 1: Restore View 61
■

Phase 2: Apply Request Values 63
Phase 3: Process Validations 65
■
Phase 4: Update Model
Values 66
■
Phase 5: Invoke Application 66
■
Phase 6:
Render Response 68
2.3 Understanding component and client identifiers 69
Naming containers 72
■
Referencing identifiers 73
2.4 Exploring the JSF expression language 76
Understanding scoped variables 80
■
Using implicit
variables 81
■
Using the EL with components 83
2.5 Summary 86
3
Warming up: getting around JSF 88
3.1 Setting up your JSF environment 89
Basic requirements 89
■
Choosing a JSF implementation 89
Directory structure 90
■

Configuration 92
3.2 The role of JSP 102
Using JSP includes 103
■
Using JSF with JSTL and other JSP
custom tags 104
3.3 Creating and initializing beans 110
Declaring managed beans 113
■
Declaring Lists and Maps as
managed beans 123
■
Setting values with value-binding
expressions 125
3.4 Navigating the sea of pages 129
3.5 Summary 136
Licensed to JOSE CARLOS ROMERO FIGUEROA <>
www.it-ebooks.info
CONTENTS xi
4
Getting started with the standard components 137
4.1 It’s all in the components 138
Using HTML attributes 142
■
Understanding facets 143
The power of tools 145
■
The render kit behind the scenes 148
4.2 Common component properties 148
4.3 Controlling the page with UIViewRoot 149

4.4 Setting component parameters with UIParameter 151
4.5 Displaying data with the Output components 153
Displaying ordinary text with HtmlOutputText 153
■
Using
UIOutput with the <f:verbatim> tag 155
■
Creating input
labels with HtmlOutputLabel 158
■
Using HtmlOutputFormat
for parameterized text 160
■
Displaying hyperlinks with
HtmlOutputLink 165
4.6 Displaying images with HtmlGraphicImage 167
4.7 Displaying component messages
with HtmlMessage 169
4.8 Displaying application messages
with HtmlMessages 172
4.9 Grouping and layout with the Panel components 176
Grouping components with HtmlPanelGroup 176

Creating tables with HtmlPanelGrid 178
4.10 Summary 184
5
Using the input and data table components 185
5.1 Registering event listeners 186
Declaring value-change listeners 187

Declaring action listeners 187
5.2 Common component properties 189
5.3 Handling forms with HtmlForm 190
5.4 Handling basic user input 192
Declaring basic text fields with HtmlInputText 193
■
Using
HtmlInputTextarea for memo fields 194
■
Displaying password
fields with HtmlInputSecret 195
■
Declaring hidden fields with
HtmlInputHidden 197
Licensed to JOSE CARLOS ROMERO FIGUEROA <>
www.it-ebooks.info
xii CONTENTS
5.5 Using HtmlSelectBooleanCheckbox
for checkboxes 198
5.6 Defining item lists 199
Using UISelectItem for single items 200
■
Using UISelectItems
for multiple items 203
5.7 Handling multiple-item selections 205
Using HtmlSelectManyCheckbox for checkbox groups 205
Displaying listboxes with HtmlSelectManyListbox 208
Using HtmlSelectManyMenu for single-item listboxes 210
5.8 Handling single-item selections 212
Using HtmlSelectOneRadio for radio button groups 212

Using single-select listboxes with HtmlSelectOneListbox 215
Declaring combo boxes with HtmlSelectOneMenu 217
5.9 Executing application commands 219
Declaring buttons with HtmlCommandButton 219
Creating an action link with HtmlCommandLink 221
5.10 Displaying data sets with HtmlDataTable 223
5.11 Summary 233
6
Internationalization, validators, and converters 234
6.1 Internationalization and localization 235
Looking into locales 236
■
Creating resource bundles 238
Using resource bundles with components 241
Internationalizing text from back-end code 244
6.2 Input validation 245
Using validator methods 245
■
Using validators 246
Using the standard validators 247
■
Combining different
validators 251
6.3 Type conversion and formatting 251
Using converters 254
■
Working with the

standard converters 255
6.4 Customizing application messages 269

6.5 Summary 273
Licensed to JOSE CARLOS ROMERO FIGUEROA <>
www.it-ebooks.info
CONTENTS xiii
PART 2 BUILDING USER INTERFACES 275
7
Introducing ProjectTrack 277
7.1 Requirements 278
7.2 The conceptual model 281
7.3 User interface 283
7.4 Development team 284
7.5 Summary 286
8
Developing a user interface without Java code:

the Login page 287
8.1 Getting started 289
Setting up web.xml 289
■
Setting up faces-config.xml 290
8.2 Creating the Login page 291
Starting with HtmlGraphicImage and HtmlOutputText
components 292
■
Adding a form 295
8.3 Sprucing things up 300
Using an image for the button 301
■
Integrating with
JavaScript 301

■
Adding Cascading Style Sheets 303
8.4 Adding validators 304
Customizing validation messages 307
8.5 Improving layout with HtmlPanelGrid 308
8.6 Summary 314
9
Developing a user interface without Java code:

the other pages 316
9.1 Building the header with a custom component 317
Using a custom toolbar component 321
■
Configuring the
navigation rule 323
9.2 Prototyping data tables with panels 324
The Inbox page 325
■
Configuring the navigation rule 329
The Show All page 330
■
Configuring the

navigation rule 330
Licensed to JOSE CARLOS ROMERO FIGUEROA <>
www.it-ebooks.info
xiv CONTENTS
9.3 Creating input forms 331
The Approve a Project page 331
■

Configuring the navigation
rule 337
■
The Reject a Project page 338
■
Configuring the
navigation rule 341
■
The Create a Project page 341
Configuring the navigation rule 347
9.4 The Project Details page 347
Configuring the navigation rule 351
9.5 Summary 353
10
Integrating application functionality 354
10.1 Understanding JSF development approaches 355
10.2 Exploring the application environment 357
10.3 Reorganizing pages for security 360
10.4 The Login page 360
Updating the navigation rule 364
10.5 The header 365
Updating the navigation rule 369
10.6 Integrating data grids 370
The Inbox page 370
■
The Show All page 378
10.7 Integrating input forms 379
Updating the includes 379
■
The Approve a Project page 382

The Reject a Project page 385
■
The Create a Project
page 386
10.8 The Project Details page 390
Updating the navigation rule 395
10.9 Adding an error page 396
Updating web.xml 397
■
Updating the navigation rule 397
10.10 Internationalizing and localizing the UI 398
Externalizing text into the resource bundle 398
Internationalizing the header 400
Localizing for Russian 402
10.11 Summary 404
Licensed to JOSE CARLOS ROMERO FIGUEROA <>
www.it-ebooks.info
CONTENTS xv
PART 3 DEVELOPING APPLICATION LOGIC 407
11
The JSF environment 409
11.1 From servlets to JSF 410
11.2 The application foundation 413
Application 413
■
Evaluation expressions 417
11.3 It’s all in the context 419
FacesContext 420
■
FacesMessage 422

ExternalContext 424
11.4 Event handling 428
FacesEvent 430
■
Handling action events 432
■
Handling
value-change events 434
■
Handling phase events 435
11.5 Components revisited 438
UIComponent 442
■
UIViewRoot 446
ValueHolder 449
■
EditableValueHolder 451
SelectItem and SelectItemGroup model beans 453
11.6 Summary 455
12
Building an application: design issues

and foundation classes 456
12.1 Layers of the pie 457
12.2 Roasting the beans 460
The importance of toString 461
■
Serialization for
breakfast 462
■

It’s all in the properties 462
Exposing beans 472
12.3 Exploring the business layer and data layers 473
12.4 Developing the application layer 476
Handling constants 478
■
Organizing utility methods 480
Initializing singletons 482
■
Adapting business objects 484
12.5 Writing a visit object for session state 491
12.6 Developing a base backing bean class 494
12.7 Summary 498
Licensed to JOSE CARLOS ROMERO FIGUEROA <>
www.it-ebooks.info
xvi CONTENTS
13
Building an application: backing beans, security,

and internationalization 499
13.1 Writing backing beans 500
Thread safety 501
■
Handling errors 501
■
Performing
authentication 505
■
Listing projects with UIData and
parameterizing listeners 511

■
Updating projects 522
Creating new projects 528
■
Paging through the project

history with UIData 534
■
Working with JDBC ResultSets

and UIData 540
13.2 Adding security 545
Container-based vs. custom security 546

Using custom security 547
13.3 Supporting internationalization in code 551
Internationalizing text with resource bundles 552
Internationalizing messages 557
13.4 Design consequences and alternatives 562
Accessing the business layer 562
■
Organizing beans by
function 563
■
Action methods implemented by backing
beans 564
■
Initializing backing bean properties with the
Managed Bean Creation facility 565
13.5 Summary 566

14
Integrating JSF with Struts and existing
applications 568
14.1 What integration means 569
14.2 When to use JSF with other frameworks 569
14.3 The many faces of requests and responses 571
14.4 Integrating JSF with Struts applications 572
First steps 575
■
Migrating Struts JSP tags 577
Using JSF action methods and managed beans 597
Who’s controlling whom? 599
14.5 Integrating JSF with non-Struts applications 600
14.6 Summary 601
Licensed to JOSE CARLOS ROMERO FIGUEROA <>
www.it-ebooks.info
CONTENTS xvii
PART 4 WRITING CUSTOM COMPONENTS, RENDERERS,
VALIDATORS, AND CONVERTERS 603
15
The JSF environment: a component

developer’s perspective 605
15.1 Three steps to UI extension nirvana 606
15.2 Developing UI components 607
Deciding when to write a UI component 608
■
Classes and
interfaces 610
■

Event handling with method bindings 623
Registration 624
■
JSP integration 627
15.3 Developing renderers 636
Deciding when to write a renderer 640
■
Renderer 641
RenderKit 643
■
Registration 644
■
JSP integration 647
15.4 Developing validators 648
Validator 649
■
Registration 650
■
JSP integration 652
15.5 Developing converters 654
Converter 654
■
Registration 657
■
JSP integration 658
15.6 Handling internationalization 660
15.7 Packaging UI extensions 660
15.8 Summary 661
appendix A: Using JSF without JSP 665
references 675

index 679
online extension:
See page xviii for contents
Licensed to JOSE CARLOS ROMERO FIGUEROA <>
www.it-ebooks.info
xviii
The online extension consists of five chapters in part 5 as well as four
appendixes that are not included in the print edition. They are available
for free download from the book’s web site at www.manning.com/mann.
This is the table of contents for the online extension.

PART 5 WRITING CUSTOM COMPONENTS, RENDERERS,
VALIDATORS, AND CONVERTERS: EXAMPLES 703
16
UIInputDate: a simple input component 705
16.1 Writing the UIInputDate class 708
Encoding 709
■
Decoding 715
■
Implementing

StateHolder methods 717
16.2 Registering the component 718
16.3 JSP integration 718
Writing the JSP custom tag 718
■
Validating the tag 721
Adding the tag to the tag library 722
16.4 Using the component 724

16.5 Summary 726
online extension
Licensed to JOSE CARLOS ROMERO FIGUEROA <>
www.it-ebooks.info
ONLINE EXTENSION xix
17
RolloverButton renderer: a renderer with

JavaScript support 727
17.1 Writing the RolloverButtonRenderer class 729
Encoding 731
■
Decoding 735
Registering the renderer 736
17.2 JSP Integration 737
Writing the HtmlBaseTag class 738
■
Writing the JSP custom
tag 741
■
Validating the tag 744
■
Adding the tag to the

tag library 745
17.3 Using the renderer 748
17.4 Wrapping an existing renderer 750
Developing the RolloverButtonDecoratorRenderer class 750
17.5 Summary 754
18

UIHeadlineViewer: a composite, data-aware
component 756
18.1 RSS and the Informa API 758
18.2 Using UIData with Informa 763
18.3 Subclassing DataModel 765
18.4 Writing the UIHeadlineViewer class 768
18.5 Registering the component 780
18.6 JSP integration 781
Writing the JSP custom tag 781
Adding the tag to the tag library 787
18.7 Using the component 789
18.8 Summary 793
19
UINavigator: a model-driven toolbar component 794
19.1 Writing the model classes 796
19.2 Writing the UINavigator class 801
Implementing ActionSource methods 803
■
Overriding
UIComponentBase methods 806
■
Implementing StateHolder
methods 807
■
Developing NavigatorActionListener:

a custom ActionListener 809
Licensed to JOSE CARLOS ROMERO FIGUEROA <>
www.it-ebooks.info
xx ONLINE EXTENSION

19.3 Registering the component 810
19.4 Writing the ToolbarRenderer class 811
Encoding 811
■
Decoding 820
19.5 Registering the renderer 821
19.6 JSP integration 822
Writing the Navigator_ToolbarTag component tag 822
Writing the NavigatorItemTag tag handler 826
Adding the tags to the tag library 831
19.7 Using the component 834
19.8 Summary 838
20
Validator and converter examples 839
20.1 Validator methods vs. validator classes 840
20.2 Developing a validator 840
Writing the RegularExpressionValidator class 842
Registering the validator 847
■
Integrating with JSP 847
Using the validator 852
20.3 When custom converters are necessary 854
20.4 Developing a converter 854
Writing the UserConverter class 856
■
Registering the
converter 865
■
JSP integration 866
Using the converter 870

20.5 Summary 872
appendix B: A survey of JSF IDEs and implementations 873
appendix C: Extending the core JSF classes 935
appendix D: JSF configuration 958
appendix E: Time zone, country, language, and currency codes 976
Licensed to JOSE CARLOS ROMERO FIGUEROA <>
www.it-ebooks.info
xxi
foreword
As I write this foreword, I am collaborating with four leading user interface
(
UI) component vendors on a presentation for the 2004 JavaOne
SM
conference.
In our presentation, the vendors will show how they leverage JavaServer
TM
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 ven-
dors 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 lead-
ing 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
Licensed to JOSE CARLOS ROMERO FIGUEROA <>
www.it-ebooks.info
xxii FOREWORD
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 implement-
ing 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 frame-
works, including its first-class component model, its well-defined state manage-
ment 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 “relation-
ship of concepts” diagram in chapter 2. This is a great way to understand the ratio-

nale 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 frame-
work 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 JSFCentral.com 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.
E
D BURNS
JavaServer Faces Specification Lead
Licensed to JOSE CARLOS ROMERO FIGUEROA <>
www.it-ebooks.info
xxiii
preface
I’ve always enjoyed writing. I was one of those computer geeks who found
humanities classes easier, in some ways, than computer science courses—that

is, if I could manage to convince my professors that I had actually read the
dozens of books they gave me. In the late 1990s, I finally fused my affection
for writing with my obsession for software development by writing magazine
articles and performing technical book reviews. Then, in 2000, after years of
financial consulting with Fortune 500 companies, I took the start-up plunge.
Okay, so it was a little late. But I was jealous of my friends who had joined
start-ups and intrigued by all of those wonderful stories in magazine articles.
The start-up I chose was an educational application service provider (recently
acquired by McGraw-Hill) that, surprisingly, had a real business plan. A key
part of our product was a web-based application, and one of my tasks, as chief
architect, was to build it (with, of course, the help of other poor souls). Instead
of using my own homegrown web application framework, I chose Struts, which
at the time was a good decision. As I directed development through a couple
of release cycles, I gained an understanding of the good and bad parts of
Struts, as well as the issues involved with developing a mission-critical web
application with team members who all had different backgrounds.
After two years of burning myself out and neglecting my girlfriend Tracey,
I resigned and spent some time getting to know the stranger called Sleep. After
we had been sufficiently reacquainted, I inhaled as much information as possible
Licensed to JOSE CARLOS ROMERO FIGUEROA <>
www.it-ebooks.info
xxiv PREFACE
about new technologies, and stumbled across the Java Specification Request (JSR)
127—JavaServer Faces (
JSF). JSF seemed like an answer to the growing problem of
framework mania. Moreover, since
JSF abstracts so many tedious details of web
application development, it seemed superior to Struts in many ways. It was clear
to me that
JSF was the Next Big Thing in Java web development.

Because I was anxious to get back into writing something other than architec-
ture specifications and memos, writing a book on
JSF seemed like a good idea. I
had reviewed several books for Manning, so I contacted the publisher to discuss
writing one about
JSF. After some lobbying, Manning agreed, and the JavaServer
Faces in Action project was born. Little did we know that the specification would
go through radical changes before its final (late) release in March 2004. (If I had
a crystal ball, I would certainly not have written so much of it in early 2003;
rewriting is just not fun.)
Throughout the last year and half, a lot has happened. In May 2003, I mar-
ried Tracey (I suppose leaving the start-up was a good thing after all). Later that
year, I launched
JSF Central, a web site dedicated to the JSF community, chock-
full of resources and a handy
FAQ. And finally, on March 3, 2004, JSF 1.0 was
released (with the 1.1 maintenance release appearing in May). The result is a
solid technology that I believe will add fire to the world of Java web develop-
ment, not only by making life easier for day-to-day development but also by
igniting a third-party user interface (
UI) component industry, à la Microsoft’s
ASP.NET Web Forms.
To that end, I’ve worked hard to ensure that this book will serve as a catalyst
on both fronts, not only helping you understand what
JSF is, how it works, and
how to use it, but also teaching you how to write your own
UI components. I’ve
also worked with representatives from Oracle,
IBM, and Sun to paint a picture of
how

JSF is integrated into different IDEs. In addition, this text was influenced by
my role as editor-in-chief of
JSF Central, where I have gained a unique vantage
point of the growing
JSF ecosystem.
So, there you have it. I hope JavaServer Faces in Action will inspire in you the
enthusiasm that I have for this technology and serve as a useful tool in your own
projects. In the meantime, I intend to reacquaint myself with that old friend,
Sleep. Feel free to send your comments about this book to or
post them in the Author Online forum for this book at www.manning.com/mann;
once awake, I’ll be happy to read them.

Licensed to JOSE CARLOS ROMERO FIGUEROA <>
www.it-ebooks.info
xxv
acknowledgments
Most projects are not one-person endeavors, even if they start out that way.
Technical books require the talents of an enormous range of people, many of
whom donate their free time. (I will, however, take the prize for that particular
sacrifice.) Let’s start at the beginning with Clay Anders, the person at Manning
who believed that this book was a good idea, well before anyone else was talking
about JavaServer Faces. Then, there’s Marjan Bace, Manning’s publisher, who
authorized the project, then promptly ripped the first draft of my introduction
to shreds. Without Marjan, this book would have already put you to sleep. (If
you’re holding open your eyelids with your fingertips right now, blame him.)
Next, there’s Jackie Carter—I couldn’t dream of a better developmental
editor. Jackie didn’t just critique and guide my work; she was a true partner
throughout the process. I’d also like to thank the legions of technical reviewers
who let my words consume their evenings without compensation: Roland Bar-
cia, Todd Cunningham, Jeff Duska, Carl Hume, Will Forster, Aleksandar Kol-

undzija, Jason LeCount, Josh Oberwetter, Michael Nash, Russ Pearlman, Mark
Pippins, Matthew Schmidt, Keyur Shah, Sang Shin, and Henri Yandell. Ted
Kennedy (rest in peace) and Dave Roberson deserve mention for doing a com-
mendable job coordinating the review process.
Several members of the
JSF Expert Group (Eric Lazarus, Brian Murray,
Adam Winer, and especially Michael Nash) helped ensure the technical accu-
racy of this book, and Ed Burns (the co-spec lead) wrote an excellent foreword.
Licensed to JOSE CARLOS ROMERO FIGUEROA <>
www.it-ebooks.info