Java EE 6 Programming - JBoss / JBoss Developer
Request a Class



COURSE TIMES: 9:00am - 4:30pm

Printable version of this course


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.


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

Participants should already have an understanding of Java programming.


*Course Cost listed does not include the cost of courseware or lunch. Course is subject to minimum enrollment. Course may run virtually as a Virtual Instructor-Led class if minimum enrollment is not met.


Module 1: Overview of Java EE 6
Java Platforms
Community Innovation
A Whole New Java EE Platform
The Java EE Specifications
Major Java EE Technologies
Java EE Application Packaging
Java Web Applications
Java Persistence
ava EE Business Components
Dependency Injection
Java Web Services
Java EE Application Architecture

Milestone 2: Introduction to Javaserver Face 2.0
What is JavaServer Faces (JSF)?
JSF Implementations
Faces Servlet URL Mapping
Managed Bean
The View Layer
XML Validity of a Page
The Input Form: form.xhtml
The Controller: AddressBean
Under the Covers: The Rendered Form HTML
Under the Covers: The Layout Tree
Additional References

Module 3: Basic JSF User Interface Components
JSF UI Components
A Basic Page
Define a Form
Labels and Images
Text Input
Check Box
Multiple Selection List Box
Component Identifier
Adding JavaScript and Stylesheet

Module 4: Basic Managed Bean and JSF Expression and Scope
JSF Expression Language (EL)
Simple Value Property
Complex Value Property
Method Expression
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

Module 5: JSF Event Handling
Request Processing Phases
Action Request Processing Phases
JSF Event, Listener Model & Classes
Action Event Handling
Action Listener
Passing Arguments
Value Change Event & Handler
Listener Classes & Interfaces
Value Change Listener Class
Phase Event Listener
Request Processing Lifecycle
Phase Identifiers

Module 6: JSF Navigation
JSF Navigation
Example Action Event Handler
Implicit Navigation
Pros and Cons of Implicit Navigation
Defining Rules in faces-config.xml File
Stating the Source View ID
Stating the Action Handler Method
Global Rule
Doing Redirection
Implementing Redirection
Conditional Navigation
Preemptive Navigation

Module 7: Advanced JSF User Interface Components
HTML Panel
Applying Styles
Grouping Components
Data Table
Using a Data Table
Displaying a Header and Footer Row
Applying Styles
Adding Links to a Row
Handling Action

Module 8: 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
CDI Implementation

Module 9: Defining CDI Beans
CDI Beans in JSF
Introduction to Scopes
Normal and Pseudo- scopes
Declaring Scope of a Bean
Scope Boundaries
Instance Sharing
How Dependent Scope Works
Forcing a Dependent Instance
Conversation Scope
Starting and Ending Conversations
Propagating Conversations
Conversations and HttpSession

Module 10: Defining CDI Beans
Requirements of Bean Classes
Bean Initialization Methods
Managed Bean Type
Using Beans with EL
Beans Have Default Names
Bean Scopes

Module 11: JSR 303 Bean Validation
Validation in Applications
Using Validation
Built-in Validation Constraints
Using Constraints & Custom Constraints
Showing Error Messages in JSF
Custom Validation Messages
Bootstrapping Validation
The Validator API
Validation Groups
Using Bean Validation in JPA 2.x and JSF 2.x

Module 12: 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 and Tags
Passing Request Parameters
Passing Request Parameters from POST Action Methods
Causing Redirection
Using a PreRenderView Event
The Flash Object

Module 13: Overview of Enterprise Javabeans (EJB)
What are EJBs?
Distributed Transaction
Distributed Security
Distributed Computing
EJB Container
EJB Client
Enterprise JavaBeans
Session Beans
Message-Driven Beans (MDBs)
Asynchronous Session EJBs
EJB Timers, Lite, and Packaging

Module 14: Stateless Session EJB
Stateless Session Bean
Stateless Session Bean Components
Example: Business Interface
Example: Bean Class
Business Interface Details
Using an EJB in a Client
Portable JNDI Syntax
No-interface EJB
Stateless Session Bean Lifecycle
Stateless Session Bean Initialization

Module 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
Why Use Stateful Session EJBs?
Stateful Session EJB and Transactions

Module 16: Overview of Java Persistence API
Data Persistence
Java Persistence API 2.0
Session EJB vs JPA Entities
Persisting and Retrieving Data
Accessing Entities
EntityManager & Persistence Unit
Persistence Context
persistence.xml - Hibernate & Open JPA Providers, and Toplink,
Creating EntityManager in Session EJB
Creating EntityManager in a Plain Java Class
Transaction Basics

Module 17: JPA Entitiy Lifecycle
Entity Lifecycle
When is an Entity Managed or Detached?
Implementing the CRUD Pattern
Accessing Entities Using Stateless Session Beans
Inserting, Retrieving, Updating, Deleting, and Merging Data
Life-Cycle Callbacks
External Callback Class
Synchronizing with Databases
Entity Lookup
JPAQL (JPA Query Language)

Module 18: Java Persistence Query Langauge
JPA Query Language
Basic JPAQL Syntax
Simple SELECT Examples
The SELECT clause
Reading Data from Code
The WHERE Clause
Named Query
Multiple Named Queries
Bulk Updates & Deletes
Running Native SQL Query
Named Native Query

Module 19: Basic JPA Entity Relationships
Relationship Between Entities
Anatomy of a Relationship
Example Schema
One-to-One Unidirectional
Creating Entity Instances
The Cascade Behavior
One-to-One Bidirectional
Maintaining & Simplifying Bidirectional Links
Traversing the Relationship

Module 20: Complex Entity Relationships
One-To-Many and Many-To-One
Creating Entity Instances
Modeling Many-to-Many
Maintaining Bidirectional Links
Creating Entity Instances
Modeling Unidirectional One-to-Many - @JoinTable & @JoinColumn
Creating Entity Instances
Relationship in JPA QL
Fetching Optimizations
Lazy vs. Eager Initialization
Fetch Join Query

Module 21: Message Driven EJFS
The Limitations of RMI/IIOPMessaging to the Rescue
Message-Oriented Middleware as Messaging Platform
Messaging Domains
JMS Programming: Sending a Message & Receiving a Message
The JMS Interfaces
Message-Driven Beans, Big Picture, Lifecycle, and Interfaces
Transactions, Security, and Load Balancing
Clustering and Topics & Queues
How the System Administrator Can Avoid Poison Messages
How the Programmer & System Administrator Can Avoid Poison Messages

Module 22: Overview of Java Web Services
A Conceptual Look at Services
Defining Services
Benefits of Web Services
Many Flavors of Services
Java Web Service Implementation Choices
Future of JAX-RPC
Java SOAP Web Services with JAX-WS
Java REST Web Services with JAX-RS
REST vs SOAP Summary
Java and XML with JAXB
Java Web Service Clients