Prentice hall core javaserver faces 2nd edition may 2007 ISBN 0131738860 pdf

vi Visual Builder Tools 22 Automation of the Build Process with Ant 24 JSF Framework Services 28 Behind the Scenes 30 Rendering Pages 30 Decoding Requests 32 The Life Cycle 33 Definition

core

This page intentionally left blank

DAVID GEARY

CAY HORSTMANN

Upper Saddle River, NJ • Boston • Indianapolis • San Francisco

New York • Toronto • Montreal • London • Munich • Paris • Madrid

Capetown • Sydney • Tokyo • Singapore • Mexico City

core

Many of the designations used by manufacturers and sellers to distinguish their products are claimed as trademarks Where those designations appear in this book, and the publisher was aware of a trademark claim, the designations have been printed with initial capital letters or in all capitals.

Sun Microsystems, Inc., has intellectual property rights relating to implementations of the technology described in this publication

In particular, and without limitation, these intellectual property rights may include one or more U.S patents, foreign patents, or pending applications Sun, Sun Microsystems, the Sun logo, J2ME, Solaris, Java, Javadoc, NetBeans, and all Sun and Java based trademarks and logos are trademarks or registered trademarks of Sun Microsystems, Inc., in the United States and other countries UNIX is a registered trademark in the United States and other countries, exclusively licensed through X/Open Company, Ltd The authors and publisher have taken care in the preparation of this book, but make no expressed or implied warranty of any kind and assume no responsibility for errors or omissions No liability is assumed for incidental or consequential damages in connection with or arising out of the use of the information or programs contained herein.

THIS PUBLICATION IS PROVIDED “AS IS” WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESS OR IMPLIED,

INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE, OR NON-INFRINGEMENT THIS PUBLICATION COULD INCLUDE TECHNICAL INACCURACIES OR

TYPOGRAPHICAL ERRORS CHANGES ARE PERIODICALLY ADDED TO THE INFORMATION HEREIN; THESE CHANGES WILL BE INCORPORATED IN NEW EDITIONS OF THE PUBLICATION SUN MICROSYSTEMS, INC., MAY MAKE

IMPROVEMENTS AND/OR CHANGES IN THE PRODUCT(S) AND/OR THE PROGRAM(S) DESCRIBED IN THIS

PUBLICATION AT ANY TIME.

The publisher offers excellent discounts on this book when ordered in quantity for bulk purchases or special sales, which may include electronic versions and/or custom covers and content particular to your business, training goals, marketing focus, and branding interests For more information, please contact: U.S Corporate and Government Sales, (800) 382-3419,

corpsales@pearsontechgroup.com For sales outside the United States, please contact: International Sales,

international@pearsoned.com.

Visit us on the Web: www.prenhallprofessional.com

Library of Congress Cataloging-in-Publication Data

Geary, David M.

Core JavaServer faces / David Geary, Cay Horstmann.—2nd ed.

p cm.

Includes bibliographical references and index.

ISBN-13: 978-0-13-173886-7 (pbk : alk paper)

ISBN-10: 0-13-173886-0 (pbk : alk paper) 1 JavaServer pages 2.

Web site development 3 Web sites—Design I Horstmann, Cay S.,

1959- II Title

TK5105.8885.J38G433 2007

005.2'768—dc22

2007006830

Copyright © 2007 Sun Microsystems, Inc.

4150 Network Circle, Santa Clara, California 95054 U.S.A.

All rights reserved Printed in the United States of America This publication is protected by copyright, and permission must be obtained from the publisher prior to any prohibited reproduction, storage in a retrieval system, or transmission in any form or by any means, electronic, mechanical, photocopying, recording, or likewise

For information regarding permissions, write to: Pearson Education, Inc., Rights and Contracts Department, One Lake Street, Upper Saddle River, NJ 07458; fax, (201) 236-3290.

ISBN 0-13-173886-0

Text printed in the United States on recycled paper at RR Donnelley in Crawfordsville, Indiana.

First printing, April 2007

JSF Pages 13 Navigation 16 Servlet Configuration 18 The Welcome File 20 Development Environments for JSF 21

Integrated Development Environments 21

vi

Visual Builder Tools 22 Automation of the Build Process with Ant 24 JSF Framework Services 28

Behind the Scenes 30 Rendering Pages 30 Decoding Requests 32 The Life Cycle 33

Definition of a Bean 37 Bean Properties 39 Value Expressions 41 Message Bundles 42

Messages with Variable Parts 44 Setting the Application Locale 45

A Sample Application 46 Backing Beans 53

Session Scope 54 Application Scope 56 Request Scope 56 Life Cycle Annotations 57 Configuring Beans 57

Setting Property Values 58 Initializing Lists and Maps 59 Chaining Bean Definitions 61 String Conversions 62

The Syntax of Value Expressions 64 Using Brackets 64

Map and List Expressions 65 Resolving the Initial Term 66 Composite Expressions 68 Method Expressions 69

An Overview of the JSF Core Tags 92

An Overview of the JSF HTML Tags 94

Using Command Buttons 121 Using Command Links 125 Selection Tags 130

Checkboxes and Radio Buttons 133 Menus and Listboxes 136

viii

h:column Attributes 178 Headers, Footers, and Captions 178

Editing Table Cells 186 Styles 189

Styles by Column 190 Styles by Row 190 Database Tables 191 JSTL Result Versus Result Sets 197 Table Models 197

Editing Table Models 198 Sorting and Filtering 203 Scrolling Techniques 214 Scrolling with a Scrollbar 215 Scrolling with Pager Widgets 216

Overview of the Conversion and Validation Process 219 Using Standard Converters 221

Conversion of Numbers and Dates 221 Conversion Errors 225

A Complete Converter Example 230 Using Standard Validators 233

Validating String Lengths and Numeric Ranges 234 Checking for Required Values 235

Displaying Validation Errors 236 Bypassing Validation 237

A Complete Validation Example 238 Programming with Custom Converters and Validators 240 Implementing Custom Converter Classes 240 Implementing Custom Validator Classes 254 Registering Custom Validators 257

Validating with Bean Methods 259

Life Cycle Events 268

Value Change Events 269

Action Events 275

Event Listener Tags 285

The f:actionListener and f:valueChangeListener Tags 285

Using Immediate Input Components 288 Using Immediate Command Components 290 Passing Data from the UI to the Server 291

The f:param Tag 292 The f:attribute Tag 292 The f:setPropertyActionListener Tag 293 Phase Events 295

Putting It All Together 303

A Book Viewer and a Library 316

The Book Viewer 318

Monolithic JSF Pages 320 Common Content Inclusion 326 Content Inclusion in JSP-Based Applications 326 JSF-Specific Considerations 327

Content Inclusion in the Book Viewer 328

Looking at Tiles 331 Installing Tiles 332 Using Tiles with the Book Viewer 333 Parameterizing Tiles 334

x

Extending Tiles 335 The Library 339

Nested Tiles 339 Tile Controllers 341

Using an External Renderer 387 Calling Converters from External Renderers 393 Supporting Value Change Listeners 394

Supporting Method Expressions 396 The Sample Application 397

Encoding JavaScript to Avoid Server Roundtrips 404 Using Child Components and Facets 408

Processing SelectItem Children 411 Processing Facets 412

Encoding CSS Styles 413 Using Hidden Fields 415 Saving and Restoring State 415 Firing Action Events 418 Using the Tabbed Pane 425

Contents xi

Implementing Custom Converters and Validators 432

Custom Converter Tags 432 Custom Validator Tags 441

Database Access with JDBC 451

Issuing SQL Statements 451 Connection Management 453 Plugging Connection Leaks 453 Using Prepared Statements 455 Configuring a Data Source 457

Configuring a Database Resource in GlassFish 457 Configuring a Database Resource in Tomcat 459 Accessing a Container-Managed Resource 462

A Complete Database Example 464

An Introduction to LDAP 473

LDAP Directories 473 Configuring an LDAP Server 474 Accessing LDAP Directory Information 479 Managing Configuration Information 483

Configuring a Bean 484 Configuring the External Context 486 Configuring a Container-Managed Resource 487 Creating an LDAP Application 491

Container-Managed Authentication and Authorization 505

Using Web Services 516

xii

Realtime Validation 537 Propagating Client-Side View State 542 Direct Web Remoting 543

Ajax Components 546 Hybrid Components 546 Keeping JavaScript Out of Renderers 551 Transmitting JSP Tag Attributes to JavaScript Code 552 Ajax4jsf 554

Implementing Form Completion with Ajax4jsf 555 Implementing Realtime Validation with Ajax4jsf 558

Dialog Configuration 576 Entering a Dialog 576 Dialog Navigation 577 Dialog Scope 578 Dialog Context Sensitivity 580 Subdialogs 583

Alternate View Technologies—Facelets 585

Replacing Markup with JSF Components:

The jsfc Attribute 587 Using JSF Tags 590 Page Composition with Templates 592 Facelets Custom Tags 594

EJB Integration—Seam 596

An Address Book 596 Configuration 601 Entity Beans 601 Stateful Session Beans 603 JSF DataModel Integration 606 Conversation Scope 608

Contents xiii

Web User Interface Design 611

How do I find more components? 611 How do I support file uploads? 614 How do I show an image map? 623 How do I include an applet in my page? 625 How do I produce binary data in a JSF page? 627 How do I show a large data set, one page at a time? 638 How do I generate a pop-up window? 644

How do I selectively show and hide components? 653 How do I customize error pages? 654

How do I package a set of tags into a JAR file? 677 How do I get the form ID for generating

document.forms[id] in JavaScript? 678 How do I make a JavaScript function appear only once per page? 679

How do I carry out initialization or cleanup work? 679 How do I store a managed bean longer than

request scope but shorter than session scope? 680 How do I extend the JSF expression language? 681 Debugging and Logging 684

How do I decipher a stack trace? 684 How do I avoid the “stack trace from hell”? 687

xiv

How do I “hot deploy” my application? 688 How do I comment out a part of a JSF page? 689 How do I find the logs? 689

How do I find out what parameters my page received? 691

How do I turn on logging of the JSF container? 692 How do I debug a stuck page? 696

How do I find the library source? 697

Chapter

Preface

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 fieldsand menus instead of fretting over page flips and request parameters Each of

us proposed a book project to the publisher, who promptly suggested that weshould 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 releasethe JSF 1.0 specification and reference implementation A bug fix 1.1 releaseemerged shortly afterwards, and an incremental 1.2 release added a number ofcleanups and convenience features in 2006

JSF is now the preeminent server-side Java web framework, and it has fulfilledmost of its promises You really can design web user interfaces by putting com-ponents on a form and linking them to Java objects, without having to mixcode and markup A strong point of JSF is its extensible component model, and

a large number of third-party components have become available The flexibledesign of the framework has allowed it to grow well and accommodate newtechnologies such as Ajax The framework was designed for tool support, and

xvi

usable drag-and-drop GUI builders have finally emerged And finally, unlikecompeting technologies that let you tumble down a deep cliff once you stepbeyond the glitz, JSF supports the hard stuff—separation of presentation andbusiness logic, navigation, connections with external services, and configura-tion management

We are still excited about JSF, and we hope you will share this excitement whenyou learn how this technology makes you a more effective web applicationdeveloper

About This Book

This book is suitable for web developers whose main focus is user interfacedesign, as well as for programmers who implement reusable components forweb applications This is in stark contrast to the official JSF specification, adense and pompously worded document whose principal audience is frame-work 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 blocksfor JSF user interfaces No programming is required for use of the tags Weassume only basic HTML skills for web pages and standard Java programmingfor 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 learnhow to perform advanced tasks, and how to extend the JSF framework Hereare 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

Preface xvii

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

implemen-tation 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

soft-ware 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

develop-ment, 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 http://corejsf.com 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

This page intentionally left blank

Chapter

Acknowledgments

First and foremost, we’d like to thank Greg Doench, our editor at Prentice Hall,

who has shepherded us through this project, never losing his nerve in spite of

numerous delays and complications

We very much appreciate our reviewers for both editions who have done a

splendid job, finding errors and suggesting improvements in various drafts of

the manuscript They are:

• Gail Anderson, Anderson Software Group, Inc

• Larry Brown, LMBrown.com, Inc

• Frank Cohen, PushToTest

• Brian Goetz, Sun Microsystems, Inc

• Rob Gordon, Crooked Furrow Farm

• Marty Hall, author of Core Java Servlets and JavaServer Pages

• Charlie Hunt, Sun Microsystems, Inc

• Jeff Langr, Langr Software Solutions

• Bill Lewis, Tufts University

• Jeff Markham, Markham Software Company

• Angus McIntyre, IBM Corporation

• John Muchow, author of Core J2ME

• Dan Shellman, BearingPoint

xx

• Sergei Smirnov, principal architect of Exadel JSF Studio

• Roman Smolgovsky, Flytecomm

• Stephen Stelting, Sun Microsystems, Inc

• Christopher Taylor, Nanshu Densetsu

• Kim Topley, Keyboard Edge Limited

• Michael Yuan, co-author of JBoss Seam: Simplicity and Power Beyond

Java EE

Finally, thanks to our families and friends who have supported us through thisproject and who share our relief that it is finally completed

core

G ETTING S TARTED

Topics in This Chapter

• “Why JavaServer Faces?” on page 3

• “Software Installation” on page 4

• “A Simple Example” on page 6

• “Sample Application Analysis” on page 12

• “Development Environments for JSF” on page 21

• “JSF Framework Services” on page 28

• “Behind the Scenes” on page 30

3

1

Why JavaServer Faces?

Judging from the job advertisements at employment web sites, there are two

popular techniques for developing web applications:

• The “rapid development” style, in which you use a visual development

environment, such as Microsoft ASP.NET

• The “hard-core coding” style, in which you write lots of code to support a

high-performance backend, such as Java EE (Java Enterprise Edition)

Development teams face a difficult choice Java EE is an attractive platform It

is highly scalable, portable to multiple platforms, and supported by many

ven-dors On the other hand, ASP.NET makes it easy to create attractive user

inter-faces without tedious programming Of course, programmers want both: a

high-performance backend and easy user interface programming The promise

of JSF (JavaServer Faces) is to bring rapid user interface development to

server-side Java

If you are familiar with client-side Java development, you can think of JSF as

“Swing for server-side applications.” If you have experience with JSP

(Java-Server Pages), you will find that JSF provides much of the plumbing that JSP

developers have to implement by hand, such as page navigation and

valida-tion You can think of servlets and JSP as the “assembly language” under

the hood of the high-level JSF framework If you already know a server-side

Chapter 1 ■ Getting Started

4

framework such as Struts, you will find that JSF uses a similar architecture but provides many additional services

NOTE: You need not know anything about Swing, JSP, or Struts to use this

book We assume basic familiarity only with Java and HTML

JSF has these parts:

• A set of prefabricated UI (user interface) components

• An event-driven programming model

• A component model that enables third-party developers to supply additional components

Some JSF components are simple, such as input fields and buttons Others are quite sophisticated—for example, data tables and trees

JSF contains all the necessary code for event handling and component zation Application programmers can be blissfully ignorant of these details and spend their effort on the application logic

organi-Perhaps most important, JSF is part of the Java EE standard JSF is included in every Java EE application server, and it can be easily added to a standalone web container such as Tomcat

For additional details, see “JSF Framework Services” on page 28 Many IDEs (integrated development environments) support JSF, with features that range from code completion to visual page designers See “Development Environments for JSF” on page 21 for more information In the following sections, we show you how to compose a JSF application by hand, so that you understand what your IDE does under the hood and you can troubleshoot problems effectively

Software Installation

You need the following software packages to get started:

• JDK (Java SE Development Kit) 5.0 or higher (http://java.sun.com/j2se)

• JSF 1.2

• The sample code for this book, available at http://corejsf.com

We assume that you have already installed the JDK and that you are familiar with the JDK tools For more information on the JDK, see Horstmann, Cay, and

Cornell, Gary, 2004, 2005 Core Java™ 2, vol 2—Advanced Features (7th ed.) Santa

Clara, CA: Sun Microsystems Press/Prentice Hall

Software Installation 5

Since JSF 1.2 is part of the Java EE 5 specification, the easiest way to try out JSF

is to use an application server that is compatible with Java EE 5 In this section,

we describe the GlassFish application server (http://glassfish.dev.java.net) You

will find instructions for other application servers on the companion web site

(http://corejsf.com)

NOTE: As this book is published, there are two major versions of JSF The

most recent version, JSF 1.2, was released as part of Java EE 5 in 2006

The original version, JSF 1.0, was released in 2004, and a bug-fix release,

named JSF 1.1, was issued shortly thereafter This book covers both

ver-sions 1.1 and 1.2, but the main focus is on version 1.2

NOTE: If you do not want to install a complete application server, you can

also use Tomcat (http://tomcat.apache.org), together with the JSF libraries

from Sun Microsystems (http://javaserverfaces.dev.java.net) See the

book’s companion web site (http://corejsf.com)for installation instructions

Install GlassFish, following the directions on the web site Then start the

appli-cation server On Unix/Linux, you use the command

To test that GlassFish runs properly, point your browser to http://localhost:8080

You should see a welcome page (see Figure 1–2)

Chapter 1 ■ Getting Started

6

Figure 1–2 GlassFish welcome page

You shut down GlassFish with the command

A Simple Example 7

Of course, in a real web application, this screen would be beautified by a

skilled graphic artist

The file that describes the login screen is essentially an HTML file with a few

additional tags (see Listing 1–1) Its visual appearance can be easily improved

by a graphic artist who need not have any programming skills

We discuss the contents of this file in detail later in this chapter, in the

section “JSF Pages” on page 13 For now, note the following points:

• A number of the tags are standard HTML tags: body,table, and so on

• Some tags have prefixes, such as f:view and h:inputText These are JSF tags

The two taglib declarations declare the JSF tag libraries

Listing 1–1 login/web/index.jsp

1.<html>

2. <%@ taglib uri="http://java.sun.com/jsf/core" prefix="f" %>

3. <%@ taglib uri="http://java.sun.com/jsf/html" prefix="h" %>

Chapter 1 ■ Getting Started

8

• The h:inputText,h:inputSecret, and h:commandButton tags correspond to the text field, password field, and submit button in Figure 1–3

• The input fields are linked to object properties For example, the attribute

value="#{user.name}" tells the JSF implementation to link the text field with thename property of a user object We discuss this linkage in more detail later in this chapter, in the section “Beans” on page 12

When the user enters the name and password, and clicks the “Login” button, a welcome screen appears (see Figure 1–4) Listing 1–3 on page 14 shows the source code for this screen The section “Navigation” on page 16 explains how the application navigates from the login screen and the welcome screen

Figure 1–4 A welcome screen

The welcome message contains the username The password is ignored for now

The purpose of this application is, of course, not to impress anyone but to illustrate the various pieces that are necessary to produce a JSF application

Ingredients

Our sample application consists of the following ingredients:

• Pages that define the login and welcome screens We call them index.jsp

and welcome.jsp

• A bean that manages the user data (in our case, username and password)

A bean is a Java class that exposes properties, usually by following a simple

naming convention for the getter and setter methods The code is in the file UserBean.java (see Listing 1–2) Note that the class is contained in the

com.corejsf package

A Simple Example 9

• A configuration file for the application that lists bean resources and

navi-gation rules By default, this file is called faces-config.xml

• Miscellaneous files that are needed to keep the servlet container happy:

theweb.xml file, and an index.html file that redirects the user to the correct

URL for the login page

More advanced JSF applications have the same structure, but they can

con-tain additional Java classes, such as event handlers, validators, and custom

components

Directory Structure

A JSF application is deployed as a WAR file: a zipped file with extension .war

and a directory structure that follows a standardized layout:

For example, the WAR file of our sample application has the directory structure

shown in Figure 1–5 Note that the UserBean class is in the package com.corejsf

Listing 1–2 login/src/java/com/corejsf/UserBean.java

1.package com.corejsf;

2.

3.public class UserBean {

4. private String name;

5. private String password;

6.

7. // PROPERTY: name

8. public String getName() { return name; }

9. public void setName(String newValue) { name = newValue; }

10.

11. // PROPERTY: password

12. public String getPassword() { return password; }

13. public void setPassword(String newValue) { password = newValue; }

Chapter 1 ■ Getting Started

10

The META-INF directory is automatically produced by the jar program when the WAR file is created

Figure 1–5 Directory structure of the sample WAR file

We package our application source in a slightly different directory structure, following the Java Blueprints conventions (http://java.sun.com/blueprints/code/projectconventions.html) The source code is contained in an src/java directory, and the JSF pages and configuration files are contained in a web directory (see Figure 1–6)

Figure 1–6 Directory structure of the sample application

Build Instructions

We now walk you through the steps required for building JSF applications with your bare hands At the end of this chapter, we show you how to auto-mate this process

A Simple Example 11

1 Launch a command shell

2 Change to the corejsf-examples directory—that is, the directory that contains

the sample code for this book

3 Run the following commands:

cd ch1/login/src/java

mkdir / /web/WEB-INF/classes

javac -d / /web/WEB-INF/classes com/corejsf/UserBean.java

On Windows, use backslashes instead:

cd ch1\login\web

mkdir WEB-INF\classes

javac -d \ \web\WEB-INF\classes com\corejsf\UserBean.java

4 Change to the ch1/login/web directory

5 Run the following command:

jar cvf login.war

(Note the period at the end of the command, indicating the current directory.)

6 Copy the login.war file to the directory glassfish/domains/domain1/autodeploy

7 Make sure that GlassFish has been started Point your browser to

http://localhost:8080/login

The application should start up at this point

The bean classes in more complex programs may need to interact with the JSF

framework In that case, the compilation step is more complex Your class

path must include the JSF libraries With the GlassFish application server,

add a single JAR file:

glassfish/lib/javaee.jar

With other systems, you may need multiple JAR files

A typical compilation command would look like this:

javac -classpath :glassfish/lib/javaee.jar

-d / /web/WEB-INF/classes com/corejsf/*.java

On Windows, use semicolons to separate the path elements:

javac -classpath ;glassfish\lib\javaee.jar

-d \ \web\WEB-INF\classes com\corejsf\*.java

Be sure to include the current directory (denoted by a period) in the class path

Chapter 1 ■ Getting Started

12

Sample Application Analysis

Web applications have two parts: the presentation layer and the business logic.

The presentation layer is concerned with the look of the application In the text of a browser-based application, the look is determined by the HTML tags that specify layout, fonts, images, and so on The business logic is implemented

con-in the Java code that determcon-ines the behavior of the application

Some web technologies intermingle HTML and code That approach is tive since it is easy to produce simple applications in a single file But for seri-ous applications, mixing markup and code poses considerable problems.Professional web designers know about graphic design, but they typically rely

seduc-on tools that translate their visiseduc-on into HTML They would certainly not want

to deal with embedded code On the other hand, programmers are notoriously unqualified when it comes to graphic design (The example programs in this book bear ample evidence.)

Thus, for designing professional web applications, it is important to separate the

presentation from the business logic This allows both web designers and grammers to focus on their core competences

pro-In the context of JSF, the application code is contained in beans, and the design

is contained in web pages We look at beans first

con-For example, the UserBean class has two properties, name and password, both of type

String:

public class UserBean {

public String getName() { }

public void setName(String newValue) { }

public String getPassword() { }

public void setPassword(String newValue) { }

}

Sample Application Analysis 13

The get/set methods can carry out arbitrary actions In many cases, they simply

get or set an instance field But they might also access a database or a JNDI

(Java Naming and Directory Interface) directory

NOTE: According to the bean specification, it is legal to omit a read or write

method For example, if getPassword is omitted, then password is a write-only

property That might indeed be desirable for security reasons However, JSF

deals poorly with this situation and throws an exception instead of taking a

default action when a read or write method is absent Therefore, it is best to

give read/write access to all bean properties

In JSF applications, you use beans for all data that needs to be accessible from a

page The beans are the conduits between the user interface and the backend of

the application

JSF Pages

You need a JSF page for each browser screen Depending on your development

environment, JSF pages typically have the extension jsp or jsf At the time of

this writing, the extension jsp requires less configuration effort For that

rea-son, we use the jsp extension in the examples of this book

NOTE: The extension of the page files is jsp or jsf, whereas in the preferred

configuration, the extension of the page URLs is faces For example, when

the browser requests the URL http://localhost:8080/login/index.faces, the

URL extension faces is mapped to the file extension.jsp and the servlet

con-tainer loads the file index.jsp This process sounds rather byzantine, but it is a

consequence of implementing JSF on top of the servlet technology

Now we take another look at the first page of our sample application in

Listing 1–1

The page starts out with the tag library declarations:

<%@ taglib uri="http://java.sun.com/jsf/core" prefix="f" %>

<%@ taglib uri="http://java.sun.com/jsf/html" prefix="h" %>

The JSF implementation defines two sets of tags The HTML tags generate

HTML-specific markup If you want your web application to render pages for

an alternative client technology, you must use a different tag library The core

tags are independent of the rendering technology For example, you need the

f:view tag both for HTML pages and for pages that are rendered by a cell phone

Chapter 1 ■ Getting Started

14

NOTE: You can choose any prefixes for tags, such as faces:view and html:inputText In this book, we use f for the core tags and h for the HTML tags

Much of the page is similar to an HTML form Note the following differences:

• All JSF tags are contained in an f:view tag

• Instead of using an HTML form tag, you enclose all the JSF components in

<h:inputText value="#{user.name}"/>

You will see the declaration of the user variable in “Navigation” on page 16 The

#{ } delimiters are explained in “The Syntax of Value Expressions” on page 64

of Chapter 2

When the page is displayed, the framework calls the getName method to obtain the current property value When the page is submitted, the framework invokes the setName method to set the value that the user entered

The h:commandButton tag has an action attribute whose value is used when ing navigation rules:

specify-<h:commandButton value="Login" action="login"/>

We discuss navigation rules in “Navigation” on page 16 The value attribute is the string that is displayed on the button

The second JSF page of our application is even simpler than the first It uses the

h:outputText tag to display the username (see Listing 1–3)

Listing 1–3 login/web/welcome.jsp

1.<html>

2. <%@ taglib uri="http://java.sun.com/jsf/core" prefix="f" %>

3. <%@ taglib uri="http://java.sun.com/jsf/html" prefix="h" %>

Sample Application Analysis 15

NOTE: We use a plain and old-fashioned format for our JSF pages so that

they are as easy to read as possible

XML-savvy readers will want to do a better job First, it is desirable to use

proper XML for the tag library declarations, eliminating the <% %> tags

Moreover, you will want to emit a proper DOCTYPE declaration for the generated

Chapter 1 ■ Getting Started

<%@ taglib uri="http://java.sun.com/jsf/html" prefix="h" %>

<%@ taglib uri="http://java.sun.com/jsf/core" prefix="f" %>

<f:view>

.This may have been acceptable at one time, but nowadays, it is quite repre-

hensible Plainly, this document is not an “HTML 4.01 Transitional”

docu-ment It merely aims to produce such a docudocu-ment Many XML editors and tools do not take it kindly when you lie about the document type Therefore, either omit the DOCTYPE altogether or follow the outline given in the preceding note

Navigation

To complete our JSF application, we need to specify the navigation rules A navigation rule tells the JSF implementation which page to send back to the browser after a form has been submitted

In this case, navigation is simple When the user clicks the login button, we want to navigate from the index.jsp page to welcome.jsp You specify this naviga-tion rule in the faces-config.xml file:

<h:commandButton value="Login" action="login"/>

In addition to the navigation rules, the faces-config.xml file contains the bean definitions Here is the definition of the user bean:

<managed-bean>

<managed-bean-name>user</managed-bean-name>

<managed-bean-class>

com.corejsf.UserBean

Sample Application Analysis 17

</managed-bean-class>

<managed-bean-scope>session</managed-bean-scope>

</managed-bean>

You can use the bean name, user, in the attributes of the user interface

compo-nents For example, index.jsp contains the tag

<h:inputText value="#{user.name}"/>

The value attribute refers to the name property of the user bean

The managed-bean-class tag specifies the bean class, in our case, com.corejsf.UserBean

Finally, the scope is set to session This means that the bean object is available

for one user across multiple pages Different users who use the web application

are given different instances of the bean object

Listing 1–4 shows the complete faces-config.xml file

NOTE: JSF 1.2 uses a schema declaration to define the syntax of a

configu-ration file The configuconfigu-ration tags are enclosed in

JSF 1.1 uses a DOCTYPE declaration instead:

<!DOCTYPE faces-config PUBLIC

"-//Sun Microsystems, Inc.//DTD JavaServer Faces Config 1.0//EN"

"http://java.sun.com/dtd/web-facesconfig_1_0.dtd">

<faces-config>

</faces-config>

We recommend that you use an XML editor that understands XML Schema

declarations If you use Eclipse, a good choice is the XMLBuddy plugin

(http://xmlbuddy.com)

Chapter 1 ■ Getting Started

Sample Application Analysis 19

The only remarkable aspect of this file is the servlet mapping All JSF pages are

processed by a special servlet that is a part of the JSF implementation code To

ensure that the correct servlet is activated when a JSF page is requested, the JSF

URLs have a special format In our configuration, they have an extension faces

For example, you cannot simply point your browser to http://localhost:8080/

login/index.jsp The URL has to be http://localhost:8080/login/index.faces The

serv-let container uses the servserv-let mapping rule to activate the JSF servserv-let, which

strips off the faces suffix and loads the index.jsp page

NOTE: You can also define a prefix mapping instead of the faces extension

mapping Use the following directive in your web.xml file:

<servlet-mapping>

<servlet-name>Faces Servlet</servlet-name>

<url-pattern>/faces/*</url-pattern>

</servlet-mapping>

Then use the URL http://localhost:8080/login/faces/index.jsp That URL

activates the JSF servlet, which then strips off the faces prefix and loads the

file /login/index.jsp

NOTE: If you want to use a jsf extension for JSF page files, then you need

to configure your web application so that it invokes the JSP servlet for files

with that extension Use the following mapping in the web.xml file: