1 / 40

JavaServer Faces

JavaServer Faces. Presented by: Jim O’Hara Ed Kausmeyer Jingming Zhang. Introducing JavaServer Faces (JSF). New and upcoming web application framework for building user interfaces (UI’s) for web applications For building server-side UI’s

kara
Download Presentation

JavaServer Faces

An Image/Link below is provided (as is) to download presentation Download Policy: Content on the Website is provided to you AS IS for your information and personal use and may not be sold / licensed / shared on other websites without getting consent from its author. Content is provided to you AS IS for your information and personal use only. Download presentation by click this link. While downloading, if for some reason you are not able to download a presentation, the publisher may have deleted the file from their server. During download, if you can't get a presentation, the file might be deleted by the publisher.

E N D

Presentation Transcript

  1. JavaServer Faces Presented by: Jim O’Hara Ed Kausmeyer Jingming Zhang

  2. Introducing JavaServer Faces (JSF) • New and upcoming web application framework for building user interfaces (UI’s) for web applications • For building server-side UI’s • Accomplishes the Model-View-Controller (MVC) paradigm • Designed to be flexible and easy to use • Leverages existing standard UI and web-tier concepts without limiting developers to a particular mark-up language, protocol, or client device • Comparable to the well-known Struts Framework • Features and concepts that are beyond those of Struts, especially the component orientation

  3. Introducing JavaServer Faces (JSF) • Set of APIs for representing UI components and managing their state, handling events and input validation, defining page navigation, and supporting internationalization and accessibility • A JavaServer Pages (JSP) custom tag library for expressing a JSF interface within a JSP page • JSF version 1.0 relies on JSP 1.2 • Since JSP 2.0 is a superset of JSP 1.2, it is possible to use JSF 1.0 with JSP 2.0 • Future versions of the JSF specification will be able to take better advantage of JSP 2.0

  4. Standardization of JSF • JavaServer Faces Developer Forum: http://forum.java.sun.com/forum.jspa?forumID=427 • JSF APIs are being designed so that they can be leveraged by tools that will make web application development even easier • Developed through the Java Community Process under JSR-127 • JSRs: Java Specification Requests • JSR-127: http://www.jcp.org/en/jsr/detail?id=127 • JSR-252: http://jcp.org/en/jsr/detail?id=252 • A number of important industry players are collaborating with Sun to develop the JSF specification • Many prominent tool vendors are part of the expert group and are committed to supporting the JSF technology in their tools, thus promoting the adoption of the JSF technology standard

  5. JSF User Interfaces • A UI created with JSF handles all the complexities of UI management • Input validation, component-state management, page navigation, and event handling • The UI component classes encapsulate the component functionality, not the client-specific presentation • UI components can be rendered to various client devices • Renderers: define rendering attributes for a specific UI component

  6. JSF User Interfaces • By combining the UI component functionality with custom renderers, developers can construct custom tags to a particular client device • Device Independence: By defining only component functionality in extensible UI component classes, JSF allows component developers to extend the component classes to generate their own component tag libraries targeted for specific clients • JSF provides a custom renderer and a JSP custom tag library for rendering to an HTML client • Allows developers of Java 2 Platform, Enterprise Edition (J2EE) applications to use JSF technology in their applications

  7. Benefits of the JSF Design • The JSF architecture clearly defines a separation between application logic and presentation while making it easy to connect the presentation layer to the application code • With this simple, well-defined programming model, developers of varying skill levels can quickly and easily build Web applications by assembling reusable UI components in a page, connecting these components to an application data source, and wiring client-generated events to server-side event handlers

  8. Benefits of the JSF Design • These web applications handle all of the complexity of managing the UI on the server, allowing each member of a web application development team to focus on their piece of the development process (i.e., their application code) • Allows a wide range of users, from web-page designers to component developers, to take advantage of JSF • Example: Web page developers with no programming expertise can use JSF UI component tags to link to application code from within a web page without writing any scripts • Division of labor, shorter development cycle

  9. Benefits of the JSF Design • How various developers and web-page designers can take advantage of JSF's extensibility, ease-of-use, and capabilities: • Page Authors • Build the UI using component tags from within web pages, such as JSP pages • Probably the primary users of the JSF custom tag library • Application Developers • Write the application code, including the data-access, event-handling, and business logic • Component Writers • Construct reusable UI components • Take advantage of the extensibility of the UI component classes to build custom components that can be targeted for a specific client • Tools Vendors • Build tools leveraging JSF technology to make building a UI even easier

  10. JSF and MVC JavaServer Faces (JSF) technology is a new user interface framework for J2EE applications. It is particularly suited, by design, for use with applications based on the MVC (Model-View-Controller) architecture.

  11. MVC(Model-View-Controller) • MVC was first described by Xerox in a number of papers published in the late 1980s, in conjunction with the Smalltalk language. This model has since been used for GUI applications developed in all popular programming languages. • The basic idea is to separate the application data and business logic, the presentation of the data, and the interaction with the data into distinct entities labeled the Model, the View, and the Controller, respectively.

  12. The MVC design pattern splits an application design into three separate parts: • The Model handles data and logic. Model code accesses and represents data, and handles business operations. "Business operations" include changes to both persistent business data, and to things like shopping cart contents • The View handles output. View code displays data to the user. • The Controller handles input. Controller code manipulates the Model or changes the view accordingly in response to user input (the Controller can also do both).

  13. These parts have specific relationships to one another: • The View accesses the Model to retrieve data for display. • The Controller receives user input, and makes business method invocations on the Model. • The Controller updates the View, or selects a new View, based on the state of the Model and on the its own View navigation rules. • The Model provides data to the View, but knows nothing about how that data is presented. The Model also provides business services to the Controller, but knows nothing about user events the Controller might have received.

  14. How does JSF fit into the overall MVC architecture?

  15. Model-View-Controller Pattern • Model = Persistent data • View =JSP • Servlet =Controller =FacesServlet

  16. To create a JSF application, you typically perform the following steps: • Define and implement the application Model classes • Describe the Model to the framework • Create application Views using JSP pages • Define data validation rules • Define View navigation for the Controller

  17. Defining the Model public class DataBean { protected String _string; protected long _n_long; protected double _n_real; public DataBean() { _string = "Default"; _n_long = 1000; _n_real = 0.5; } public String getString() { return _string; } public void setString(String string) { _string = string; } public long getLongnumber() { return _n_long;} public void setLongnumber(long n_long) { _n_long = n_long; } public double getRealnumber() { return _n_real; } public void setRealnumber(double n_real) { _n_real = n_real; } }

  18. Describe the Model to JSF <managed-bean> <managed-bean-name>data</managed-bean-name> <managed-bean-class> com.elucify.tips.mar2004.DataBean </managed-bean-class> <managed-bean-scope>session</managed-bean-scope> </managed-bean>

  19. Create Application Views <%@ taglib uri="http://java.sun.com/jsf/core" prefix="f" %> <%@ taglib uri="http://java.sun.com/jsf/html" prefix="h" %> <html> <head> <title>Validating JSF Page</title> </head> <body> <h1>Please enter the requested data</h1> <f:view> <h:form> <b>Enter a string from three to twelve characters in length:</b><br/> <h:inputText id="string" required="true" value="#{data.string}" size="20"> <f:validateLength minimum="3" maximum="12"/> </h:inputText> <h:message for="string" style="color: red;"/> <br/> <p> ... </f:view> </body></html>

  20. Defining Data Validation When the user posts an input form to the Controller, the Controller validates each of the inputs <h:inputText id="string" required="true" value="#{data.string}" size="20"> <f:validateLength minimum="3" maximum="12"/> </h:inputText> <h:message for="string" style="color: red;"/> <br/> This example shows how to perform server-side validation. JSF also provides a way to perform the requested validations on the client side. The default implementation of client-side validation runs as JavaScript in the Web browser.

  21. Defining View Navigation for the Controller <h:commandButton id="submit" action="validated" value="Submit values"/> In this case, the commandButton tells the Controller to execute the "validated" action if all inputs are valid. <navigation-rule> <from-view-id>/jsp/values.jsp</from-view-id> <navigation-case> <from-outcome>validated</from-outcome> <to-view-id>/jsp/valid.jsp</to-view-id> </navigation-case> </navigation-rule> This rule tells the Controller the following: if you receive valid inputs from a form in the page /jsp/values.jsp, and the action is 'validated', then go to page /jsp/valid.jsp.

  22. Why JavaServer Faces • The promise of JSF is to bring rapid user-interface development to server-side Java. • JSF has these parts: • a set of pre-fabricated UI components • an event-driven programming model • A component model that enables third-party developers to supply additional components

  23. A Simple JSF Applications <body> <h:outputText value="#{msgs.pageTitle}"/> <p> <h:form> <h:dataTable value="#{tableData.names}" var="name"> <h:column> <h:outputText value="#{name.last}"/> <f:verbatim>,</f:verbatim> </h:column> <h:column> <h:outputText value="#{name.first}"/> </h:column> </h:dataTable> </h:form> </body> Code behind the page

  24. Web 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 “browser-speak”, the look is determined by the HTML tags that specify the layout, fonts, images and other elements to display the page.

  25. Web Application Analysis • The business logic is implemented in the Java code that determines the behavior of the application.

  26. Web Application Analysis • Some web application intermingle HTML and code. • The approach is easy to implement for simple applications in a single file. • For serious application development projects, mixing markup and code poses considerable problems.

  27. Behind the Scenes Graphic ofHTML form Name: pw: Submit A JSF form is represented internally as a tree UI components are managed on the server in a view, or component tree. The components can be wired directly to the values of JavaBean properties. Components are rendered to the client in HTML.

  28. Validators • It is the responsibility of the person designing the UI to ensure that the user entered the correct type of information • In web design this was usually done when validation routines written in JavaScript • JSF handles validation in three ways: • At the UI component level • By validator methods in backing beans • By validator classes

  29. Process Validations • In the Process Validation phase, JSF traverses the component tree and interrogates each component to make sure its submitted value is acceptable. • Validation is handled either directly by the component or delegated to one or more validators.

  30. Some JSF Examples • JSF Code Samples and Apps • http://java.sun.com/j2ee/javaserverfaces/reference/codesamples/index.html

  31. Servlet Configuration • JSF applications require a servlet, calledFacesServlet, which acts as a front controller for the entire application. • Servlets are configured in the web application’s deployment descriptor file, web.xml <web-app> <servlet> <servlet-name>Faces Servlet</servlet-name> <servlet-class>javax.faces.webapp.FacesServlet</servlet-class> </servlet>

  32. Using JSP includes • One of JSP’s key features is the ability to integrate content for multiple JSPs into a single page. <jsp:include page =“disclaimer.jsp”/> …. <jsp:include page =“footer.jsp”/>

  33. Issuing SQL Statements • To issue SQL commands to a database, you need a connection object. • Using Java Naming and Directory Interface (JNDI) String myUri = “java:cmp/env/jdbc/mydb”; Context ctx = new InitialContext(); DataSource source (DataSource) ctx.lookup(myUri); Connection conn = source.getConnection();

  34. API Documentation http://java.sun.com/j2ee/javaserverfaces/1.1_01/docs/api/index.html

  35. JSF Goals • The core promise of JSF is support for UI components—reusable units of code. • JSF has a specific goal: to make web applications with less effort.

  36. Top Ten Reasons to Prefer JSF to Struts (David Geary’s Blog) • Components • Render Kits • Renderers • Value Binding Expressions • Event Model • Extensibility • Managed Beans (Dependency Injection) • POJO Action Methods • JSF is the standard Java-based web app framework • There's only one Struts

  37. References (cont’d) • The J2EE 1.4 Tutorialhttp://java.sun.com/j2ee/1.4/docs/tutorial/doc/ • Code Samples and Appshttp://java.sun.com/j2ee/javaserverfaces/reference/codesamples/index.html • Core Java ServerFacesDavid Geary, Cay Horstmann,Sun Microsystems Press Java Series • http://www.jroller.com/comments/dgeary/Weblog/

More Related