Keith / Schincariol Pro JPA 2

Mastering the Java(TM) Persistence API
1. ed
ISBN: 978-1-4302-1957-6
Verlag: Apress
Format: PDF
Kopierschutz: 1 - PDF Watermark

E-Book, Englisch, 500 Seiten

Pro JPA 2 introduces, explains, and demonstrates how to use the Java Persistence API (JPA). JPA provides Java developers with both the knowledge and insight needed to write Java applications that access relational databases through JPA. Authors Mike Keith and Merrick Schincariol take a hands-on approach to teaching by giving examples to illustrate each concept of the API and showing how it is used in practice. All of the examples use a common model from an overriding sample application, giving readers a context from which to start and helping them to understand the examples within an already familiar domain. After completing the book, you will have a full understanding and be able to successfully code applications using JPA. The book also serves as a reference guide during initial and later JPA application experiences. Hands-on examples for all the aspects of the JPA specification, based on the reference implementation of this specification A special section on migration to JPA Expert insight about various aspects of the API and when they are useful Portability hints to provide increased awareness of the potential for non-portable JPA code

Mike Keith wasthe co-specification lead for JPA 1.0 and a member of the JPA 2.0 and JPA 2.1expert groups. He sits on a number of other Java Community Process expertgroups and the Enterprise Expert Group (EEG) in the OSGi Alliance. He holds aMasters degree in Computer Science from Carleton University, and has over 20years experience in persistence and distributed systems research and practice.He has written papers and articles on JPA and spoken at numerous conferencesaround the world. He is employed as an architect at Oracle in Ottawa, Canada,and is married with four kids and two dogs.

Autoren/Hrsg.

Keith, Mike

Schincariol, Merrick

Keith, Jeremy

Inhaltsverzeichnis

1;Title Page;1
2;Copyright Page;2
3;Contents at a Glance;4
4;Table of Contents ;5
5;Foreword;20
6;About the Author;21
7;About the Technical Reviewer;22
8;Acknowledgments;23
8.1;Mike Keith;23
8.2;Merrick Schincariol;23
9;Preface;24
9.1;This Book Is For You;24
9.2;Code Examples;25
9.3;Contacting Us;25
10;Chapter 1: Introduction;26
10.1;Object-Relational Mapping;27
10.1.1;The Impedance Mismatch;28
10.1.1.1;Class Representation;28
10.1.1.2;Relationships;30
10.1.1.3;Inheritance;32
10.2;Java Support for Persistence;34
10.2.1;Proprietary Solutions;34
10.2.2;JDBC;34
10.2.3;Enterprise JavaBeans;35
10.2.4;Java Data Objects;35
10.3;Why Another Standard?;36
10.4;The Java Persistence API;37
10.4.1;History of the Specification;37
10.4.1.1;EJB 3.0 and JPA 1.0;37
10.4.1.2;JPA 2.0;38
10.4.1.3;JPA and You;38
10.4.2;Overview;38
10.4.2.1;POJO Persistence;39
10.4.2.2;Nonintrusiveness;39
10.4.2.3;Object Queries;39
10.4.2.4;Mobile Entities;39
10.4.2.5;Simple Configuration;40
10.4.2.6;Integration and Testability;40
10.5;Summary;40
11;Chapter 2: Getting Started;42
11.1;Entity Overview;42
11.1.1;Persistability;43
11.1.2;Identity;43
11.1.3;Transactionality;43
11.1.4;Granularity;43
11.2;Entity Metadata;44
11.2.1;Annotations;44
11.2.2;XML;44
11.2.3;Configuration by Exception;45
11.3;Creating an Entity;45
11.4;Entity Manager;47
11.4.1;Obtaining an Entity Manager;48
11.4.2;Persisting an Entity;49
11.4.3;Finding an Entity;49
11.4.4;Removing an Entity;50
11.4.5;Updating an Entity;51
11.4.6;Transactions;51
11.4.7;Queries;52
11.5;Putting It All Together;53
11.6;Packaging It Up;55
11.6.1;Persistence Unit;55
11.6.2;Persistence Archive;56
11.7;Summary;57
12;Chapter 3: Enterprise Applications;58
12.1;Application Component Models;58
12.2;Session Beans;59
12.2.1;Stateless Session Beans;60
12.2.1.1;Defining a Stateless Session Bean;60
12.2.1.2;Lifecycle Callbacks;62
12.2.1.3;Remote Business Interfaces;63
12.2.2;Stateful Session Beans;64
12.2.2.1;Defining a Stateful Session Bean;64
12.2.2.2;Lifecycle Callbacks;66
12.2.3;Singleton Session Beans;67
12.2.3.1;Defining a Singleton Session Bean;67
12.2.3.2;Lifecycle Callbacks;68
12.2.3.3;Singleton Concurrency;68
12.3;Message-Driven Beans;70
12.3.1;Defining a Message-Driven Bean;70
12.4;Servlets;71
12.5;Dependency Management;72
12.5.1;Dependency Lookup;72
12.5.2;Dependency Injection;74
12.5.2.1;Field Injection;74
12.5.2.2;Setter Injection;75
12.5.3;Declaring Dependencies;76
12.5.3.1;Referencing a Persistence Context;76
12.5.3.2;Referencing a Persistence Unit;77
12.5.3.3;Referencing Enterprise JavaBeans;77
12.5.3.4;Referencing Server Resources;78
12.6;Transaction Management;78
12.6.1;Transaction Review;79
12.6.2;Enterprise Transactions in Java;80
12.6.2.1;Transaction Demarcation;80
12.6.2.2;Container-Managed Transactions;81
12.6.2.3;Bean-Managed Transactions;83
12.6.2.3.1;UserTransaction;83
12.7;Using Java EE Components;85
12.7.1;Using a Stateless Session Bean;85
12.7.2;Using a Stateful Session Bean;85
12.7.3;Using a Singleton Session Bean;87
12.7.4;Using a Message-Driven Bean;87
12.7.5;Adding the Entity Manager;88
12.8;Putting It All Together;89
12.8.1;Defining the Component;89
12.8.2;Defining the User Interface;91
12.8.3;Packaging It Up;92
12.9;Summary;92
13;Chapter 4: Object-Relational Mapping;94
13.1;Persistence Annotations;94
13.2;Accessing Entity State;95
13.2.1;Field Access;95
13.2.2;Property Access;96
13.2.3;Mixed Access;96
13.3;Mapping to a Table;98
13.4;Mapping Simple Types;99
13.4.1;Column Mappings;100
13.4.2;Lazy Fetching;101
13.4.3;Large Objects;102
13.4.4;Enumerated Types;103
13.4.5;Temporal Types;105
13.4.6;Transient State;105
13.5;Mapping the Primary Key;106
13.5.1;Overriding the Primary Key Column;106
13.5.2;Primary Key Types;106
13.5.3;Identifier Generation;107
13.5.3.1;Automatic Id Generation;107
13.5.3.2;Id Generation Using a Table;108
13.5.3.3;Id Generation Using a Database Sequence;110
13.5.3.4;Id Generation Using Database Identity;111
13.6;Relationships;112
13.6.1;Relationship Concepts;112
13.6.1.1;Roles;112
13.6.1.2;Directionality;112
13.6.1.3;Cardinality;114
13.6.1.4;Ordinality;114
13.6.2;Mappings Overview;115
13.6.3;Single-Valued Associations;115
13.6.3.1;Many-to-One Mappings;115
13.6.3.2;Using Join Columns;116
13.6.3.3;One-to-One Mappings;118
13.6.3.4;Bidirectional One-to-One Mappings;119
13.6.4;Collection-Valued Associations;120
13.6.4.1;One-to-Many Mappings;120
13.6.4.2;Many-to-Many Mappings;122
13.6.4.3;Using Join Tables;124
13.6.4.4;Unidirectional Collection Mappings;125
13.6.5;Lazy Relationships;126
13.7;Embedded Objects;127
13.8;Summary;131
14;Chapter 5: Collection Mapping;132
14.1;Relationships and Element Collections;132
14.2;Using Different Collection Types;135
14.2.1;Sets or Collections;136
14.2.2;Lists;136
14.2.2.1;Ordering By Entity or Element Attribute;136
14.2.2.2;Persistently Ordered Lists;137
14.2.3;Maps;139
14.2.3.1;Keys and Values;140
14.2.3.2;Keying By Basic Type;140
14.2.3.3;Keying by Entity Attribute;143
14.2.3.4;Keying by Embeddable Type;144
14.2.3.4.1;Overriding Embeddable Attributes;146
14.2.3.5;Keying by Entity;148
14.2.3.6;Untyped Maps;149
14.2.3.7;Rules for Maps;150
14.2.4;Duplicates;151
14.2.5;Null Values;153
14.3;Best Practices;153
14.4;Summary;154
15;Chapter 6: Entity Manager;155
15.1;Persistence Contexts;155
15.2;Entity Managers;156
15.2.1;Container-Managed Entity Managers;156
15.2.1.1;Transaction-Scoped;156
15.2.1.2;Extended;157
15.2.2;Application-Managed Entity Managers;160
15.3;Transaction Management;162
15.3.1;JTA Transaction Management;162
15.3.1.1;Transaction-Scoped Persistence Contexts;163
15.3.1.2;Extended Persistence Contexts;165
15.3.1.2.1;Persistence Context Collision;166
15.3.1.2.2;Persistence Context Inheritance;167
15.3.1.3;Application-Managed Persistence Contexts;168
15.3.2;Resource-Local Transactions;171
15.3.3;Transaction Rollback and Entity State;173
15.4;Choosing an Entity Manager;174
15.5;Entity Manager Operations;174
15.5.1;Persisting an Entity;174
15.5.2;Finding an Entity;175
15.5.3;Removing an Entity;176
15.5.4;Cascading Operations;177
15.5.4.1;Cascade Persist;178
15.5.4.2;Cascade Remove;179
15.5.5;Clearing the Persistence Context;180
15.6;Synchronization with the Database;181
15.7;Detachment and Merging;183
15.7.1;Detachment.;183
15.7.2;Merging Detached Entities;185
15.7.3;Working with Detached Entities;188
15.7.3.1;Planning for Detachment;190
15.7.3.1.1;Triggering Lazy Loading;190
15.7.3.1.2;Configuring Eager Loading;191
15.7.3.2;Avoiding Detachment;192
15.7.3.2.1;Transaction View;192
15.7.3.2.2;Entity Manager per Request;194
15.7.3.3;Merge Strategies;196
15.7.3.3.1;Session Façade;196
15.7.3.3.2;Edit Session;198
15.8;Summary;201
16;Chapter 7: Using Queries;202
16.1;Java Persistence Query Language;202
16.1.1;Getting Started;203
16.1.2;Filtering Results;204
16.1.3;Projecting Results;204
16.1.4;Joins Between Entities;204
16.1.5;Aggregate Queries;205
16.1.6;Query Parameters;205
16.2;Defining Queries;206
16.2.1;Dynamic Query Definition;206
16.2.2;Named Query Definition;208
16.3;Parameter Types;210
16.4;Executing Queries;211
16.4.1;Working with Query Results;213
16.4.1.1;Untyped Results;214
16.4.1.2;Optimizing Read-Only Queries;214
16.4.1.3;Special Result Types;215
16.4.2;Query Paging;216
16.4.3;Queries and Uncommitted Changes;218
16.4.4;Query Timeouts;221
16.5;Bulk Update and Delete;222
16.5.1;Using Bulk Update and Delete;222
16.5.2;Bulk Delete and Relationships;224
16.6;Query Hints;225
16.7;Query Best Practices;226
16.7.1;Named Queries;226
16.7.2;Report Queries;227
16.7.3;Vendor Hints;227
16.7.4;Stateless Session Beans;227
16.7.5;Bulk Update and Delete;228
16.7.6;Provider Differences;228
16.8;Summary;228
17;Chapter 8: Query Language;230
17.1;Introduction;230
17.1.1;Terminology;231
17.1.2;Example Data Model;231
17.1.3;Example Application;232
17.2;Select Queries;234
17.2.1;SELECT Clause;235
17.2.1.1;Path Expressions;235
17.2.1.2;Entities and Objects;236
17.2.1.3;Combining Expressions;237
17.2.1.4;Constructor Expressions;238
17.2.1.5;Inheritance and Polymorphism;238
17.2.2;FROM Clause;239
17.2.2.1;Identification Variables;239
17.2.2.2;Joins;239
17.2.2.2.1;Inner Joins;240
17.2.2.2.1.1;JOIN Operator and Collection Association Fields;240
17.2.2.2.1.2;JOIN Operator and Single-Valued Association Fields;242
17.2.2.2.1.3;Join Conditions in the WHERE Clause;243
17.2.2.2.1.4;Multiple Joins;243
17.2.2.2.2;Map Joins;243
17.2.2.2.3;Outer Joins;244
17.2.2.2.4;Fetch Joins;245
17.2.3;WHERE Clause;246
17.2.3.1;Input Parameters;246
17.2.3.2;Basic Expression Form;246
17.2.3.3;BETWEEN Expressions;247
17.2.3.4;LIKE Expressions;247
17.2.3.5;Subqueries;248
17.2.3.6;IN Expressions;249
17.2.3.7;Collection Expressions;250
17.2.3.8;EXISTS Expressions;251
17.2.3.9;ANY, ALL, and SOME Expressions;251
17.2.4;Scalar Expressions;251
17.2.4.1;Literals;252
17.2.4.2;Function Expressions;253
17.2.4.3;CASE Expressions;254
17.2.5;ORDER BY Clause;256
17.3;Aggregate Queries;256
17.3.1;Aggregate Functions;258
17.3.1.1;AVG;258
17.3.1.2;COUNT;258
17.3.1.3;MAX;258
17.3.1.4;MIN;258
17.3.1.5;SUM;258
17.3.2;GROUP BY Clause;259
17.3.3;HAVING Clause;259
17.4;Update Queries;260
17.5;Delete Queries;260
17.6;Summary;261
18;Chapter 9: Criteria API;262
18.1;Overview;262
18.1.1;The Criteria APi;263
18.1.2;Parameterized Types;264
18.1.3;Dynamic Queries;264
18.2;Building Criteria API Queries;267
18.2.1;Creating a Query Definition;267
18.2.2;Basic Structure;269
18.2.3;Criteria Objects and Mutability;269
18.2.4;Query Roots and Path Expressions;270
18.2.4.1;Query Roots;270
18.2.4.2;Path Expressions;271
18.2.5;The SELECT Clause;272
18.2.5.1;Selecting Single Expressions;272
18.2.5.2;Selecting Multiple Expressions;273
18.2.5.3;Using Aliases;274
18.2.6;The FROM Clause;274
18.2.6.1;Inner and Outer Joins;275
18.2.6.2;Fetch Joins;276
18.2.7;The WHERE Clause;277
18.2.8;Building Expressions;277
18.2.8.1;Predicates;280
18.2.8.2;Literals;281
18.2.8.3;Parameters;281
18.2.8.4;Subqueries;281
18.2.8.5;In Expressions;284
18.2.8.6;Case Expressions;285
18.2.8.7;Function Expressions;287
18.2.9;The ORDER BY Clause;287
18.2.10;The GROUP BY and HAVING Clauses;288
18.3;Strongly Typed Query Definitions;288
18.3.1;The Metamodel APi;288
18.3.2;Strongly Typed API Overview;290
18.3.3;The Canonical Metamodel;291
18.3.3.1;Using the Canonical Metamodel;292
18.3.3.2;Generating the Canonical Metamodel;293
18.3.4;Choosing the Right Type of Query;294
18.4;Summary;294
19;Chapter 10: Advanced Object-Relational Mapping;295
19.1;Table and Column Names;295
19.2;Complex Embedded Objects;297
19.2.1;Advanced Embedded Mappings;297
19.2.2;Overriding Embedded Relationships;298
19.3;Compound Primary Keys;300
19.3.1;Id Class;300
19.3.2;Embedded Id Class;302
19.4;Derived Identifiers;303
19.4.1;Basic Rules for Derived Identifiers;304
19.4.2;Shared Primary Key;305
19.4.3;Multiple Mapped Attributes;306
19.4.4;Using Embeddedld;308
19.5;Advanced Mapping Elements;310
19.5.1;Read-Only Mappings;310
19.5.2;Optionality;311
19.6;Advanced Relationships;311
19.6.1;Using Join Tables;312
19.6.2;Avoiding Join Tables;313
19.6.3;Compound Join Columns;314
19.6.4;Orphan Removal;316
19.6.5;Mapping Relationship State;317
19.7;Multiple Tables;319
19.8;Inheritance;322
19.8.1;Class Hierarchies;322
19.8.1.1;Mapped Superclasses;323
19.8.1.2;Transient Classes in the Hierarchy;325
19.8.1.3;Abstract and Concrete Classes;325
19.8.2;Inheritance Models;326
19.8.2.1;Single-Table Strategy;326
19.8.2.1.1;Discriminator Column;327
19.8.2.1.2;Discriminator Value;327
19.8.2.2;Joined Strategy;329
19.8.2.3;Table-per-Concrete-Class Strategy;331
19.8.3;Mixed Inheritance;333
19.9;Summary;335
20;Chapter 11: Advanced Topics;337
20.1;SQl Queries;337
20.1.1;Native Queries versus JDBC;338
20.1.2;Defining and Executing SQl Queries;340
20.1.3;SQl Result Set Mapping;342
20.1.3.1;Mapping Foreign Keys;343
20.1.3.2;Multiple Result Mappings;343
20.1.3.3;Mapping Column Aliases;343
20.1.3.4;Mapping Scalar Result Columns;344
20.1.3.5;Mapping Compound Keys;346
20.1.3.6;Mapping Inheritance;347
20.1.4;Parameter Binding;348
20.2;Lifecycle Callbacks;348
20.2.1;Lifecycle Events;348
20.2.1.1;Pre Persist and PostPersist;348
20.2.1.2;PreRemove and PostRemove;349
20.2.1.3;PreUpdate and PostUpdate;349
20.2.1.4;Post Load;349
20.2.2;Callback Methods;349
20.2.2.1;Enterprise Contexts;351
20.2.3;Entity Listeners;351
20.2.3.1;Attaching Entity Listeners to Entities;351
20.2.3.2;Default Entity Listeners;353
20.2.4;Inheritance and Lifecycle Events;353
20.2.4.1;Inheriting Callback Methods;353
20.2.4.2;Inheriting Entity Listeners;354
20.2.4.3;Lifecycle Event Invocation Order;354
20.3;Validation;357
20.3.1;Using Constraints;358
20.3.2;Invoking Validation;359
20.3.3;Validation Groups;360
20.3.4;Creating New Constraints;362
20.3.4.1;Constraint Annotations;362
20.3.4.2;Constraint Implementation Classes;363
20.3.5;Validation in JPA;364
20.3.6;Enabling Validation;365
20.3.7;Setting Lifecycle Validation Groups;365
20.4;Concurrency;366
20.4.1;Entity Operations;366
20.4.2;Entity Access;367
20.5;Refreshing Entity State;367
20.6;Locking;370
20.6.1;Optimistic Locking;370
20.6.1.1;Versioning;371
20.6.1.2;Advanced Optimistic Locking Modes;372
20.6.1.2.1;Optimistic Read Locking;373
20.6.1.2.2;Optimistic Write Locking;375
20.6.1.3;Recovering from Optimistic Failures;377
20.6.2;Pessimistic Locking;380
20.6.2.1;Pessimistic Locking Modes;380
20.6.2.1.1;Pessimistic Write Locking;380
20.6.2.1.2;Pessimistic Read Locking;382
20.6.2.1.3;Pessimistic Forced Increment Locking;382
20.6.2.2;Pessimistic Scope;382
20.6.2.3;Pessimistic Timeouts;382
20.6.2.4;Recovering From Pessimistic Failures;383
20.7;Caching;383
20.7.1;Sorting Through the Layers;383
20.7.2;Shared Cache;385
20.7.2.1;Static Configuration of the Cache;387
20.7.2.2;Dynamic Cache Management;388
20.8;Utility Classes;390
20.8.1;PersistenceUtil;390
20.8.2;PersistenceUnitUtil;390
20.9;Summary;391
21;Chapter 12: XML Mapping Files;393
21.1;The Metadata Puzzle;394
21.2;The Mapping File;395
21.2.1;Disabling Annotations;395
21.2.1.1;xml-mapping-metadata-complete;396
21.2.1.2;metadata-complete;396
21.2.2;Persistence Unit Defaults;397
21.2.2.1;schema;398
21.2.2.2;catalog;398
21.2.2.3;delimited-identifiers;398
21.2.2.4;access;399
21.2.2.5;cascade-persist;399
21.2.2.6;entity-listeners;400
21.2.3;Mapping File Defaults;400
21.2.3.1;package;401
21.2.3.2;schema;401
21.2.3.3;catalog;402
21.2.3.4;access;402
21.2.4;Queries and Generators;403
21.2.4.1;sequence-generator;403
21.2.4.2;table-generator;404
21.2.4.3;named-query;404
21.2.4.4;named-native-query;405
21.2.4.5;sql-result-set-mapping;406
21.2.5;Managed Classes and Mappings;407
21.2.5.1;Attributes;407
21.2.5.2;Tables;408
21.2.5.2.1;table;408
21.2.5.2.2;secondary-table;408
21.2.5.3;Identifier Mappings;409
21.2.5.3.1;id;409
21.2.5.3.2;embedded-id;410
21.2.5.3.3;id-class;411
21.2.5.4;Simple Mappings;411
21.2.5.4.1;basic;411
21.2.5.4.2;transient;412
21.2.5.4.3;version;413
21.2.5.5;Relationship and Collection Mappings;413
21.2.5.5.1;many-to-one;414
21.2.5.5.2;one-to-many;415
21.2.5.5.3;one-to-one;416
21.2.5.5.4;many-to-many;418
21.2.5.5.5;element-collection;419
21.2.5.6;Embedded Object Mappings;420
21.2.5.6.1;embedded;420
21.2.5.6.2;attribute-override;421
21.2.5.6.3;association-override;422
21.2.5.7;Inheritance Mappings;423
21.2.5.7.1;inheritance;423
21.2.5.7.2;discriminator-column;424
21.2.5.7.3;discriminator-value;424
21.2.5.7.4;attribute-override and association-override;425
21.2.5.8;Lifecycle Events;426
21.2.5.9;Entity Listeners;426
21.2.5.9.1;entity-listeners;426
21.2.5.9.2;exclude-default-listeners;428
21.2.5.9.3;exclude-superclass-listeners;428
21.3;Summary;428
22;Chapter 13: Packaging and Deployment;429
22.1;Configuring Persistence Units;429
22.1.1;Persistence Unit Name;430
22.1.2;Transaction Type;430
22.1.3;Persistence Provider;430
22.1.4;Data Source;431
22.1.5;Mapping Files;432
22.1.6;Managed Classes;433
22.1.6.1;Local Classes;433
22.1.6.2;Classes in Mapping Files;434
22.1.6.3;Explicitly Listed Classes;434
22.1.6.4;Additional JARs of Managed Classes;435
22.1.7;Shared Cache Mode;435
22.1.8;Validation Mode;436
22.1.9;Adding Vendor Properties;436
22.2;Building and Deploying;437
22.2.1;Deployment Classpath;437
22.2.2;Packaging Options;438
22.2.2.1;EJB JAR;438
22.2.2.2;Web Archive;440
22.2.2.3;Persistence Archive;441
22.2.3;Persistence Unit Scope;442
22.3;Outside the Server;442
22.3.1;Configuring the Persistence Unit;443
22.3.1.1;Transaction Type;443
22.3.1.2;Data Source;443
22.3.1.3;Providers;444
22.3.1.4;Listing the Entities;444
22.3.2;Specifying Properties at Runtime;445
22.3.3;System Classpath;445
22.4;Schema Generation;445
22.4.1;Unique Constraints;446
22.4.2;Null Constraints;447
22.4.3;String-Based Columns;447
22.4.4;Floating Point Columns;448
22.4.5;Defining the Column;448
22.5;Summary;449
23;Chapter 14: Testing;451
23.1;Testing Enterprise Applications;451
23.1.1;Terminology;452
23.1.2;Testing Outside the Server;453
23.1.3;Test Frameworks;454
23.2;Unit Testing;455
23.2.1;Testing Entities;455
23.2.2;Testing Entities in Components;456
23.2.3;The Entity Manager in Unit Tests;458
23.3;Integration Testing;461
23.3.1;Using the Entity Manager;461
23.3.1.1;Test Setup and Teardown;463
23.3.1.2;Switching Configurations for Testing;464
23.3.1.3;Minimizing Database Connections;466
23.3.2;Components and Persistence;467
23.3.2.1;Transaction Management;467
23.3.2.1.1;When to Use Transactions;467
23.3.2.1.2;Container-Managed Transactions;468
23.3.2.1.3;Bean-Managed Transactions;469
23.3.2.2;Container-Managed Entity Managers;472
23.3.2.3;Other Services;474
23.3.2.4;Using an Embedded EJB Container for Integration Testing;475
23.4;Best Practices;477
23.5;Summary;477
24;Chapter 15: Migration;479
24.1;Migrating from CMP Entity Beans;479
24.1.1;Scoping the Challenge;480
24.1.2;Entity Bean Conversion;481
24.1.2.1;Converting the Business Interface;481
24.1.2.1.1;Migrating Properties;481
24.1.2.1.2;Migrating Business Methods;482
24.1.2.1.3;Migrating Container-Managed Relationships;483
24.1.2.2;Converting the Home Interface;485
24.1.2.2.1;Migrating Home Methods;486
24.1.2.2.2;Creating the Façade;487
24.2;Migrating from JDBC;489
24.3;Migrating from Other ORM Solutions;490
24.4;Leveraging Design Patterns;491
24.4.1;Transfer Object;491
24.4.1.1;Fine-Grained Transfer Objects;491
24.4.1.2;Coarse-Grained Transfer Objects;493
24.4.2;Session FaGade;494
24.4.3;Data Access Object;496
24.4.4;Business Object;500
24.4.5;Fast Lane Reader;501
24.4.6;Active Record;501
24.5;Summary;502
25;Index;503