Java EE 5 Programming with Servlets and JSPs in Eclipse and WebLogic 10 Course

Course Code: IN 747
Course Abstract:

Participants will learn to develop and test server-side applications based on the Java Platform, Enterprise Edition (Java EE) component model using the WebLogic software platform of products and tools. Develop and test server-side applications that use Servlets and JavaServer Pages (JSPs) for the control and flow of e-business applications.

Practical Work
Participants will have the opportunity to build a simple Java program, Servlets and JSPs using Eclipse. Participants will also deploy a Java EE application to WebLogic 10.

Audience:

This course is designed for Java programmers who build server-side web applications interested in leveraging Eclipse to streamline their development cycle.

Duration: 5 days
Learning Outcomes:

Upon completion of this course, the participant will be able to:
> Develop and test Servlets
> Develop and test JavaServer Pages (JSPs)
> Develop and test Java EE applications following the Model/View/Controller architecture
> Integrate business logic using Java Beans and Java Database Connectivity (JDBC)
> Apply best practices to Servlet and JSP development

Course Topics:

Introduction to Eclipse
Overview
The Eclipse Platform
Eclipse 3.0 Java IDE
Views, Perspective and Editor Areas
Basic Operations with Eclipse Views and Perspectives
The Java Perspective
The Debug Perspective
Navigator View
Build and Validation
Templates and Code Completion
Searching
WTP
Summary

Introduction to Java EE 5
Objectives
Java Web Applications
Java Web Application Architecture
J2EE Architecture
J2EE Software Packaging
Deployment Descriptors
J2EE Module Structure
Enterprise Archive (EAR)
Web Modules and WAR
EJB Modules
Web Application Programming Model – MVC
An MVC Example
The Infrastructure for Enterprise Web Applications
Summary

Servlet Basics
Objectives
History – CGI
Server Extension APIs
Java Servlet
Servlet Container
Servlet Responsibilities
J2EE and Servlet
The Servlet Class
The HttpServlet Class
An Example – Hello World
The Servlet Container
The Servlet API
Life Cycle – Initialization
Example Initialization
Life Cycle – Processing
Life Cycle – Destroy
User Input
Example – User Input
Output to Client
Servlet Error Handling
Threading Issues
Registering a Servlet in the Web Deployment Descriptor
Create a Servlet
Code Servlet Methods
The Web Deployment Descriptor
Test the Servlet
Debug Servlets
Summary

Servlet Interaction Interface
Objectives
Request
Request Parameters
Request Attributes
Request Headers
Request Path
Other Request Information
Response
Cookies
Setting Cookies
Servlet Context
Servlet Context Attributes
Resource
Session Tracking
Tracking Techniques
Cookies
Cookies – an Example
HTML Hidden Fields
Using HttpSession
Session Invalidation
An Example of Session Tracking Code...
An Example of Session Tracking Code…
HttpSession - URL Rewriting
Summary

JavaServer Page (JSP) Basics
Objectives
JavaServer Pages
A Simple Example - Hello.jsp
JSP Benefits
Evolution of Dynamic Content Technologies
How JSP Works
JSP Invocation
JSP Scripting Elements
JSP Directive
page Directive Attributes
page Directive – an Example
page Attribute – errorPage
page Attribute – isErrorPage
Directives – include
Include – an Example
Include at compile time vs. at request time
Request time inclusion
JSP Declarations
Declarations – an Example
JSP Expressions
JSP Expressions – an Example
JSP Scriptlets
JSP Scriptlets – an Example
JSP Comments
JSP Predefined Variables
The request Object
The response Object
The out Object
Out – an Example
Creating a JSP
Editing a JSP
Testing a JSP
Debugging a JSP
Summary

Advanced JSP
Objectives
What is a JavaBean?
Structure of a JavaBean
Life Cycle
Properties
Very Simple Bean
Using Java Beans in JSP
The jsp:useBean tag
Java Bean scope
jsp:useBean in Action
The jsp:getProperty tag
The jsp:setProperty tag
Mapping all the request parameters
Another Example
Mixing Scriptlets and Bean tags
Configuring JSPs in Deployment Descriptor
Summary

Unified Expression Language and JSP Standard Tag Library (JSTL)
Objectives
Unified Expression Language
Basic Usage
Built-in Objects
Working With Arrays and Maps
Operators
Full Example
JSP Standard Template Library (JSTL)
Run Time Version
Basic Tags
Condition Tags
Interator Tags
Internationalization (I18N)
Setting Preferred Locale
Specifying Resource Bundle
Display Translated Text
Display Number
Display Date
JDBC Tags
Specify Data Source
Performing a Query
Display Result
Pagination Example
Deferred Expressions
Summary

Servlet Programming – Advanced
Objectives
Key Issues for Web Application Development Productivity
Web Application Programming Model – MVC
Model
View
Controller
What is JDBC?
JDBC Architecture
JDBC: Basic Steps
Loading a Driver
DB2 UDB JDBC Drivers
Oracle JDBC Drivers
Create a Connection
Connection
Statement
PreparedStatement
ResultSet
ResultSet…
Example JDBC Servlet With Transactions
Close the Connection
Need for Connection Pooling
Connection Pooling in JDBC 2.0
Connection Pooling
Basic Steps in Using JDBC Connection Pooling
Access a DataSource
Get a Connection
Release Connections
Connection Pool Example
Resource References
JavaBeans
MVC Implementation
Request Dispatching
Request Dispatching - Forward vs. Include
HTTP Redirection
Dispatch vs. redirection
Integrating Servlet and JSP
Calling a JSP from a Servlet
Request Dispatching - forward Request to JSP
Supply Result information to the JSP
A Simple Example
Display JavaBean Properties in JSP
Creating a Data Source
Adding Resource Reference
Create a Java Bean
Add Attributes and Getters and Setters
Summary

Servlet Filters
Objectives
What is a filter?
Why use a filter?
Uses for Filtering
Features of filters
The Filter interface
How a filter works
In what order?
A simple logging filter
Configuring the filter
Mapping the filter
The Web Deployment Descriptor
Common filter tasks
Request and Response Wrappers
Summary

Servlet Event Listener
Objectives
What are Listeners?
Types of Listeners
Writing a Servlet Context Listener
Writing a Servlet Context Attribute Listener
Writing a Session Activation Listener
Writing a Session Attribute Listener
Registering Listeners
Lifecycle of Listeners
Summary

Simple Custom Tags
Objectives
What are Custom Tags (a.k.a. Tag Extensions)?
Motivation
Simple Tags, Tag Files, and Classic Tags
Simple Tag Handlers
Tag Attributes
Tag Body
Tag Library Descriptor
Tag Library Descriptor Details
carPrice.tld
The Java Server Page
Writing a Simple Tag Handler Class
Simple Tag Handler Life Cycle
Rendering Content
Implementing Empty Body Tag
Example: CarPriceHandler
carPrice.jsp
Implementing a Tag with Unprocessed Body
Handling Tag Bodies
Implementing Body Processing
Example: Body Tag Support
Implementing an Iteration Tag
Nested Tags
Summary

JSP Tag Files
Objectives
What are JSP Tag Files?
Motivation
Similarities to a JSP
Example
The Java Server Page
Location of Tag Files
Simple Attributes
Fragment Attributes
Fragment Attribute Example
Tag File Directives
Implicit Objects
Reusing Tag Files
Summary

J2EE Security
Objectives
Overview
Authentication
J2EE Authentication Mechanisms
Specifying Authentication Mechanism
Example: Form-Based Authentication
Authorization
J2EE Roles
Sample Role Mapping
Declaring Roles
Protecting Web Resources
Programmatic Authorization
Summary

J2EE Annotations
Objectives
What are Annotations?
Java Metadata Specification (JSR-175)
Where Can Annotations Be Used?
@EJB, @EJBs
@PersistenceContext, @PersistenceContexts
@PersistenceUnit, @PersistenceUnits
@PostConstruct, @PreDestroy
@Resource, @Resources
@WebServiceRef, @WebServiceRefs
Summary

J2EE Application Deployment
Objectives
Overview
Application Deployment Descriptor
Deployment Descriptors
Bean Developer Entries
Application Assembler Entries
Separate Client Side Code (Optional)
Generate Deployed Code
Export EAR
Export Client JAR
J2EE Deployment
Administrative Console
Environment Variables
Security
Resources
Installing Applications
Server Options
Starting an Application
Summary

Introduction to JavaServer Faces
What is JavaServer Faces (JSF)?
Why Use JSF?
Nature of a JSF Application
The Sun Reference Implementation (RI)
JSF and MVC
Faces Servlet
Managed Bean
The View
A Simple JSF Application
The Input Form: form.jsp
The Result: thanks.jsp
The Controller: AddressBean
Page Flow or Navigation Rule
How Does the Application Work?
Under the Covers: The Rendered Form HTML
Under the Covers: The Layout Tree
Summary

Appendix A. Enterprise JavaBeans (EJBs) Overview
Objectives
Need for EJBs
Distributed Computing
Distributed Transaction
Distributed Security
What are EJBs?
Main Characteristics of EJBs
EJB Remote Method Call
EJB Architecture Components
EJB Client
EJB JAR File
EJB Container
EJB Server
Enterprise JavaBeans
Session Beans
Entity Beans
Java Persistence API - Entities
Message-Driven Beans (MDBs)
EJB Specification
Summary

Appendix B. Introduction to Struts
Objectives
What is Struts?
Why Struts?
Struts Components
The Controller Layer
The View
The Form Bean
A Simple Action
Struts Configuration
Define HelloAction
Invoking HelloAction
Finding Information About Struts
Summary

Appendix C. Legacy Tag Library API
Objectives
Introduction
Tag Attributes
Tag Body
Tag Library Descriptor
Tag Library Descriptor Details
carPrice.tld
The Java Server Page
Writing a Classic Tag Handler Class
Tag Handler Life Cycle
Rendering Content
Implementing Empty Body Tag
Example: CarPriceHandler
CarPriceHandler…
carPrice.jsp
Implementing a Tag with Unprocessed Body
Handling Tag Bodies
Implementing Body Processing
Example: Body Tag Support
Implementing an Iteration Tag
Nested Tags
Summary

Prerequisites: Participants should understand essential concepts of Object-Oriented Programming and be able to write simple Java programs with assistance.
Note: All fields are required
At the present time we do not offer training for individuals or groups less then 6 individuals. We apologize for any inconvenience.


We Value Your Privacy!

Ready to get started or in need of more information? Contact us today.

Go To Blog Virtual Learning