|
Building J2EE Web Applications using Struts and JavaServer Faces
|
Course Overview
Geared for experienced Java
developers new to Servlets & JSPs,
this five-day, hands-on workshop
offers a comprehensive hands-on
tutorial in the design and
programming of servlets and JSPs,
and includes all the important
concepts and hands on labs that will
have you building basic working
Struts applications in no time flat.
In addition, this course covers how
to extend the Struts framework to
fit your unique needs.
What will I learn?
JavaServer Faces (JSF) provides
event driven, component –based
technology for developing J2EE 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. Throughout
the five day course students will be
led through a series of
progressively advanced topics, where
each topic consists of lecture,
group discussion, comprehensive
hands-on lab exercises, and lab
review.
This is an intermediate level Java
programming course, designed for
developers who wish to create
dynamic HTML content using Server
Side Java and JSF.
Course Style
Struts addresses many major issues
in using vanilla Servlets/JSP to build web systems. It solves the problem of
controller complexity by removing the workflow logic from the Servlets, and
directing workflow in an XML configuration file. Struts improves on the limited
form support in JSP by adding numerous capabilities to form processing including
easy validation, easy error display, and the refilling of form input on form
retries from a users previous entries. It minimizes the complexity of JSP pages,
by supplying a very extensive and flexible set of custom tag libraries for many
of the standard operations needed in JSP pages.
Students will also learn about the capabilities of servlets, their advantages
over CGI, servlet architecture, and session management. Developers will also
learn about JSP syntax, deployment, and application models, how to use Java as a
scripting language, how to use custom tags, and how to build robust and capable
web applications using Servlets and JSP.
Java Servlets, JavaServer Pages and JavaServer Faces are essential server-side
Java technologies for building web applications. Servlets are programs that run
on a web server; they can respond to client requests and create dynamic content.
JavaServer Pages are useful for dividing work between Java developers and HTML
designers.. This course is a comprehensive tutorial in the design and
programming of servlets and JSPs within a JSF environment. Students will learn
about the capabilities of servlets, Servlet architecture, and JSF. They will
learn about JSP syntax, deployment, and application models, how to use Java as a
scripting language (or not!), and how to build robust and capable web
applications using Servlets and JSP within a JSF environment.
A correct architecture and design is paramount. That's why we explain all
technologies within the Model 2 architecture (de de-facto standard, which is
also followed by frameworks like Struts and Maverick). So we will not explain
Servlets and JSP as a list of technologies as they where specified chronically,
but always within its architectural context. You will learn all technologies.
Course Overview
This is an overview of the course. For a detailed description with objectives
per topic, we refer to the detailed workshop overview, listed further below in
this document.
Session: Struts overview
* Getting Started with Struts
* Your First Struts Application
Session: Introduction to JavaServer Faces
* Lesson: Introduction
* Lesson: Understanding the JSF life-cycle
* Lesson: Creating a basic JSF application
Session: JSF Component Model
* Lesson: JSF UI Components
* Lesson: Managed Beans & Backing Beans
* Lesson: JSF Navigation Model
* Lesson: JSF Data Conversion
* Lesson: JSF Validation
* Lesson: JSF Event and Listener Model
Detailed overview
Struts overview
Getting Started with Struts
* Jakarta Struts Project
* MVC and Struts
* Review Servlets, JSP and Web Applications
* Struts Controller, Views and Resources
Your First Struts Application
* Configuring Struts applications
* Defining views & actions
* Defining FormBeans
* Action Mappings
Introduction to JavaServer Faces
Lesson: Introduction
* Introduce JavaServer Faces
* Explain the benefits of the JavaServer Faces technology
* Provide a global overview of the JSF architecture
* Introduce the building blocks of a JSF application
* Define the development roles during the development of a JSF application
* Explain the use of IDEs for building JSF applications
* Explain the role of MVC within JSF
* Define the view components of JSF
* Define the controller components of JSF
Lesson: Understanding the JSF life-cycle
* Explain the position of the JSF controller servlet within the JSF framework
* Explain the phases of the request-response life-cycle
* Define the role of the developer in each phase
* Define the role of the system in each phase
* Explain the request processing life cycle scenarios
* Explain the FacesContext
* Using FacesContext.renderResponse
Lesson: Creating a basic JSF application
* Introduce the JSF development environment
* Configure the JSF servlet in the web.xml
* Introduce some of the JSF tags for building JSP pages
* Create a basic JSP page, using JSF tags
* Create a backing bean
* Define page flow in the faces-config.xml file
* Define the backing bean in the faces-config.xml file
JSF Component Model
Lesson: JSF UI 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
Lesson: Managed Beans & Backing Beans
* Develop an backing bean to support a JSP page
* Store UI component values in a managed bean
* Store UI component references in the backing bean
* Configure beans using the managed bean creation Facility
Lesson: JSF Navigation Model
* Explain the JSF Navigation Model
* Configure Navigation Rules in the faces-config.xml
* Implement action methods to handle navigation
Lesson: JSF Data Conversion
* Using standard data conversion
* Writing custom data conversion
Lesson: JSF Validation
* Introduce the Standard Validation components
* Add validation to user input
* Display validation messages
* Creating Custom Validation components
Lesson: JSF Event and Listener Model
* Create an event listener
* Explain the three ways to handle an event
* Register event listeners to JSF components
Hands-on lab exercises
1. Writing a
complete Struts application
2. Setup the Webserver-Configure the webserver and test the installation
3. Creating a basic JSF application-Become familiar with the JSF framework.
4. Adding the Resource file-using Resource file in the JSF application
5. Create and Define the JSF Beans-Test the usage and configuration of beans
within a JSF applicaton
6. Define the Highview Datasource-Use the admin console to configure a
datasource
7. Define Navigation Rules and Action methods-Understand how to define
navigation and action methods
8. Add validation to a User Input Form-Understand how to add validation to your
JSF application
9. Add event handlers to the DVD application-Understand how to add event
handlers to a JSF application
Prerequisites
Attending students should be able to
use the syntax of the Java language
without difficulty. Familiarity with
the behavior of accessing web
content from the perspective of the
end user is also helpful.
Recommended Follow-On Courses
.
Duration
5 days
Next Dates
Please call for dates
Cost
£1,500 plus VAT