The final section of the book is dedicated to , a powerful, type-safe library for writing SQL in Java. jOOQ is presented as a perfect complement to JPA for complex querying scenarios, allowing developers to write complex SQL queries with the full power of a modern programming language. The book covers advanced features like window functions, common table expressions (CTEs), and UPSERT operations, all while maintaining compile-time safety.
[ Application Thread ] │ ▼ ┌──────────────────────────────────────┐ │ First-Level Cache (Session/EM) │ ── (Scoped to current transaction) └──────────────────────────────────────┘ │ (Cache Miss) ▼ ┌──────────────────────────────────────┐ │ Second-Level Cache (2L Cache) │ ── (Shared across application clusters) └──────────────────────────────────────┘ │ (Cache Miss) ▼ ┌──────────────────────────────────────┐ │ Relational Database │ └──────────────────────────────────────┘ First-Level Cache (Persistence Context)
@Query("SELECT p FROM Parent p JOIN FETCH p.children") List findAllWithChildren(); Use code with caution.
Vlad Mihalcea argues that you cannot write high-performance data access code unless you understand the underlying database. The PDF is structured into three distinct parts, which we will unpack below. High-performance Java Persistence.pdf
This comprehensive guide explores the core principles required to achieve high-performance Java persistence, mirroring the advanced architectural patterns found in industry-standard literature and production environments. 1. The Core Philosophy of High-Performance Persistence
This happens when you fetch a list of entities and then issue a separate SQL query for each entity to load its child associations.
spring.jpa.properties.hibernate.jdbc.batch_size=50 spring.jpa.properties.hibernate.order_inserts=true The final section of the book is dedicated
A common mistake is assuming that a larger connection pool yields better performance. In reality, too many concurrent connections cause excessive context switching on the database server's CPU, disk thrashing, and row contention.
Use JOIN FETCH in JPQL or Entity Graphs to load associations in a single query. 2. JDBC Batching: The Key to Bulk Performance
SELECT a FROM Author a LEFT JOIN FETCH a.books WHERE a.id = :id Use code with caution. and trigger unexpected queries.
: FetchType.EAGER forces the framework to load data you might not need, bloat memory, and trigger unexpected queries. 3. Efficient Data Mappings
While the book is dense with practical advice, several core principles underpin its approach to achieving high performance:
