Course Description
WA1718 Java EE 5 Programming with JSF, EJB 3.0, and JPA using JBoss 5.1
Students learn how to develop Java EE 5 applications using Eclipse for the JBoss Application Server 5.1. This course covers some of the newest technologies of the Java EE 5 platform, including JSF 1.2, EJB 3.0, and JPA, including JAX-WS web services.
Who Should Attend:
This course is designed for Java programmers and web application designers who have interest in learning how to build or maintain enterprise applications based on the Java EE architecture using Eclipse tools. Prerequisites: Intermediate level Java programming knowledge is required.
Duration:
* Classroom Learning - 5 Day(s)
* Online LIVE - 5 Day(s)
Lesson 1: Java Enterprise Edition (EE) Overview
* •Introduction to Java Platform
* •Java Community Process (JCP)
* •Introduction to Java EE
* •Why Move to Java EE
* •Java EE - New and Enhanced Features
* •Java EE Software Packaging
* •Java EE Technologies
* •Summary
Lesson 2: Java EE Tools in Eclipse WTP
* •Eclipse Platform
* •Eclipse Workspace
* •Perspectives, Views & Editors
* •Basic Operations with Eclipse Views and Perspectives
* •The Java Perspective
* •The Debug Perspective
* •Navigator View
* •Package Explorer
* •Outline View
* •Problems View
* •Eclipse Preferences
* •Build and Validation
* •Code Completion, Templates and Snippets
* •Searching
* •Configure Compiler Class Path
* •JRE Switching
* •Eclipse WTP
* •Java EE Perspectives
* •Project Explorer View
* •Servers View
* •JPA Tools
Lesson 3: 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
*
Lesson 4: Managed Bean
* •What is a Managed Bean?
* •Why Do You Need Managed Beans?
* •Managed Bean As a Controller
* •Registering a Managed Bean
* •Lifecycle of a Managed Bean
* •Initializing a Managed Bean
* •What Scope to Use?
* •Value Binding
* •Property Data Conversion
* •Advanced Property Types
* •Component Binding
* •Other Binding Types
* •Basic Input Processing
* •Advanced Input Processing
* •JSF Expression Language
* •Language Basics
* •Use of Expression in JSF
* •Basic Expression
* •Property Access Expression
* •Map Access Expression
* •Complex Access Expression
* •Predefined Objects
* •Operators
Lesson 5: 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
* •Buttons
* •Links
* •Adding Parameters to Links
* •Text Input
* •Simple Check Box
* •Check Box Group
* •Check Box Group Example
* •Radio Button
* •List Boxes
* •Dynamic List Box
* •Example
* •Another Example
* •JSF Core Library
* •JSF Core Library - Components
* •JSF Component Model
* •Base Class Hierarchy
* •Useful Base Classes
* •Useful HTML Classes
Lesson 6: 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
* •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
Lesson 7: JSF Navigation
* •JSF Navigation
* •Example Action Listener
* •faces-config.xml File
* •JSF Navigation
* •Navigation Rules: Example
* •Choosing Between Redirect & Direct Rendering
* •Navigation: Scenarios
Lesson 8: Validation
* •Introduction
* •Validation
* •Standard Validators
* •
* •
* •
* •Checking for Required Values
* •Showing Validation Error Messages
* •Customizing Standard Error Messages
* •Standard Validation Error Messages
* •Validation Process
* •Sequence Diagram
* •Bypassing Validation
* •Immediate Command Components
* •Immediate Input Components
* •Accessing User Input
* •Immediate Command Component Example
* •Immediate Input Component Example
* •Advanced Field Validation
* •Model Layer Error Handling
Lesson 9: Advanced GUI 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
Lesson 10: JSF Techniques
* •A Typical Application
* •The Create Form
* •Create Action Method
* •Listing Items
* •Editing an Item
* •Adding the Edit Link
* •The Edit Form
* •Update Item
* •Things to Keep in Mind
Lesson 11: Enterprise JavaBeans (EJBs) Overview
* •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
*
Lesson 12: Stateless Session Beans
* •Session Beans
* •Stateless Session Bean
* •Stateless Session Bean Pooling
* •Stateless Session Bean Examples
* •Stateful Session Bean
* •Stateful Session Bean Examples
* •Annotations
* •Stateless Session Bean Components
* •Example: Business Interface
* •Example: Bean Class
* •Alternative Example
* •JNDI - Overview
* •Example: The Client
* •Business Interface Details
* •Bean Class Details
* •Session Bean Lifecycle
* •Stateless Session Bean Lifecycle
* •Summary
Lesson 13: Stateful Session Beans
* •Stateful Session Bean
* •Stateful Session Beans
* •Session Bean Lifecycle
* •Stateful Session Bean Lifecycle
* •Stateful Session Bean Components
* •Stateful Session Bean Example
* •Stateful Session Bean Client
* •Removing the Bean
* •Summary
*
Lesson 14: Entities and Java Persistence API
* •Data Persistence
* •Java Persistence API
* •Entities
* •Session Beans Vs 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
* •Summary
*
Lesson 15: 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)
* •Summary
Lesson 16: References and Dependency Injection
* •Role of References
* •EJB Reference Annotations
* •Resource Reference Annotations
* •Dependency Injection
* •Annotation Injection
* •Example: Field Level Injection
* •Example: Method Level Injection
* •Deployment Descriptor Injection
* •Example: Deployment Descriptor Injection
* •Class Level References
* •Multiple References
* •EJB References in Deployment Descriptors
* •Resource References in Deployment Descriptors
* •Reference Lookup
* •EJBContext
* •JNDI Lookup with EJBContext
* •Overriding Reference Annotations
* •Default Reference Name
* •Resolving References
* •mappedName Attribute
* •Overloaded Reference Names
* •Reference Best Practices
* •Summary
*
Lesson 17: 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
* •Summary
*
Lesson 18: Basic 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
* •Summary
Lesson 19: Complex Entity Relationships
* •One-To-Many and Many-To-One
* •Many-to-One Unidirectional
* •Creating Entity Instances
* •Traversing the Relationship
* •Modeling One-to-Many
* •Maintaining Bidirectional Links
* •Creating Entity Instances
* •Traversing the Relationship
* •Many-to-Many
* •Modeling Many-to-Many
* •Maintaining Bidirectional Links
* •Creating Entity Instances
* •Traversing Relationship
* •Unidirectional One-to-Many
* •Modeling Unidirectional One-to-Many
* •Creating Entity Instances
* •Traversing the Relationship
* •Relationship in JPA QL
* •Fetching Optimizations
* •Lazy vs. Eager Initialization
* •Lazy Initialization
* •Various Problems with Lazy Initialization
* •Fetch Join Query
* •Summary
Lesson 20: Message-Driven Beans
* •The Trouble with RMI/IIOP
* •Messaging to the Rescue
* •Messaging Features
* •Message-Oriented Middleware
* •Messaging Domains
* •Publish/Subscribe
* •Point-to-Point
* •Java Message Service
* •JMS Programming: Overview
* •JMS Programming: Overview…
* •The JMS Interfaces
* •Integrating JMS and EJB
* •Message-Driven Beans Are Different From Other EJBs
* •Message-Driven Beans Cannot Talk to Their Clients
* •Message-Driven Beans are Stateless
* •Durable Subscription
* •Message-Driven Bean Interfaces
* •javax.jms.MessageListener
* •javax.jms.Message
* •Specialized Message Types
* •Lifecycle
* •Message Driven Bean - Example
* •Message Driven Bean - Client Example (JSP)
* •Transactions
* •Security
* •Load Balancing
* •Clustering and Topics
* •Clustering and Queues
* •A Few Tips
* •Poison Messages
* •How the Programmer Can Avoid Poison Messages
* •How the System Administrator Can Avoid Poison Messages
* •Building a Response
* •Potential Problems
* •A Simple Alternative
* •Type Checking and Messages
* •Testing Message-Driven Bean
* •Summary
* •References
Lesson 21: JSF, EJB 3 and JPA Integration
* •Integrating JSF
* •EJB 3
* •JPA
* •Putting It All Together
* •Simple Application
* •Code the JPA Entity
* •The Managed Bean
* •Managed Bean Option 1
* •Managed Bean Option 2
* •Accessing the Entity Manager
* •Local Entity Manager
* •Remote – Session Bean EM
* •Entity As DTO
* •Managed Bean Scope
* •Summary
Lesson 22: Introduction to JAX-WS
* •What is JAX-WS?
* •Advantages of JAX-WS
* •Why Do We Need a Programming Model?
* •Basic Java to WSDL Mapping
* •Developing a Service Provider
* •The Service Implementation Class
* •The Service Endpoint Interface (SEI)
* •Service Implementation Options
* •Developing a Consumer
* •Static Client Development
* •The Service Class
* •The BindingProvider Interface
* •Summary
Agenda
Java Enterprise Edition (EE) Overview
- •Introduction to Java Platform
•Java Community Process (JCP)
•Introduction to Java EE
•Why Move to Java EE
•Java EE - New and Enhanced Features
•Java EE Software Packaging
•Java EE Technologies
•Summary
Java EE Tools in Eclipse WTP
- •Eclipse Platform
•Eclipse Workspace
•Perspectives, Views & Editors
•Basic Operations with Eclipse Views and Perspectives
•The Java Perspective
•The Debug Perspective
•Navigator View
•Package Explorer
•Outline View
•Problems View
•Eclipse Preferences
•Build and Validation
•Code Completion, Templates and Snippets
•Searching
•Configure Compiler Class Path
•JRE Switching
•Eclipse WTP
•Java EE Perspectives
•Project Explorer View
•Servers View
•JPA Tools
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
Managed Bean
- •What is a Managed Bean?
•Why Do You Need Managed Beans?
•Managed Bean As a Controller
•Registering a Managed Bean
•Lifecycle of a Managed Bean
•Initializing a Managed Bean
•What Scope to Use?
•Value Binding
•Property Data Conversion
•Advanced Property Types
•Component Binding
•Other Binding Types
•Basic Input Processing
•Advanced Input Processing
•JSF Expression Language
•Language Basics
•Use of Expression in JSF
•Basic Expression
•Property Access Expression
•Map Access Expression
•Complex Access Expression
•Predefined Objects
•Operators
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
•Buttons
•Links
•Adding Parameters to Links
•Text Input
•Simple Check Box
•Check Box Group
•Check Box Group Example
•Radio Button
•List Boxes
•Dynamic List Box
•Example
•Another Example
•JSF Core Library
•JSF Core Library - Components
•JSF Component Model
•Base Class Hierarchy
•Useful Base Classes
•Useful HTML Classes
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
•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
JSF Navigation
- •JSF Navigation
•Example Action Listener
•faces-config.xml File
•JSF Navigation
•Navigation Rules: Example
•Choosing Between Redirect & Direct Rendering
•Navigation: Scenarios
Validation
- •Introduction
•Validation
•Standard Validators
•
•
•
•Checking for Required Values
•Showing Validation Error Messages
•Customizing Standard Error Messages
•Standard Validation Error Messages
•Validation Process
•Sequence Diagram
•Bypassing Validation
•Immediate Command Components
•Immediate Input Components
•Accessing User Input
•Immediate Command Component Example
•Immediate Input Component Example
•Advanced Field Validation
•Model Layer Error Handling
Advanced GUI Components
- •HTML Panel
•Applying Styles
•Grouping Components
•Data Table
•Using a Data Table
•Data Table Model
•Using a Data Table
•D
Comments
Virtual WA1718 Java EE 5 Programming with JSF, EJB 3.0, and JPA using JBoss 5.1 Online Live training option
Imagine an industry-leading classroom training experience from wherever you have access to the Internet.
The Virtual Online Live events listed here gives you an effective and proven online virtual learning experience with the freedom to attend virtually from anywhere.
There is also an option of experiencing Online Live from one of the many national partner centers where a computer and headset will be provided for you.
This rich and engaging virtual classroom environment lets you conveniently interact with instructors and other students.
You will hear and see your instructor as they teach the course and answer your questions via voice or text.
Choose the online live virtual training option and you can access the recorded version even after the class has finished.
The onDemand labs give you access to the same client and server technologies covered in class so you can test, apply and hone your skills by accessing the labs before and even after the class.
Technical Requirements: a computer or laptop with a modern browser and high speed internet access along with one or two monitors.
