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. JDO API Two classes  I18NHelper  JDOHelper Six interfaces 1.PersistenceManagerFactory 2.PersistenceManager 3.Transaction 4.Extent 5.Query 6.InstanceCallbacks Persistence Manager Factory Persistence Manager TransactionQueryExtent Instance Callbacks JDOHelper I18NHelper

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

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

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

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

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

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

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

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

14. Address book example Persistent Object Model  Many to many relation PersonCategory *

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 http://java.sun.com/dtd/jdo_1_0.dtd

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 PersistenceCapable transient PersistenceCapable Query Transaction Extent

19. Access PersistenceCapable objects Code template 1.PersistenceManagerFactory pmf = JDOHelper. getPersistenceManagerFactory(properties); 2.PersistenceManager pm = pmf.getPersistenceManager(); 3.Transaction tx = pm.currentTransaction(); 4.tx.begin(); 5.execute(); // transaction code 6.tx.commit(); 7.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.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