Pro Jakarta Persistence in Jakarta EE 10: An In-Depth Guide to Persistence in Enterprise Java Development

Table of Contents
About the Authors
About the Technical Reviewer
Acknowledgments
Chapter 1: Introduction
	Relational Databases
	Object-Relational Mapping
		The Impedance Mismatch
			Class Representation
			Relationships
			Inheritance
	Java Support for Persistence
		Proprietary Solutions
			Data Mappers
		JDBC
		Enterprise JavaBeans
		Java Data Objects
	Why Another Standard?
	The Jakarta Persistence API
		History of the Specification
			EJB 3.0 and Java Persistence API 1.0
			Java Persistence API 2.0
			Java Persistence 2.1
			Java Persistence 2.2 and EJB 3.2
			Jakarta Persistence and Enterprise Beans
			Jakarta Persistence 3.0 and Enterprise Beans 4.0
			Jakarta Persistence 3.1
			Jakarta Persistence and You
		Overview
			POJO Persistence
			Nonintrusiveness
			Object Queries
			Mobile Entities
			Simple Configuration
			Integration and Testability
	Summary
Chapter 2: Getting Started
	Entity Overview
		Persistability
		Identity
		Transactionality
		Granularity
	Entity Metadata
		Annotations
		XML
		Configuration by Exception
	Creating an Entity
	Entity Manager
		Obtaining an Entity Manager
		Persisting an Entity
		Finding an Entity
		Removing an Entity
		Updating an Entity
		Transactions
		Queries
	Putting It All Together
	Packaging It Up
		Persistence Unit
		Persistence Archive
	Summary
Chapter 3: Enterprise Applications
	Application Component Models
	Session Beans
		Stateless Session Beans
			Defining a Stateless Session Bean
			Lifecycle Callbacks
		Stateful Session Beans
			Defining a Stateful Session Bean
			Lifecycle Callbacks
		Singleton Session Beans
			Defining a Singleton Session Bean
			Lifecycle Callbacks
	Servlets
	Dependency Management and CDI
		Dependency Lookup
		Dependency Injection
			Field Injection
			Setter Injection
		Declaring Dependencies
			Referencing a Persistence Context
			Referencing a Persistence Unit
			Referencing Server Resources
	CDI and Contextual Injection
		CDI Beans
		Injection and Resolution
		Scopes and Contexts
		Qualified Injection
		Producer Methods and Fields
		Using Producer Methods with Jakarta Persistence Resources
	Transaction Management
		Transaction Review
		Enterprise Transactions in Java
			Transaction Demarcation
			Container-Managed Transactions
				Enterprise Beans Container-Managed Transactions
				Transactional Interceptors
			Bean-Managed Transactions
				UserTransaction
	Putting It All Together
		Defining the Component
		Defining the User Interface
		Packaging It Up
	Summary
Chapter 4: Object-Relational Mapping
	Persistence Annotations
	Accessing Entity State
		Field Access
		Property Access
		Mixed Access
	Mapping to a Table
	Mapping Simple Types
		Column Mappings
		Lazy Fetching
		Large Objects
		Enumerated Types
		Temporal Types
		Transient State
	Mapping the Primary Key
		Overriding the Primary Key Column
		Primary Key Types
		Identifier Generation
			Automatic ID Generation
			ID Generation Using a Table
			ID Generation Using a Database Sequence
			ID Generation Using Database Identity
	Relationships
		Relationship Concepts
			Roles
			Directionality
			Cardinality
			Ordinality
		Mappings Overview
		Single-Valued Associations
			Many-to-One Mappings
			Using Join Columns
			One-to-One Mappings
			Bidirectional One-to-One Mappings
		Collection-Valued Associations
			One-to-Many Mappings
			Many-to-Many Mappings
			Using Join Tables
			Unidirectional Collection Mappings
		Lazy Relationships
	Embedded Objects
	Summary
Chapter 5: Collection Mapping
	Relationships and Element Collections
	Using Different Collection Types
		Sets or Collections
		Lists
			Ordering by Entity or Element Attribute
			Persistently Ordered Lists
		Maps
			Keys and Values
			Keying by Basic Type
			Keying by Entity Attribute
			Keying by Embeddable Type
				Sharing Embeddable Key Mappings with Values
				Overriding Embeddable Attributes
			Keying by Entity
			Untyped Maps
			Rules for Maps
		Duplicates
		Null Values
	Best Practices
	Summary
Chapter 6: Entity Manager
	Persistence Contexts
	Entity Managers
		Container-Managed Entity Managers
			Transaction-Scoped
			Extended
		Application-Managed Entity Managers
	Transaction Management
		Jakarta Transactions Transaction Management
			Transaction-Scoped Persistence Contexts
			Extended Persistence Contexts
				Persistence Context Collision
				Persistence Context Inheritance
			Application-Managed Persistence Contexts
			Unsynchronized Persistence Contexts
		Resource-Local Transactions
		Transaction Rollback and Entity State
	Choosing an Entity Manager
	Entity Manager Operations
		Persisting an Entity
		Finding an Entity
		Removing an Entity
		Cascading Operations
			Cascade Persist
			Cascade Remove
		Clearing the Persistence Context
	Synchronization with the Database
	Detachment and Merging
		Detachment
		Merging Detached Entities
		Working with Detached Entities
			Planning for Detachment
				Triggering Lazy Loading
				Configuring Eager Loading
			Avoiding Detachment
				Transaction View
				Entity Manager per Request
			Merge Strategies
				Session Façade
				Edit Session
				Conversation
	Summary
Chapter 7: Using Queries
	Jakarta Persistence Query Language
		Getting Started
		Filtering Results
		Projecting Results
		Joins Between Entities
		Aggregate Queries
		Query Parameters
	Defining Queries
		Dynamic Query Definition
		Named Query Definition
		Dynamic Named Queries
	Parameter Types
	Executing Queries
		Working with Query Results
		Stream Query Results
			Untyped Results
			Optimizing Read-Only Queries
			Special Result Types
		Query Paging
		Queries and Uncommitted Changes
		Query Timeouts
	Bulk Update and Delete
		Using Bulk Update and Delete
		Bulk Delete and Relationships
	Query Hints
	Query Best Practices
		Named Queries
		Report Queries
		Vendor Hints
		Stateless Beans
		Bulk Update and Delete
		Provider Differences
	Summary
Chapter 8: Query Language
	Introducing Jakarta Persistence QL
		Terminology
		Example Data Model
		Example Application
	Select Queries
		SELECT Clause
			Path Expressions
			Entities and Objects
			Combining Expressions
			Constructor Expressions
		FROM Clause
			Identification Variables
			Joins
				Inner Joins
					JOIN Operator and Collection Association Fields
					JOIN Operator and Single-Valued Association Fields
					Join Conditions in the WHERE Clause
					Multiple Joins
				Map Joins
				Outer Joins
				Fetch Joins
		WHERE Clause
			Input Parameters
			Basic Expression Form
			BETWEEN Expressions
			LIKE Expressions
			Subqueries
			IN Expressions
			Collection Expressions
			EXISTS Expressions
			ANY, ALL, and SOME Expressions
		Inheritance and Polymorphism
			Subclass Discrimination
			Downcasting
		Scalar Expressions
			Literals
			Function Expressions
			Native Database Functions
			Case Expressions
		ORDER BY Clause
	Aggregate Queries
		Aggregate Functions
			AVG
			COUNT
			MAX
			MIN
			SUM
		GROUP BY Clause
		HAVING Clause
	Update Queries
	Delete Queries
	Summary
Chapter 9: Criteria API
	Overview
		The Criteria API
		Parameterized Types
		Dynamic Queries
	Building Criteria API Queries
		Creating a Query Definition
		Basic Structure
		Criteria Objects and Mutability
		Query Roots and Path Expressions
			Query Roots
			Path Expressions
		The SELECT Clause
			Selecting Single Expressions
			Selecting Multiple Expressions
			Using Aliases
		The FROM Clause
			Inner and Outer Joins
			Fetch Joins
		The WHERE Clause
		Building Expressions
			Predicates
			Literals
			Parameters
			Subqueries
			IN Expressions
			Case Expressions
			Function Expressions
			Downcasting
			Outer Join Criteria
		The ORDER BY Clause
		The GROUP BY and HAVING Clauses
	Bulk Update and Delete
	Strongly Typed Query Definitions
		The Metamodel API
		Strongly Typed API Overview
		The Canonical Metamodel
			Using the Canonical Metamodel
			Generating the Canonical Metamodel
		Choosing the Right Type of Query
	Summary
Chapter 10: Advanced Object- Relational Mapping
	Table and Column Names
	Converting Entity State
		Creating a Converter
		Declarative Attribute Conversion
			Converting Embedded Attributes
			Converting Collections
			Limitations
		Automatic Conversion
		Converters and Queries
	Complex Embedded Objects
		Advanced Embedded Mappings
		Overriding Embedded Relationships
	Compound Primary Keys
		ID Class
		Embedded ID Class
	Derived Identifiers
		Basic Rules for Derived Identifiers
		Shared Primary Key
		Multiple Mapped Attributes
		Using EmbeddedId
	Advanced Mapping Elements
		Read-Only Mappings
		Optionality
	Advanced Relationships
		Using Join Tables
		Avoiding Join Tables
		Compound Join Columns
		Orphan Removal
		Mapping Relationship State
	Multiple Tables
	Inheritance
		Class Hierarchies
			Mapped Superclasses
			Transient Classes in the Hierarchy
			Abstract and Concrete Classes
		Inheritance Models
			Single-Table Strategy
				Discriminator Column
				Discriminator Value
			Joined Strategy
			Table-per-Concrete-Class Strategy
		Mixed Inheritance
			Supporting the Java Date and Time API
	Summary
Chapter 11: Advanced Queries
	SQL Queries
		Native Queries vs. JDBC
		Defining and Executing SQL Queries
		SQL Result Set Mapping
			Mapping Foreign Keys
			Multiple Result Mappings
			Mapping Column Aliases
			Mapping Scalar Result Columns
			Mapping Compound Keys
			Mapping Inheritance
			Mapping to Nonentity Types
		Parameter Binding
		Stored Procedures
			Defining and Executing Stored Procedure Queries
				Scalar Parameter Types
				Result Set Parameter Types
			Stored Procedure Mapping
	Entity Graphs
		Entity Graph Annotations
			Basic Attribute Graphs
			Using Subgraphs
			Entity Graphs with Inheritance
			Map Key Subgraphs
		Entity Graph API
		Managing Entity Graphs
			Accessing Named Entity Graphs
			Adding Named Entity Graphs
			Creating New Entity Graphs from Named Ones
		Using Entity Graphs
			Fetch Graphs
			Load Graphs
			Best Practices for Fetch and Load Graphs
	Summary
Chapter 12: Other Advanced Topics
	Lifecycle Callbacks
		Lifecycle Events
			PrePersist and PostPersist
			PreRemove and PostRemove
			PreUpdate and PostUpdate
			PostLoad
		Callback Methods
			Enterprise Contexts
		Entity Listeners
			Entity Listeners as CDI Beans
			Attaching Entity Listeners to Entities
			Default Entity Listeners
		Inheritance and Lifecycle Events
			Inheriting Callback Methods
			Inheriting Entity Listeners
			Lifecycle Event Invocation Order
	Validation
		Using Constraints
		Invoking Validation
		Validation Groups
		Creating New Constraints
			Constraint Annotations
			Constraint Implementation Classes
		Validation in Jakarta Persistence
		Enabling Validation
		Setting Lifecycle Validation Groups
	Concurrency
		Entity Operations
		Entity Access
	Refreshing Entity State
	Locking
		Optimistic Locking
			Versioning
			Advanced Optimistic Locking Modes
				Optimistic Read Locking
				Optimistic Write Locking
			Recovering from Optimistic Failures
		Pessimistic Locking
			Pessimistic Locking Modes
				Pessimistic Write Locking
				Pessimistic Read Locking
				Pessimistic Forced Increment Locking
			Pessimistic Scope
			Pessimistic Timeouts
			Recovering from Pessimistic Failures
	Caching
		Sorting Through the Layers
		Shared Cache
			Static Configuration of the Cache
			Dynamic Cache Management
	Utility Classes
		PersistenceUtil
		PersistenceUnitUtil
	Summary
Chapter 13: XML Mapping Files
	The Metadata Puzzle
	The Mapping File
		Disabling Annotations
			xml-mapping-metadata-complete
			metadata-complete
		Persistence Unit Defaults
			schema
			catalog
			delimited-identifiers
			access
			cascade-persist
			entity-listeners
		Mapping File Defaults
			package
			schema
			catalog
			access
		Queries and Generators
			sequence-generator
			table-generator
			named-query
			named-native-query
			named-stored-procedure-query
			sql-result-set-mapping
		Managed Classes and Mappings
			Attributes
			Tables
				table
				secondary-table
			Identifier Mappings
				id
				embedded-id
				id-class
			Simple Mappings
				basic
				transient
				version
			Relationship and Collection Mappings
				many-to-one
				one-to-many
				one-to-one
				many-to-many
				element-collection
			Embedded Object Mappings
				embedded
				attribute-override
				association-override
			Inheritance Mappings
				inheritance
				discriminator-column
				discriminator-value
				attribute-override and association-override
			Lifecycle Events
			Entity Listeners
				entity-listeners
				exclude-default-listeners
				exclude-superclass-listeners
			Named Entity Graphs
		Converters
			converter
			convert
	Summary
Chapter 14: Packaging and Deployment
	Configuring Persistence Units
		Persistence Unit Name
		Transaction Type
		Persistence Provider
		Data Source
		Mapping Files
		Managed Classes
			Local Classes
			Classes in Mapping Files
			Explicitly Listed Classes
			Additional JARs of Managed Classes
		Shared Cache Mode
		Validation Mode
		Adding Properties
	Building and Deploying
		Deployment Classpath
		Packaging Options
			Enterprise Beans JAR
			Web Archive
			Persistence Archive
		Persistence Unit Scope
	Outside the Server
		Configuring the Persistence Unit
			Transaction Type
			Data Source
			Providers
			Listing the Managed Classes
		Specifying Properties at Runtime
		System Classpath
	Schema Generation
		The Generation Process
		Deployment Properties
			Generation Output
				jakarta.persistence.schema-generation.database.action
				jakarta.persistence.schema-generation.scripts.action
				jakarta.persistence.schema-generation.scripts.create-target
				jakarta.persistence.schema-generation.scripts.drop-target
			Generation Input
				jakarta.persistence.schema-generation.create-source
				jakarta.persistence.schema-generation.drop-source
				jakarta.persistence.schema-generation.create-script-source
				jakarta.persistence.schema-generation. drop-script-source
				jakarta.persistence. sql-load-script-source
		Runtime Properties
		Mapping Annotations Used by Schema Generation
		Unique Constraints
		Null Constraints
		Indexes
		Foreign Key Constraints
		String-Based Columns
		Floating Point Columns
		Defining the Column
	Summary
Chapter 15: Testing
	Testing Enterprise Applications
		Terminology
		Testing Outside the Server
		JUnit
	Unit Testing
		Testing Entities
		Testing Entities in Components
		The Entity Manager in Unit Tests
	Integration Testing
		Using the Entity Manager
			Test Setup and Teardown
			Switching Configurations for Testing
			Minimizing Database Connections
		Components and Persistence
			Transaction Management
				When to Use Transactions
				Container-Managed Transactions
				Bean-Managed Transactions
			Container-Managed Entity Managers
			Other Services
			Using an Embedded Enterprise Beans Container for Integration Testing
		Test Frameworks
			JPA-Unit
			Spring TestContext
			Arquillian
	Best Practices
	Summary
Index