JAVA EE 6 PROGRAMMING - WEBLOGIC 12C ECLIPSE
CLASS DATE(s):
Request a Class

COURSE LENGTH: 5 Days

COURSE COST: $2495.00

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

Printable version of this course
print

COURSE OVERVIEW

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.

AUDIENCE AND PREREQUISITES

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. For those that require Java experience before this course the following course is suggested:

  

*Course Cost listed does not include the cost of courseware or lunch, required in your registration. Please refer to your Enrollment Sales Order or Invoice for the additional cost. If you have any questions, please contact us (learn@vtec.org or 207-775-0244). Course is subject to minimum enrollment. Course may run as a live distance learning course if minimum is not met.

COURSE TOPICS:


OBJECTIVES
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

TOPICS
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

CHAPTER 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
Java EE Business Components
Dependency Injection
Java Web Services
Java EE Application Architecture & Java EE Architecture Example

CHAPTER 2. INTRODUCTION TO JAVASERVER FACES 2.0
What is JavaServer Faces (JSF)?
Why Use JSF?
Nature of a JSF Application
JSF Implementations
JSF and MVC,
Faces Servlet & Faces Servlet URL Mapping
Managed Bean
The View Layer
XML Validity of a Page
A Simple JSF Application
The Input Form: form.xhtml
The Result: thanks.xhtml

.
The Controller: AddressBean
How Does the Application Work?
Under the Covers: The Rendered Form HTML
Under the Covers: The Layout Tree
Additional References

CHAPTER 3. BASIC JSF USER INTERFACE COMPONENTS
JSF UI Components, JSF UI Tags
A Basic Page, Define a Form, Labels and Images
Botton, Links, Output Link, Text Input
Simple Check Box
Check Box Group & Check Box Group Example
Radio Button, List Boxes
Multiple Selection List Box
Dynamic List Box, Example
Component Identifier
Showing and Hiding Components
Other Common Attributes
Adding JavaScript and Stylesheet

CHAPTER 4. BASIC MANAGED BEAN AND JSF EXPRESSION AND SCOPE
Introduction
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

CHAPTER 5. JSF EVENT HANDLING
Request Processing Phases
Action Request Processing Phases
JSF Event & Listener Model…
JSF Event Classes, Event Classes
Event Classes: Hierarchy
Action Event Handling
Action Event: Example
Action Listener
Passing Arguments
Value Change Event, Value Change Event Handler
Listener Classes, Listener Interfaces
Listener Classes: Hierarchy

.
Action Listener Class
Value Change Listener Class
Phase Event Listener
Request Processing Lifecycle
Phase Identifiers

CHAPTER 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

CHAPTER 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

CHAPTER 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
Other Advanced Features of CDI
CDI Implementation

CHAPTER 9. DEFINING CDI BEANS
Requirements of Bean Classes
Bean Initialization Methods
beans.xml
Managed Bean Type
Using Beans with EL
Beans Have Default Names
Bean Scopes
EJBs in CDI

CHAPTER 10. 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 11. 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
Interface, Validator
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 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

CHAPTER 13. OVERVIEW OF ENTERPRISE JAVABEANS (EJB)
What are EJBs?
Distributed Transaction
Distributed Security
Distributed Computing
Main Characteristics of EJBs
EJB Container, EJB Client, Annotations
Enterprise JavaBeans
Session Beans, Message-Driven Beans (MDBs)
Asynchronous Session EJBs
EJB Timers, EJB Lite,
EJB Packaging
EJBs are Simple!

CHAPTER 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

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

CHAPTER 16. OVERVIEW OF JAVA PERSISTENCE API
Data Persistence
Java Persistence API
Entities
Session EJB vs JPA Entities, 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 17. 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 18. 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
TypedQuery, Bulk Updates, Bulk Delete
Running Native SQL Query, Native SELECT Query
Native SQL Delete and Insert
Named Native Query

CHAPTER 19. 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 and More........