book

Hibernate Recipes: A Problem-Solution Approach

Name: Hibernate Recipes: A Problem-Solution Approach
ISBN: 9781430227960

by SRINIVAS GURUZU, GARY MAK

July 2010

Intermediate to advanced

312 pages

5h 43m

English

Apress

Read now

Unlock full access

Copyright
About the Authors
About the Technical Reviewer
Acknowledgments
1. Starting with Hibernate
1.1. Setting Up Hibernate1.1.1. Problem1.1.2. Solution1.1.3. How It Works1.1.3.1. Installing the JDK1.1.3.2. Installing the Eclipse Web Tools Platform (WTP)1.1.3.3. Installing Derby1.1.3.3.1. Creating a Derby Database Instance1.1.3.3.2. Creating the Tables (Relational Model)1.2. Programming with Basic JDBC1.2.1. Problem1.2.2. Solution1.2.3. How It Works1.2.3.1. Creating an Eclipse Project1.2.3.2. JDBC Initialization and Cleanup1.2.3.3. Using JDBC to Query a Database1.2.3.4. Using JDBC to Update a Database1.2.3.5. Creating the Domain Model1.2.3.6. Retrieving Object Graphs1.2.3.7. Persisting Object Graphs1.2.3.8. Problems with Using JDBC1.3. Configuring Hibernate1.3.1. Problem1.3.2. Solution1.3.3. How It Works1.3.3.1. Getting the Required Jars1.3.3.2. Creating Mapping Definitions1.3.3.3. Configuration1.3.3.4. Programmatic Configuration1.3.3.4.1. SessionFactory1.3.3.5. XML Configuration1.3.3.6. Opening and Closing Sessions1.3.3.7. Retrieving Objects1.4. Configuring a JPA Project1.4.1. Problem1.4.2. Solution1.4.3. How It Works1.4.3.1. Opening a Session1.5. Using Entity Manager1.5.1. Problem1.5.2. Solution1.5.3. How It Works1.6. Enabling Logging in Hibernate1.6.1. Problem1.6.2. Solution1.6.3. How It Works1.6.3.1. Inspecting the SQL Statements Issued by Hibernate1.6.3.2. Configuring Log4j1.6.3.3. Enabling Live Statistics1.7. Generating a Database Schema Using Hibernate1.7.1. Problem1.7.2. Solution1.7.3. How It Works1.7.3.1. Creating an Ant Build File1.7.3.2. Generating Database Schema Using SchemaExport1.7.3.3. Updating a Database Schema Using SchemaUpdate1.7.3.4. Specifying the Details of a Database Schema1.8. Summary
2. Basic Mapping and Object Identity
2.1. Providing an ID for Persistence2.1.1. Problem2.1.2. Solution2.1.3. How It Works2.1.3.1. Hibernate XML Mapping2.1.3.1.1. Using the Database Sequence2.1.3.1.2. Using a Native Generator2.1.3.1.3. Using an Increment Generator2.1.3.1.4. Using the Hilo Generator2.1.3.2. Using JPA to Generate Identifiers2.2. Creating a Composite Key in Hibernate2.2.1. Problem2.2.2. Solution2.2.3. How It Works2.3. SaveOrUpdate in Hibernate2.3.1. Problem2.3.2. Solution2.3.3. How It Works2.4. Dynamic SQL Generation in Hibernate2.4.1. Problem2.4.2. Solution2.4.3. How It Works2.5. Naming Entities in Hibernate2.5.1. Problem2.5.2. Solution2.5.3. How It Works2.6. Summary
3. Component Mapping
3.1. Implementing a Value Type as a Component3.1.1. Problem3.1.2. Solution3.1.3. How It Works3.1.3.1. Using Hibernate XML Mapping3.1.4. Using JPA Annotations3.2. Nesting Components3.2.1. Problem3.2.2. Solution3.2.3. How It Works3.3. Adding References in Components3.3.1. Problem3.3.2. Solution3.3.3. How It Works3.4. Mapping a Collection of Components3.4.1. Problem3.4.2. Solution3.4.3. How It Works3.5. Using Components as Keys to a Map3.5.1. Problem3.5.2. Solution3.5.3. How It Works3.6. Summary
4. Inheritance and Custom Mapping
4.1. Mapping Entities with Table per Class Hierarchy4.1.1. Problem4.1.2. Solution4.1.3. How It Works4.2. Mapping Entities with Table per Subclass4.2.1. Problem4.2.2. Solution4.2.3. How It Works4.3. Mapping Entities with Table per Concrete Class4.3.1. Problem4.3.2. Solution4.3.3. How It Works4.4. Custom Mappings4.4.1. Problem4.4.2. Solution4.4.3. How It Works4.5. CompositeUserType Mappings4.5.1. Problem4.5.2. Solution4.5.3. How It Works4.6. Summary
5. Many-to-One and One-to-One Mapping
5.1. Using Many-To-One Associations5.1.1. Problem5.1.2. Solution5.1.3. How It Works5.2. Using a Many-to-One Association with a Join Table5.2.1. Problem5.2.2. Solution5.2.3. How It Works5.3. Using Lazy Initialization on Many-to-One Associations5.3.1. Problem5.3.2. Solution5.3.3. How It Works5.4. Sharing Primary Key Associations5.4.1. Problem5.4.2. Solution5.4.3. How It Works5.5. Creating a One-to-One Association Using a Foreign Key5.5.1. Problem5.5.2. Solution5.5.3. How It Works5.6. Creating a One-to-One Association Using a Join Table5.6.1. Problem5.6.2. Solution5.6.3. How It Works5.7. Summary
6. Collection Mapping
6.1. Mapping a Set6.1.1. Problem6.1.2. Solution6.1.3. How It Works6.2. Mapping a Bag6.2.1. Problem6.2.2. Solution6.2.3. How It Works6.3. Mapping a List6.3.1. Problem6.3.2. Solution6.3.3. How It Works6.4. Mapping an Array6.4.1. Problem6.4.2. Solution6.4.3. How It Works6.5. Mapping a Map6.5.1. Problem6.5.2. Solution6.5.3. How It Works6.6. Sorting Collections6.6.1. Problem6.6.2. Solution6.6.3. How It Works6.6.3.1. Using the Natural Order6.6.3.2. Writing Your Own Comparator6.6.3.3. Sorting in the Database6.7. Using Lazy Initialization6.7.1. Problem6.7.2. Solution6.7.3. How It Works6.8. Summary

7. Many-Valued Associations
7.1. Mapping a One-to-Many Association with a Foreign Key7.1.1. Problem7.1.2. Solution7.1.3. How It Works7.2. Mapping a One-to-Many Bidirectional Association Using a Foreign Key7.2.1. Problem7.2.2. Solution7.2.3. How It Works7.3. Mapping a One-to-Many Bidirectional Association Using a Join Table7.3.1. Problem7.3.2. Solution7.3.3. How It Works7.4. Mapping a Many-to-Many Unidirectional Association with a Join Table7.4.1. Problem7.4.2. Solution7.4.3. How It Works7.5. Creating a Many-to-Many Bidirectional Association with a Join Table7.5.1. Problem7.5.2. Solution7.5.3. How It Works7.6. Summary
8. HQL and JPA Query Language
8.1. Using the Query Object8.1.1. Problem8.1.2. Solution8.1.3. How It Works8.1.3.1. Creating a Query Object8.1.3.2. The from Clause8.1.3.3. The where Clause8.1.3.4. Pagination8.1.3.5. Parameter Binding8.1.3.6. Named Queries8.2. Using the Select Clause8.2.1. Problem8.2.2. Solution8.2.3. How It Works8.3. Joining8.3.1. Problem8.3.2. Solution8.3.3. How It Works8.3.3.1. Explicit Joins8.3.3.2. Implicit Joins8.3.3.3. Outer Joins8.3.3.4. Matching Text8.3.3.5. Fetching Associations8.4. Creating Report Queries8.4.1. Problem8.4.2. Solution8.4.3. How It Works8.4.3.1. Projection with Aggregation Functions8.4.3.2. Grouping Aggregated Results8.5. Summary
9. Querying with Criteria and Example
9.1. Using Criteria9.1.1. Problem9.1.2. Solution9.1.3. How It Works9.2. Using Restrictions9.2.1. Problem9.2.2. Solution9.2.3. How It Works9.2.3.1. Writing Subqueries9.3. Using Criteria in Associations9.3.1. Problem9.3.2. Solution9.3.3. How It Works9.4. Using Projections9.4.1. Problem9.4.2. Solution9.4.3. How It Works9.4.3.1. Aggregate Functions and Groupings with Projections9.5. Querying by Example9.5.1. Problem9.5.2. Solution9.5.3. How It Works9.6. Summary
10. Working with Objects
10.1. Identifying Persistent Object States10.1.1. Problem10.1.2. Solution10.1.3. How It Works10.1.3.1. Transient Objects10.1.3.2. Persistent Objects10.1.3.3. Detached Objects10.1.3.4. Removed Objects10.2. Working with Persistent Objects10.2.1. Problem10.2.2. Solution10.2.3. How It Works10.2.3.1. Creating a Persistent Object10.2.3.2. Retrieving a Persistent Object10.2.3.3. Modifying a Persistent Object10.2.3.4. Deleting a Persistent Object10.3. Persisting Detached Objects10.3.1. Problem10.3.2. Solution10.3.3. How It Works10.3.3.1. Reattaching a Detached Object10.3.3.2. Merging a Detached Object10.4. Using Data Filters10.4.1. Problem10.4.2. Solution10.4.3. How It Works10.5. Using Interceptors10.5.1. Problem10.5.2. Solution10.5.3. How It Works10.6. Summary
11. Batch Processing and Native SQL
11.1. Performing Batch Inserts11.1.1. Problem11.1.2. Solution11.1.3. How It Works11.2. Performing Batch Updates and Deletes11.2.1. Problem11.2.2. Solution11.2.3. How It Works11.3. Using Native SQL11.3.1. Problem11.3.2. Solution11.3.3. How It Works11.4. Using Named SQL Queries11.4.1. Problem11.4.2. Solution11.4.3. How It Works11.5. Summary
12. Cashing in Hibernate
12.1. Using the Second-Level Cache in Hibernate12.2. Concurrency Strategies12.3. Cache Providers12.4. What Are Cache Regions?12.5. Caching Query Results12.6. Using the First-Level Cache12.6.1. Problem12.6.2. Solution12.6.3. How It Works12.7. Configuring the Second-Level Cache12.7.1. Problem12.7.2. Solution12.7.3. How It Works12.8. Caching Associations12.8.1. Problem12.8.2. Solution12.8.3. How It Works12.9. Caching Collections12.9.1. Problem12.9.2. Solution12.9.3. How It Works12.10. Caching Queries12.10.1. Problem12.10.2. Solution12.10.3. How It Works12.11. Summary
13. Transactions and Concurrency
13.1. Using Programmatic Transactions in a Standalone Java Application13.1.1. Problem13.1.2. Solution13.1.3. How It Works13.2. Using Programmatic Transactions with JTA13.2.1. Problem13.2.2. Solution13.2.3. How It Works13.3. Enabling Optimistic Concurrency Control13.3.1. Problem13.3.2. Solution13.3.3. How It Works13.4. Using Pessimistic Concurrency Control13.4.1. Problem13.4.2. Solution13.4.3. How It Works13.5. Summary
14. Web Applications
14.1. Creating a Controller for the Bookshop Web Application14.1.1. Problem14.1.2. Solution14.1.3. How It Works14.1.3.1. Creating a Dynamic Web Project14.1.3.2. Configuring the Connection Pool14.1.3.3. Developing an Online Bookshop14.1.3.4. Creating a Global Session Factory14.1.3.5. Listing Persistent Objects14.1.3.6. Updating Persistent Objects14.1.3.7. Creating Persistent Objects14.1.3.8. Deleting Persistent Objects14.2. Creating a Data-Access Layer14.2.1. Problem14.2.2. Solution14.2.3. How It Works14.2.3.1. Organizing Data Access in Data-Access Objects14.2.3.2. Using Generic Data-Access Objects14.2.3.3. Using a Factory to Centralize DAO Retrieval14.2.3.4. Navigating Lazy Associations14.2.3.5. Using the Open Session in View Pattern14.3. Summary

Content preview from Hibernate Recipes: A Problem-Solution Approach

Chapter 10. Working with Objects

This chapter discusses the states an object goes through during its lifecycle. The session is responsible for managing object state in Hibernate, and the EntityManager does the same in Java Persistence. Hibernate provides a persistence mechanism that is transparent to the entities and the application; the application has to know the state of an object.

The chapter also discusses the persistence context provided by Hibernate. The persistence context manages objects and caches object states within a transaction (unit of work). You will learn how to use data filtering and interceptors.

Identifying Persistent Object States

Problem

What are the states that an object can have in Hibernate? How does the object lifecycle work? ...

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

Hibernate Recipes: A Problem-Solution Approach, Second Edition

Publisher Resources

ISBN: 9781430227960Purchase book

Cloud Computing

Data Engineering

Data Science

AI & ML

Programming Languages

Software Architecture

IT/Ops

Security

Design