1. Designing a Persistence Framework With Patterns
Presented By
Dr. Shazzad Hosain

2. What is Framework An extendable set of objects for related function.
Example: GUI Framework, such as Java’s AWT or Swing
Criteria of a framework: It provides an implementation for the core and unvarying functions, and includes a mechanism to allow plug in or to extend the functions.
Example: Developer can extend swing classes
Frameworks provide high degree of reuse.

3. Persistent Objects
Objects that are stored in persistent storage and brought into local memory during application use, e.g. ProductSpecification
Storage mechanisms
Object Databases
Relational Databases
Other formats e.g. XML etc.

4. Persistence Framework
Persistence Framework: A general purpose, reusable and extendable set of types that provide functionality to support persistent objects.
Persistence Service (or Subsystem): Actually provides the service, and will be created with a persistence framework.
O-R Mapping Service: A persistence service that is written to work with RDBs.

5. Requirements for the Persistence Service and Framework
The framework should provide the following functions
Store and retrieve objects in a persistent storage mechanism
Commit and rollback transactions.
Design should be extendable to support different storage mechanisms and formats, such as RDBs, records in flat files or XML in files.

6. Key Ideas for Persistence Framework
Mapping
Object identity
Database mapper
Materialization and dematerialization
Caches
Transaction state of object
Transaction operations
Lazy materialization
Virtual proxies

7. Pattern: Representing Objects as Tables
How to map an object to a record or relational database schema?
Mapping objects and tables

8. Pattern: Object Identifier
Object Identifier pattern proposes assigning an object identifier (OID) to each record and object (or proxy of an object)
An OID is usually an alphanumeric value
Objects identifiers link objects and records

9. Accessing a Persistence Service with a Facade
The PersistenceFacade
Class Class

10. Pattern: Database Mapper / Broker
PersistenceFacade – as true of all facades – does not do the work itself, but delegates requests to subsystem objects
Who should be responsible for materialization and dematerialization of objects from a persistent store?
Information Expert (or Expert) suggests the class itself
But violates low coupling and high cohesion

11. Direct Mapping vs. Indirect Mapping
Direct Mapping: If the class saves data itself
Workable if the database related code is automatically generated and injected into the class by a post-processing compiler
Indirect Mapping: Uses other objects to do the maping for persistent objects.
Class Sale {
total = …
float getTotal () { }
…….
void saveObject () {
SQL code goes here
Class Sale {
total = …
float getTotal () { }
…….

13. PersistenceFacade Class PersistenceFacade{ // ….
public Object get (OID oid, Class persistenceClass) {
// an Imapper is keyed by the Class of the persistence Object
Imapper mapper = (IMapper) mappers.get (persistenceClass)
// delegate
return mapper.get ( oid ) ; }
HashMap <IMapper> mappers = new HashMap <IMapper> () ;
mappers.put ( new ProducSpecification (), new ProductSpecificationRDBMapper () ) ;
Mappers.put ( new Sale (), new SaleRDBMapper () ) ;

14. Hand Crafted mapper Class PersistenceFacade{ // ….
public Object get (OID oid, Class persistenceClass) {
// an Imapper is keyed by the Class of the persistence Object
Imapper mapper = (IMapper) mappers.get (persistenceClass)
// delegate
return mapper.get ( oid ) ; }
Class ProductSpecificationRDBMapper {
// ….
Object get (OID oid) {
ProductSpecification ps = new ProductSpecification () ;
SQL statements to get produc specification from tbl_product_specification
ps.setProductName (pName) ;
ps.setPrice (pPrice) ;
return ps ; }
Hand Crafted mapper

15. Metadata-Based Mapper
Dynamically generate the mapping from an object schema to another schema (such as relational)
Mapping can be made also in external property files

16. Framework Design with the Template Method Pattern
Template Method pattern is at the heart of framework design
Familiar to most OO programmers, though not by name
The idea is to define a method (the template method) in a superclass that defines the skeleton of an algorithm
Template method invokes other methods some of which may be overridden in a subclass

17. Materialization with the Template Method pattern
If we were to program two / three mapper classes there will be some commonality in the code
If ( object in cache )
return it
Else
create the object from its representation in storage
save object in cache
The point of variation is how the object is created from storage

18. Template Method for mapper objects

19. Overriding the hook method Apply Template Again
DB Record
Only table name
Object from DB Record
Overriding the hook method
Apply Template Again

20. DB Record
Object from DB Record

22. References
Chapter 34 of “Applying UML and Patterns – An Introduction to Object-Oriented Analysis and Design and the Unified Process” – by Craig Larman