This chapter is from the book
This chapter is from the book
This chapter is from the book
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.