Live Panel Discussion - Leveraging Red Hat OpenShift for a Multi-Cloud Strategy

closeClose

JavaServer Faces (JSF) Essentials

Course Details
Code: TT6300
Tuition (USD): $1,695.00 • Classroom (2 days)
Course Details
GSA (USD): $1,809.06 • Classroom (2 days)

JavaServer Faces (JSF) Essentials a lab-intensive, hands-on programming course that will provide students with the skills required to design and build scalable, secure, maintainable web applications - leveraging our team’s extensive experience in the delivery of scalable enterprise applications with complex web interfaces based on JEE technologies.

Helping front-end developers, back-end developers, and architects understand how they can get the most out of JavaServer Faces (JSF), this course explores the official standard for simplifying Java web development, explaining what JSF is, how it works, and how it relates to other technologies like, Servlets, JSP, and JSTL.

JavaServer Faces (JSF) provides event driven, component –based technology for developing JEE web applications. This technology greatly simplifies developing web applications. Finally, Java web developers can assemble reusable UI components into rich GUI pages. A standard UI component model will create a rich third-party market of reusable GUI components. JSP is to JavaServer Faces as ASP is to ASP.net.

Skills Gained

Students who attend JavaServer Faces (JSF) Essentials will leave the course armed with the required skills to design, implement, and deploy JSF-based web applications utilizing Ajax. This course provides coverage of all the standard components, renderers, converters, and validators, along with advice on how to use them to create solid applications. Working in a hands-on, lab-intensive environment, students will explore and use complex user interface layouts, prototyping, and integrating templates with back-end model objects. Also covered are advanced techniques like internationalization, and extending JSF with custom components, renderers, converters, and validators.

Topics include:

  • Introduction and Overview
  • The JSF Architecture
  • JSF Request Processing
  • JSF User Interface components
  • EL Expression Language
  • Event Handling
  • Data Validation
  • Data Conversion
  • Rendering Interface Objects

Who Can Benefit

  • Experienced Java developers that need to further expand their skills in web development

Prerequisites

This is an intermediate level Java EE (JEE) developer course, designed for experienced Java developers, new to JEE, that need to further extend their skills in JEE web development. Attendees should have an extensive working knowledge in developing basic Java applications.

Course Details

Working in a dynamic, interactive discussion and hands-on programming environment, developers will:

  • Write web applications that take advantage of the FacesServlet, FacesContext and Action Java classes to control the user experience of the web application.
  • Write JSF applications that gather and update information from external application servers such as EJBs, CORBA servers, and database servers.
  • Understand the use of the standard JSF Validators and how to write custom Validators.
  • Understand the use of the standard JSF Data Conversion classes and how to write custom Data Converters.

Session: Developing Java EE applications

Lesson: Enterprise Development

  • Enterprise Application Software
  • Requirements of Enterprise applications
  • Scalability, Load Balancing, Fail Over
  • Resource pooling

Lesson: Java EE Core Components

  • Overview of Java EE Core Components
  • Web Tier Components
  • Application Tier
  • Deployable Units
  • Deployment Descriptors
  • The Java Naming and Directory Interface (JNDI)
  • Tutorial: Working with Eclipse (JEE version) and TomEE

Lesson: Implementing MVC in JEE

  • Model View Control
  • Using the RequestDispatcher
  • Handling Requests
  • The Request Scope
  • Handling Request Attributes
  • The Expression Language (JSR 341)
  • EL in Template text
  • Exercise: Implementing MVC

Session: Expression Language 3.0 (EL)

Lesson: Overview of EL

  • The Expression Language (JSR 341)
  • Value and Method Expressions
  • Immediate and Deferred Evaluation Syntax
  • Read and Read/Write expressions

Lesson: The EL language

  • EL Operators
  • EL Reserved Words
  • EL Implicit objects
  • Referencing Objects using EL
  • Exercise: Working with EL

Session: Introduction to Java Server Faces

Lesson: Introduction to JSF

  • JSF Overview
  • The JSF ‘Components’
  • Configuring a JSF Application
  • MVC using JSF
  • Exercise: First JSF

Lesson: JSF Components

  • Understand the component architecture of JSF
  • Explain the use of the RenderKit
  • User Interface Component Model
  • Introduce the JSF Custom Tags
  • Explain the functionality of the various input tags
  • Panels and tables in JSF
  • Exercise: JSF HTML Tags

Session: Facelets

Lesson: Facelets

  • Facelets as View Handlers
  • Custom Tags Used in Facelets
  • The @Named Annotation
  • The @RequestScoped and @SessionScoped Annotations
  • Using the dataTable Custom Tag
  • Exercise: Working With Facelets

Lesson: Facelets Templating and Resources

  • Creating a Consistent Look and Feel
  • Templating and Placeholders
  • JSF resource management
  • Exercise: Facelets Templating

Session: Extending JSF

Lesson: Composite Components

  • Creating Reusable Components
  • Creating Resource Libraries
  • Defining The Component Interface
  • Implementing A Custom Component
  • Exercise: Composite Components

Lesson: The JSF LifeCycle

  • The Lifecycle of JSF
  • The Request Processing Lifecycle Phases

Lesson: JSF and AJAX

  • Adding AJAX to the Web Page
  • Partial Page Rendering
  • The f:ajax Tag
  • Exercise: JSF and AJAX

Lesson: JSF extension points

  • Converters
  • The @FacesConverter Annotation
  • Validators
  • The @FacesValidator Annotation
  • Listeners
  • Handling Component Events
  • Exercise: Adding Event Listeners