3.11. Object Identity

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.