jsf-jta-1.0

JavaServer Faces Job Task Analysis

Please review this Job Task Analysis and provide input by adding your comments to this wiki. Please also complete the short survey at: JSF Survey

Web Application Developer

Job Description

SCJWAD targets application developers required to build internal and external user driven web application with Java Web technologies.

Responsibilities

  • Understand Web application architecture and web application standards and protocols
  • Test, package and deploy applications
    • Configure Web application for deployment
  • Identify, develop test cases and test suites
  • Identify and organize artifacts and dependencies
  • Identify and implement a security model
  • Design and implement views using JSF, JSTL, and JSPs
  • Identify and integrate 3rd party components and frameworks.
  • Identify, design, develop and integrate entities
  • Validate application data
  • Identify, capture and resolve errors
  • Determine and implement application navigation flow

Core Skills

Scenario 1 (Internal CSR Application using JSF)

  • Find/install JSF component lib/ 3rd part lib
  • Configure servlet
  • Define/Develop models
  • Define/Develop views
    • Page templating with Facelets
    • Resource loading (JS, CSS, IMGs, etc.)
    • Composite component development
  • Integrate Models and views
    • Managed beans ?
  • Integrate resources/JPA
    • Resource injection
  • Integrate validations
  • Integrate navigation flow/ redirection
    • Bookmarking pages
  • Integrate Security
  • Tests
  • Packages application for deployment
  • Deploys application

Scenario 1b (Internal CSR Application using JSF with Ajax)

  • Find/install JSF component lib/ 3rd part lib
  • Configure servlet
  • Find/install JavaScript lib
  • Configure/develop JavaScript code with framework
  • Define/Develop models
  • Define/Develop views
    • Page templating with Facelets
    • Resource loading (JS, CSS, IMGs, etc.)
    • Composite component development
  • Integrate Models and views
    • Managed beans ?
  • Integrate resources/JPA
    • Resource injection
  • Integrate validations
  • Integrate navigation flow/ redirection
    • Bookmarking pages
  • Integrate Security
  • Tests
  • Packages application for deployment
  • Deploys application

Role

Gap: Undefined.

Validity

  • Java EE 5 - Yes
  • Java EE 6 - No

Notes

  • Nothing that examines HTML or CSS.
  • REST Web Services

JSF Web Application Development Tasks

Task 1: Design web applications using standard architectures, protocols, technologies and components

  1. Identify the key technologies, standards, protocols, and components used to build a JSF-based web application
  2. Given a design, correctly identify which JSF and Java EE technologies would be applicable to implement the design
  3. Identify the difference between a web container and a web server in the relation to servlets and JSF development
  4. Describe the characteristics of HTTP-based communication and how it effects web application development
  5. For HTTP GET and POST methods, describe the purpose of the method and its relationship to JSF development, the technical characteristics of the HTTP Method protocol, list triggers that might cause a Client (usually a Web browser) to use the method
  6. Given a design, correctly identify the advantages/disadvantages of using JSF over JSP as the implementation technology
  7. Describe the components of JSF that can be used to create a model-view-controller architecture

Task 2: Configure JSF within the Web Container

  1. Determine which version of JSF the web container supports
  2. Determine whether the web container is already configured to support JSF
    1. If it is not configured, locate and install the correct JSF implementation classes
  3. Create a basic web application archive that functions as the base structure for a JSF application
    1. Add Faces Servlet declaration to web.xml
    2. Create a <servlet> XML element with a <servlet-name> whose content is the string "Faces Servlet"
    3. As a silbling to <servlet-name> create a <servlet-class> element whose content is the string "javax.faces.webapp.FacesServlet"
    4. Map the faces servlet to the URL pattern of your choice
      1. Create a <servlet-mapping> entry whose child elements are a <servlet-name> element that is a copy of the one from the previous step
      2. Add one or more <url-pattern> elements whose content is a url pattern such as "/faces/" or ".jsf", or "*.faces".

Task 3: Design views using JSF and EL

  1. Given a set of functional requirements, determine the most appropriate implementation strategy for JSF views
    1. Design the views using JSF within JSP
    2. Design the views using JSF within XHTML (Facelets)
  2. Describe the purpose and event sequence of the JSF life cycle:
    1. JSF page translation, compilation, instantiation, and invocation
    2. JSF application lifecycle including:
      1. restore view
      2. apply request values
      3. process validations
      4. update model values
      5. invoke application
      6. render response
    3. JSF event processing stages and flow
      1. event processing within the application lifecycle
      2. describe the different types of events: action, value, and phase
      3. controlling event processing flow using immediate attribute
  3. Create sketches of the user interface and application navigation flow
    1. From the functional design, derive a collection of web pages sketches that expose the business logic
    2. Determine which JSF components (if any) are required to build the view
    3. Determine which entity (model) components each page has a dependency on
    4. Determine which phases of the application and event processing lifecycle are required to facilitate navigation and business logic

Task 4: Design custom components using Facelets

  1. Create a list of potential components
  2. For each potential component in the list create a composite component
    1. Define the resource loading (JS, CSS, IMGs, etc.) requirements
    2. Specifiy the usage contract of the composite component, including what attached objects it accepts and which events it emits.
    3. Bundle the component into a composite component library
    4. Modify existing usage sites to use the component from the library, rather than the un-componentized version
  3. Generalize common user interfaces into custom components or Facelets
    1. Look at the resulting collection of web page sketches and determine what common content needs to be on every page that could be included in the template; such things usually include a navigation panel, a search panel, some sort of footer content, status indicators, etc.
    2. Derive a collection of web pages sketches representing the custom components
    3. Design Facelets template XHTML pages to represent the re-usable content
    4. Design Facelets XHTML pages to represent each of the pages in the collection of web page sketches, making sure to use the templates for the re-usable content
    5. Use the JSF 2 Implicit Navigation feature to prototype the user's traversal through the views.

Task 5: Design and develop the model using JavaBeans or Pojos

  1. Identify possible candidates for a model
    1. Referring to user interface sketches and templates identify and develop JavaBeans
    2. Referring to underlying database schema, identify and develop JPA entities
    3. Determine if user interface models directly map to JPA entities
      1. Decide is the solution will use JPA entities as the user interface model
      2. Or create a JavaBeans to JPA entity model translator
  2. Based on the identified candidates, design the model
    1. Determine the properties and state variables required for each model
    2. Determine the various valid states of the model objects and the transitions to those states
    3. Determine how to implement the business logic layer in a stateful while addressing multiple simultaneous users
    4. Determine the implications JSF and the web-based application place on the models
  3. Implement the models adhering to JavaBeans standards
  4. Compile and package JavaBeans or JPA entities with web application

Task 6: Integrate external resources such as JPA within Web Application

  1. Access application data using JPA. Overlap with JPA
    1. Create basic JPA Entity classes
    2. Utilize Entity classes by creating code that uses the EntityManager API by injecting it into the Servlet
    3. Use JPA relationships to model relational table joins
    4. Ensure data integrity by using Transaction and Locking
    5. Apply Entity Listeners and Callback Methods
    6. Create error handling code
    7. Optimize database access
    8. Configure and package JPA Entity classes in enterprise modules

Task 7: Integrate navigation flow/ redirection

  1. Return to the collection of views and examine the traversal paths among them
    1. Define the traversal paths as a directed graph
    2. Create a list of the arcs in this graph
  2. For each arc in the list, determine the best navigation approach
    1. If the implicit navigation technique is sufficent do nothing
    2. If not, create a faces-config.xml file and add <navigation-rule> elements to it to describe the arc.
  3. Look at the source node in the arc.
    1. Consider if you want to make the page corresponding to that node bookmarkable.
    2. If so, take the necessary action to preserve the navigation capabilities even when the page is bookmarked.

Task 8: Integrate models and views using events

  1. Note: IS THIS SECTION COMPLETE ENOUGH?
  2. Based on the user interface sketches, determine the most appropriate design strategy to integrate the models with the views
    1. Choose either a coupled strategy where the model contains "action" methods
    2. Or a decoupled strategy where events are processed using event handlers
  3. Define the business logic processing that will occur in the "event handling" processing
    1. Identify and associate the navigational flow with the views and the event processing
    2. Identify the inputs and outputs of the processing
    3. Identify the expected and unexpected results of the processing
    4. Identify the expected and unexpected navigational results
  4. Implement the "event hanlding" processing based on the chosen design paradigm
    1. Annotate each view-dependant object with the @ManagedBean annotation
    2. Implement the proper attributes to expose the ManagedBean to the view, including name and scoping
    3. Conform to JavaBeans naming conventions for properties. Namely having a getter and a setter for each property.
  5. Implement the model with the view based on bean names, properties, and scoping
    1. Associate the model with the view using the Unified Expression Language syntax
    2. Create conditional rendering based on the state of a model's property
    3. Render properties of the model using JSF components, XHTML, and EL
    4. Associate "event processing" with the model in the view using the appropriate component action or a JSF listener

Task 9: Validate application data

  1. Note: IS THIS SECTION COMPLETE ENOUGH?
  2. Based on the user interface design and the model design, identify and define which elements require validation
    1. Determine which validation model to utilize: client-side validation, server-side validation, or both
    2. identify how validation effects the each user interface, possibly including the JSF custom components
    3. identify how validation effects the model
    4. identify how validation effects the navigational flow within the application
    5. identify how validation effects error notification mechanism on validation failure
  3. Determine and implement the validation strategy
    1. See if a standard JSF validator exists capable of supporting the describe the validation constraint
    2. Build a custom validation mechanism as a method with in the Java Bean
      1. Define the validation method
      2. Develop the validation logic
      3. Create validation error messages (FacesMessage) and add them to the FacesContext
    3. Build a custom validator
      1. Create an implementation of the Validator interface
      2. Implement the validate method based on the constraints
      3. Register the validator with JSF using the faces-config.xml file
      4. Apply validation to the view using the <f:validator /> tag
    4. Or use the JSR-303 bean validation standard
  4. Associate the validation constraints with the model in the view based on the chosen validation implementation strategy
  5. Display validation errors and messages within the view

Task 10: Application data conversion

  1. Determine and develop a type conversion
    1. Associating the identified validation constraints to the model, determine if type conversion needs to occur
    2. For each property in the list, think about what constitutes valid or invalid input from the user.
    3. Determine if the type associated with the property needs to be narrowed or widen to more appropriate accept user input
  2. Determine if a standard JSF converter will is capable of performing the type conversion
    1. Identify the correct JSF converter
    2. Associate the converter with the bean property in the JSF view
    3. Configure the converter to match expected application data format / values
  3. Determine if a custom converter is better suited for the conversion
    1. Or develop and associate a custom converter
    2. Implement the Converter interface
    3. Implement the getAsObject and getAsString conversion methods
    4. Register the converter with the Faces context
    5. Associate your custom converter with the view using the <f:converter /> tag

Task 11: Identify, Capture, and Resolve Errors

  1. Note: IS THIS SECTION COMPLETE ENOUGH?
  2. Note: THIS SECTION NEEDS TO BE TAILORED TO JSF
  3. Define the presentation level error handling strategy for JSPs
    1. Implement error pages using isErrorPage attribute
    2. Integrate error redirection using errorPage attribute
    3. Define exception-level error redirection in web.xml
  4. Define the model level error handing strategy for POJOs
    1. Implement custom Exception classes
    2. Implement try / catch / finally blocks to detect and recover from errors
  5. Define error logging strategy
    1. Configure logging java.util.logging properties
    2. Retrieve Logger from logging system
    3. Log error with Logger
  6. Define HTTP-level / navigation-level error handling strategy
    1. Design HTML or JSP error page
    2. Register HTML or JSP with HTTP specific error in web.xml

Task 12: Integrate Security

  1. Note: THIS SECTION IS DEPENDENT UPON REVIEW OF SERLET-JTA-1.0 SECURITY SECTION
  2. Note: THIS SECTION NEEDS TO BE TAILORED TO JSF
  3. Return to the business logic and see if there are any portions of the application that are role specific. Make a list of such application portions.
  4. If so, define a user authentication scheme and a corresponding login page
    1. For each role specific portion of the application, use the servlet role based access control to constrain access to the pages accordingly

Task 13: Test, package and deploy applications

  1. Note: IS THIS SECTION COMPLETE ENOUGH?
  2. Note: THIS SECTION NEEDS TO BE TAILORED TO JSF
  3. Construct the file and directory structure of a Web Application that may contain
    1. static content,
    2. JSP pages,
    3. servlet classes,
    4. the deployment descriptor,
    5. tag libraries,
    6. JAR files, and
    7. Java class files; and describe how to protect resource files from HTTP access.
  4. Describe the purpose and semantics of the deployment descriptor.
  5. Construct the correct structure of the deployment descriptor.
  6. Configure the deployment descriptor to declare one or more tag libraries, deactivate the evaluation language, and deactivate the scripting language.
  7. Explain the purpose of a WAR file and describe the contents of a WAR file, how one may be constructed.
  8. Define URL mappings to support designed navigation flow
Enter labels to add to this page:
Please wait 
Looking for a label? Just start typing.

Sign up or Log in to add a comment or watch this page.


The individuals who post here are part of the extended Sun Microsystems community and they might not be employed or in any way formally affiliated with Sun Microsystems. The opinions expressed here are their own, are not necessarily reviewed in advance by anyone but the individual authors, and neither Sun nor any other party necessarily agrees with them.

Copyright 1994-2009 Sun Microsystems, Inc.
Powered by Atlassian Confluence Sun Guidelines on Public Discourse Privacy Policy Terms of Use Trademarks Site Map Employment Investor Relations Contact