UMBC Training Centers logo

Developing Java EE Applications with Spring 3.0, JSF, and JPA Using RAD 7.5

 

Course Description | Outline | IT Home

Introduction to the Spring Framework
* What is the Spring Framework?
* Spring Characteristics
* Spring Modules
* Why Spring?
* Problems with EJB
* Spring Philosophies
* Alternatives to Spring
* Simple Example
* What is Inversion of Control?
* IoC Example

Spring Dependency Injection
* Spring Containers
* Spring Containers
* Bean Creation
* Bean Destruction
* Wiring Beans
* Bean Element
* Dependency Injection – Primitives and Strings
* Dependency Injection - References
* Dependency Injection – Inner Beans
* Dependency Injection – Lists, Arrays and Sets
* Dependency Injection – Maps
* Dependency Injection - Properties
* Constructor Injection
* Constructor Injection – Handling Multiple Arguments
* Constructor vs. Setter Injection
* Autowiring
* Autowiring Example
* Autowiring
* Mixing Explicit and Autowiring
* Special Spring Interfaces
* BeanPostProcessor
* BeanFactoryPostProcessor
* PropertyPlaceholderConfigurer
* PropertyPlaceholderConfigurer
* CustomEditorConfigurer
* CustomEditorConfigurer
* Awareness Interfaces
* Listening For and Publishing Events
* XML Schema-based Configuration
* XML Schema-based Configuration
* XML Schema-based Configuration
* XML Schema – jndi Example
* XML Schema – util Example

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
* JSF and MVC
* Faces Servlet
* Faces Servlet
* 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?
* How Does the Application Work?
* Under the Covers: The Rendered Form HTML
* Under the Covers: The Layout Tree

Using JSF with Spring
* JSF Integration Options
* DelegatingVariableResolver
* DelegatingVariableResolver
* SpringBeanVariableResolver
* SpringBeanFacesELResolver
* Spring Bean Scopes
* FacesContextUtils
* JSF with Spring Web Flow

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
* Value Binding
* Property Data Conversion
* Advanced Property Types
* 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 UI Components
* JSF Component Tag Libraries
* Using the Tag Libraries
* HTML Tag Library
* HTML Tag Library
* Identifying Components
* Component Identifier
* Client Identifier
* Form Input Field Names
* Define a Form
* Labels and Images
* Buttons
* Links
* Links
* Adding Parameters to Links
* Text Input
* Simple Check Box
* Check Box Group
* Check Box Group Example
* Radio Button
* List Boxes
* List Boxes
* List Boxes
* Dynamic List Box
* Example
* Another Example
* JSF Core Library
* JSF Core Library - Components
* JSF Core Library - Components
* JSF Core Library - Components
* JSF Core Library - Components
* JSF Core Library - Components
* JSF Component Model
* JSF Component Model
* Base Class Hierarchy
* Useful Base Classes
* Useful HTML Classes
* Useful HTML Classes

Introduction to Facelets
* Constructing and Rendering a View (JSP way)
* Constructing and Rendering a View (JSP way)
* Facelets
* Facelets
* Facelets
* Getting Facelets
* Using Facelets
* Using Facelets
* Using Facelets
* Using Facelets
* Page Templates
* Define a Page Template
* Define a Page Template
* Define a Template Client
* Define a Template Client
* Define a Template Client
* Run the Template Client
* Summary

JSF Event Handling
* Request Processing Phases
* Action Request Processing Phases
* Action 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
* Value Change Event Handler
* 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
* Phase Identifiers

JSF Navigation
* JSF Navigation
* Example Action Listener
* faces-config.xml File
* JSF Navigation
* JSF Navigation
* JSF Navigation
* Navigation Rules: Example
* Navigation Rules: Example
* Choosing Between Redirect & Direct Rendering
* Navigation: Scenarios
* Navigation: Scenarios
* Navigation: Scenarios
* Navigation: Scenarios
* Navigation: Scenarios
* Navigation: Scenarios
* Navigation: Scenarios

Validation
* Introduction
* Validation
* Validation
* Standard Validators
* <f:validateLength>
* <f:validateDoubleRange>
* <f:validateLongRange>
* Checking for Required Values
* Checking for Required Values
* Showing Validation Error Messages
* Customizing Standard Error Messages
* Standard Validation Error Messages
* Standard Validation Error Messages
* Validation Process
* 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
* Advanced Error Handling

Advanced GUI Components
* HTML Panel
* Applying Styles
* Grouping Components
* Data Table
* Using a Data Table
* Data Table Model
* 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

Entities and Java Persistence API
* Data Persistence
* Data Persistence
* Java Persistence API
* Entities
* Session Beans Vs Entities
* Entities
* Entities
* Persisting and Retrieving Data
* Accessing Entities
* EntityManager & Persistence Unit
* Persistence Context
* Entities - Example
* Entities - Example
* persistence.xml – Hibernate Provider
* persistence.xml – Open JPA Provider
* persistence.xml - Toplink
* Entity Instance Lifecycle
* Entity Instance Lifecycle
* Creating EntityManager in Session EJB
* Creating EntityManager in a Plain Java Class
* Working With the EntityManager Interface
* Working With the EntityManager Interface
* Transaction Basics
* Summary

Using Spring with JPA
* LocalEntityManagerFactoryBean
* Spring JpaTemplate
* Spring JpaCallback
* JpaTemplate Convenience Features

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
* Life-Cycle Callbacks
* Example: Internal callback
* Example: Internal callback
* External Callback Class
* Listener Class - Example
* Synchronizing with Databases
* Entity Lookup
* JPAQL (JPA Query Language)
* Summary

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
* The WHERE Clause
* The WHERE Clause
* The WHERE Clause
* Example Using JPAQL from Session EJB
* Named Query
* 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

Basic Entity Relationships
* Relationship Between Entities
* Anatomy of a Relationship
* 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

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
* Maintaining Bidirectional Links
* Maintaining Bidirectional Links
* Creating Entity Instances
* Creating Entity Instances
* Traversing the Relationship
* Many-to-Many
* Modeling Many-to-Many
* Maintaining Bidirectional Links
* 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

Spring Security
* HTTP Request Authorization
* Security Annotations
* Security Tag Library
* Servlet Security API Compatibility
* Authentication Backend Support
* LDAP Support
* Password Encoding
* Web Flow Security
* Web Service Security
* Summary

New Features in Spring 3.0
* Spring MVC Changes
* New Spring Configuration Options
* Task Scheduling
* Using AJAX with Spring
* Summary