jdo
DESCRIPTION
Introduction to a framework in Java used to persist object into some kind of store, e.g. database.TRANSCRIPT
JDO – Java Data Object
Björn Granvik, Jayway
Overview
An introduction to JDO• Goals, pros, cons
• Terms• Enhancement process• Classes & interfaces• Code• A comparison or two
What is JDO?
• “Write once, persist everywhere!”• Standard for Java object persistence
JDO Goals
• Java-centric view of persistent information• Transparent• Data store independence
– Relational, object, hierarchical, file ...
• Use in a range of implementations– Embedded, client/server, application server
JDO Terms
• JDO instance• JDO identity• Persistence Manager
• Persistence Capable• Transient vs. persistent instance• JDO enhancer• (Non)Managed
• JDOQL
(Non)managed
• Managed mode – application serverServer handles connections, pooling transactions, security etc
• Nonmanaged mode – 1 tier, 2 tier etcYou handle connections and so onCaching included, life cycle and persistence handled
Architecture OverviewNonmanaged JDO
Class enhancer
A life cycle
What’s in an interface?
• PersistenceManagerFactory• PersistenceManager• Transaction• Extent• Query• PersistenceCapable• InstanceCallbacks• JDOHelper• JDO Exception Classes...
PersistenceManagerFactory
• To get a persistence manager instance
PersistenceManager
• Primary interface for JDO-aware application components
• Provides:– Cache management– Extent Management– JDO Identity Management– Life cycle management– Query management
– Transaction management
Transaction
• Data store Transaction Management• Optimistic Transaction Management• In a non-managed environment, a local
transaction is associated with the PM
• In a managed environment, a user transaction or a local transaction is associated with the PM
Extent
• Logical view of all persistent instances of a given persistence-capable class
• Used to specify the candidate objects to a Query
• Later some code...
Query
• Goals– Query language neutrality– Optimization to specific query language– Accommodation of multi-tier architectures– Large result set support– Compiled query support
• Data store Transaction Management• Optimistic Transaction Management
PersistenceCapable
• JDO instances implement the PersistenceCapable interface– Provides the management view of user defined
persistence-capable classes– Persistent state of the object must be
represented entirely by the state of its Java fields prior to being loaded into the execution environment
– Depends on the persistence manager for services such as transaction and life cycle
InstanceCallbacks
• Persistence capable classes should implement this interface if they want instance callbacks– jdoPostLoad()– jdoPreStore()– jdoPreClear()– jdoPreDelete()
JDOHelper
• Utility classes for state inspection of persistence capable classes
Example: UML
Now some code ...brace yourselves :-)
Example: Fleetpublic class Fleet {
private List vehicles = new Vector();
public void addVehicle(Vehicle vehicle) {vehicles.add(vehicle);
}
public Iterator getVehicles() {return vehicles.iterator();
}
public String toString() {StringBuffer buffer = new StringBuffer("Fleet:\n");Iterator iter = getVehicles();while (iter.hasNext()) {
buffer.append("\t" + iter.next() + "\n");}return buffer.toString();
}
Example: Vehiclepublic class Vehicle {
private int numberOfWheels;
public Vehicle(int numberOfWheels) {
this.numberOfWheels = numberOfWheels;
}
public int getNumberOfWheels() {
return numberOfWheels;
}
}
Example: Bicyclepublic class Bicycle extends Vehicle {
private String model;
public Bicycle(String model) {
super(2);
this.model = model;
}
public String toString() {
return "Bike: Model " + model;
}
}
Example: MotorVehiclepublic class MotorVehicle extends Vehicle {
private Engine engine;
public MotorVehicle(int numberOfWheels, Engine engine) {
super(numberOfWheels);
this.engine = engine;
}
public String toString() {
return "MotorVehicle With " + getNumberOfWheels()
+ " Wheels. " + engine;
}
}
Example: Enginepublic class Engine {
private int numberOfCylinders;
public Engine(int numberOfCylinders) {this.numberOfCylinders = numberOfCylinders;
}
public int getNumberOfCylinders() {return numberOfCylinders;
}
public String toString() {return numberOfCylinders + " Cylinder Engine.";
}}
Example: package.jdo<?xml version="1.0"?><jdo>
<package name="com.jdodemo"><class name="Engine"/><class name="Vehicle"/><class name="Bicycle"
persistence-capable-superclass="Vehicle"/><class name="MotorVehicle"
persistence-capable-superclass="Vehicle"/><class name="Fleet">
<field name="vehicles"><collection element-type="Vehicle"/>
</field></class>
</package></jdo>
Example: Seed, set it up/* SeedDatabase.java */
import com.solarmetric.kodo.impl.jdbc.JDBCPersistenceManagerFactory;
public class SeedDatabase {
public static void main(String[] args) {
Fleet fleet = new Fleet();
fleet.addVehicle(new Bicycle("Schwinn"));
fleet.addVehicle(new Bicycle("Giant"));
fleet.addVehicle(new MotorVehicle(4, new Engine(8)));
fleet.addVehicle(new MotorVehicle(2, new Engine(4)));
fleet.addVehicle(new MotorVehicle(4, new Engine(4)));
...
Example: Seed, wrap it upPersistenceManager pm =
new JDBCPersistenceManagerFactory().getPersistenceManager();
// begin a transaction...
Transaction transaction = pm.currentTransaction();
transaction.begin();
// persist the fleet...
pm.makePersistent(fleet);
// commit the transaction...
transaction.commit();
// close the manager...
pm.close();
Example: List all...
public class ListAll {
...
Extent ext = manager.getExtent( Vehicle.class, true );
Query query = manager.newQuery( ext, "" );
Collection vehicles = (Collection)query.execute();
Iterator iterator = vehicles.iterator();
while (iterator.hasNext()) {
Vehicle vehicle = (Vehicle) iterator.next();
System.out.println("vehicle = " + vehicle);
}
...
Example: Result
c:> java ListAll
vehicle = Bike: Model Schwinn
vehicle = Bike: Model Giant
vehicle = MotorVehicle With 4 Wheels. 8 Cylinder Engine.
vehicle = MotorVehicle With 2 Wheels. 4 Cylinder Engine.
vehicle = MotorVehicle With 4 Wheels. 4 Cylinder Engine.
= Polymorphism
Example: List four cylinders...public class ListFourCylinderVehicles {
public static void main(String[] args) {...Extent ext = manager.getExtent(MotorVehicle.class, true);
// only retrieve vehicles with 4 cylinders...Query query = manager.newQuery( ext,
"engine.numberOfCylinders == 4");
Collection vehicles = (Collection) query.execute();Iterator iterator = vehicles.iterator();while (iterator.hasNext()) {
Vehicle vehicle = (Vehicle) iterator.next();System.out.println("vehicle = " + vehicle);
}...
JDOQL
What is JDOQL?
• ”Query language”• Not like SQL – more like Java.• Modeled after Java boolean expressions
Example: Result
c:> java ListFourCylinderVehicles
vehicle = MotorVehicle With 2 Wheels. 4 Cylinder Engine.
vehicle = MotorVehicle With 4 Wheels. 4 Cylinder Engine.
= No bicycles or 8 cylinder wheels
JDO vs. CMPJDO CMP
Remote behaviour
Managed relations
Method security/transaction
Encapsulation
Inheritence
Polymorphic references
Field access Abstract get/setCollection, Set
List, Array, Map OptionalOperating environment 1-tier, 2-tier, app.server
web- and app.serverMetadata Identify classes Identify classes,
defaults on field and fieldsrelationshipts and relationships
Trans synch callbacks
JDO vs. CMP cont’dQuery language:
JDOQL – modeled after Java boolean expressionsEJBQL – modeled after SQL
Required classes/interfacesJDO Persistent class
CMP EJBHome/EJBLocalHomeremote/local interfaceAbstract beans must implement EJBEntityBean
Required lifecycle methods JDO no-arg constructor
CMP setEntityContext, unsetEntityContext, ejbActivate, ejbPassivate, ejbLoad, ejbStore, ejbRemove
= ValueObject
JDO – preferred setup?
• JDO for persistence behind EJB session bean (façade)
• Split application server dependency for: – faster development– faster unit testing– more dynamic architecture (combine 2 tier with
application server setup)
• Separate database dependency for faster unit testing
JDO Pros
• Transparent persistence mechanism• Object oriented = Java friendly
• Multi solution architecture friendly• Dynamic• Fast development as compared to other tools• Portable across databases• Ease of use• High performance• Integration with EJB
JDO Cons
• Not “proven”, as in J2EE• Added features by vendors
JDO To Do list• Nested Transactions• Savepoint, Undosavepoint• Inter-PersistenceManager References• Enhancer Invocation API• Prefetch API• BLOB/CLOB datatype support• Managed (inverse) relationship support• Closing PersistenceManagerFactory at VM shutdown• Case-Insensitive Query• String conversion in Query• Read-only fields• Enumeration pattern• Non-static inner classes• Projections in query• LogWriter support
JDO - now and future
• Now - maintenance release JDO 1.0.1• Jboss
– Then:”JDO will probably go down in history as the proverbial chicken that crossed the road when the CMP2.0 truck came along”.
Marc Fleury, Why I Love EJBs
– Almost now: JDO for their CMP implementation– Now: Hibernate?
• Sun 2002 ”off”, 2003 ”on”• JDO 2.0 in the works
Resources: Links
• Sun JDO:java.sun.com/products/jdo
• JDO Community:www.jdocentral.com
• JSR 12:www.jcp.org/jsr/detail/12.jsp
Resources: BooksJava Data Objects
Free pdf www.ogilviepartners.com
Java Data Objects
Craig Russell JSR 12
Core Java Data Objects
Understanding and using Java Data Objects
JDO vendors
• Kodo JDO – SolarMetric• Fast Objects – Poet Software• LiDO – Lebelis
• OpenFusion - PrismTech • enJin – Versant• ObjectFrontier - ObjectFrontier
JDO Open Source ”Race”
Who will be first?• JORM• TJDO
2.0 - 11 November 2003http://tjdo.sourceforge.net/
• XORM• OJB
• JBossDO – Hibernate (will be JDO 2.0 compliant?)
Enhancer
”Add persistent ability” to your domain model.
Can use:
• Bytecode enhancer• Sourcecode enhancer• ”By hand” - not practical