Pro JPA 2 - Mastering the Java™ Persistence API

Title Page

Copyright Page

Contents at a Glance

Table of Contents

Foreword

About the Author

About the Technical Reviewer

Acknowledgments

Mike Keith

Merrick Schincariol

Preface

This Book Is For You

Code Examples

Contacting Us

Chapter 1: Introduction

Object-Relational Mapping

The Impedance Mismatch

Class Representation

Relationships

Inheritance

Java Support for Persistence

Proprietary Solutions

JDBC

Enterprise JavaBeans

Java Data Objects

Why Another Standard?

The Java Persistence API

History of the Specification

EJB 3.0 and JPA 1.0

JPA 2.0

JPA 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

Remote Business Interfaces

Stateful Session Beans

Defining a Stateful Session Bean

Lifecycle Callbacks

Singleton Session Beans

Defining a Singleton Session Bean

Lifecycle Callbacks

Singleton Concurrency

Message-Driven Beans

Defining a Message-Driven Bean

Servlets

Dependency Management

Dependency Lookup

Dependency Injection

Field Injection

Setter Injection

Declaring Dependencies

Referencing a Persistence Context

Referencing a Persistence Unit

Referencing Enterprise JavaBeans

Referencing Server Resources

Transaction Management

Transaction Review

Enterprise Transactions in Java

Transaction Demarcation

Container-Managed Transactions

Bean-Managed Transactions

UserTransaction

Using Java EE Components

Using a Stateless Session Bean

Using a Stateful Session Bean

Using a Singleton Session Bean

Using a Message-Driven Bean

Adding the Entity Manager

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

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

JTA Transaction Management

Transaction-Scoped Persistence Contexts

Extended Persistence Contexts

Persistence Context Collision

Persistence Context Inheritance

Application-Managed 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

Summary

Chapter 7: Using Queries

Java Persistence Query Language

Getting Started

Filtering Results

Projecting Results

Joins Between Entities

Aggregate Queries

Query Parameters

Defining Queries

Dynamic Query Definition

Named Query Definition

Parameter Types

Executing Queries

Working with 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 Session Beans

Bulk Update and Delete

Provider Differences

Summary

Chapter 8: Query Language

Introduction

Terminology

Example Data Model

Example Application

Select Queries

SELECT Clause

Path Expressions

Entities and Objects

Combining Expressions

Constructor Expressions

Inheritance and Polymorphism

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

Scalar Expressions

Literals

Function Expressions

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

The ORDER BY Clause

The GROUP BY and HAVING Clauses

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

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 Embeddedld

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

Summary

Chapter 11: Advanced Topics

SQl Queries

Native Queries versus 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

Parameter Binding

Lifecycle Callbacks

Lifecycle Events

Pre Persist and PostPersist

PreRemove and PostRemove

PreUpdate and PostUpdate

Post Load

Callback Methods

Enterprise Contexts

Entity Listeners

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 JPA

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 12: 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

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

Summary

Chapter 13: 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 Vendor Properties

Building and Deploying

Deployment Classpath

Packaging Options

EJB JAR

Web Archive

Persistence Archive

Persistence Unit Scope

Outside the Server

Configuring the Persistence Unit

Transaction Type

Data Source

Providers

Listing the Entities

Specifying Properties at Runtime

System Classpath

Schema Generation

Unique Constraints

Null Constraints

String-Based Columns

Floating Point Columns

Defining the Column

Summary

Chapter 14: Testing

Testing Enterprise Applications

Terminology

Testing Outside the Server

Test Frameworks

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 EJB Container for Integration Testing

Best Practices

Summary

Chapter 15: Migration

Migrating from CMP Entity Beans

Scoping the Challenge

Entity Bean Conversion

Converting the Business Interface

Migrating Properties

Migrating Business Methods

Migrating Container-Managed Relationships

Converting the Home Interface

Migrating Home Methods

Creating the Façade

Migrating from JDBC

Migrating from Other ORM Solutions

Leveraging Design Patterns

Transfer Object

Fine-Grained Transfer Objects

Coarse-Grained Transfer Objects

Session FaGade

Data Access Object

Business Object

Fast Lane Reader

Active Record

Summary

Index