ebook img

Pro JPA 2 in Java EE 8: An In-Depth Guide to Java Persistence APIs PDF

771 Pages·2018·7.28 MB·English
Save to my drive
Quick download
Download
Most books are stored in the elastic cloud where traffic is expensive. For this reason, we have a limit on daily download.

Preview Pro JPA 2 in Java EE 8: An In-Depth Guide to Java Persistence APIs

Pro JPA 2 in Java EE 8 An In-Depth Guide to Java Persistence APIs — Third Edition — Mike Keith Merrick Schincariol Massimo Nardone Pro JPA 2 in Java EE 8 An In-Depth Guide to Java Persistence APIs Third Edition Mike Keith Merrick Schincariol Massimo Nardone Pro JPA 2 in Java EE 8: An In-Depth Guide to Java Persistence APIs Mike Keith Merrick Schincariol Ottawa, Ontario, Canada Almonte, Ontario, Canada Massimo Nardone Helsinki, Finland ISBN-13 (pbk): 978-1-4842- 3419-8 ISBN-13 (electronic): 978-1-4842- 3420-4 https://doi.org/10.1007/978-1-4842-3420-4 Library of Congress Control Number: 2018932342 Copyright © 2018 by Mike Keith, Merrick Schincariol, Massimo Nardone This work is subject to copyright. All rights are reserved by the Publisher, whether the whole or part of the material is concerned, specifically the rights of translation, reprinting, reuse of illustrations, recitation, broadcasting, reproduction on microfilms or in any other physical way, and transmission or information storage and retrieval, electronic adaptation, computer software, or by similar or dissimilar methodology now known or hereafter developed. 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. While the advice and information in this book are believed to be true and accurate at the date of publication, neither the authors nor the editors nor the publisher can accept any legal responsibility for any errors or omissions that may be made. The publisher makes no warranty, express or implied, with respect to the material contained herein. Cover image by Freepik (www.freepik.com) Managing Director: Welmoed Spahr Editorial Director: Todd Green Acquisitions Editor: Steve Anglin Development Editor: Matthew Moodie Technical Reviewer: Mario Faliero Coordinating Editor: Mark Powers Copy Editor: Kezia Endsley Distributed to the book trade worldwide by Springer Science+Business Media New York, 233 Spring Street, 6th Floor, New York, NY 10013. Phone 1-800-SPRINGER, fax (201) 348-4505, e-mail orders-ny@springer- sbm.com, or visit www.springeronline.com. Apress Media, LLC is a California LLC and the sole member (owner) is Springer Science + Business Media Finance Inc (SSBM Finance Inc). SSBM Finance Inc is a Delaware corporation. For information on translations, please e-mail [email protected], or visit http://www.apress.com/ rights-permissions. Apress titles 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 Print and eBook Bulk Sales web page at http://www.apress.com/bulk-sales. Any source code or other supplementary material referenced by the author in this book is available to readers on GitHub via the book’s product page, located at www.apress.com/9781484234198. For more detailed information, please visit http://www.apress.com/source-code. Printed on acid-free paper To my wife Darleen, the perfect mother, and to Cierra, Ariana, Jeremy, and Emma, who brighten my life and make me strive to be a better person. —Mike To Anthony, whose boundless creativity continues to inspire me. To Evan, whose boisterous enthusiasm motivates me to take on new challenges. To Kate, who proves that size is no object when you have the right attitude. I love you all. —Merrick I would like to dedicate this book to the memory of my beloved late mother Maria Augusta Ciniglio. Thanks mom for all the great things you taught me, for making me a good person, for making me study to become a computing scientist, and for the great memories you left me. You will be loved and missed forever. I love you mom. RIP. —Massimo Table of Contents About the Authors ��������������������������������������������������������������������������������������������������xvii About the Technical Reviewer ��������������������������������������������������������������������������������xix Acknowledgments ��������������������������������������������������������������������������������������������������xxi Chapter 1: Introduction���������������������������������������������������������������������������������������������1 Relational Databases ��������������������������������������������������������������������������������������������������������2 Object-Relational Mapping �����������������������������������������������������������������������������������������������3 The Impedance Mismatch ����������������������������������������������������������������������������������������������������������������������4 Java Support for Persistence �����������������������������������������������������������������������������������������11 Proprietary Solutions ����������������������������������������������������������������������������������������������������������������������������11 JDBC �����������������������������������������������������������������������������������������������������������������������������������������������������13 Enterprise JavaBeans ���������������������������������������������������������������������������������������������������������������������������13 Java Data Objects ���������������������������������������������������������������������������������������������������������������������������������15 Why Another Standard? ��������������������������������������������������������������������������������������������������16 The Java Persistence API �����������������������������������������������������������������������������������������������17 History of the Specification �����������������������������������������������������������������������������������������������������������������17 Overview �����������������������������������������������������������������������������������������������������������������������������������������������21 Summary ������������������������������������������������������������������������������������������������������������������������24 Chapter 2: Getting Started ��������������������������������������������������������������������������������������25 Entity Overview ��������������������������������������������������������������������������������������������������������������25 Persistability �����������������������������������������������������������������������������������������������������������������������������������������26 Identity ��������������������������������������������������������������������������������������������������������������������������������������������������26 Transactionality ������������������������������������������������������������������������������������������������������������������������������������27 Granularity ��������������������������������������������������������������������������������������������������������������������������������������������27 v Table of ConTenTs Entity Metadata ��������������������������������������������������������������������������������������������������������������28 Annotations �������������������������������������������������������������������������������������������������������������������������������������������28 XML �������������������������������������������������������������������������������������������������������������������������������������������������������30 Configuration by Exception �������������������������������������������������������������������������������������������������������������������30 Creating an Entity �����������������������������������������������������������������������������������������������������������31 Entity Manager ���������������������������������������������������������������������������������������������������������������34 Obtaining an Entity Manager ����������������������������������������������������������������������������������������������������������������36 Persisting an Entity �������������������������������������������������������������������������������������������������������������������������������37 Finding an Entity �����������������������������������������������������������������������������������������������������������������������������������38 Removing an Entity �������������������������������������������������������������������������������������������������������������������������������39 Updating an Entity ��������������������������������������������������������������������������������������������������������������������������������40 Transactions �����������������������������������������������������������������������������������������������������������������������������������������41 Queries �������������������������������������������������������������������������������������������������������������������������������������������������42 Putting It All Together �����������������������������������������������������������������������������������������������������44 Packaging It Up ��������������������������������������������������������������������������������������������������������������47 Persistence Unit ������������������������������������������������������������������������������������������������������������������������������������47 Persistence Archive ������������������������������������������������������������������������������������������������������������������������������48 Summary ������������������������������������������������������������������������������������������������������������������������49 Chapter 3: Enterprise Applications �������������������������������������������������������������������������51 Application Component Models ��������������������������������������������������������������������������������������54 Session Beans ����������������������������������������������������������������������������������������������������������������56 Stateless Session Beans ����������������������������������������������������������������������������������������������������������������������57 Stateful Session Beans �������������������������������������������������������������������������������������������������������������������������61 Singleton Session Beans ����������������������������������������������������������������������������������������������������������������������65 Servlets ��������������������������������������������������������������������������������������������������������������������������67 Dependency Management and CDI ��������������������������������������������������������������������������������69 Dependency Lookup �����������������������������������������������������������������������������������������������������������������������������70 Dependency Injection ���������������������������������������������������������������������������������������������������������������������������72 Declaring Dependencies �����������������������������������������������������������������������������������������������������������������������74 vi Table of ConTenTs CDI and Contextual Injection ������������������������������������������������������������������������������������������78 CDI Beans ���������������������������������������������������������������������������������������������������������������������������������������������78 Injection and Resolution �����������������������������������������������������������������������������������������������������������������������79 Scopes and Contexts ����������������������������������������������������������������������������������������������������������������������������80 Qualified Injection ���������������������������������������������������������������������������������������������������������������������������������81 Producer Methods and Fields ���������������������������������������������������������������������������������������������������������������82 Using Producer Methods with JPA Resources ��������������������������������������������������������������������������������������83 Transaction Management �����������������������������������������������������������������������������������������������85 Transaction Review ������������������������������������������������������������������������������������������������������������������������������85 Enterprise Transactions in Java ������������������������������������������������������������������������������������������������������������86 Putting It All Together �����������������������������������������������������������������������������������������������������95 Defining the Component �����������������������������������������������������������������������������������������������������������������������96 Defining the User Interface �������������������������������������������������������������������������������������������������������������������97 Packaging It Up �������������������������������������������������������������������������������������������������������������������������������������98 Summary ������������������������������������������������������������������������������������������������������������������������99 Chapter 4: Object-Relational Mapping ������������������������������������������������������������������101 Persistence Annotations �����������������������������������������������������������������������������������������������102 Accessing Entity State ��������������������������������������������������������������������������������������������������103 Field Access ����������������������������������������������������������������������������������������������������������������������������������������104 Property Access ����������������������������������������������������������������������������������������������������������������������������������105 Mixed Access ��������������������������������������������������������������������������������������������������������������������������������������106 Mapping to a Table �������������������������������������������������������������������������������������������������������108 Mapping Simple Types �������������������������������������������������������������������������������������������������110 Column Mappings �������������������������������������������������������������������������������������������������������������������������������111 Lazy Fetching��������������������������������������������������������������������������������������������������������������������������������������113 Large Objects ��������������������������������������������������������������������������������������������������������������������������������������114 Enumerated Types ������������������������������������������������������������������������������������������������������������������������������115 Temporal Types �����������������������������������������������������������������������������������������������������������������������������������118 Transient State ������������������������������������������������������������������������������������������������������������������������������������119 vii Table of ConTenTs Mapping the Primary Key ���������������������������������������������������������������������������������������������120 Overriding the Primary Key Column ���������������������������������������������������������������������������������������������������120 Primary Key Types ������������������������������������������������������������������������������������������������������������������������������121 Identifier Generation ���������������������������������������������������������������������������������������������������������������������������121 Relationships ����������������������������������������������������������������������������������������������������������������129 Relationship Concepts ������������������������������������������������������������������������������������������������������������������������129 Mappings Overview ����������������������������������������������������������������������������������������������������������������������������132 Single-Valued Associations ����������������������������������������������������������������������������������������������������������������133 Collection-Valued Associations �����������������������������������������������������������������������������������������������������������140 Lazy Relationships ������������������������������������������������������������������������������������������������������������������������������148 Embedded Objects �������������������������������������������������������������������������������������������������������149 Summary ����������������������������������������������������������������������������������������������������������������������154 Chapter 5: Collection Mapping �����������������������������������������������������������������������������157 Relationships and Element Collections ������������������������������������������������������������������������157 Using Different Collection Types �����������������������������������������������������������������������������������161 Sets or Collections ������������������������������������������������������������������������������������������������������������������������������162 Lists ����������������������������������������������������������������������������������������������������������������������������������������������������162 Maps ���������������������������������������������������������������������������������������������������������������������������������������������������167 Duplicates �������������������������������������������������������������������������������������������������������������������������������������������185 Null Values ������������������������������������������������������������������������������������������������������������������������������������������187 Best Practices ��������������������������������������������������������������������������������������������������������������188 Summary ����������������������������������������������������������������������������������������������������������������������189 Chapter 6: Entity Manager ������������������������������������������������������������������������������������191 Persistence Contexts ����������������������������������������������������������������������������������������������������191 Entity Managers �����������������������������������������������������������������������������������������������������������192 Container-Managed Entity Managers �������������������������������������������������������������������������������������������������192 Application-Managed Entity Managers�����������������������������������������������������������������������������������������������198 Transaction Management ���������������������������������������������������������������������������������������������201 JTA Transaction Management �������������������������������������������������������������������������������������������������������������202 Resource-Local Transactions ��������������������������������������������������������������������������������������������������������������218 Transaction Rollback and Entity State ������������������������������������������������������������������������������������������������221 viii Table of ConTenTs Choosing an Entity Manager ����������������������������������������������������������������������������������������224 Entity Manager Operations �������������������������������������������������������������������������������������������225 Persisting an Entity �����������������������������������������������������������������������������������������������������������������������������225 Finding an Entity ���������������������������������������������������������������������������������������������������������������������������������227 Removing an Entity �����������������������������������������������������������������������������������������������������������������������������228 Cascading Operations �������������������������������������������������������������������������������������������������������������������������229 Clearing the Persistence Context �������������������������������������������������������������������������������������������������������234 Synchronization with the Database ������������������������������������������������������������������������������234 Detachment and Merging ���������������������������������������������������������������������������������������������238 Detachment ����������������������������������������������������������������������������������������������������������������������������������������238 Merging Detached Entities �����������������������������������������������������������������������������������������������������������������241 Working with Detached Entities����������������������������������������������������������������������������������������������������������246 Summary ����������������������������������������������������������������������������������������������������������������������267 Chapter 7: Using Queries ��������������������������������������������������������������������������������������269 Java Persistence Query Language �������������������������������������������������������������������������������270 Getting Started �����������������������������������������������������������������������������������������������������������������������������������270 Filtering Results ����������������������������������������������������������������������������������������������������������������������������������271 Projecting Results �������������������������������������������������������������������������������������������������������������������������������272 Joins Between Entities �����������������������������������������������������������������������������������������������������������������������272 Aggregate Queries ������������������������������������������������������������������������������������������������������������������������������273 Query Parameters �������������������������������������������������������������������������������������������������������������������������������273 Defining Queries �����������������������������������������������������������������������������������������������������������274 Dynamic Query Definition �������������������������������������������������������������������������������������������������������������������275 Named Query Definition����������������������������������������������������������������������������������������������������������������������278 Dynamic Named Queries ��������������������������������������������������������������������������������������������������������������������280 Parameter Types �����������������������������������������������������������������������������������������������������������282 Executing Queries ��������������������������������������������������������������������������������������������������������285 Working with Query Results ���������������������������������������������������������������������������������������������������������������287 Stream Query Results �������������������������������������������������������������������������������������������������������������������������288 Query Paging ��������������������������������������������������������������������������������������������������������������������������������������293 ix Table of ConTenTs Queries and Uncommitted Changes ���������������������������������������������������������������������������������������������������296 Query Timeouts �����������������������������������������������������������������������������������������������������������������������������������299 Bulk Update and Delete ������������������������������������������������������������������������������������������������300 Using Bulk Update and Delete ������������������������������������������������������������������������������������������������������������301 Bulk Delete and Relationships ������������������������������������������������������������������������������������������������������������304 Query Hints �������������������������������������������������������������������������������������������������������������������305 Query Best Practices ����������������������������������������������������������������������������������������������������307 Named Queries �����������������������������������������������������������������������������������������������������������������������������������307 Report Queries ������������������������������������������������������������������������������������������������������������������������������������308 Vendor Hints ���������������������������������������������������������������������������������������������������������������������������������������308 Stateless Beans ����������������������������������������������������������������������������������������������������������������������������������309 Bulk Update and Delete ����������������������������������������������������������������������������������������������������������������������309 Provider Differences ���������������������������������������������������������������������������������������������������������������������������310 Summary ����������������������������������������������������������������������������������������������������������������������310 Chapter 8: Query Language ����������������������������������������������������������������������������������313 Introducing JP QL ���������������������������������������������������������������������������������������������������������313 Terminology ����������������������������������������������������������������������������������������������������������������������������������������314 Example Data Model ���������������������������������������������������������������������������������������������������������������������������315 Example Application ���������������������������������������������������������������������������������������������������������������������������316 Select Queries ��������������������������������������������������������������������������������������������������������������319 SELECT Clause ������������������������������������������������������������������������������������������������������������������������������������321 FROM Clause ��������������������������������������������������������������������������������������������������������������������������������������325 WHERE Clause ������������������������������������������������������������������������������������������������������������������������������������336 Inheritance and Polymorphism �����������������������������������������������������������������������������������������������������������344 Scalar Expressions �����������������������������������������������������������������������������������������������������������������������������347 ORDER BY Clause �������������������������������������������������������������������������������������������������������������������������������353 Aggregate Queries ��������������������������������������������������������������������������������������������������������354 Aggregate Functions���������������������������������������������������������������������������������������������������������������������������356 GROUP BY Clause �������������������������������������������������������������������������������������������������������������������������������357 HAVING Clause ������������������������������������������������������������������������������������������������������������������������������������358 Update Queries �������������������������������������������������������������������������������������������������������������359 x

See more

The list of books you might like

Most books are stored in the elastic cloud where traffic is expensive. For this reason, we have a limit on daily download.