book

Java Persistence with Spring Data and Hibernate

Name: Java Persistence with Spring Data and Hibernate
Author: Catalin Tudose
ISBN: 9781617299186

by Catalin Tudose

March 2023

Intermediate to advanced

616 pages

17h 35m

English

Manning Publications

Read now

Unlock full access

inside front cover
Java Persistence with Spring Data and Hibernate
Copyright
dedication
brief contents
contents
front matter
forewordsprefaceacknowledgmentsabout this bookWho should read this bookHow this book is organized: A road mapAbout the codeliveBook discussion forumabout the authorauthors of Java Persistence with Hibernate, Second Editionabout the cover illustration
Part 1. Getting started with ORM
1 Understanding object/relational persistence
1.1 What is persistence?1.1.1 Relational databases1.1.2 Understanding SQL1.1.3 Using SQL in Java1.2 The paradigm mismatch1.2.1 The problem of granularity1.2.2 The problem of inheritance1.2.3 The problem of identity1.2.4 The problem of associations1.2.5 The problem of data navigation1.3 ORM, JPA, Hibernate, and Spring DataSummary
2 Starting a project
2.1 Introducing Hibernate2.2 Introducing Spring Data2.3 “Hello World” with JPA2.3.1 Configuring a persistence unit2.3.2 Writing a persistent class2.3.3 Storing and loading messages2.4 Native Hibernate configuration2.5 Switching between JPA and Hibernate2.6 “Hello World” with Spring Data JPA2.7 Comparing the approaches of persisting entitiesSummary

3 Domain models and metadata
3.1 The example CaveatEmptor application3.1.1 A layered architecture3.1.2 Analyzing the business domain3.1.3 The CaveatEmptor domain model3.2 Implementing the domain model3.2.1 Addressing leakage of concerns3.2.2 Transparent and automated persistence3.2.3 Writing persistence-capable classes3.2.4 Implementing POJO associations3.3 Domain model metadata3.3.1 Annotation-based metadata3.3.2 Applying constraints to Java objects3.3.3 Externalizing metadata with XML files3.3.4 Accessing metadata at runtimeSummary
4 Working with Spring Data JPA
4.1 Introducing Spring Data JPA4.2 Starting a new Spring Data JPA project4.3 First steps for configuring a Spring Data JPA project4.4 Defining query methods with Spring Data JPA4.5 Limiting query results, sorting, and paging4.6 Streaming results4.7 The @Query annotation4.8 Projections4.9 Modifying queries4.10 Query by ExampleSummary
Part 2. Mapping strategies
5 Mapping persistent classes
5.1 Understanding entities and value types5.1.1 Fine-grained domain models5.1.2 Defining application concepts5.1.3 Distinguishing entities and value types5.2 Mapping entities with identity5.2.1 Understanding Java identity and equality5.2.2 A first entity class and mapping5.2.3 Selecting a primary key5.2.4 Configuring key generators5.2.5 Identifier generator strategies5.3 Entity-mapping options5.3.1 Controlling names5.3.2 Dynamic SQL generation5.3.3 Making an entity immutable5.3.4 Mapping an entity to a subselectSummary
6 Mapping value types
6.1 Mapping basic properties6.1.1 Overriding basic property defaults6.1.2 Customizing property access6.1.3 Using derived properties6.1.4 Transforming column values6.1.5 Generated and default property values6.1.6 The @Temporal annotation6.1.7 Mapping enumerations6.2 Mapping embeddable components6.2.1 The database schema6.2.2 Making classes embeddable6.2.3 Overriding embedded attributes6.2.4 Mapping nested embedded components6.3 Mapping Java and SQL types with converters6.3.1 Built-in types6.3.2 Creating custom JPA converters6.3.3 Extending Hibernate with UserTypesSummary
7 Mapping inheritance
7.1 Table per concrete class with implicit polymorphism7.2 Table per concrete class with unions7.3 Table per class hierarchy7.4 Table per subclass with joins7.5 Mixing inheritance strategies7.6 Inheritance of embeddable classes7.7 Choosing a strategy7.8 Polymorphic associations7.8.1 Polymorphic many-to-one associations7.8.2 Polymorphic collectionsSummary
8 Mapping collections and entity associations
8.1 Sets, bags, lists, and maps of value types8.1.1 The database schema8.1.2 Creating and mapping a collection property8.1.3 Selecting a collection interface8.1.4 Mapping a set8.1.5 Mapping an identifier bag8.1.6 Mapping a list8.1.7 Mapping a map8.1.8 Sorted and ordered collections8.2 Collections of components8.2.1 Equality of component instances8.2.2 Set of components8.2.3 Bag of components8.2.4 Map of component values8.2.5 Components as map keys8.2.6 Collection in an embeddable component8.3 Mapping entity associations8.3.1 The simplest possible association8.3.2 Making it bidirectional8.3.3 Cascading stateSummary
9 Advanced entity association mappings
9.1 One-to-one associations9.1.1 Sharing a primary key9.1.2 The foreign primary key generator9.1.3 Using a foreign key join column9.1.4 Using a join table9.2 One-to-many associations9.2.1 Considering one-to-many bags9.2.2 Unidirectional and bidirectional list mappings9.2.3 Optional one-to-many with a join table9.2.4 One-to-many association in an embeddable class9.3 Many-to-many and ternary associations9.3.1 Unidirectional and bidirectional many-to-many associations9.3.2 Many-to-many with an intermediate entity9.3.3 Ternary associations with components9.4 Entity associations with maps9.4.1 One-to-many with a property key9.4.2 Key/value ternary relationshipSummary
Part 3. Transactional data processing
10 Managing data
10.1 The persistence lifecycle10.1.1 Entity instance states10.1.2 The persistence context10.2 The EntityManager interface10.2.1 The canonical unit of work10.2.2 Making data persistent10.2.3 Retrieving and modifying persistent data10.2.4 Getting a reference10.2.5 Making data transient10.2.6 Refreshing data10.2.7 Replicating data10.2.8 Caching in the persistence context10.2.9 Flushing the persistence context10.3 Working with detached state10.3.1 The identity of detached instances10.3.2 Implementing equality methods10.3.3 Detaching entity instances10.3.4 Merging entity instancesSummary
11 Transactions and concurrency
11.1 Transaction essentials11.1.1 ACID attributes11.1.2 Database and system transactions11.2 Controlling concurrent access11.2.1 Understanding database-level concurrency11.2.2 Optimistic concurrency control11.2.3 Explicit pessimistic locking11.2.4 Avoiding deadlocks11.3 Non-transactional data access11.3.1 Reading data in auto-commit mode11.3.2 Queuing modifications11.4 Managing transactions with Spring and Spring Data11.4.1 Transaction propagation11.4.2 Transaction rollback11.4.3 Transaction properties11.4.4 Programmatic transaction definition11.4.5 Transactional development with Spring and Spring DataSummary
12 Fetch plans, strategies, and profiles
12.1 Lazy and eager loading12.1.1 Understanding entity proxies12.1.2 Lazy persistent collections12.1.3 Eager loading of associations and collections12.2 Selecting a fetch strategy12.2.1 The n+1 selects problem12.2.2 The Cartesian product problem12.2.3 Prefetching data in batches12.2.4 Prefetching collections with subselects12.2.5 Eager fetching with multiple SELECTs12.2.6 Dynamic eager fetching12.3 Using fetch profiles12.3.1 Declaring Hibernate fetch profiles12.3.2 Working with entity graphsSummary
13 Filtering data
13.1 Cascading state transitions13.1.1 Available cascading options13.1.2 Transitive detachment and merging13.1.3 Cascading refresh13.1.4 Cascading replication13.2 Listening to and intercepting events13.2.1 JPA event listeners and callbacks13.2.2 Implementing Hibernate interceptors13.2.3 The core event system13.3 Auditing and versioning with Hibernate Envers13.3.1 Enabling audit logging13.3.2 Creating an audit trail13.3.3 Finding revisions13.3.4 Accessing historical data13.4 Dynamic data filters13.4.1 Defining dynamic filters13.4.2 Applying a dynamic filter13.4.3 Enabling a dynamic filter13.4.4 Filtering collection accessSummary
Part 4. Building Java persistence applications with Spring
14 Integrating JPA and Hibernate with Spring
14.1 Spring Framework and dependency injection14.2 JPA application using Spring and the DAO pattern14.3 Generifying a JPA application that uses Spring and DAO14.4 Hibernate application using Spring and the DAO pattern14.5 Generifying a Hibernate application that uses Spring and DAOSummary
15 Working with Spring Data JDBC
15.1 Creating a Spring Data JDBC project15.2 Working with queries in Spring Data JDBC15.2.1 Defining query methods with Spring Data JDBC15.2.2 Limiting query results, sorting, and paging15.2.3 Streaming results15.2.4 The @Query annotation15.2.5 Modifying queries15.3 Modeling relationships with Spring Data JDBC15.3.1 Modeling a one-to-one relationship with Spring Data JDBC15.3.2 Modeling embedded entities with Spring Data JDBC15.3.3 Modeling a one-to-many relationship with Spring Data JDBC15.3.4 Modeling a many-to-many relationship with Spring Data JDBCSummary
16 Working with Spring Data REST
16.1 Introducing REST applications16.2 Creating a Spring Data REST application16.3 Using ETags for conditional requests16.4 Limiting access to repositories, methods, and fields16.5 Working with REST events16.5.1 Writing an AnnotatedHandler16.5.2 Writing an ApplicationListener16.6 Using projections and excerptsSummary
Part 5. Building Java persistence applications with Spring
17 Working with Spring Data MongoDB
17.1 Introducing MongoDB17.2 Introducing Spring Data MongoDB17.3 Using MongoRepository to access a database17.3.1 Defining query methods with Spring Data MongoDB17.3.2 Limiting query results, sorting, and paging17.3.3 Streaming results17.3.4 The @Query annotation17.4 Query by Example17.5 Referencing other MongoDB documents17.6 Using MongoTemplate to access a database17.6.1 Configuring access to the database through MongoTemplate17.6.2 Executing CRUD operations using MongoTemplateSummary
18 Working with Hibernate OGM
18.1 Introducing Hibernate OGM18.2 Building a simple MongoDB Hibernate OGM application18.2.1 Configuring the Hibernate OGM application18.2.2 Creating the entities18.2.3 Using the application with MongoDB18.3 Switching to the Neo4j NoSQL databaseSummary
Part 6. Writing queries and testing Java persistence applications
19 Querying JPA with Querydsl
19.1 Introducing Querydsl19.2 Creating a Querydsl application19.2.1 Configuring the Querydsl application19.2.2 Creating the entities19.2.3 Creating the test data to query19.3 Querying a database with Querydsl19.3.1 Filtering data19.3.2 Ordering data19.3.3 Grouping data and working with aggregates19.3.4 Working with subqueries and joins19.3.5 Updating entities19.3.6 Deleting entitiesSummary
20 Testing Java persistence applications
20.1 Introducing the test pyramid20.2 Creating the persistence application to test20.3 Using the Spring TestContext Framework20.4 The @DirtiesContext annotation20.5 @Transactional execution20.6 The @BeforeTransaction and @AfterTransaction annotations20.7 Working with Spring profiles20.8 Working with test execution listenersSummary
Appendix A. Maven
A.1 Convention over configurationA.2 Strong dependency managementA.3 Maven build lifecyclesA.4 Plugin-based architectureA.5 The Maven project object model (POM)A.6 Installing Maven
Appendix B. Spring Data JPA keyword usage
Appendix C. Spring Data JDBC keyword usage
Appendix D. Spring Data MongoDB keyword usage
references
index
inside back cover

Content preview from Java Persistence with Spring Data and Hibernate

inside front cover

Comparison of working with JPA, native Hibernate, and Spring Data JPA

Framework

Characteristics

JPA

Uses the general JPA API and requires a persistence provider.
We can switch between persistence providers from the configuration.
Requires explicit management of the EntityManagerFactory, EntityManager, and transactions.
The configuration and the amount of code to be written is similar to the native Hibernate native approach.
We can switch to the JPA approach by constructing an EntityManagerFactory from a native Hibernate configuration.

Native Hibernate

Uses the native Hibernate API. You are locked into using this chosen framework.
Builds its configuration starting with the default Hibernate ...

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

Master Hibernate and JPA with Spring Boot in 100 Steps

Publisher Resources

ISBN: 9781617299186Publisher Support Publisher Website

Cloud Computing

Data Engineering

Data Science

AI & ML

Programming Languages

Software Architecture

IT/Ops

Security

Design

Business

Soft Skills

Java Persistence with Spring Data and Hibernate

by Catalin Tudose

inside front cover

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.