Transcript Che-Rung Lee`s talk on JDO

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 API
An example
Datastore mapping
JDO implementation
JDO API
 Two classes
 I18NHelper
 JDOHelper
JDOHelper
I18NHelper
 Six interfaces
1.
2.
3.
4.
5.
6.
PersistenceManagerFactory
PersistenceManager
Instance
Transaction
Callbacks
Extent
Query
InstanceCallbacks Transaction
Persistence
Manager
Factory
Persistence
Manager
Query
Extent
1. PersistenceManagerFactory
Create PersistenceManager
May implement PersistenceManager
pooling, connection pooling among
PersistenceManagers
I18NHelper
JDOHelper
Persistence
Manager
Factory
Datastore configuration
Supports JNDI
Instance
Callbacks
Transaction
Persistence
Manager
Query
Extent
2. PersistenceManager
Primary application interface
PersistenceCapable instance management
identity
life cycle
Transaction factory
Query factory
JDOHelper
I18NHelper
Persistence
Manager Factory
Instance
Callbacks
Persistence
Manager
Extent factory
Transaction
Query
Extent
3. Transactions
One-one relation to Persistence Manager
Transaction interface for local transactions
isActive, begin,
commit, rollback
Persistence
Manager Factory
Provide ACID transaction
Atomic, Consistent,
Isolated, Durable
JDOHelper
I18NHelper
Instance
Callbacks
Transaction
Persistence
Manager
Query
Extent
4. Extents
Defined for PersistenceCapable classes
pm.getExtent (Class pc, boolean subclasses);
Used in Query and
class navigation
JDOHelper
I18NHelper
Persistence
Manager Factory
Instance
Callbacks
Transaction
Persistence
Manager
Query
Extent
5. Query
Can do filtering and ordering
Outer/inner join
Has JDOQL
JDOHelper
I18NHelper
Persistence
Manager Factory
Instance
Callbacks
Transaction
Persistence
Manager
Query
Extent
6. InstanceCallbacks
Event trigger functions in DBMS
PersistenceCapable class that provides
callback methods implements this interface
JDOHelper
I18NHelper
Methods
jdoPostLoad(),
jdoPreStore(),
jdoPreClear(),
jdoPreDelete()
Persistence
Manager Factory
Instance
Callbacks
Transaction
Persistence
Manager
Query
Extent
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
Write PersistenceCapable objects
.java
Java
Compiler
.class
Byte code enhancement
JDO
Enhancer
.class
JDO MetaData
(XML)
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
Category.class
JDO Runtime Environment
JVM
Application
transient
transient
transient
PersistenceManager
PersistenceCapable
Extent
Query
PersistenceCapable
Transaction
PersistenceCapable
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();
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 persistentnew 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/
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