Hibernate实战(英文版.第2版)(Hibernate之父亲自执笔)（china-pub全国首发）

. 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