POJOs in Action: Developing Enterprise Applications with Lightweight Frameworks

POJOs in Action......Page 1
Brief contents......Page 8
Contents......Page 10
Preface......Page 20
Acknowledgments......Page 22
About this book......Page 24
About the title......Page 31
About the cover illustration......Page 32
PART 1 Overview of POJOs and lightweight frameworks......Page 34
Developing with POJOs: faster and easier......Page 36
1.1.1 A brief history of EJBs......Page 38
1.1.2 A typical EJB 2 application architecture......Page 39
1.1.3 The problems with EJBs......Page 40
1.1.4 EJB 3 is a step in the right direction......Page 44
1.2 Developing with POJOs......Page 45
1.2.1 Using an object-oriented design......Page 47
1.2.2 Using POJOs......Page 48
1.2.3 Persisting POJOs......Page 49
1.2.4 Eliminating DTOs......Page 51
1.2.5 Making POJOs transactional......Page 52
1.2.6 Configuring applications with Spring......Page 58
1.2.7 Deploying a POJO application......Page 60
1.2.8 POJO design summary......Page 61
1.3 Summary......Page 63
J2EE design decisions......Page 64
2.1 Business logic and database access decisions......Page 65
2.2.1 Using a procedural design......Page 68
2.2.2 Using an object-oriented design......Page 69
2.3 Decision 2: encapsulating the business logic......Page 70
2.3.1 EJB session facade......Page 71
2.3.2 POJO façade......Page 72
2.3.3 Exposed Domain Model pattern......Page 73
2.4.1 What’s wrong with using JDBC directly?......Page 74
2.4.2 Using iBATIS......Page 75
2.4.3 Using a persistence framework......Page 76
2.5.1 Isolated database transactions......Page 77
2.5.3 Pessimistic locking......Page 78
2.6.1 Optimistic Offline Lock pattern......Page 79
2.6.2 Pessimistic Offline Lock pattern......Page 80
2.7.1 Overview of the example application......Page 81
2.7.2 Making high-level design decisions......Page 84
2.7.3 Making use case-level decisions......Page 86
2.8 Summary......Page 91
PART 2 A simpler, faster approach......Page 92
Using the Domain Model pattern......Page 94
3.1 Understanding the Domain Model pattern......Page 95
3.1.1 Where the domain model fits into the overall architecture......Page 96
3.1.2 An example domain model......Page 97
3.1.3 Roles in the domain model......Page 99
3.2 Developing a domain model......Page 101
3.2.2 Adding behavior to the domain model......Page 102
3.3.1 Implementing a domain service method......Page 113
3.3.2 Implementing a domain entity method......Page 120
3.3.3 Summary of the design......Page 125
3.4 Summary......Page 126
Overview of persisting a domain model......Page 128
4.1 Mapping an object model to a database......Page 129
4.1.1 Mapping classes......Page 130
4.1.2 Mapping object relationships......Page 132
4.1.3 Mapping inheritance......Page 136
4.1.5 Persistent object identity......Page 140
4.2 Overview of ORM frameworks......Page 141
4.2.2 The key features of an ORM framework......Page 142
4.2.3 Benefits and drawbacks of using an ORM framework......Page 147
4.3.1 Declarative mapping between the object model and the schema......Page 150
4.3.2 API for creating, reading, updating, and deleting objects......Page 151
4.3.3 Query language......Page 152
4.3.4 Support for transactions......Page 153
4.3.6 Object caching......Page 154
4.3.8 Hibernate vs. JDO......Page 157
4.4.1 Implementing JDO and Hibernate repositories......Page 158
4.4.2 Using the Spring ORM classes......Page 159
4.4.3 Making repositories easier to test......Page 162
4.5 Testing a persistent domain model......Page 165
4.5.1 Object/relational testing strategies......Page 166
4.5.2 Testing against the database......Page 168
4.5.3 Testing without the database......Page 171
4.5.4 Overview of ORMUnit......Page 173
4.6.1 Without any tuning......Page 174
4.6.2 Configuring eager loading......Page 175
4.6.4 Using the query cache......Page 178
4.7 The example schema......Page 179
4.8 Summary......Page 181
Persisting a domain model with JDO 2.0......Page 182
5.1 JDO issues and limitations......Page 183
5.1.1 Configuring JDO object identity......Page 184
5.1.2 Persisting interfaces......Page 188
5.1.3 Using the JDO enhancer......Page 191
5.2.1 Writing JDO persistence tests with ORMUnit......Page 192
5.2.2 Testing persistent JDO objects......Page 197
5.2.3 Making a class persistent......Page 203
5.3 Implementing the JDO repositories......Page 206
5.3.1 Writing a mock object test for findRestaurants()......Page 207
5.3.2 Implementing JDORestaurantRepositoryImpl......Page 211
5.3.4 Writing tests for a query......Page 213
5.4 JDO performance tuning......Page 216
5.4.1 Using fetch groups to optimize object loading......Page 217
5.4.2 Using a PersistenceManagerFactory-level cache......Page 224
5.5 Summary......Page 226
Persisting a domain model with Hibernate 3......Page 228
6.1.1 Fields or properties......Page 229
6.1.2 Hibernate entities and components......Page 231
6.1.3 Configuring object identity......Page 233
6.1.4 Using the cascade attribute......Page 238
6.1.5 Persisting interfaces......Page 240
6.2.2 Lazy loading and inheritance hierarchies......Page 242
6.3 Persisting a domain model class using Hibernate......Page 245
6.3.1 Writing Hibernate persistence tests with ORMUnit......Page 246
6.3.2 Testing persistent Hibernate objects......Page 250
6.3.3 Making a class persistent......Page 257
6.4.1 Writing a mock object test for a repository method......Page 261
6.4.2 Implementing HibernateRestaurantRepositoryImpl......Page 264
6.4.3 Writing the query that finds the restaurants......Page 265
6.4.4 Writing tests for a query......Page 266
6.5 Hibernate performance tuning......Page 267
6.5.1 Using eager loading......Page 268
6.5.2 Using a process-level cache......Page 273
6.5.3 Using a query cache......Page 274
6.6 Summary......Page 275
Encapsulating the business logic with a POJO façade......Page 276
7.1 Overview of a POJO façade......Page 277
7.1.1 An example POJO façade......Page 278
7.1.2 Benefits of a POJO façade......Page 280
7.1.3 Drawbacks of a POJO façade......Page 281
7.1.4 When to use a POJO façade and detached domain objects......Page 283
7.2.1 Encapsulating the domain objects......Page 284
7.2.2 Detaching objects......Page 287
7.2.3 Exceptions versus status codes......Page 289
7.2.4 Managing transactions and connections......Page 290
7.2.5 Implementing security......Page 294
7.2.6 Supporting remote clients......Page 296
7.3.1 Determining the method signatures......Page 297
7.4.1 Writing a test for a POJO façade method......Page 300
7.4.2 Implementing updateRestaurant()......Page 303
7.5 Implementing a result factory......Page 305
7.5.1 Implementing a Hibernate result factory......Page 306
7.5.2 Implementing a JDO result factory......Page 308
7.6 Deploying the POJO façade with Spring......Page 312
7.6.1 Generic bean definitions......Page 313
7.6.2 JDO-specific bean definitions......Page 315
7.6.3 Hibernate bean definitions......Page 317
7.7 Summary......Page 319
PART 3 Variations......Page 320
Using an exposed domain model......Page 322
8.1 Overview of the Exposed Domain Model pattern......Page 323
8.1.1 Applying the Exposed Domain Model pattern......Page 324
8.1.2 Benefits and drawbacks of this pattern......Page 326
8.1.3 When to use the Exposed Domain Model pattern......Page 327
8.2 Managing connections using a Spring filter......Page 328
8.3 Managing transactions......Page 329
8.3.1 Managing transactions in the presentation tier......Page 330
8.3.2 Managing transactions in the business tier......Page 332
8.4 An example of the Exposed Domain Model pattern......Page 337
8.4.1 Servlet design......Page 339
8.4.2 JSP page design......Page 342
8.4.3 PlaceOrderService configuration......Page 343
8.5.1 Defining the Spring beans......Page 344
8.5.2 Configuring the web application......Page 345
8.6.2 Configuring the web application......Page 347
8.7 Summary......Page 349
Using the Transaction Script pattern......Page 350
9.1 Overview of the Transaction Script pattern......Page 351
9.1.1 Applying the Transaction Script pattern......Page 352
9.1.2 Benefits and drawbacks of the Transaction Script pattern......Page 355
9.1.3 When to use the Transaction Script pattern......Page 357
9.2.1 Analyzing the use case......Page 358
9.2.2 Analyzing the user interface design......Page 359
9.2.3 The PlaceOrderTransactionScripts interface......Page 360
9.3.1 Writing a test for the transaction script......Page 362
9.3.2 Writing the transaction script......Page 366
9.4 Implementing the DAOs with iBATIS and Spring......Page 370
9.4.1 Overview of using iBATIS with Spring......Page 372
9.4.2 Implementing a DAO method......Page 376
9.5.1 How Spring manages JDBC connections and transactions......Page 387
9.5.2 The Spring bean definitions......Page 388
9.6 Summary......Page 391
Implementing POJOs with EJB 3......Page 393
10.1 Overview of EJB 3......Page 394
10.1.1 Key improvements in EJB 3......Page 395
10.1.2 Key limitations of EJB 3......Page 401
10.2.1 Mapping the classes to the database......Page 405
10.2.2 Implementing repositories......Page 413
10.2.3 Testing the persistent EJB domain model......Page 415
10.3 Implementing a façade with EJB 3......Page 418
10.3.1 Turning a POJO façade into a session bean......Page 419
10.3.2 Detaching objects......Page 420
10.4 Assembling the components......Page 422
10.4.1 Using EJB dependency injection......Page 423
10.4.2 Integrating Spring and EJB dependency injection......Page 425
10.4.3 Using Spring dependency injection......Page 431
10.5.1 Implementing the Exposed Domain Model pattern......Page 433
10.5.3 Implementing dynamic paged queries......Page 434
10.6 Summary......Page 436
PART 4 Dealing with databases and concurrency......Page 438
Implementing dynamic paged queries......Page 440
11.1 Key design issues......Page 441
11.1.1 Implementing a paging mechanism......Page 443
11.1.2 Generating queries dynamically......Page 446
11.1.3 Improving the performance of SQL queries......Page 447
11.2 Implementing dynamic paged queries with iBATIS......Page 451
11.2.1 Using queryForList() to select the rows......Page 453
11.2.2 Using ROWNUM to select the rows......Page 455
11.3 Implementing paged queries with JDO and Hibernate......Page 457
11.3.1 Generating Hibernate and JDO queries dynamically......Page 459
11.3.2 Loading the data with a single SELECT statement......Page 461
11.3.3 Loading a subset of an object’s fields......Page 464
11.3.4 Working with a denormalized schema......Page 467
11.3.5 Implementing paging......Page 468
11.4 A JDO design example......Page 471
11.4.1 The JDOOrderRepositoryImpl class......Page 472
11.4.2 The ExecuteFindOrdersQuery class......Page 474
11.5 A Hibernate design example......Page 475
11.5.1 The HibernateOrderRepositoryImpl class......Page 476
11.5.2 The FindOrdersHibernateCallback class......Page 477
11.6.1 Using JDO native SQL queries......Page 479
11.6.2 Using Hibernate SQL queries......Page 481
11.7 Summary......Page 482
Database transactions and concurrency......Page 484
12.1 Handling concurrent access to shared data......Page 485
12.1.1 Using fully isolated transactions......Page 486
12.1.2 Optimistic locking......Page 487
12.1.3 Pessimistic locking......Page 491
12.1.4 Using a combination of locking mechanisms......Page 494
12.2.1 Design overview......Page 495
12.2.2 Using optimistic locking......Page 497
12.2.4 Using serializable or repeatable read transactions......Page 499
12.2.5 Signaling concurrent update failures......Page 501
12.3.1 Example domain model design......Page 505
12.3.2 Handling concurrent updates with JDO......Page 507
12.3.3 Handling concurrent updates with Hibernate......Page 511
12.4 Recovering from data concurrency failures......Page 516
12.4.1 Using an AOP interceptor to retry transactions......Page 517
12.4.2 Configuring the AOP interceptor......Page 518
12.5 Summary......Page 519
Using offline locking patterns......Page 521
13.1 The need for offline locking......Page 522
13.1.2 Handling concurrency in an edit-style use case......Page 523
13.2 Overview of the Optimistic Offline Lock pattern......Page 525
13.2.1 Applying the Optimistic Offline Lock pattern......Page 526
13.2.3 When to use this pattern......Page 527
13.3.1 Using version numbers or timestamps......Page 528
13.3.2 Using detached objects......Page 530
13.4 Optimistic offline locking with detached objects example......Page 534
13.4.1 Implementing the domain service......Page 535
13.4.2 Implementing the persistent domain class......Page 537
13.4.3 Detaching and attaching orders......Page 538
13.5.1 Motivation......Page 541
13.5.2 Using the Pessimistic Offline Lock pattern......Page 542
13.5.3 Benefits and drawbacks......Page 543
13.6 Pessimistic offline locking design decisions......Page 544
13.6.3 Choosing the type of lock......Page 545
13.6.5 Maintaining the locks......Page 546
13.6.6 Handling locking failures......Page 552
13.7.1 Implementing a lock manager with iBATIS......Page 553
13.7.2 Implementing the domain service......Page 555
13.7.3 Adapting the other use cases......Page 562
13.8 Summary......Page 565
References......Page 568
Index......Page 572