book

Pro JPA 2: Mastering the Java™ Persistence API

Name: Pro JPA 2: Mastering the Java™ Persistence API
ISBN: 9781430219569

by Mike Keith, Merrick Schincariol

December 2009

Beginner to intermediate

536 pages

16h 39m

English

Apress

Read now

Unlock full access

Copyright
Foreword
About the Author
About the Technical Reviewer
Acknowledgments
Mike KeithMerrick Schincariol
Preface
This Book Is For YouCode ExamplesContacting Us
1. Introduction
1.1. Object-Relational Mapping1.1.1. The Impedance Mismatch1.1.1.1. Class Representation1.1.1.2. Relationships1.1.1.3. Inheritance1.2. Java Support for Persistence1.2.1. Proprietary Solutions1.2.2. JDBC1.2.3. Enterprise JavaBeans1.2.4. Java Data Objects1.3. Why Another Standard?1.4. The Java Persistence API1.4.1. History of the Specification1.4.1.1. EJB 3.0 and JPA 1.01.4.1.2. JPA 2.01.4.1.3. JPA and You1.4.2. Overview1.4.2.1. POJO Persistence1.4.2.2. Nonintrusiveness1.4.2.3. Object Queries1.4.2.4. Mobile Entities1.4.2.5. Simple Configuration1.4.2.6. Integration and Testability1.5. Summary
2. Getting Started
2.1. Entity Overview2.1.1. Persistability2.1.2. Identity2.1.3. Transactionality2.1.4. Granularity2.2. Entity Metadata2.2.1. Annotations2.2.2. XML2.2.3. Configuration by Exception2.3. Creating an Entity2.4. Entity Manager2.4.1. Obtaining an Entity Manager2.4.2. Persisting an Entity2.4.3. Finding an Entity2.4.4. Removing an Entity2.4.5. Updating an Entity2.4.6. Transactions2.4.7. Queries2.5. Putting It All Together2.6. Packaging It Up2.6.1. Persistence Unit2.6.2. Persistence Archive2.7. Summary
3. Enterprise Applications
3.1. Application Component Models3.2. Session Beans3.2.1. Stateless Session Beans3.2.1.1. Defining a Stateless Session Bean3.2.1.2. Lifecycle Callbacks3.2.1.3. Remote Business Interfaces3.2.2. Stateful Session Beans3.2.2.1. Defining a Stateful Session Bean3.2.2.2. Lifecycle Callbacks3.2.3. Singleton Session Beans3.2.3.1. Defining a Singleton Session Bean3.2.3.2. Lifecycle Callbacks3.2.3.3. Singleton Concurrency3.3. Message-Driven Beans3.3.1. Defining a Message-Driven Bean3.4. Servlets3.5. Dependency Management3.5.1. Dependency Lookup3.5.2. Dependency Injection3.5.2.1. Field Injection3.5.2.2. Setter Injection3.5.3. Declaring Dependencies3.5.3.1. Referencing a Persistence Context3.5.3.2. Referencing a Persistence Unit3.5.3.3. Referencing Enterprise JavaBeans3.5.3.4. Referencing Server Resources3.6. Transaction Management3.6.1. Transaction Review3.6.2. Enterprise Transactions in Java3.6.2.1. Transaction Demarcation3.6.2.2. Container-Managed Transactions3.6.2.3. Bean-Managed Transactions3.6.2.3.1. UserTransaction3.7. Using Java EE Components3.7.1. Using a Stateless Session Bean3.7.2. Using a Stateful Session Bean3.7.3. Using a Singleton Session Bean3.7.4. Using a Message-Driven Bean3.7.5. Adding the Entity Manager3.8. Putting It All Together3.8.1. Defining the Component3.8.2. Defining the User Interface3.8.3. Packaging It Up3.9. Summary
4. Object-Relational Mapping
4.1. Persistence Annotations4.2. Accessing Entity State4.2.1. Field Access4.2.2. Property Access4.2.3. Mixed Access4.3. Mapping to a Table4.4. Mapping Simple Types4.4.1. Column Mappings4.4.2. Lazy Fetching4.4.3. Large Objects4.4.4. Enumerated Types4.4.5. Temporal Types4.4.6. Transient State4.5. Mapping the Primary Key4.5.1. Overriding the Primary Key Column4.5.2. Primary Key Types4.5.3. Identifier Generation4.5.3.1. Automatic Id Generation4.5.3.2. Id Generation Using a Table4.5.3.3. Id Generation Using a Database Sequence4.5.3.4. Id Generation Using Database Identity4.6. Relationships4.6.1. Relationship Concepts4.6.1.1. Roles4.6.1.2. Directionality4.6.1.3. Cardinality4.6.1.4. Ordinality4.6.2. Mappings Overview4.6.3. Single-Valued Associations4.6.3.1. Many-to-One Mappings4.6.3.2. Using Join Columns4.6.3.3. One-to-One Mappings4.6.3.4. Bidirectional One-to-One Mappings4.6.4. Collection-Valued Associations4.6.4.1. One-to-Many Mappings4.6.4.2. Many-to-Many Mappings4.6.4.3. Using Join Tables4.6.4.4. Unidirectional Collection Mappings4.6.5. Lazy Relationships4.7. Embedded Objects4.8. Summary

5. Collection Mapping
5.1. Relationships and Element Collections5.2. Using Different Collection Types5.2.1. Sets or Collections5.2.2. Lists5.2.2.1. Ordering By Entity or Element Attribute5.2.2.2. Persistently Ordered Lists5.2.3. Maps5.2.3.1. Keys and Values5.2.3.2. Keying By Basic Type5.2.3.3. Keying by Entity Attribute5.2.3.4. Keying by Embeddable Type5.2.3.4.1. Sharing Embeddable Key Mappings with Values5.2.3.4.2. Overriding Embeddable Attributes5.2.3.5. Keying by Entity5.2.3.6. Untyped Maps5.2.3.7. Rules for Maps5.2.4. Duplicates5.2.5. Null Values5.3. Best Practices5.4. Summary
6. Entity Manager
6.1. Persistence Contexts6.2. Entity Managers6.2.1. Container-Managed Entity Managers6.2.1.1. Transaction-Scoped6.2.1.2. Extended6.2.2. Application-Managed Entity Managers6.3. Transaction Management6.3.1. JTA Transaction Management6.3.1.1. Transaction-Scoped Persistence Contexts6.3.1.2. Extended Persistence Contexts6.3.1.2.1. Persistence Context Collision6.3.1.2.2. Persistence Context Inheritance6.3.1.3. Application-Managed Persistence Contexts6.3.2. Resource-Local Transactions6.3.3. Transaction Rollback and Entity State6.4. Choosing an Entity Manager6.5. Entity Manager Operations6.5.1. Persisting an Entity6.5.2. Finding an Entity6.5.3. Removing an Entity6.5.4. Cascading Operations6.5.4.1. Cascade Persist6.5.4.2. Cascade Remove6.5.5. Clearing the Persistence Context6.6. Synchronization with the Database6.7. Detachment and Merging6.7.1. Detachment6.7.2. Merging Detached Entities6.7.3. Working with Detached Entities6.7.3.1. Planning for Detachment6.7.3.1.1. Triggering Lazy Loading6.7.3.1.2. Configuring Eager Loading6.7.3.2. Avoiding Detachment6.7.3.2.1. Transaction View6.7.3.2.2. Entity Manager per Request6.7.3.3. Merge Strategies6.7.3.3.1. Session Façade6.7.3.3.2. Edit Session6.8. Summary
7. Using Queries
7.1. Java Persistence Query Language7.1.1. Getting Started7.1.2. Filtering Results7.1.3. Projecting Results7.1.4. Joins Between Entities7.1.5. Aggregate Queries7.1.6. Query Parameters7.2. Defining Queries7.2.1. Dynamic Query Definition7.2.2. Named Query Definition7.3. Parameter Types7.4. Executing Queries7.4.1. Working with Query Results7.4.1.1. Untyped Results7.4.1.2. Optimizing Read-Only Queries7.4.1.3. Special Result Types7.4.2. Query Paging7.4.3. Queries and Uncommitted Changes7.4.4. Query Timeouts7.5. Bulk Update and Delete7.5.1. Using Bulk Update and Delete7.5.2. Bulk Delete and Relationships7.6. Query Hints7.7. Query Best Practices7.7.1. Named Queries7.7.2. Report Queries7.7.3. Vendor Hints7.7.4. Stateless Session Beans7.7.5. Bulk Update and Delete7.7.6. Provider Differences7.8. Summary
8. Query Language
8.1. Introduction8.1.1. Terminology8.1.2. Example Data Model8.1.3. Example Application8.2. Select Queries8.2.1. SELECT Clause8.2.1.1. Path Expressions8.2.1.2. Entities and Objects8.2.1.3. Combining Expressions8.2.1.4. Constructor Expressions8.2.1.5. Inheritance and Polymorphism8.2.2. FROM Clause8.2.2.1. Identification Variables8.2.2.2. Joins8.2.2.2.1. Inner Joins8.2.2.2.2. JOIN Operator and Collection Association Fields8.2.2.2.3. JOIN Operator and Single-Valued Association Fields8.2.2.2.4. Join Conditions in the WHERE Clause8.2.2.2.5. Multiple Joins8.2.2.2.6. Map Joins8.2.2.2.7. Outer Joins8.2.2.2.8. Fetch Joins8.2.3. WHERE Clause8.2.3.1. Input Parameters8.2.3.2. Basic Expression Form8.2.3.3. BETWEEN Expressions8.2.3.4. LIKE Expressions8.2.3.5. Subqueries8.2.3.6. IN Expressions8.2.3.7. Collection Expressions8.2.3.8. EXISTS Expressions8.2.3.9. ANY, ALL, and SOME Expressions8.2.4. Scalar Expressions8.2.4.1. Literals8.2.4.2. Function Expressions8.2.4.3. CASE Expressions8.2.5. ORDER BY Clause8.3. Aggregate Queries8.3.1. Aggregate Functions8.3.1.1. AVG8.3.1.2. COUNT8.3.1.3. MAX8.3.1.4. MIN8.3.1.5. SUM8.3.2. GROUP BY Clause8.3.3. HAVING Clause8.4. Update Queries8.5. Delete Queries8.6. Summary
9. Criteria API
9.1. Overview9.1.1. The Criteria API9.1.2. Parameterized Types9.1.3. Dynamic Queries9.2. Building Criteria API Queries9.2.1. Creating a Query Definition9.2.2. Basic Structure9.2.3. Criteria Objects and Mutability9.2.4. Query Roots and Path Expressions9.2.4.1. Query Roots9.2.4.2. Path Expressions9.2.5. The SELECT Clause9.2.5.1. Selecting Single Expressions9.2.5.2. Selecting Multiple Expressions9.2.5.3. Using Aliases9.2.6. The FROM Clause9.2.6.1. Inner and Outer Joins9.2.6.2. Fetch Joins9.2.7. The WHERE Clause9.2.8. Building Expressions9.2.8.1. Predicates9.2.8.2. Literals9.2.8.3. Parameters9.2.8.4. Subqueries9.2.8.5. In Expressions9.2.8.6. Case Expressions9.2.8.7. Function Expressions9.2.9. The ORDER BY Clause9.2.10. The GROUP BY and HAVING Clauses9.3. Strongly Typed Query Definitions9.3.1. The Metamodel API9.3.2. Strongly Typed API Overview9.3.3. The Canonical Metamodel9.3.3.1. Using the Canonical Metamodel9.3.3.2. Generating the Canonical Metamodel9.3.4. Choosing the Right Type of Query9.4. Summary
10. Advanced Object-Relational Mapping
10.1. Table and Column Names10.2. Complex Embedded Objects10.2.1. Advanced Embedded Mappings10.2.2. Overriding Embedded Relationships10.3. Compound Primary Keys10.3.1. Id Class10.3.2. Embedded Id Class10.4. Derived Identifiers10.4.1. Basic Rules for Derived Identifiers10.4.2. Shared Primary Key10.4.3. Multiple Mapped Attributes10.4.4. Using EmbeddedId10.5. Advanced Mapping Elements10.5.1. Read-Only Mappings10.5.2. Optionality10.6. Advanced Relationships10.6.1. Using Join Tables10.6.2. Avoiding Join Tables10.6.3. Compound Join Columns10.6.4. Orphan Removal10.6.5. Mapping Relationship State10.7. Multiple Tables10.8. Inheritance10.8.1. Class Hierarchies10.8.1.1. Mapped Superclasses10.8.1.2. Transient Classes in the Hierarchy10.8.1.3. Abstract and Concrete Classes10.8.2. Inheritance Models10.8.2.1. Single-Table Strategy10.8.2.1.1. Discriminator Column10.8.2.1.2. Discriminator Value10.8.2.2. Joined Strategy10.8.2.3. Table-per-Concrete-Class Strategy10.8.3. Mixed Inheritance10.9. Summary
11. Advanced Topics
11.1. SQL Queries11.1.1. Native Queries versus JDBC11.1.2. Defining and Executing SQL Queries11.1.3. SQL Result Set Mapping11.1.3.1. Mapping Foreign Keys11.1.3.2. Multiple Result Mappings11.1.3.3. Mapping Column Aliases11.1.3.4. Mapping Scalar Result Columns11.1.3.5. Mapping Compound Keys11.1.3.6. Mapping Inheritance11.1.4. Parameter Binding11.2. Lifecycle Callbacks11.2.1. Lifecycle Events11.2.1.1. PrePersist and PostPersist11.2.1.2. PreRemove and PostRemove11.2.1.3. PreUpdate and PostUpdate11.2.1.4. PostLoad11.2.2. Callback Methods11.2.2.1. Enterprise Contexts11.2.3. Entity Listeners11.2.3.1. Attaching Entity Listeners to Entities11.2.3.2. Default Entity Listeners11.2.4. Inheritance and Lifecycle Events11.2.4.1. Inheriting Callback Methods11.2.4.2. Inheriting Entity Listeners11.2.4.3. Lifecycle Event Invocation Order11.3. Validation11.3.1. Using Constraints11.3.2. Invoking Validation11.3.3. Validation Groups11.3.4. Creating New Constraints11.3.4.1. Constraint Annotations11.3.4.2. Constraint Implementation Classes11.3.5. Validation in JPA11.3.6. Enabling Validation11.3.7. Setting Lifecycle Validation Groups11.4. Concurrency11.4.1. Entity Operations11.4.2. Entity Access11.5. Refreshing Entity State11.6. Locking11.6.1. Optimistic Locking11.6.1.1. Versioning11.6.1.2. Advanced Optimistic Locking Modes11.6.1.2.1. Optimistic Read Locking11.6.1.2.2. Optimistic Write Locking11.6.1.3. Recovering from Optimistic Failures11.6.2. Pessimistic Locking11.6.2.1. Pessimistic Locking Modes11.6.2.1.1. Pessimistic Write Locking11.6.2.1.2. Pessimistic Read Locking11.6.2.1.3. Pessimistic Forced Increment Locking11.6.2.2. Pessimistic Scope11.6.2.3. Pessimistic Timeouts11.6.2.4. Recovering From Pessimistic Failures11.7. Caching11.7.1. Sorting Through the Layers11.7.2. Shared Cache11.7.2.1. Static Configuration of the Cache11.7.2.2. Dynamic Cache Management11.8. Utility Classes11.8.1. PersistenceUtil11.8.2. PersistenceUnitUtil11.9. Summary
12. XML Mapping Files
12.1. The Metadata Puzzle12.2. The Mapping File12.2.1. Disabling Annotations12.2.1.1. xml-mapping-metadata-complete12.2.1.2. metadata-complete12.2.2. Persistence Unit Defaults12.2.2.1. schema12.2.2.2. catalog12.2.2.3. delimited-identifiers12.2.2.4. access12.2.2.5. cascade-persist12.2.2.6. entity-listeners12.2.3. Mapping File Defaults12.2.3.1. package12.2.3.2. schema12.2.3.3. catalog12.2.3.4. access12.2.4. Queries and Generators12.2.4.1. sequence-generator12.2.4.2. table-generator12.2.4.3. named-query12.2.4.4. named-native-query12.2.4.5. sql-result-set-mapping12.2.5. Managed Classes and Mappings12.2.5.1. Attributes12.2.5.2. Tables12.2.5.2.1. table12.2.5.2.2. secondary-table12.2.5.3. Identifier Mappings12.2.5.3.1. id12.2.5.3.2. embedded-id12.2.5.3.3. id-class12.2.5.4. Simple Mappings12.2.5.4.1. basic12.2.5.4.2. transient12.2.5.4.3. version12.2.5.5. Relationship and Collection Mappings12.2.5.5.1. many-to-one12.2.5.5.2. one-to-many12.2.5.5.3. one-to-one12.2.5.5.4. many-to-many12.2.5.5.5. element-collection12.2.5.6. Embedded Object Mappings12.2.5.6.1. embedded12.2.5.6.2. attribute-override12.2.5.6.3. association-override12.2.5.7. Inheritance Mappings12.2.5.7.1. inheritance12.2.5.7.2. discriminator-column12.2.5.7.3. discriminator-value12.2.5.7.4. attribute-override and association-override12.2.5.8. Lifecycle Events12.2.5.9. Entity Listeners12.2.5.9.1. entity-listeners12.2.5.9.2. exclude-default-listeners12.2.5.9.3. exclude-superclass-listeners12.3. Summary
13. Packaging and Deployment
13.1. Configuring Persistence Units13.1.1. Persistence Unit Name13.1.2. Transaction Type13.1.3. Persistence Provider13.1.4. Data Source13.1.5. Mapping Files13.1.6. Managed Classes13.1.6.1. Local Classes13.1.6.2. Classes in Mapping Files13.1.6.3. Explicitly Listed Classes13.1.6.4. Additional JARs of Managed Classes13.1.7. Shared Cache Mode13.1.8. Validation Mode13.1.9. Adding Vendor Properties13.2. Building and Deploying13.2.1. Deployment Classpath13.2.2. Packaging Options13.2.2.1. EJB JAR13.2.2.2. Web Archive13.2.2.3. Persistence Archive13.2.3. Persistence Unit Scope13.3. Outside the Server13.3.1. Configuring the Persistence Unit13.3.1.1. Transaction Type13.3.1.2. Data Source13.3.1.3. Providers13.3.1.4. Listing the Entities13.3.2. Specifying Properties at Runtime13.3.3. System Classpath13.4. Schema Generation13.4.1. Unique Constraints13.4.2. Null Constraints13.4.3. String-Based Columns13.4.4. Floating Point Columns13.4.5. Defining the Column13.5. Summary
14. Testing
14.1. Testing Enterprise Applications14.1.1. Terminology14.1.2. Testing Outside the Server14.1.3. Test Frameworks14.2. Unit Testing14.2.1. Testing Entities14.2.2. Testing Entities in Components14.2.3. The Entity Manager in Unit Tests14.3. Integration Testing14.3.1. Using the Entity Manager14.3.1.1. Test Setup and Teardown14.3.1.2. Switching Configurations for Testing14.3.1.3. Minimizing Database Connections14.3.2. Components and Persistence14.3.2.1. Transaction Management14.3.2.1.1. When to Use Transactions14.3.2.1.2. Container-Managed Transactions14.3.2.1.3. Bean-Managed Transactions14.3.2.2. Container-Managed Entity Managers14.3.2.3. Other Services14.3.2.4. Using an Embedded EJB Container for Integration Testing14.4. Best Practices14.5. Summary
15. Migration
15.1. Migrating from CMP Entity Beans15.1.1. Scoping the Challenge15.1.2. Entity Bean Conversion15.1.2.1. Converting the Business Interface15.1.2.1.1. Migrating Properties15.1.2.1.2. Migrating Business Methods15.1.2.1.3. Migrating Container-Managed Relationships15.1.2.2. Converting the Home Interface15.1.2.2.1. Migrating Queries15.1.2.2.2. Migrating Home Methods15.1.2.2.3. Creating the Façade15.2. Migrating from JDBC15.3. Migrating from Other ORM Solutions15.4. Leveraging Design Patterns15.4.1. Transfer Object15.4.1.1. Fine-Grained Transfer Objects15.4.1.2. Coarse-Grained Transfer Objects15.4.2. Session Façade15.4.3. Data Access Object15.4.4. Business Object15.4.5. Fast Lane Reader15.4.6. Active Record15.5. Summary

Overview

Pro JPA 2 introduces, explains, and demonstrates how to use the new Java Persistence API (JPA). JPA provides Java developers with both the knowledge and insight needed to write Java applications that access relational databases through JPA. Authors Mike Keith and Merrick Schincariol take a hands-on approach to teaching by giving examples to illustrate each new concept of the API and showing how it is used in practice.

Become an O’Reilly member and get unlimited access to this title plus top books and audiobooks from O’Reilly and nearly 200 top publishers, thousands of courses curated by job role, 150+ live events each month,
and much more.

Read now

Unlock full access

More than 5,000 organizations count on O’Reilly

O’Reilly covers everything we've got, with content to help us build a world-class technology community, upgrade the capabilities and competencies of our teams, and improve overall team performance as well as their engagement.

Julian F.

Head of Cybersecurity

I wanted to learn C and C++, but it didn't click for me until I picked up an O'Reilly book. When I went on the O’Reilly platform, I was astonished to find all the books there, plus live events and sandboxes so you could play around with the technology.

Addison B.

Field Engineer

I’ve been on the O’Reilly platform for more than eight years. I use a couple of learning platforms, but I'm on O'Reilly more than anybody else. When you're there, you start learning. I'm never disappointed.

Amir M.

Data Platform Tech Lead

I'm always learning. So when I got on to O'Reilly, I was like a kid in a candy store. There are playlists. There are answers. There's on-demand training. It's worth its weight in gold, in terms of what it allows me to do.

Mark W.

Embedded Software Engineer

Rapid Java Persistence and Microservices: Persistence Made Easy Using Java EE8, JPA and Spring

Publisher Resources

ISBN: 9781430219569Purchase book

Cloud Computing

Data Engineering

Data Science

AI & ML

Programming Languages

Software Architecture

IT/Ops

Security

Design

Business

Soft Skills