Java Data Object (JDO) Overview for Transparent Persistence

1. Java Data Object Che-Rung Lee

2. JDO Objectives • Transparent persistence • Range of implementations • embedded (J2ME) • two tier (J2SE) • enterprise (J2EE, EJB) • Datastore independence • relational, object, hierarchical databases • XML DB, file systems

3. What’s the difference? • Serialization • no database capabilities (transactions, queries) • JDBC • cannot storing Java object models. • incompatibilities among SQL implementations can result in a loss of application portability • CMP (Container Managed Persistence) • a distributed model of computation, imposing performance degradations

4. JDO Introduction • JDO API • An example • Datastore mapping • JDO implementation

5. JDOHelper I18NHelper Persistence Manager Factory Instance Callbacks Persistence Manager Transaction Query Extent JDO API • Two classes • I18NHelper • JDOHelper • Six interfaces • PersistenceManagerFactory • PersistenceManager • Transaction • Extent • Query • InstanceCallbacks

6. JDOHelper I18NHelper Persistence Manager Factory Instance Callbacks Persistence Manager Transaction Query Extent 1. PersistenceManagerFactory • Create PersistenceManager • May implement PersistenceManager pooling, connection pooling among PersistenceManagers • Datastore configuration • Supports JNDI

7. JDOHelper I18NHelper Persistence Manager Factory Instance Callbacks Persistence Manager Transaction Query Extent 2. PersistenceManager • Primary application interface • PersistenceCapable instance management • identity • life cycle • Transaction factory • Query factory • Extent factory

8. JDOHelper I18NHelper Persistence Manager Factory Instance Callbacks Persistence Manager Transaction Query Extent 3. Transactions • One-one relation to Persistence Manager • Transaction interface for local transactions • isActive, begin, commit, rollback • Provide ACID transaction • Atomic, Consistent, Isolated, Durable

9. JDOHelper I18NHelper Persistence Manager Factory Instance Callbacks Persistence Manager Transaction Query Extent 4. Extents • Defined for PersistenceCapable classes • pm.getExtent (Class pc, boolean subclasses); • Used in Query andclass navigation

10. JDOHelper I18NHelper Persistence Manager Factory Instance Callbacks Persistence Manager Transaction Query Extent 5. Query • Can do filtering and ordering • Outer/inner join • Has JDOQL

11. JDOHelper I18NHelper Persistence Manager Factory Instance Callbacks Persistence Manager Transaction Query Extent 6. InstanceCallbacks • Event trigger functions in DBMS • PersistenceCapable class that provides callback methods implements this interface • Methods • jdoPostLoad(), • jdoPreStore(), • jdoPreClear(), • jdoPreDelete()

12. How to use JDO • Write persistent object (Persistence Capable) • Write normal java objects • Specify their relation in a XML file • Enhance classes for persistence • Make transactions (Persistence Aware) • Create and connect to a datastore • Insert / update / delete • Query

13. Write PersistenceCapable objects .java Java Compiler .class Byte code enhancement JDO Enhancer JDO MetaData (XML) .class

14. Person Category * * Address book example • Persistent Object Model • Many to many relation

15. Classes to Persist • public class Person { Vector category; // element is Category … public Person() {} } • public class Category { Vector person; // element is Person … private Category() {} }

16. JDO MetaData <?xml version=“1.0” encoding=UTF-8?> <!doctype jdo public http://java.sun.com/dtd/jdo_1_0.dtd> <jdo> <package name=“addressBook”> <class name = “Person”> <field name= category> <collection element-type = “Category”> </field> </class> <class name = “Category”> <field name= person> <collection element-type = “Person”> </field> </class> </package> </jdo>

17. JDO Enhancer • Enhance classes to implement the interface PersistenceCapable • run Enhancer with JDO metadata (.xml file) and class files • $enhancer$ addressbook.jdo Person.class Category.class

18. JDO Runtime Environment JVM Application PersistenceManager Extent PersistenceCapable transient Query transient PersistenceCapable Transaction transient PersistenceCapable

19. Access PersistenceCapable objects • Code template • PersistenceManagerFactory pmf = JDOHelper. getPersistenceManagerFactory(properties); • PersistenceManager pm = pmf.getPersistenceManager(); • Transaction tx = pm.currentTransaction(); • tx.begin(); • execute(); // transaction code • tx.commit(); • pm.close();

20. Create a Datastore • JDO will create database, tables, indexes • Set property ConnectCreate = true • Unset this property if not creating a datastore • Do nothing on code • void execute() {}

21. Create persistence object • void execute(){ Person p = new Person(…); pm.makePersistent(p); // pm is a PersistenceManager }

22. Update persistence object • We need get persistent objects from datastore for update and delete • Assume we already got the object (Person p) from datastore. For update, it’s simple • void execute(){ p.setName (newName); }

23. Delete persistence object • Assume we get the object (Person p) from datastore, and we want to delete it • void execute(){ Vector cat = p.getCategory(); for ( i=0;i<cat.size(); i++) { Category c = (Category)cat.elementAt(i); c.getPerson().remove (p); } pm.deletePersistent(p); }

24. Get objects from datastore • Navigation • Query • From PersistenceManager • Object getObjectById(Object oid) • Object getTransactionalInstance(Object pco)

25. Navigate whole class • void execute(){ Extent ext = pm.getExtent(Person.class); Iterator itor = ext.iterator(); while (itor.hasNext()) { Person p = (Person) itor.next(); } }

26. Query with Filters • void execute(){ Query qry = pm.newQuery(Person.class); qry.setFilter(filters); // filter is a String qry.setOrdering(“name ascending; birth descending”); Collection result = (Collection) qry.execute(); for(Iterator i = result.iterator();i.hasNext();) Person p = (Person) i.next(); }

27. Query examples • Find the person named “Roger” • qry.setFilter (“name == \”Roger\”“); • Find the person by parameter (String who) • qry.declareParameters (“String who"); qry.setFilter (“name == who"); result = qry.execute (who)

28. JDO Query Language • JDO defines a set of functions for querying • isEmpty(): null singleton or collection or empty collection. • contains(): collection • startsWith(), endWith(): String matching • Find persons in “CS*” Category • qry.declareParameters (“Category cat"); qry.setFilter(“category.contains(cat) && cat.name.startWith(\”CS\”)”);

29. Inside JDO • PersistenceCapable • Object identity • Object life cycle • Data mapping • Inheritance • Collection • Other issues

30. Primary key of PersistenceCapable • In datastore • assigned by the datastore and is not based on field values in the object • In application • uses values of object state to form a unique identity • Nondurable • not uniquely identifiable

31. How to compare o1 and o2? • Java identity • implemented by JVM • o1 == o2 • Object equality • implemented by class developer • o1.equals (o2) • JDO identity • implemented by JDO vendor • o1.jdoGetObjectId().equals(o2.jdoGetObjectId())

32. Life Cycle of PersistenceCapable

33. Life Cycle States (1) • Persistent-new. • During the current transaction, the instance has been placed under the control of JDO and a JDO identity has been assigned. • Persistent-clean. • The instance’s fields have been read but not modified in the current transaction. • Persistent-dirty. • The instance’s fields have been modified in the current transaction.

34. Life Cycle States (2) • Hollow. • Only the JDO identity is loaded. Non-key fields are reread from the datastore in subsequent transactions. • Provides uniqueness of persistent instances across transactions. • Hollow objects are subject to garbage collection if the application does not hold strong references to them. • Persistent-clean, persistent-dirty and persistent-new instances all become hollow after commit.

35. Life Cycle States (3) • Persistent-deleted. • Deleted in the current transaction. Access to non-key fields will throw a JDOUserException. • Persistent-new-deleted. • Made persistent-new and then deleted in the current transaction. • Transient, Transient-clean, Transient-dirty • The instance has not been placed under the control of JDO.

36. Data Mapping • Issues • Database normalization: multi-table per class… • Performance: number of joins, update… • Field mapping: data types, read only… • Relation: delete policy… • Implementation dependence • Some implementations can configure data mapping in JDO meta file

37. Data Mapping • Inheritance • Map all hierarchy to base class • Discriminator is required • Collection • Collection objects are second order object • Not have a JDO identity • Its owner can aware of its change • Difference among Set, List and Map

38. Other issues • Object instantiation during query execution • Invocation of object methods • Persistence by reachability • Garbage collector in database • JDOQL to SQL compilation • Allowing SQL in JDOQL • Cache management • Search caches for uncommitted objects • More …

39. Some JDO Implementations • Free • Sun Reference Implementation • Object Relational Bridge (OJB) • Commercial • Fast Objects • Frontier Suit for JDO (Object Frontier) • JDO Genie • LIBeLIS LiDO • SolarMetric Kodo JDO

40. Next version ? • Managed relationship support • Inter-PersistenceManager references • JDOQL to support projections • API for specification of pre-read policy • Enhancer invocation API • Read-only fields • Generation of sequence numbers for fields. • Aggregation functions for JDOQL

41. Summery

42. References • http://access1.sun.com/jdo/ • http://www.JDOcentral.com/index.html • http://www.oreilly.com/catalog/jvadtaobj/chapter/ch01.pdf • http://www.cognitivemachines.com/JDOchat.html • http://java.sun.com/products/jdo/ • http://db.apache.org/ojb/ • http://servlet.java.sun.com/javaone/javaone2000