本书是毋庸置疑的Hibernate和ORM(对象／关系映射)权威著作的最新版本，由包括Hibernate之父在内的两位核心开发人员亲自执笔，详细讲述了Hibernate 3．2、Java Persistence和EJB 3．O标准。

本书通过一个应用将数百个例子融合起来，不仅深入剖析THibernate 3．2和Java Persistence丰富的编程模型。还深刻阐述了数据库设计、ORM和优化等方面的基本原则、策略和最佳实践。书中处处闪烁着作者超凡的真知灼见，将大大升华读者对ORMT乃至企业级应用开发的理解。

本书全面讲述了Hibernate和Java Persistence，并对两者进行了详细的对比分析。书中通过一个应用将数百个例子融合起来，不仅深入剖析了Hibernate 3.2和Java Persistence 丰富的编程模型，还深刻阐述了数据库设计、对象/关系映射（ORM）和优化等方面的基本原则、策略和最佳实践。书中处处闪烁着作者超凡的真知灼见，将大大升华读者对ORM乃至企业级应用开发的理解。

本书适合广大的开发人员，从ORM的初学者到经验丰富的开发人员。

Part1 Getting started with Hibernate and EJB 3.0 

1 Understanding object/relational persistence 

1.1 What is persistence?

 Relational databases 

 Understanding SQL 

 Using SQL in Java 

 Persistence in object-oriented applications

1.2 The paradigm mismatch 

 The problem of granularity 

 The problem of subtypes 

 The problem of identity 

 Problems relating to associations

 The problem of data navigation 

  The cost of the mismatch 

1.3 Persistence layers and alternatives

 Layered architecture

 Hand-coding a persistence layer with SQL/JDBC 

 Using serialization 

 Object-oriented database systems 

 Other options 

1.4 Object/relational mapping 

 What is ORM? 

 Generic ORM problems 

 Why ORM? 

 Introducing Hibernate, EJB3, and JPA 

1.5 Summary 

2 Starting a project 

2.1 Starting a Hibernate project 

 Selecting a development process 

 Setting up the project 

 Hibernate configuration and startup 

 Running and testing the application

2.2 Starting a Java Persistence project

 Using Hibernate Annotations

 Using Hibernate EntityManager 

 Introducing EJB components 

 Switching to Hibernate interfaces 

2.3 Reverse engineering a legacy database

 Creating a database configuration

 Customizing reverse engineering

 Generating Java source code 

2.4 Integration with Java EE services

 Integration with JTA 

 JNDI-bound SessionFactory 

 JMX service deployment 

2.5 Summary 

3 Domain models and metadata 

3.1 The CaveatEmptor application 

 Analyzing the business domain 

 The CaveatEmptor domain model 

3.2 Implementing the domain model

 Addressing leakage of concerns 

 Transparent and automated persistence

 Writing POJOs and persistent entity classes 

 Implementing POJO associations 

 Adding logic to accessor methods 

3.3 Object/relational mapping metadata 

 Metadata in XML 

 Annotation-based metadata 

 Using XDoclet 

 Handling global metadata 

 Manipulating metadata at runtime 

3.4 Alternative entity representation

 Creating dynamic applications 

 Representing data in XML 

3.5 Summary 

Part 2 Mapping concepts and strategies 

4 Mapping persistent classes 

4.1 Understanding entities and value types

 Fine-grained domain models 

 Defining the concept 

 Identifying entities and value types 

4.2 Mapping entities with identity 

 Understanding Java identity and equality 

 Handling database identity 

 Database primary keys 

4.3 Class mapping options 

 Dynamic SQL generation

 Making an entity immutable 

 Naming entities for querying 

 Declaring a package name 

 Quoting SQL identifiers 

 Implementing naming conventions 

4.4 Fine-grained models and mappings

 Mapping basic properties 

 Mapping components

4.5 Summary

5 Inheritance and custom types 

5.1 Mapping class inheritance

 Table per concrete class with implicit polymorphism

 Table per concrete class with unions

 Table per class hierarchy 

 Table per subclass

 Mixing inheritance strategies 

 Choosing a strategy 

5.2 The Hibernate type system

 Recapitulating entity and value types 

 Built-in mapping types 

 Using mapping types 

5.3 Creating custom mapping types 

 Considering custom mapping types 

 The extension points

 The case for custom mapping types 

 Creating a UserType

 Creating a CompositeUserType

 Parameterizing custom types 

 Mapping enumerations

5.4 Summary

6 Mapping collections and entity associations 

6.1 Sets, bags, lists, and maps of value types 

 Selecting a collection interface

 Mapping a set 

 Mapping an identifier bag

 Mapping a list 

 Mapping a map 

 Sorted and ordered collections 

6.2 Collections of components 

 Writing the component class 

 Mapping the collection 

 Enabling bidirectional navigation

 Avoiding not-null columns

6.3 Mapping collections with annotations 

 Basic collection mapping 

 Sorted and ordered collections

 Mapping a collection of embedded objects

6.4 Mapping a parent/children relationship 

 Multiplicity 

 The simplest possible association 

 Making the association bidirectional 

 Cascading object state 

6.5 Summary 

7 Advanced entity association mappings

7.1 Single-valued entity associations

 Shared primary key associations 

 One-to-one foreign key associations 

 Mapping with a join table 

7.2 Many-valued entity associations 

 One-to-many associations 

 Many-to-many associations 

 Adding columns to join tables

 Mapping maps 

7.3 Polymorphic associations 

 Polymorphic many-to-one associations 

 Polymorphic collections 

 Polymorphic associations to unions

 Polymorphic table per concrete class

7.4 Summary

8 Legacy databases and custom SQL 

8.1 Integrating legacy databases

 Handling primary keys 

 Arbitrary join conditions with formulas

 Joining arbitrary tables 

 Working with triggers 

8.2 Customizing SQL 

 Writing custom CRUD statements 

 Integrating stored procedures and functions

8.3 Improving schema DDL 

 Custom SQL names and datatypes

 Ensuring data consistency

 Adding domains and column constraints

 Table-level constraints 

 Database constraints

 Creating indexes 

 Adding auxiliary DDL 

8.4 Summary 

Part 3 Conversational object processing

9 Working with objects 

9.1 The persistence lifecycle 

 Object states

 The persistence context

9.2 Object identity and equality 

 Introducing conversations 

 The scope of object identity 

 The identity of detached objects 

 Extending a persistence context 

9.3 The Hibernate interfaces

 Storing and loading objects 

 Working with detached objects

 Managing the persistence context

9.4 The Java Persistence API 

 Storing and loading objects 

 Working with detached entity instances 

9.5 Using Java Persistence in EJB components

 Injecting an EntityManager 

 Looking up an EntityManager 

 Accessing an EntityManagerFactory 

9.6 Summary 

10 Transactions and concurrency 

10.1 Transaction essentials 

 Database and system transactions

 Transactions in a Hibernate application

 Transactions with Java Persistence 

10.2 Controlling concurrent access

 Understanding database-level concurrency

 Optimistic concurrency control 

 Obtaining additional isolation guarantees

10.3 Nontransactional data access 

 Debunking autocommit myths 

 Working nontransactionally with Hibernate

 Optional transactions with JTA 

10.4 Summary 

11 Implementing conversations 

11.1 Propagating the Hibernate Session

 The use case for Session propagation

 Propagation through thread-local

 Propagation with JTA 

 Propagation with EJBs 

11.2 Conversations with Hibernate 

 Providing conversational guarantees 

 Conversations with detached objects 

 Extending a Session for a conversation 

11.3 Conversations with JPA 

 Persistence context propagation in Java SE 

 Merging detached objects in conversations 

 Extending the persistence context in Java SE 

11.4 Conversations with EJB 3.0 

 Context propagation with EJBs 

 Extended persistence contexts with EJBs 

11.5 Summary 

12 Modifying objects efficiently 

12.1 Transitive persistence 

Persistence by reachability 

 Applying cascading to associations 

 Working with transitive state 

 Transitive associations with JPA 

12.2 Bulk and batch operations 

 Bulk statements with HQL and JPA QL 

 Processing with batches 

 Using a stateless Session 

12.3 Data filtering and interception

 Dynamic data filters

 Intercepting Hibernate events

 The core event system 

 Entity listeners and callbacks

12.4 Summary 

13 Optimizing fetching and caching 

13.1 Defining the global fetch plan 

 The object-retrieval options 

 The lazy default fetch plan 

 Understanding proxies 

 Disabling proxy generation 

 Eager loading of associations and collections 

 Lazy loading with interception 

13.2 Selecting a fetch strategy 

 Prefetching data in batches 

 Prefetching collections with subselects

 Eager fetching with joins 

 Optimizing fetching for secondary tables

 Optimization guidelines 

13.3 Caching fundamentals 

 Caching strategies and scopes 

 The Hibernate cache architecture 

13.4 Caching in practice 

 Selecting a concurrency control strategy 

 Understanding cache regions 

 Setting up a local cache provider

 Setting up a replicated cache 

 Controlling the second-level cache 

13.5 Summary

14 Querying with HQL and JPA QL 

14.1 Creating and running queries 

 Preparing a query

 Executing a query

 Using named queries

14.2 Basic HQL and JPA QL queries

 Selection 

 Restriction

 Projection

14.3 Joins, reporting queries, and subselects 

 Joining relations and associations 

 Reporting queries 

 Using subselects 

14.4 Summary 

15 Advanced query options 

15.1 Querying with criteria and example 

 Basic criteria queries 

 Joins and dynamic fetching

 Projection and report queries 

 Query by example 

15.2 Using native SQL queries

 Automatic resultset handling 

 Retrieving scalar values 

 Native SQL in Java Persistence

15.3 Filtering collections 

15.4 Caching query results 

 Enabling the query result cache

 Understanding the query cache

 When to use the query cache 

 Natural identifier cache lookups

15.5 Summary 

16 Creating and testing layered applications

16.1 Hibernate in a web application 

 Introducing the use case 

 Writing a controller 

 The Open Session in View pattern

 Designing smart domain models 

16.2 Creating a persistence layer 

 A generic data-access object pattern 

 Implementing the generic CRUD interface

 Implementing entity DAOs 

 Using data-access objects 

16.3 Introducing the Command pattern 

 The basic interfaces

 Executing command objects

 Variations of the Command pattern 

16.4 Designing applications with EJB 3.0

 Implementing a conversation with stateful beans 

 Writing DAOs with EJBs 

 Utilizing dependency injection 

16.5 Testing 

 Understanding different kinds of tests

 Introducing TestNG 

 Testing the persistence layer 

 Considering performance benchmarks 

16.6 Summary 

17 Introducing JBoss Seam 

17.1 The Java EE 5.0 programming model

 Considering JavaServer Faces

 Considering EJB 3.0

 Writing a web application with JSF and EJB 3.0

 Analyzing the application

17.2 Improving the application with Seam 

 Configuring Seam 

 Binding pages to stateful Seam components

 Analyzing the Seam application 

17.3 Understanding contextual components 

 Writing the login page

 Creating the components 

 Aliasing contextual variables 

 Completing the login/logout feature 

17.4 Validating user input 

 Introducing Hibernate Validator

 Creating the registration page 

 Internationalization with Seam 

17.5 Simplifying persistence with Seam 

 Implementing a conversation 

 Letting Seam manage the persistence context 

17.6 Summary 

appendix A SQL fundamentals 

appendix B Mapping quick reference 

references 

index