WIXLIB

Value binding expressionWrite a managed bean identifier and property name by concatenating them with "." (dot) in "#{ }".If beans are nested, as many beans as the number of nested beans can be concatenated using "."A sample JSP page is shown below. f:view !-- Displaying the myprop property of the managed bean, whichis defined with the name mybean -- h:outputText value "#{mybean.myprop}" / !-- Displaying the myprop property of mybean3, while mybean1,mybean2, and mybean3 are nested -- h:outputText value "#{mybean1.mybean2.mybean3.myprop}" / /f:view If the property is an array, java.util.List, java.util.Map, refer to the value by using "[]". f:view !-- If the myArray property is an array, display the 0th elementof the array. -- h:outputText value "#{mybean.myArray[0]}" / !-- If the myList property is of the java.util.List type, displaythe 3rd element of the list. -- h:outputText value "#{mybean.myList[3]}" / !-- If the myMap property is of the java.util.Map type, displaythe value corresponding to "mykey". -- h:outputText value "#{mybean.myMap['mykey']}" / /f:view Method binding expressionWrite a managed bean identifier and method name by concatenating them with "." (dot) in "#{ }".As with referencing of values, if beans are nested, as many beans as the number of nested beans can beconcatenated using "."A sample JSP page is shown below. f:view h:form !-- Use the validate method of the managed bean defined withthe name mybean to verify the value. -- h:inputText value "#{mybean.myprop}"validator "#{mybean.validate}" / /h:form /f:view 6

Reserved variablesThe following reserved variables can be used in value binding expressions and method binding expressions.Variable nameTypeExplanationjava.util.MapCollection of all application scopevariablescookiejava.util.MapCollection of cookies in a request.The Map key is a cookie name, andthe value is .FacesContext class instanceheaderjava.util.MapCollection of all request headers.Individual values in Map are of thejava.lang.String type.headerValuesjava.util.MapCollection of all request headers.Individual values are arrays of thejava.lang.String type.initParamjava.util.MapCollection of applicationinitialization parametersparamjava.util.MapCollection of request parameters.The value of the first requestparameter of those corresponding toindividual keys is stored.paramValuesjava.util.MapCollection of request parameters.The request parametercorresponding to each key is storedin the java.lang.String array.requestScopejava.util.MapCollection of all request scopevariablessessionScopejava.util.MapCollection of all session javax.faces.component.UIViewRoot class instance corresponding tothe page being displayedapplicationScopeAn example of use of a reserved variable is shown below. f:view !-- Display for the request parameter corresponding to key"paramKey" -- h:outputText value "#{param['paramKey']}" / /f:view 2.5 Event ProcessingJavaServer Faces applications handle three types of events: ActionEvent, ValueChangeEvent, andPhaseEvent.An event listener model of JavaServer Faces receives an event class using the listener interface and processesevents occurring in UIComponents.7

JavaServer Faces supports the following three types of events:· ActionEvent occurs at such times as when the user clicks a button or hyperlink component.This eventoccurs in the Invoke Application or Apply Request Values phase.· ValueChangeEvent occurs when the user changes the value of a UIComponent. This event does notoccur at the time that a validation error is detected.This event occurs in the Process Validations or ApplyRequest Values phase.· PhaseEvent can perform processing by causing an interrupt before or after a JavaServer Faces lifecyclephase.This event can be used for unified preprocessing and postprocessing of a business logic.Applications can process these events as follows:· The application creates an event listener and assigns it to a UIComponent by using thef:valueChangeListener tag or f:actionListener tag on an input-output page.In the case of thePhaseEvent listener, the application defines it in the JavaServer Faces definition file (faces-config.xml).· The application uses the managed bean method to create event processing and specifies themethod-binding expression in the appropriate attribute of a UIComponent.For details on how to create and invoke individual events, refer to "Creating an Event Listener".2.6 Page TransitionsGenerally, each Web application, such as a JavaServer Faces application, consists of multiple input-outputpages.Therefore, transitions between the pages must be defined and implemented when an application iscreated.JavaServer Faces applications can easily define page transitions and which transition is executed according toevent processing.Page transition is a series of rules to select the transition destination page when the user clicksa button or hyperlink.Define these rules by using the navigation-rule tag in the JavaServer Faces definitionfile (faces-config.xml) written in XML.Write transition source names, action results, and transition destinationpage names for the rules.A coding example is shown below.[Coding example of the JavaServer Faces definition file (faces-config.xml)] faces-config . navigation-rule !-- Write the transition source JSP name. -- from-view-id /input.jsp /from-view-id !-- Change the transition destination according to the actionresult. -- navigation-case from-outcome success /from-outcome to-view-id /result.jsp /to-view-id /navigation-case navigation-case from-outcome fail /from-outcome to-view-id /input.jsp /to-view-id /navigation-case /navigation-rule . /faces-config 8

The following methods can be used to specify rules for selections according to the type of user operation:· Specify the character string showing the action result for the value of the action attribute of aUIComponent.· Specify the method that returns the action result by using the method binding expression as the value ofthe action attribute of a UIComponent.For details on each method, refer to "Creating a Page Transition Definition".2.7 ValidatorsJavaServer Faces supports a method for verifying data in UIComponents such as text fields in which users canenter data.Data in a UIComponent is verified before updated data is set in properties of the managed beanallocated to the UIComponent. If verification fails, properties of the managed bean are not updated.JavaServer Faces defines the classes of a series of validators that implement standard data checks. In addition,it provides basic tags corresponding to the standard validators.Developers of input-output pages can register validators in UIComponents. The standard validators provided byJavaServer Faces are available. In addition, custom validators can be created and used.The procedure for using a validator is as follows:1. Decide the validator to be used.- Use a standard validator if it satisfies the function requirements.- Otherwise, create and use a custom validator.2. When using a custom validator, define it in the JavaServer Faces definition file (faces-config.xml).3. Register the validator in a UIComponent on an input-output page.For details on the following points of validator development, refer to "Creating a Validator":· Standard validators provided by JavaServer Faces· Creating and registering a custom validator· Specifying a validator on an input-output page2.8 ConvertersWhen UIComponents are assigned to Bean properties, the data handled by JavaServer Faces is represented inthe following two formats:· Format in which data is represented in data types, such as int and long, within a model· Format in which data is represented in such a way that users can read, enter, and correct itWhen a value on an input-output page is updated or when a Bean data value is changed by event processing,conversion processing between the two formats is performed.Data is automatically converted in standard modeunless otherwise specified. However, data may need to be converted to a specified format other than thestandard format.For this reason, JavaServer Faces enables converters to be registered in UIComponents.Theconverters provided by JavaServer Faces can be used as well as custom converters created by users.The procedure for using a converter is as follows:1. Decide the converter to be used.- Use a standard converter if it satisfies the requirements.- Otherwise, create and use a custom converter.2. Register the converter in a UIComponent on an input-output page.For details on the following points of converter development, refer to "Creating a Converter":· Standard converters provided by JavaServer Faces· Creating a custom converter· Specifying a converter on an input-output page9

10

Chapter 3 Development of JavaServer FacesApplicationsThis section explains a standard development method using JavaServer Faces. An event model application hasthe following basic components:Managed bean (model)Input-output page (JSP)Event listener (business logic)ValidatorConverterPage transition definition (XML)Subsequent sections explain how to create these components.3.1 Creating a Managed BeanCreate a Bean for storing values to be displayed or data to be sent.The Bean has values in its properties, and it also has accessor methods (Setter and Getter). In addition, it canimplement event listeners.For details, refer to "Creating an Input-Output Page". Registering the Bean as a managed bean enables thefollowing types of operations through an input-output page:· Allocating input and output data to Bean properties· Allocating an input data validator to a Bean method· Allocating UIComponent event processing to a Bean methodIn the following example, a listener that operates when a value is updated and a listener that operates when abutton is clicked are implemented.package mypkg;import javax.faces.event.ActionEvent;import javax.faces.event.ValueChangeEvent;public class MyBean {protected String message "My Message";public String getMessage() {return this.message;}public void setMessage(String message) {this.message message;}public String getIdForNextPage() {// Acquires a value for a page transition.return "success";11

}public void messageChanged(ValueChangeEvent event) {// Coding of the processing executed at the time that the messageproperty value is updated}public void pushed(ActionEvent e) {// Coding of the processing executed at the time that an associatedbutton is clicked}}Specify the name and scope of the created model in the JavaServer Faces definition file (faces-config.xml). In thefollowing example, the mypkg.MyBean class is registered with the name myBean, and the scope is session. faces-config managed-bean managed-bean-name myBean /managed-bean-name managed-bean-class mypkg.MyBean /managed-bean-class managed-bean-scope session /managed-bean-scope /managed-bean /faces-config Specify the scope by selecting none, application, session, or request.If no scope is specified, none isassumed, and the Bean is not saved to any scope, i.e., the Bean exists only while it is referenced.3.2 Creating an Input-Output PageTo use JavaServer Faces UIComponents on a JSP page, use the JavaServer Faces component tag library andJavaServer Faces basic tag library.The component tags are user interface component tags. The basic tags specifyapplication and page structures and operations.These tag libraries can be used in the same way as generalcustom tag libraries.To use these tags on an input-output page, the beginning of the page must have a declaration as shown below. %@ taglib uri "http://java.sun.com/jsf/html" prefix "h" % %@ taglib uri "http://java.sun.com/jsf/core" prefix "f" % The uri attribute identifies a tag library. The prefix attribute identifies the tag library to which a tagbelongs.The above example specifies that a component tag be preceded by h: and that a basic tag be preceded byf: .The JavaServer Faces tags represent a tree of UIComponents. The root of the tree is the UIViewRootcomponent, which is represented by the f:view tag. f:view Other JavaServer Faces tags /f:view HTML and JSP tags can be written outside the f:view tags, but JavaServer Faces tags must be written within12

the scope enclosed by the f:view tags.And, f:view corresponding to one screen is only one.For details on the standard tags provided by JavaServer Faces and the display resulting from each tag, refer to"Development Using JavaServer Faces Tags".Using value binding expressions and method binding expressions, UIComponent tags can allocate Beanproperties to UIComponents and specify event processing, validators, and converters for them. An example isshown below. Note that the example provides comments with !-- -- for explanations, but no comment canactually be written between the and of a tag. f:view h:form h:inputText !-- Assigns the myBean message property value to theh:inputText value attribute. -- value "#{myBean.message}" !-- Invokes the messageChanged method of myBean when thevalue is changed. -- valueChangeListener "#{myBean.messageChanged}" !-- Specifies the maximum number of characters with avalidator. -- f:validateLength maximum "10"/ /h:inputText h:commandButton !-- Invokes the getIdForNextPage of myBean when the sendbutton is clicked. The resulting page transition is based on thereturn value. -- action "#{myBean.getIdForNextPage}"value "Send" !-- Invokes the pushed method of myBean when the send buttonis clicked. -- actionListener "#{myBean.pushed}" / /h:form /f:view For details on how to specify the following processing definitions, refer to the respective sections indicated nextto them:····Event listener - Creating an Event ListenerConverter - Creating a ConverterValidator - Creating a ValidatorPage transition - Creating a Page Transition Definition3.3 Creating an Event ListenerThere are three types of events: ActionEvent, ValueChangeEvent, and PhaseEvent.ActionEventTheA

· JavaServer Faces supports an "event model" that implements processing on a server at the time that an event that occurred on a client is received. · Original UIs can be developed using the JavaServer Faces framework. The figure below shows an outline of an application using JavaServer Faces.