1 / 72

JSF: JavaServer Faces

JSF: JavaServer Faces. Vinay Kumar. Session Schedule. JSF Introduction Page Navigation Managed Beans Expression Language Properties File. Session Schedule -contd. Event Handling HTML Library Validation JDBC in JSF Data Tables. Session Schedule -contd. Ajax-4-JSF

misu
Download Presentation

JSF: 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. JSF: JavaServer Faces Vinay Kumar

  2. Session Schedule • JSF Introduction • Page Navigation • Managed Beans • Expression Language • Properties File

  3. Session Schedule -contd • Event Handling • HTML Library • Validation • JDBC in JSF • Data Tables

  4. Session Schedule -contd • Ajax-4-JSF • Basic component tags • Advanced custom tags • Custom components

  5. JSF Introduction • Different views of JSF • Comparing JSF to standard servlet/JSP technology • Comparing JSF to Apache Struts

  6. What is JSF? A set of Web-based GUI controls and associated handlers? – JSF provides many prebuilt HTML-oriented GUI controls, along with code to handle their events. A device-independent GUI control framework? – JSF can be used to generate graphics in formats other than HTML, using protocols other than HTTP. A better Struts? – Like Apache Struts, JSF can be viewed as an MVC framework for building HTML forms, validating their values, invoking business logic, and displaying results.

  7. Advantages of JSF • Custom GUI controls – JSF provides a set of APIs and associated custom tags to create HTML forms that have complex interfaces • Event handling – JSF makes it easy to designate Java code that is invoked when forms are submitted. The code can respond to particular buttons, changes in particular values, certain user selections, and so on. • Managed beans – In JSP, you can use property="*" with jsp:setProperty to automatically populate a bean based on request parameters. JSF extends this capability and adds in several utilities, all of which serve to greatly simplify request param processing. • Expression Language – JSF provides a concise and powerful language for accessing bean properties and collection elements

  8. Disadvantages of JSF • Bigger learning curve – To use MVC with the standard RequestDispatcher, you need to be comfortable with the standard JSP and servlet APIs. To use MVC with JSF, you have to be comfortable with the standard JSP and servlet APIs and a large and elaborate framework that is almost equal in size to the core system. This drawback is especially significant with smaller projects, near-term deadlines, and less experienced developers; you could spend as much time learning JSF as building your actual system. • Worse documentation – Compared to the standard servlet and JSP APIs, JSF has fewer online resources, and many first-time users find the online JSF documentation confusing and poorly organized. MyFaces is particularly bad.

  9. JSF: Page Navigation Static Navigation

  10. Static Navigation • When form submitted – A static page is displayed • Static result – No business logic, beans, or Java code of any sort – The return path is specified in the button itself. • Main points – Format of original form – Use of navigation-rule in faces-config.xml

  11. Formats • Input form has following format: <%@ taglib uri="http://java.sun.com/jsf/core" prefix="f" %> <%@ taglib uri="http://java.sun.com/jsf/html" prefix="h" %> <f:view> HTML markup <h:form> HTML markup and h:blah tags </h:form> HTML markup </f:view> • faces-config.xml specifies navigation rules: <?xml version='1.0' encoding='UTF-8'?> <!DOCTYPE faces-config PUBLIC …> <faces-config> <navigation-rule> <from-view-id>/blah.jsp</from-view-id> <navigation-case> <from-outcome>some string</from-outcome> <to-view-id>/WEB-INF/results/something.jsp</to-view-id> </navigation-case> </navigation-rule> </faces-config>

  12. Create Input Form The h:form element – ACTION is automatically self (current URL) – METHOD is automatically POST • Elements inside h:form – Use special tags to represent input elements • h:inputText corresponds to <INPUT TYPE="TEXT"> • h:inputSecret corresponds to <INPUT TYPE="PASSWORD"> • h:commandButton corresponds to <INPUT TYPE="SUBMIT"> – In later sections, we will see that input elements will be associated with bean properties – For static navigation, specify simple string as action of h:commandButton • String must match navigation rule from faces-config.xml

  13. Example Code register.jsp <%@ taglib uri="http://java.sun.com/jsf/core" prefix="f" %> <%@ taglib uri="http://java.sun.com/jsf/html" prefix="h" %> <f:view> <!DOCTYPE …> <HTML> <HEAD>…</HEAD> <BODY> <CENTER> <TABLE BORDER=5> <TR><TH CLASS="TITLE">New Account Registration</TH></TR> </TABLE> <P> <h:form> Email address: <h:inputText/><BR> Password: <h:inputSecret/><BR> <h:commandButton value="Sign Me Up!" action="register"/> </h:form> </CENTER></BODY></HTML> </f:view>

  14. Example Code Result – resigter.jsp

  15. Edit faces-config.xml • General format <?xml version='1.0' encoding='UTF-8'?> <!DOCTYPE faces-config PUBLIC …> <faces-config> … </faces-config> • Specifying the navigation rules <?xml version='1.0' encoding='UTF-8'?> <!DOCTYPE faces-config PUBLIC …> <faces-config> <navigation-rule> <from-view-id>/register.jsp</from-view-id> <navigation-case> <from-outcome>register</from-outcome> <to-view-id>/WEB-INF/results/result.jsp</to-view-id> </navigation-case> </navigation-rule> </faces-config>

  16. Create Results Pages RequestDispatcher.forward used – So page can/should be in WEB-INF • Example code: – …/WEB-INF/results/result.jsp <!DOCTYPE …> <HTML> <HEAD>…</HEAD> <BODY> <CENTER> <TABLE BORDER=5> <TR><TH CLASS="TITLE">Success</TH></TR> </TABLE> <H2>You have registered successfully.</H2> </CENTER> </BODY></HTML>

  17. Example Result • Note that the URL is unchanged

  18. Prevent Direct Accessto JSP Pages Filename/URL correspondence – Actual files are of the form blah.jsp – URLs used are of the form blah.faces – You must prevent clients from directly accessing JSP pages • Since they would give erroneous results • Strategies – You cannot put input-form JSP pages in WEB-INF • Because URL must correspond directly to file location – So, use filter in web.xml. But: • You have to know the extension (.faces) • Assumes no non-JSF .jsp pages • This is a major drawback to JSF design

  19. Preventing Direct Access:FacesRedirectFilter FacesRedirectFilter public class FacesRedirectFilter implements Filter { private final static String EXTENSION = "faces"; public void doFilter(ServletRequest req, ServletResponse res, FilterChain chain) throws ServletException, IOException { HttpServletRequest request = (HttpServletRequest)req; HttpServletResponse response = (HttpServletResponse)res; String uri = request.getRequestURI(); if (uri.endsWith(".jsp")) { int length = uri.length(); String newAddress = uri.substring(0, length-3) + EXTENSION; response.sendRedirect(newAddress); } else { // Address ended in "/" response.sendRedirect("index.faces"); } }

  20. Preventing Direct Access:web.xml <filter> <filter-name>faces-redirect-filter</filter-name> <filter-class> coreservlets.FacesRedirectFilter </filter-class> </filter> <filter-mapping> <filter-name>faces-redirect-filter</filter-name> <url-pattern>*.jsp</url-pattern> </filter-mapping>

  21. JSF: Page Navigation Dynamic Navigation

  22. JSF Flow of Control • A form is displayed – Form uses f:view and h:form • The form is submitted to itself – Original URL and ACTION URL are http://…/blah.faces • A bean is instantiated – Listed in the managed-bean section of faces-config.xml • The action controller method is invoked – Listed in the action attribute of h:commandButton • The action method returns a condition – A string that matches from-outcome in the navigation rules in faces-config.xml • A results page is displayed – The page is specified by to-view-id in the navigation rules in faces-config.xml

  23. Steps : Dynamic Navigation 1) Create a bean A) Properties for form data B) Action controller method C) Placeholders for results data 2) Create an input form A) Input fields refer to bean properties B) Button specifies action controller method that will return condition 3) Edit faces-config.xml A) Declare the bean B) Specify navigation rules 4) Create results pages – Output form data and results data with h:outputText 5) Prevent direct access to JSP pages – Use a filter that redirects blah.jsp to blah.faces

  24. Example: Health Plan Signup • Collects info to see if user qualifies for health plan • When form submitted, one of two possible results will be displayed – User is accepted into health plan – User is rejected from health plan • Main points – Specifying an action controller in the form – Creating an action controller method in the bean – Using faces-config.xml to • Declare bean • Map return conditions to output pages

  25. Main Points of This Example • Specify the controller with #{beanName.methodName} <h:commandButton value="Sign Me Up!" action="#{healthPlanController.signup}"/> • Controller method returns strings corresponding to conditions – If null is returned, the form is redisplayed – Unlike with Struts, the controller need not extend a special class • Use faces-config.xml to declare the controller as follows <faces-config> <managed-bean> <managed-bean-name>controller name</managed-bean-name> <managed-bean-class>controller class</managed-bean-class> <managed-bean-scope>request</managed-bean-scope> </managed-bean> </faces-config> • Add multiple navigation-rule entries to faces-config.xml – One for each possible string returned by the controller – If no string matches, the form is redisplayed

  26. Step 1: Create a Bean (A) Properties for form data – Postponed until next session (B) Action controller method public class HealthPlanController { public String signup() { if (Math.random() < 0.2) { return("accepted"); } else { return("rejected"); } } } (C) Placeholders for results data – Postponed until next session

  27. Step 2: Create Input Form • Same general syntax as in previous example – Except for action of commandButton <%@ taglib uri="http://java.sun.com/jsf/core" prefix="f" %> <%@ taglib uri="http://java.sun.com/jsf/html" prefix="h" %> <f:view> … <h:form> First name: <h:inputText/><BR> Last name: <h:inputText/><BR> ... <h:commandButton value="Sign Me Up!" action="#{healthPlanController.signup}"/> </h:form>… </f:view>

  28. Step 2: Result

  29. Step 3: Edit faces-config.xml (A) Declaring the bean … <faces-config> <managed-bean> <managed-bean-name> healthPlanController </managed-bean-name> <managed-bean-class> coreservlets.HealthPlanController </managed-bean-class> <managed-bean-scope>request</managed-bean-scope> </managed-bean> … </faces-config>

  30. Step 3: Edit faces-config.xml (B) Specifying navigation rules – Outcomes should match return values of controller <faces-config> … (bean definitions from previous page) <navigation-rule> <from-view-id>/signup.jsp</from-view-id> <navigation-case> <from-outcome>accepted</from-outcome> <to-view-id>/WEB-INF/results/accepted.jsp</to-view-id> </navigation-case> <navigation-case> <from-outcome>rejected</from-outcome> <to-view-id>/WEB-INF/results/rejected.jsp</to-view-id> </navigation-case> </navigation-rule> </faces-config>

  31. Step 4: Create Results Pages • …/WEB-INF/results/accepted.jsp <!DOCTYPE …> <HTML> <HEAD>…</HEAD> <BODY> <CENTER> <TABLE BORDER=5> <TR><TH CLASS="TITLE">Accepted!</TH></TR> </TABLE> <H2>You are accepted into our health plan.</H2> Congratulations. </CENTER> </BODY></HTML>

  32. Step 4: Create Results Pages …/WEB-INF/results/accepted.jsp <!DOCTYPE …> <HTML> <HEAD>…</HEAD> <BODY> <CENTER> <TABLE BORDER=5> <TR><TH CLASS="TITLE">Accepted!</TH></TR> </TABLE> <H2>You are accepted into our health plan.</H2> Congratulations. </CENTER> </BODY></HTML>

  33. Step 4: Create Results Pages …/WEB-INF/results/rejected.jsp <!DOCTYPE …> <HTML> <HEAD>…</HEAD> <BODY> <CENTER> <TABLE BORDER=5> <TR><TH CLASS="TITLE">Rejected!</TH></TR> </TABLE> <H2>You are rejected from our health plan.</H2> Get lost. </CENTER> </BODY></HTML>

  34. Step 4: Results

  35. Step 5: Prevent Direct Accessto JSP Pages • Use filter that captures url-pattern *.jsp – No changes from previous example

  36. Tips • Wildcards in navigation rule – * for from-view-id matches any starting page <navigation-rule> <from-view-id>*</from-view-id> <navigation-case> <from-outcome>success</from-outcome> <to-view-id>/WEB-INF/results/success.jsp</to-view-id> </navigation-case> </navigation-rule> • Getting the request and response objects HttpServletRequest request = (HttpServletRequest)context.getRequest(); HttpServletResponse response = (HttpServletResponse)context.getResponse(); • In some environments, you cast results of getRequest and getResponse to values other than HttpServletRequest and HttpServletResponse E.g., in a portlet environment, you might cast result to PortletRequest and PortletResponse

  37. Interleaving managed-bean andnavigation-rule • If you have several different addresses in your app, it is OK to alternate <managed-bean> Stuff for bean1 </managed-bean> <navigation-rule> Rules for address that uses bean1 </navigation-rule> <managed-bean> Stuff for bean2 </managed-bean> <navigation-rule> Rules for address that uses bean2 </navigation-rule> – Of course, it is also OK to put all bean defs at the top, followed by all navigation rules.

  38. JSF: Managed Beans • Using beans to represent request parameters • Declaring beans in faces-config.xml • Referring to beans in input forms • Outputting bean properties

  39. JSF Flow of Control

  40. Steps in Using JSF 1) Create a bean A) Properties for form data B) Action controller method C) Placeholders for results data 2) Create an input form A) Input fields refer to bean properties B) Button specifies action controller method that will return condition 3) Edit faces-config.xml A) Declare the bean B) Specify navigation rules 4) Create results pages – Output form data and results data with h:outputText 5) Prevent direct access to JSP pages – Use a filter that redirects blah.jsp to blah.faces

  41. Example: Using Beans • When form submitted, three possible results – Error message re illegal email address – Error message re illegal password – Success • New features – Action controller obtains request data from within bean – Output pages access bean properties • Main points – Defining a bean with properties for the form data – Declaring beans in faces-config.xml – Outputting bean properties

  42. Step 1: Example Code (1A) Form data public class RegistrationBean implements Serializable { private String email = "user@host"; private String password = ""; public String getEmail() { return(email); } public void setEmail(String email) { this.email = email; } public String getPassword() { return(password); } public void setPassword(String password) { this.password = password; }

  43. Step 1: Example Code (1B) Action controller method public String register() { if ((email == null) || (email.trim().length() < 3) || (email.indexOf("@") == -1)) { suggestion = SuggestionUtils.getSuggestionBean(); return("bad-address"); } else if ((password == null) || (password.trim().length() < 6)) { suggestion = SuggestionUtils.getSuggestionBean(); return("bad-password"); } else { return("success"); } }

  44. Step 1: Example Code (1C) Placeholder for storing results – Note that action controller method called business logic and placed the result in this placeholder private SuggestionBean suggestion; public SuggestionBean getSuggestion() { return(suggestion); }

  45. Step 1: Example Code Result returned by business logic package coreservlets; import java.io.*; public class SuggestionBean implements Serializable { private String email; private String password; public SuggestionBean(String email, String password) { this.email = email; this.password = password; } public String getEmail() { return(email); } public String getPassword() { return(password); } }

  46. Step 1: Example Code • Business logic public class SuggestionUtils { private static String[] suggestedAddresses = { "president@whitehouse.gov", "gates@microsoft.com", “tennyson@google.com", “s.jobes@apple.com" }; private static String chars = "abcdefghijklmnopqrstuvwxyz0123456789#@$%^&*?!"; public static SuggestionBean getSuggestionBean() { String address = randomString(suggestedAddresses); String password = randomString(chars, 8); return(new SuggestionBean(address, password)); } ... }

  47. Step 2: Create Input Form • Similar to previous example, except – h:inputBlah tags given a value attribute identifying the corresponding bean property • Example code <%@ taglib uri="http://java.sun.com/jsf/core" prefix="f" %> <%@ taglib uri="http://java.sun.com/jsf/html" prefix="h" %> <f:view>… <h:form> Email address: <h:inputText value="#{registrationBean.email}"/><BR> Password: <h:inputSecret value="#{registrationBean.password}"/><BR> <h:commandButton value="Sign Me Up!" action="#{registrationBean.register}"/> </h:form>… </f:view>

  48. Step 2: Result • The user@host value comes from the bean

  49. Step 3: Edit faces-config.xml (A) Declare bean … <faces-config> <managed-bean> <managed-bean-name> registrationBean </managed-bean-name> <managed-bean-class> coreservlets.RegistrationBean </managed-bean-class> <managed-bean-scope>request</managed-bean-scope> </managed-bean> … </faces-config>

  50. Step 3: Edit faces-config.xml • (B) Define navigation rules … <faces-config> … <navigation-rule> <from-view-id>/register.jsp</from-view-id> <navigation-case> <from-outcome>bad-address</from-outcome> <to-view-id>/WEB-INF/results/bad-address.jsp</to-view-id> </navigation-case> <navigation-case> <from-outcome>bad-password</from-outcome> <to-view-id>/WEB-INF/results/bad-password.jsp</to-view-id> </navigation-case> <navigation-case> <from-outcome>success</from-outcome> <to-view-id>/WEB-INF/results/success.jsp</to-view-id> </navigation-case> </navigation-rule> </faces-config>

More Related