Java Training Overview|
This course offers a comprehensive and detail-oriented treatment of Hibernate® 4.0 and the Java Persistence API (JPA) 2.0 for developers interested in implementing persistence tiers for enterprise applications. We cover JPA basics including simple object/relational concepts and annotations, persistence contexts and entity managers, and configuration via persistence.xml. We get a good grounding in the Java Persistence Query Language (JPQL) and take advantage of a prepared JPQL query console to explore the two schemas on which the course's case studies are based. The course then moves into advanced topics including JPA-2.0 mapping options, the Criteria API, lifecycle hooks, JSR-303 validation, locking, and caching. Students will complete the course with a firm understanding of JPA architecture and plenty of hands-on exercise in entity mapping, persistence operations, and JPQL.
Course software includes two schemas: a fairly simple human-resources model (6 tables, 253 rows) for early chapters and a more sophisticated pharmacy schema (14 tables, 4255 rows) for the latter half of the course. The pharmacy schema is based on an open-source project and made available to Capstone Courseware by special permission.
The course supports either the Derby or Oracle RDBMS. Derby is bundled with the course software and is pre-configured; a script is included to change over to Oracle configurations for all exercises and schema-creation scripts are available for both.
Java Training Prerequisites
Java Training Learning Objectives
- A strong Java programming background is essential for this course
- Knowledge of relational database concepts and SQL is recommended -- but is not strictly required.
- Prior experience with JDBC will be a plus but is not required.
After completing this course, the student should be able to:
Java Training Course duration
- Understand the value of object/relational mapping and JPA's role as a standard for ORM implementations.
- Develop JPA entities using JPA annotations to align the Java classes, properties, and types to relational tables, columns, and types.
- Create entity managers and instantiate persistence contexts to perform persistence operations.
- Carry out create/retrieve/update/delete (CRUD) operations on JPA entities using entity managers.
- Implement entity relationships of all cardinalities, including unidirectional and bidirectional relationships.
- Implement special ORM cases such as composite primary keys, inheritance relationships, and cascading operations.
- Use JPQL to write object-oriented queries, and process query results.
- Use the Criteria API to define queries programmatically, and take advantage of type safety using the Metamodel API.
- Build reusable façades that encapsulate simpler and more complex persistence operations.
- Implement persistence lifecycle event handlers.
- Define JSR-303 validation constraints on JPA entities and see them enforced by the JPA provider.
- Make well-informed decisions about locking strategies, and understand the role of the JPA cache in enterprise applications.
Java Training Course outline
Chapter 1. Introduction to JPA
Chapter 2. Object/Relational Mapping
- Object/Relational Mapping
- Mismatches Between Relational and Object Models
- The Java Persistence API
- Entity Metadata
- The Entity Manager
Chapter 3. Entity Managers
- JavaBean Standards
- Property, Field, and Mixed Access
- Table and Column Mapping
- Primary Keys and Generation
- Type Mappings
- Temporal and Enumerated Types
- Embedded Types
- Entity Relationships
- @ManyToOne Relationships
- @OneToOne Relationships
- @OneToMany Relationships
- @ManyToMany Relationships
- Eager and Lazy Loading
Chapter 4. JPQL
- Putting Entities to Work
- Entity State and Transitions
- Managing Transactions
- Persistence Operations
- Creating Queries
- Named Queries
- Query Parameters
- Native Queries
Chapter 5. Advanced Mappings
- The Java Persistence Query Language
- HQL and JPQL
- Query Structure
- Path Expressions
- Scalar Functions
- Operators and Precedence
- between, like, in
- is null, is empty
- Aggregate Functions
Chapter 6. The Criteria API
- Inheritance Strategies
- Single-Table Strategy
- Joined-Table Strategy
- Table-Per-Concrete-Class Strategy
- Querying Over Inheritance Relationships
- Type Identification with .class
- Secondary Tables
- Composite Primary Keys
- @IdClass and @EmbeddedId
- Derived Identifiers
- Default Values
- @Version Fields
- Cascading and Orphan Removal
- Detachment and Merging
- Hibernate Extensions
- The @Type Annotation
Chapter 7. Lifecycle and Validation
- History of the Criteria API
- Criteria Query Structure
- The MetaModel API and Query Type Safety
- The Hibernate Metamodel Generator
- Building Expressions
- Encapsulating Persistence Logic
- Range Queries
Chapter 8. Locking and Caching
- Lifecycle Events
- Method Annotations
- Entity Listeners
- JSR-303 Validation
- The Hibernate Validator
- Constraint Annotations
- Validation Modes
- Validation Groups
- Optimistic Locking
- Optimistic Read Locking
- Optimistic Write Locking
- Pessimistic Locking
- Persistence Context as Transactional Cache
- Shared (2nd-level) Cache
- Locking and Caching "Do's and Don'ts"
Minimum Hardware Requirements
Hardware – recommended
- Dual-core 1.8 GHz, 4 gig RAM, 10 gig disk space.
- Dual-core 2.8 GHz, 8 gig RAM, 10 gig disk space.
Network and Security
- Tested on Windows 7. Course software should be viable on all systems which support a Java 6 Developer's Kit.
Limited privileges required
All free downloadable tools, with an option to use certain commercial products.