View
239
Download
1
Tags:
Embed Size (px)
Citation preview
Java Data Object
Che-Rung Lee
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
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
JDO Introduction
JDO APIAn exampleDatastore mappingJDO implementation
JDO API
Two classes I18NHelper JDOHelper
Six interfaces1. PersistenceManagerFactory2. PersistenceManager3. Transaction4. Extent5. Query6. InstanceCallbacks
Persistence Manager Factory
Persistence Manager
Transaction Query Extent
InstanceCallbacks
JDOHelperI18NHelper
1. PersistenceManagerFactory
Create PersistenceManager May implement PersistenceManager
pooling, connection pooling among PersistenceManagers
Datastore configuration Supports JNDI
Persistence Manager Factory
Persistence Manager
Transaction Query Extent
InstanceCallbacks
JDOHelperI18NHelper
2. PersistenceManager
Primary application interface
PersistenceCapable instance management identity life cycle
Transaction factory
Query factory
Extent factory
Persistence Manager Factory
Persistence Manager
Transaction Query Extent
InstanceCallbacks
JDOHelperI18NHelper
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
Transaction Query Extent
InstanceCallbacks
JDOHelperI18NHelper
4. Extents
Defined for PersistenceCapable classes pm.getExtent (Class pc, boolean subclasses);
Used in Query andclass navigation Persistence
Manager Factory
Persistence Manager
Transaction Query Extent
InstanceCallbacks
JDOHelperI18NHelper
5. Query
Can do filtering and ordering
Outer/inner join
Has JDOQL
Persistence Manager Factory
Persistence Manager
Transaction Query Extent
InstanceCallbacks
JDOHelperI18NHelper
6. InstanceCallbacks
Event trigger functions in DBMSPersistenceCapable class that provides
callback methods implements this interfaceMethods
jdoPostLoad(), jdoPreStore(), jdoPreClear(), jdoPreDelete()
Persistence Manager Factory
Persistence Manager
Transaction Query Extent
InstanceCallbacks
JDOHelperI18NHelper
How to use JDO
Write persistent object (Persistence Capable)1. Write normal java objects2. Specify their relation in a XML file3. Enhance classes for persistence
Make transactions (Persistence Aware) Create and connect to a datastore Insert / update / delete Query
Write PersistenceCapable objects
.java
.class
.class
Java Compiler
JDOEnhancer
JDO MetaData(XML)
Byte code enhancement
Address book example
Persistent Object Model Many to many relation
Person Category* *
Classes to Persist
public class Person { Vector category; // element is Category
…public Person() {}
} public class Category { Vector person; // element is Person
…private Category() {}
}
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>
JDO Enhancer
Enhance classes to implement the interface PersistenceCapable
run Enhancer with JDO metadata (.xml file) and class files $enhancer$ addressbook.jdo Person.class Cate
gory.class
JDO Runtime Environment
JVMApplication
PersistenceManager
PersistenceCapable
transient
transient
transientPersistenceCapable
PersistenceCapable
Query
Transaction
Extent
Access PersistenceCapable objects
Code template1. PersistenceManagerFactory pmf = JDOHelper.
getPersistenceManagerFactory(properties);2. PersistenceManager pm =
pmf.getPersistenceManager();3. Transaction tx = pm.currentTransaction();4. tx.begin();5. execute(); // transaction code6. tx.commit();7. pm.close();
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() {}
Create persistence object
void execute(){
Person p = new Person(…);
pm.makePersistent(p);
// pm is a PersistenceManager
}
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);
}
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);
}
Get objects from datastore
Navigation
Query
From PersistenceManager Object getObjectById(Object oid) Object getTransactionalInstance(Object pco)
Navigate whole class
void execute(){
Extent ext = pm.getExtent(Person.class);
Iterator itor = ext.iterator();
while (itor.hasNext()) {
Person p = (Person) itor.next();
}
}
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();
}
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)
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\”)”);
Inside JDO
PersistenceCapable Object identity Object life cycle
Data mapping Inheritance Collection
Other issues
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
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())
Life Cycle of PersistenceCapable
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.
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.
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.
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
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
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 …
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
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
Summery
References
http://access1.sun.com/jdo/ http://www.JDOcentral.com/index.html http://www.oreilly.com/catalog/jvadtaobj/chapter/c
h01.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