Core Java Data Objects

One of the key concepts defined in JDO is that of object identity, although in most cases a developer is not even aware that it exists. Every persistent object has a JDO object identity. This identity associates the in-memory Java object with its representation in the underlying datastore. JDO ensures that there is only one in-memory representation of a given persistent object for a given PersistenceManager . This is known as "uniquing." Uniquing ensures that no matter how many times a persistent object is found, it has only one in-memory representation. All references to the same persistent object within the scope of the same PersistenceManager instance reference the same in-memory object.

The following code snippet taken from UniquingExample.java shows uniquing at work. It creates a new Author instance, begins a new transaction, and finds the Author again using a query. The two references are then compared to validate that they both refer to the same in-memory object:

tx.begin(); Author author1 = new Author("Keiron McCammon"); pm.makePersistent(author1); tx.commit(); tx.begin(); Query query = pm.newQuery(Author.class, "name == \"Keiron McCammon\""); Collection result = (Collection) query.execute(); Author author2 = (Author) result.iterator().next(); tx.commit(); if (author1 == author2) System.out.println("There is only one object in memory");

The output would be as follows :

There is only one object in memory

However, because it is possible to create multiple PersistenceManager instances within a JVM, it is possible that a persistent object may have multiple in-memory representations at any given time ”at most, one per PersistenceManager . Each would have the same JDO object identity, but would be a different in-memory Java object. To determine whether two in-memory objects represent the same persistent object, their JDO object identities can be compared. The JDOHelper class provides a method to get the JDO object identity of an object:

static Object getObjectId(Object pc)

The returned object can be compared with another using the equals() method to determine whether two in-memory objects represent the same persistent object in the datastore.

The following code snippet taken from ObjectIdentityExample.java creates an Author using one PersistenceManager , and then using a different PersistenceManager , it finds the Author again. The two references are compared to validate that they refer to different in-memory objects. The JDO identities are then compared to validate that they do, however, represent the same persistent object:

tx1.begin(); Author author1 = new Author("Keiron McCammon"); pm1.makePersistent(author1); tx1.commit(); PersistenceManager pm2 = pmf.getPersistenceManager(); Transaction tx2 = pm2.currentTransaction(); tx2.begin(); Query query = pm2.newQuery(Author.class, "name==\"Keiron McCammon\""); Collection result = (Collection) query.execute(); Author author2 = (Author) result.iterator().next(); tx2.commit(); if (author1 != author2) System.out.println( "There are multiple objects in memory"); Object author1Id = JDOHelper.getObjectId(author1); Object author2Id = JDOHelper.getObjectId(author2); if (author1Id.equals(author2Id)) System.out.println("But they represent the same Author");

The output would be as follows:

There are multiple objects in memory But they represent the same Author

JDO actually defines three types of object identity for persistent objects: datastore identity, application identity, and non-durable identity.