EJB3 and Hibernate

Revision: TE2411_20071126

(7.89 KB) View, Download, or Print Catalog as a PDF.

Course Length:

5 Days

Course Description:

This training course provides students with the knowledge needed to use the Hibernate Object/Relational Mapping (ORM) framework to implement the persistence layer of J2EE applications.

Who Should Attend:

This course will benefit software designers, developers and programmers.

Benefits of Attendance:

Upon completion of this course, students will be able to:

• Understand the concepts of object/relational mappings
• Understand the architecture of Hibernate
• Integrate and configure Hibernate in J2EE applications
• Create Hibernate mappings
• Retrieve and update persistent objects using Hibernate
• Use HQL (Hibernate Query Language) and criteria queries
• Know when to use database and application transactions
• Understand the Hibernate caching architecture
• Tune performance of Hibernate operations
• Use various Hibernate tools

Prerequisites:

To succeed fully in this course, students should understand how to program in Java.

Course Outline:

• Introduction to Hibernate
  1. What is Hibernate?
  2. Relational Database Technology
  3. Accessing Relational Databases from Java
  4. Domain Models
  5. Comparing Object and Relational Models
  6. Identity Modeling
  7. Granularity of Objects and Tables
  8. Association Modeling
  9. Navigation
  10. Inheritance
  11. What is Object/Relational Mapping?
  12. Advantages of using an ORM Tool
  13. Architecture of Hibernate
  14. Hibernate API
  15. Extension Interfaces
  16. Hibernate Configuration
  17. Hibernate Mappings
  18. Hibernate Properties
  19. Hibernate XML Configuration Files
  20. Non-Managed and Managed Environments
  21. Configuration in a Non-Managed Environment
  22. Configuration in a Managed Environment
  23. Binding SessionFactory to JNDI
  24. A Simple Example
  25. Alternatives to Hibernate
  26. EJB Entity Beans
  27. Hand-Coded Persistence Using JDBC
  28. Object-Oriented Databases
  29. Other ORM Tools
• Basic Mappings
  1. Creating the Domain Model
  2. Domain Model
  3. Domain Objects
  4. Hibernate Requirements
  5. Object Identity
  6. Primary Keys
  7. Natural Keys vs. Surrogate Keys
  8. Identifier Property
  9. Identifier Generators
  10. Hibernate Managed Identifiers
  11. Mapping Metadata
  12. Mapping Properties
  13. Property Access Strategies
  14. Derived Properties
  15. Preventing Insert/Update
  16. Using Database Schemas
  17. Quoted SQL Identifiers
  18. Specifying Java Packages
  19. Entity and Value Types
  20. Components
  21. Bi-Directional Components
  22. Other Component Details
  23. Association Mappings
  24. Many-to-One Association
  25. One-to-Many Association
  26. Inheritance Mapping Strategies
  27. Table per Concrete Class
  28. Table per Subclass
  29. Table per Class Hierarchy
• Manipulating Persistent Objects
  1. Object States
  2. Transient Objects
  3. Persistent Objects
  4. Detached Objects
  5. Object Identity
  6. Persisting a Transient Object
  7. Retrieving and Updating a Persistent Object
  8. Deleting a Persistent Object
  9. Updating a Detached Object
  10. Transitive Persistence
  11. Using save-update
  12. Differentiating Between Transient and Detached Objects
  13. HQL Queries
  14. Parameter Binding
  15. Pagination
  16. Named Queries
  17. Polymorphic Queries
  18. Restriction
  19. String Comparison
  20. Logical Operators
  21. Ordering the Results
  22. Join Queries
  23. Implicit Joins
  24. Where Clause Joins
  25. Criteria Queries
  26. Polymorphic Criteria Queries
  27. Restricting Criteria Queries
  28. Comparing Strings in Criteria Queries
  29. Using Logical Operators in Criteria Queries
  30. Ordering Results in Criteria Queries
  31. Using Joins in Criteria Queries
  32. Using Dot Notation to Get Component Properties
• Advanced Mappings
  1. One-to-One Associations
  2. Many-to-Many Associations
  3. Polymorphic Associations
  4. Entity vs. Value Types
  5. Built-in Mapping Types
  6. Using Mapping Types
  7. Custom Mapping Types
  8. Collections of Value Types
  9. Set of Value Types
  10. Bag of Value Types
  11. List of Value Types
  12. Map of Value Types
  13. Collections of Components
  14. Sorting Collections
• Transactions, Concurrency and Performance
  1. Database Transactions
  2. JDBC and JTA Transactions
  3. Hibernate Transactions
  4. Flushing the Hibernate Session
  5. Isolation Issues
  6. Isolation Levels
  7. Configuring the Isolation Level
  8. Pessimistic Locking
  9. Application Transactions
  10. Application Transaction Isolation
  11. Managed Versioning
  12. Using Existing Properties to Implement Optimistic Locking
  13. Caching
  14. Hibernate Cache Architecture
  15. The First-Level Cache
  16. The Second-Level Cache
  17. Cache Concurrency Strategies
  18. Enabling the Second-Level Cache
  19. Cache Regions
  20. Specifying a Cache Provider
  21. Support for Cache Providers
  22. Explicitly Evicting Objects From the Second-Level Cache
  23. Fetching Strategies
  24. Fetching Strategies in Mappings – Single Point Associations
  25. Fetching Strategies in Mappings –Collections
  26. Fetching Strategies in Mappings –Batches
  27. Explicit Initialization of Lazily Loaded Objects
  28. Fetching Strategies in HQL Queries
  29. Fetching Strategies in Criteria Queries
  30. The N+1 Selects Issue
  31. Report Queries - Projections
  32. Report Queries – Projections
  33. Report Queries – Aggregation
  34. Report Queries – Grouping
• Tools and Design Techniques
  1. Generating the Database Schema
  2. Generating the Domain Model
  3. Generating the Database Schema
  4. Using Middlegen
  5. Using XDoclet
  6. The Open Session in View Pattern
  7. Using a Natural Key
  8. Using a Composite Key
  9. Dealing with Database Triggers