Opinionated JPA with Querydsl

Preface

1. Is this book for you?
2. Not in the book
3. Other JPA books
4. Books on performance of the database and persistence layer
5. Looking back to Patterns of Enterprise Application Architecture
6. Structure of the book
7. Using code examples
8. My writing background
9. Feedback
10. IJPA Good Times, Bad Times

1.Good Parts

1. JPA is standard
2. Database independence
3. Natural SQL-Java type mapping
4. Flexible mapping
5. Unit of work
6. Declarative transactions
7. Other JPA 2.1 goodies

2.The Missing Parts

1. Compared to ORM providers
2. Comparing JPQL to SQL
3. Other missing parts

3.Questionable parts

1. Lazy on basic and to-one fields
2. Generated SQL updates
3. Unit of work vs queries
4. We can’t escape SQL and relational model
5. Additional layer
6. Big unit of work
7. Other entity manager gotchas
8. JPA alternatives?

4.Caching considerations

1. Caching control
2. Second-level cache vs queries
3. Explicit application-level cache
4. Conclusion

5.Love and hate for ORM

1. Vietnam of Computer Science
2. Not much love for ORM
3. But a lot of hate
4. Is tuning-down a way out?
5. And there is more
6. IIOpinionated JPA

6.Tuning ORM down

1. Price for relations
2. How does this affect my domain model?
3. When to tune down and when not?

7.No further step without Querydsl

1. Simple example with Querydsl
2. Comparison with Criteria API
3. Comparison with JPQL
4. What about the cons?
5. Be explicit with aliases
6. Functions and operations
7. Subqueries
8. Pagination
9. Tuple results
10. Fetching to-many eagerly
11. Querydsl and code style
12. More

8.Troubles with to-one relationships

1. Simple example of @ManyToOne
2. How about going lazy?
3. Dual relationship mapping
4. Using projections for fetching
5. Entity update scenario
6. Alternative entity “views”
7. Summary

9.Removing to-one altogether

1. Why do we need ON anyway?
2. Dropping to-one annotations
3. Ad hoc joins across tables
4. Loading the relationship from the entity
5. Loosing information without mapping annotations
6. Wrapping it up

10.Modularity, if you must²⁶

1. Everybody knows layers
2. Components based on features
3. Multiple JARs with JPA entities
4. Distributing persistence.xml – do we need it?
5. It doesn’t start anyway
6. Shared cache mode
7. Putting the Spring configuration together
8. Common base entity classes in separate JAR
9. Cutting cyclic dependencies
10. Conclusion
11. IIICommon problems

11.Avoid N+1 select

1. Anatomy of N+1 select
2. Eager to-one without joins
3. Eager to-many relationships
4. Lazy relationships triggered later
5. Paginating with to-many
6. Wrapping up N+1 problem

12.Mapping Java enum

1. Naive approach
2. Encapsulated conversion
3. Conversion micro-framework
4. Refinement?
5. Simplified static resolving
6. Alternative conversions within entities
7. Java 8 and reverse enum resolution
8. Relational concerns

13.Advanced Querydsl

1. Introducing handy utility classes
2. Tricky predicate parts
3. Groups of AND/OR predicates
4. Operator precedence and expression serialization
5. Querydsl Expression hierarchy
6. Constant expressions
7. Using FUNCTION template
8. Update/delete clauses and exception handling
9. JPAQueryFactory
10. Detached queries
11. Working with dates and java.time API
12. Result transformation
13. Note about Querydsl 3 versus 4
14. IVFinal thoughts
15. JPA/ORM – yes or no?
16. JPA or concrete ORM provider?
17. JPA, Querydsl and beyond
18. This book
19. Appendices

H2 Database

1. Starting it
2. Using it as a devel/test DB

Project example

1. Querydsl and Maven
2. Querydsl and Gradle

Bugs discovered while writing this book

List of acronyms

1. Resources
2. Books
3. Online articles, blogs
4. Other online resources