Course Description

For those new to Java EE programming this course is an excellent introduction to the various technologies included in the Java EE 6 platform. Developing web applications using JSF, business logic and persistence using EJB and JPA, performing dependency injection between components using CDI, and implementing web services using JAX-WS and JAX-RS are some of the topics covered in this class. After completing this course participants will have a good foundational knowledge of the various major technologies of the Java EE platform and what they can be used for.

This course is also good for those with experience in J2EE 1.4 or earlier as the last two versions of Java EE have seen many major changes.

This course is also available using Eclipse IDE here


This class combines lecture with hands-on experience, and open ended discussion that will help the developer quickly understand the major technologies of Java EE 6. Upon completion of the course, students will:

  • Have an overview of the Servlet/JSP web technologies
  • Develop web based applications using JavaServer Faces
  • Develop business logic layer using EJB 3.1
  • Persist data using Java Persistence (JPA)
  • Use CDI (Contexts and Dependency Injection) to perform type-safe dependency injection of components
  • Use the JSF 2.0 integration with CDI including the CDI support of “conversational” web applications
  • Define standardized data validation constraints with JSR 303 Bean Validation
  • Learn the two major web service implementation choices, JAX-WS and JAX-RS, available in Java EE 6


  • The core Java EE 6 specifications – JSF, CDI, EJB and JPA
  • EJB 3.x simplified programming model
  • Web applications using JavaServer Faces
  • Java Persistence (JPA)
  • JSR 303 Bean Validation
  • Java Web Services with JAX-WS and JAX-RS



5 days


Target Audience

Software designers, developers and programmers new to Java EE or with J2EE 1.4 or earlier experience


Course Prerequisites

Participants should already have an understanding of Java programming. For those that require Java experience before this course the following course is suggested:

GTJ01 – Introduction to Java Using Eclipse


Suggested Follow on Courses

There are a number of options of suitable follow-on courses, depending on your business needs. Please contact us for further details.


Course Content

Chapter 1. Overview of Servlets

Java Servlet

Java EE and Servlet

Servlet Responsibilities

The Servlet Container

The Servlet Class

The HttpServlet Class

Servlet Configuration – web.xml

Servlet Configuration – Annotations

Life Cycle – Request Processing

User Input

Example – User Input


Request Parameters

Request Attributes


Tracking User State

Tracking Techniques

Using HttpSession

Session Invalidation

Chapter 2. Overview of JavaServer Pages (JSP)

JavaServer Pages

A Simple Example – Hello.jsp

JSP Benefits

How JSP Works

JSP Scripting Elements

JSP Directive

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

MVC Implementation

Request Dispatching – Forward Request to JSP

Using Java Beans in JSP

Chapter 3. Introduction to JavaServer Faces

What is JavaServer Faces (JSF)?

Why Use JSF?

Nature of a JSF Application

The Sun Reference Implementation (RI)


Faces Servlet

Managed Bean

The View


Facelets in JSF 2

A Simple JSF Application

The Input Form: form.xhtml

The Result: thanks.xhtml

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

Chapter 4. Basic JSF User Interface Components

JSF UI Components

JSF Component Tag Libraries

Using the Tag Libraries

HTML Tag Library

Identifying Components

Component Identifier

Client Identifier

Form Input Field Names

Define a Form

Labels and Images



Adding Parameters to Links

Text Input

Simple Check Box

Check Box Group

Check Box Group Example

Radio Button

List Boxes

Dynamic List Box


Another Example

JSF Core Library

JSF Core Library – Components

Chapter 5. Managed Bean Scopes in JSF

Managed Bean Scopes

Implications of Various Scopes

View Scoped Managed Beans

Defining Managed Bean Scope

Getting Rid of the Session

Application Scope

“None” Scope

Custom Scopes

Chapter 6. Overview of Contexts and Dependency Injection

Once upon a time

What is CDI?

The JSRs

CDI Example

What Good is DI

Old Bean Scope

CDI Bean Scope

Other Advanced Features of CDI

CDI Implementation

Chapter 7. Defining CDI Beans

Requirements of Bean Classes

Bean Initialization Methods


Managed Bean Type

Using Beans with EL

Beans Have Default Names

Bean Scopes


Chapter 8. Dependency Injection in CDI

Injection Points


Typesafe Resolution


Using an @Qualifier


The Client Proxy

Chapter 9. JSF Integration, Scope and Context

CDI Beans in JSF

JSF Example

Introduction to Scopes

Normal and Pseudo- scopes

Declaring Scope of a Bean

Scope Boundaries

Instance Sharing

Conversation Scope

Use Cases of Conversation Scope

Starting and Ending Conversations

Propagating Conversations

How Dependent Scope Works

Forcing a Dependent Instance

Chapter 10. JSF Navigation

JSF Navigation

Example Action Listener

faces-config.xml File

JSF Navigation

Choosing Between Redirect & Direct Rendering

Navigation Rules: Example

Navigation: Scenarios

Implicit and Conditional Navigation

Chapter 11. JSF GET Requests and View Parameters

Using GET Requests with JSF

POST-Redirect-GET (PRG) Pattern

Implementing PRG Pattern With JSF

Defining View Parameters

New <h:link> and <h:button> Tags

Passing Request Parameters

Passing Request Parameters from POST Action Methods

Causing Redirection

Using a PreRenderView Event

The Flash Object

Chapter 12. JSR 303 Bean Validation

Validation in Applications

Using Validation

Built-in Validation Constraints

Using Constraints

Showing Error Messages in JSF

Custom Validation Messages

Externalizing Validation Messages

External Message Example

Defining Custom Constraints

Custom Constraint Example



Custom Constraint in JSF

Bootstrapping Validation

The Validator API

Validation Groups

Group Example

Using Bean Validation in JPA 2.x and JSF 2.x

Chapter 13. Advanced JSF User Interface Components

HTML Panel

Applying Styles

Grouping Components

Data Table

Using a Data Table

Data Table Model

Using a Data Table

Displaying a Header and Footer Row

Applying Styles

Adding Links to a Row

Using Component Binding

Handling Action

Using the Data Table Model

Handling Action

Chapter 14. Overview of Enterprise JavaBeans (EJB)

Need for EJBs

Distributed Computing

Distributed Transaction

Distributed Security

What are EJBs?

Main Characteristics of EJBs

EJB Client

EJB Container

Enterprise JavaBeans

Session Beans

Message-Driven Beans (MDBs)

Stateless Session Bean


Stateless Session Bean Components

Example: Business Interface

Example: Bean Class

Business Interface Details

Chapter 15. Stateful Session EJB

Stateful Session Bean

Stateful Session Beans

Session Bean Lifecycle

Stateful Session Bean Lifecycle

Stateful Session Bean Example

Stateful Session Bean Client

Removing the Bean

Chapter 16. Message Driven EJBs

Asynchronous Messaging Features

Message-Oriented Middleware

Messaging Domains



Java Message Service

JMS Programming: Overview

JMS Programming: Overview…

The JMS Interfaces

Message Driven EJBs

Message-Driven Bean Interfaces



Specialized Message Types

Message Driven Bean – Example

Chapter 17. Overview of Java Persistence API

Data Persistence

Java Persistence API


Session EJB vs JPA Entities


Persisting and Retrieving Data

Accessing Entities

EntityManager & Persistence Unit

Persistence Context

Entities – Example

persistence.xml – Hibernate Provider

persistence.xml – Open JPA Provider

persistence.xml – Toplink

Entity Instance Lifecycle

Creating EntityManager in Session EJB

Creating EntityManager in a Plain Java Class

Working With the EntityManager Interface

Transaction Basics

Chapter 18. JPA Entity Lifecycle

Entity Lifecycle

When is an Entity Managed or Detached?

Implementing the CRUD Pattern

Accessing Entities Using Stateless Session Beans

Inserting Data

Retrieving Data

Updating Data

Deleting Data

Merging Entities

Merging Entities (example)

Life-Cycle Callbacks

Example: Internal callback

External Callback Class

Listener Class – Example

Synchronizing with Databases

Entity Lookup

JPAQL (JPA Query Language)

Chapter 19. Java Persistence Query Language (JPA QL)

JPA Query Language

Basic JPAQL Syntax

Simple SELECT Examples

Example of Using JPAQL

The SELECT clause

Reading Data from Code

The WHERE Clause

Example Using JPAQL from Session EJB

Named Query

Multiple Named Queries

Bulk Updates

Bulk Delete

Running Native SQL Query

Native SELECT Query

Native SQL Delete and Insert

Named Native Query

Chapter 20. Basic JPA Entity Relationships

Relationship Between Entities

Anatomy of a Relationship

Foreign Key

Example Schema

One-to-One Unidirectional

Creating Entity Instances

Traversing the Relationship

The Cascade Behavior

One-to-One Bidirectional

Maintaining Bidirectional Links

Simplifying Bidirectional Links

Traversing the Relationship

Chapter 21. Overview of Java Web Services

Java Web Service Implementation Choices

Java SOAP Web Services with JAX-WS

Java REST Web Services with JAX-RS


Java and XML with JAXB

Java Web Service Clients


See more WebSphere courses