Spring Persistence with Hibernate

265 Pages·2010·3.61 MB·English

by  Paul Tepper Fisher

CYAN YELLOW
MAGENTA BLACK
PANTONE 123 C
BOOKS FOR PROFESSIONALS BY PROFESSIONALS® THE EXPERT’S VOICE® IN OPEN SOURCE
Companion Covers
eBook Spring 3,
Available
Hibernate 3.5,
Spring Persistence with Hibernate
Grails, Roo!
S and
Dear Reader,
p
Persistence is the foundation upon which many applications are built. The suc-
r
cess or failure of a project often hinges on how its persistence tier is architected.
i
Spring and Hibernate take the guesswork out of designing these integral com- Spring
n
ponents, helping you to enforce solid coding practices and reduce coupling

between layers or with external frameworks. g
Paul Tepper Fisher, Author of Learning the fundamentals of these two amazing open-source frameworks

Spring Persistence — is just the beginning. To get the very most out of Spring and Hibernate, you P
A Running Start must understand how these components behave, and learn best practices for
e
integrating them into an application. An efficient, flexible persistence tier can
r
only be built on proven design patterns and strategies that address common
s
requirements such as caching, lazy-loading, and transactional semantics.
i Persistence
This book will not only teach you the features of Spring 3 and Hibernate 3.5, s
it will also guide you through the essential steps of building a real-world appli- t with
cation—addressing common pitfalls and considerations along the way. We will e
introduce you to best practices and tricks that we have learned from years of n
hands-on experience, and that you too can apply to your own projects. As a c
bonus, you will also learn about two exciting state-of-the-art projects that build
e Hibernate
upon Spring and Hibernate: Grails and Roo.

Spring and Hibernate are two of the most popular open-source frameworks, w
for very good reasons. This book will show you why so many Java projects rely
i
Brian D. Murphy on them, and teach you how to reap the even greater benefits of using them t
h
together.

H
Paul Tepper Fisher
i
b
THE APRESS ROADMAP
e
Hibernate Guides you through the essential aspects and
Recipes
Beginning Hibernate, r
Companion eBook Second Edition n best practices of building a real application, using
Spring Persistence Spring Framework 3, Hibernate 3.5, Grails, and Roo
with Hibernate a
Beginning t
Spring Spring Recipes, e
Second Edition
See last page for details
on $10 eBook version
Paul Tepper Fisher Brian D. Murphy
M and
SOURCE CODE ONLINE ISBN 978-1-4302-2632-1 uFi
www.apress.com 54499 rpsh
he
yr
US $44.99
Shelve in:
Java Programming
User level: 9 781430 226321
Intermediate–Advanced
this print for content only—size & color not accurate 7.5 x 9.25 spine = 0.71875" 264 page count

Spring Persistence
with Hibernate

■ ■ ■
PAUL TEPPER FISHER
BRIAN D. MURPHY
Spring Persistence with Hibernate
Copyright © 2010 by Paul Tepper Fisher and Brian D. Murphy
All rights reserved. No part of this work may be reproduced or transmitted in any form or by any means,
electronic or mechanical, including photocopying, recording, or by any information storage or retrieval
system, without the prior written permission of the copyright owner and the publisher.
ISBN-13 (pbk): 978-1-4302-2632-1
ISBN-13 (electronic): 978-1-4302-2633-8
Printed and bound in the United States of America 9 8 7 6 5 4 3 2 1
Trademarked names, logos, and images may appear in this book. Rather than use a trademark symbol
with every occurrence of a trademarked name, logo, or image we use the names, logos, and images only
in an editorial fashion and to the benefit of the trademark owner, with no intention of infringement of
the trademark.
The use in this publication of trade names, trademarks, service marks, and similar terms, even if they are
not identified as such, is not to be taken as an expression of opinion as to whether or not they are subject
to proprietary rights.
President and Publisher: Paul Manning
Lead Editors: Steve Anglin, Tom Welsh
Technical Reviewer: Sia Cyrus
Editorial Board: Steve Anglin, Mark Beckner, Ewan Buckingham, Gary Cornell, Jonathan Gennick,
Jonathan Hassell, Michelle Lowman, Matthew Moodie, Duncan Parkes, Jeffrey Pepper, Frank
Pohlmann, Douglas Pundick, Ben Renow-Clarke, Dominic Shakeshaft, Matt Wade, Tom Welsh
Coordinating Editor: Mary Tobin
Copy Editor: Marilyn Smith
Compositor: Kimberly Burton
Indexer: Julie Grady
Artist: April Milne
Cover Designer: Anna Ishchenko
Distributed to the book trade worldwide by Springer Science+Business Media, LLC., 233 Spring Street,
6th Floor, New York, NY 10013. Phone 1-800-SPRINGER, fax [phone], e-mail orders-ny@springer-
sbm.com, or visit www.springeronline.com.
For information on translations, please e-mail [email protected], or visit www.apress.com.
Apress and friends of ED books may be purchased in bulk for academic, corporate, or promotional use.
eBook versions and licenses are also available for most titles. For more information, reference our
Special Bulk Sales–eBook Licensing web page at www.apress.com/info/bulksales.
The information in this book is distributed on an “as is” basis, without warranty. Although every
precaution has been taken in the preparation of this work, neither the author(s) nor Apress shall have
any liability to any person or entity with respect to any loss or damage caused or alleged to be caused
directly or indirectly by the information contained in this work.
The source code for this book is available to readers at www.apress.com. You will need to answer
questions pertaining to this book in order to successfully download the code.
ii
To Melanie, for making it all worthwhile
—Paul

I would like to dedicate this, my first print book, to my mom. I miss you always
—Brian
Contents at a Glance
■About the Authors......................................................................................................xii
■About the Technical Reviewer..................................................................................xiii
■Acknowledgments....................................................................................................xiv
■Preface.....................................................................................................................xvi
■Chapter 1: Architecting Your Application with Spring, Hibernate, and Patterns........1
■Chapter 2: Spring Basics...........................................................................................17
■Chapter 3: Basic Application Setup...........................................................................33
■Chapter 4: Persistence with Hibernate......................................................................49
■Chapter 5: Domain Model Fundamentals...................................................................69
■Chapter 6: DAOs and Querying..................................................................................85
■Chapter 7: Transaction Management......................................................................109
■Chapter 8: Effective Testing.....................................................................................125
■Chapter 9: Best Practices and Advanced Techniques.............................................137
■Chapter 10: Integration Frameworks......................................................................155
■Chapter 11: GORM and Grails..................................................................................189
■Chapter 12: Spring Roo...........................................................................................215
■Index........................................................................................................................235

iv
Contents
■About the Authors......................................................................................................xii
■About the Technical Reviewer..................................................................................xiii
■Acknowledgments....................................................................................................xiv
■Preface......................................................................................................................xv
■Chapter 1: Architecting Your Application with Spring, Hibernate, and Patterns........1
The Benefit of a Consistent Approach................................................................................1
The Significance of Dependency Injection................................................................................................2
A Synergistic Partnership..................................................................................................2
The Story of Spring’s and Hibernate’s Success.......................................................................................3
A Better Approach for Integration.............................................................................................................3
Best Practices for Architecting an Application.........................................................................................4
Other Persistence Design Patterns..................................................................................12
The Template Pattern.............................................................................................................................12
The Active-Record Pattern......................................................................................................................14
Summary.........................................................................................................................15
■Chapter 2: Spring Basics...........................................................................................17
Exploring Spring’s Architecture.......................................................................................18
The Application Context..........................................................................................................................18
Beans, Beans, the Magical Fruit.............................................................................................................20
The Spring Life Cycle..............................................................................................................................20
Understanding Bean Scopes..................................................................................................................22
Dependency Injection and Inversion of Control...............................................................24
Setter-Based Dependency Injection.......................................................................................................24
v
■ CONTENTS

Constructor-Based Dependency Injection..............................................................................................25
Instance Collaboration............................................................................................................................26
Coding to Interfaces...............................................................................................................................27
Dependency Injection via Autowiring.....................................................................................................28
@Annotation-Based Dependency Injection............................................................................................29
Set It and Forget It!.................................................................................................................................30
Injecting Code Using AOP and Interceptors.....................................................................31
Summary.........................................................................................................................32
■Chapter 3: Basic Application Setup...........................................................................33
Application Management with Maven.............................................................................33
Managed Dependencies.........................................................................................................................33
Standard Directory Structure..................................................................................................................35
POM Deconstruction...............................................................................................................................35
Spring Configuration........................................................................................................37
Namespace Support...............................................................................................................................38
Externalizing Property Configurations....................................................................................................38
Component Scanning.............................................................................................................................38
Import Statements..................................................................................................................................39
Database Integration........................................................................................................40
JDBC Support.........................................................................................................................................40
Integration with JNDI..............................................................................................................................41
Web Application Configuration........................................................................................43
Servlet Definition....................................................................................................................................44
Spring MVC.............................................................................................................................................45
Summary.........................................................................................................................47
■Chapter 4: Persistence with Hibernate......................................................................49
The Evolution of Database Persistence in Java...............................................................49
EJB, JDO, and JPA..................................................................................................................................50
vi
vi
■ CONTENTS

How Hibernate Fits In.............................................................................................................................52
JPA Interface Hierarchy...................................................................................................52
The Art Gallery Domain Model and DAO Structure...........................................................54
An @Entity-Annotated POJO...................................................................................................................55
Simplified DAO Pattern with Generics....................................................................................................56
The Life Cycle of a JPA Entity.................................................................................................................62
JPA Configuration............................................................................................................64
Bare-Bones JPA Setup...........................................................................................................................64
Spring Integration...................................................................................................................................66
Summary.........................................................................................................................68
■Chapter 5: Domain Model Fundamentals...................................................................69
Understanding Associations............................................................................................69
Building the Domain Model..............................................................................................71
Convention over Configuration...............................................................................................................74
Managing Entity Identifiers.....................................................................................................................75
Using Cascading Options to Establish Data Relationships.....................................................................76
Adding Second-Level Caching................................................................................................................77
Using Polymorphism with Hibernate......................................................................................................78
Summary.........................................................................................................................84
■Chapter 6: DAOs and Querying..................................................................................85
A Basic Hibernate DAO Implementation...........................................................................85
Building a DAO........................................................................................................................................86
Using Spring’s Hibernate Support Classes.............................................................................................87
Enabling Query Caching with the HibernateTemplate............................................................................88
Going Template-less...............................................................................................................................89
Querying in Hibernate......................................................................................................92
Loading an Entity....................................................................................................................................93
Querying for a Particular Type................................................................................................................93
vii
vii
■ CONTENTS

Using Named Parameters.......................................................................................................................94
Querying Using Core Hibernate..............................................................................................................95
Using Named Queries.............................................................................................................................96
Working with Polymorphic Queries........................................................................................................96
Persisting Data with Hibernate........................................................................................97
Saving and Updating Data......................................................................................................................97
Handling Binary Data..............................................................................................................................97
Understanding the Benefits of the Criteria API.......................................................................................98
Using the JPA 2.0 Criteria API.................................................................................................................99
Summary.......................................................................................................................107
■Chapter 7: Transaction Management......................................................................109
The Joy of ACID..............................................................................................................110
Understanding Isolation Levels......................................................................................111
Serializable...........................................................................................................................................112
Repeatable Read..................................................................................................................................112
Read Committed...................................................................................................................................113
Read Uncommitted...............................................................................................................................113
Controlling ACID Reflux..................................................................................................113
Platform Transaction Management......................................................................................................114
Declarative Transaction Management..................................................................................................115
Programmatic Transaction Management.............................................................................................120
Transactional Examples.................................................................................................121
Creating a Batch Application................................................................................................................121
Using Two Datasources........................................................................................................................122
Summary.......................................................................................................................123
■Chapter 8: Effective Testing.....................................................................................125
Unit, Integration, and Functional Testing.......................................................................126
Using JUnit for Effective Testing....................................................................................127
viii
viii