hrm, equals and hashcode you say. Well, techically all of my entity objects i'm working with extend an abstract class that implements a PersistentObject interface that look like this. So I do have an overridden equals and hashcode methods but they don't use anything external to an object to determine equality.
/**
* <p>
* An <code>AbstractPersistentObject</code> is an abstract PersistentObject having id and version
* properties used during persistence to storage and that is Serializable so the id and version
* information isn't lost for concrete subclasses when they are serialized, as in RMI calls etc. The
* #equals() and #hashCode() methods have been overridden to enforce object identity to be
* defined as the object id and nothing else. Object ids are set during object creation to avoid
* objects with null ids which would evaluate to be the same object. This results in ids always being
* available and having the same meaning in java, in hibernate, and in the database. Determining
* whether or not an object has been persisted should be done with the version property which is
* also used for optimistic locking. Property change support is provided to allow easy firing of
* events on property changes. PropertyChangeEvents will be fired on changes to id and version.
* </p>
* <p>
* WARNING: Generally the id of a persistent object should NOT be changed at any time during its
* lifecycle. As #equals() and #hashCode() are now dependent on id, if the id is changed while an
* AbstractPersistentObject is in a java collection it WILL BE LOST as collections depend on these
* methods to return invariant results. Also note that AbstractPersistentObjects with null ids will be
* identified as the equal and as the same object via the #hashCode(), which may also have
* impacts when working with collections. Unless you REALLY know what you are doing, it is
* recommended that id values remain invariant. Accessor methods are provided to allow the
* Hibernate framework to set proper ids when marshalling objects from persistent storage.
* </p>
*
* @author aarmistead
*/
public abstract class AbstractPersistentObject implements PersistentObject<UUID>, Serializable {
/**
* The id for this persistent object. This is set as soon as possible to avoid null ids
* which evaluate as equal.
*/
private UUID id = UUIDFactory.getInstance().createId();
/**
* The version of this object. Used to during optimistic locking and to determine
* if the object has been persisted or not. This value will be null if the object has
* never been persisted.
*/
private Integer version;
/**
* The property change support for this persistent object. This is set in place to avoid
* having to call a superclass constructor and is protected to allow access from
* concrete implementation classes.
*/
private PropertyChangeSupport changeSupport = new PropertyChangeSupport(this);
/**
* @inheritDoc
*/
@Override
public byte[] getByteId() {
return UUIDFactory.getInstance().toByteArray(id);
}
/**
* @inheritDoc
*/
@Override
public void setByteId(byte[] array) {
UUID oldId = this.id;
id = UUIDFactory.getInstance().fromByteArray(array);
changeSupport.firePropertyChange("id", oldId, id);
}
/**
* @inheritDoc
*/
@Override
public UUID getId() {
return id;
}
/**
* @inheritDoc
*/
@Override
public void setId(UUID id) {
UUID oldID = this.id;
this.id = id;
changeSupport.firePropertyChange("id", oldID, id);
}
/**
* @inheritDoc
*/
@Override
public String getStringId() {
return UUIDFactory.getInstance().toString(id);
}
/**
* @inheritDoc
*/
@Override
public void setStringId(String string) {
UUID oldId = this.id;
id = UUIDFactory.getInstance().fromString(string);
changeSupport.firePropertyChange("id", oldId, id);
}
/**
* @inheritDoc
*/
@Override
public Integer getVersion() {
return version;
}
/**
* @inheritDoc
*/
@Override
public void setVersion(Integer version) {
Integer oldVersion = this.version;
this.version = version;
changeSupport.firePropertyChange("version", oldVersion, version);
}
/**
* Adds the specified property change <code>listener</code> to the listener
* list. The listener is registered for all properties. The same listener object
* may be added more than once, and will be called as many times as it is
* added. If the listener is null, no exception is thrown and no action is taken.
*
* @param listener The PropertyChangeListener to be added.
*/
public void addPropertyChangeListener(PropertyChangeListener listener) {
changeSupport.addPropertyChangeListener(listener);
}
/**
* Adds the specified property change <code>listener</code> for the
* specified <code>propertyName</code>. The listener will be invoked
* only when a call on firePropertyChange names that specific property.
* The same listener object may be added more than once. For each
* property, the listener will be invoked the number of times it was added
* for that property. If propertyName or listener is null, no exception is
* thrown and no action is taken.
*
* @param propertyName The name of the property to listen to.
* @param listener The PropertyChangeListener to be added.
*/
public void addPropertyChangeListener(String propertyName, PropertyChangeListener listener) {
changeSupport.addPropertyChangeListener(propertyName, listener);
}
/**
* Remove the specified property change <code>listener</code> from the
* listener list. This removes a PropertyChangeListener that was registered
* for all properties. If listener was added more than once to the same event
* source, it will be notified one less time after being removed. If listener is
* null, or was never added, no exception is thrown and no action is taken.
*
* @param listener The PropertyChangeListener to be removed.
*/
public void removePropertyChangeListener(PropertyChangeListener listener) {
changeSupport.removePropertyChangeListener(listener);
}
/**
* Remove the specified property change <code>listener</code> for the specified
* <code>propertyName</code>. If listener was added more than once to the
* same event source for the specified property, it will be notified one less time
* after being removed. If propertyName is null, no exception is thrown and no
* action is taken. If listener is null, or was never added for the specified property,
* no exception is thrown and no action is taken.
*
* @param propertyName The name of the property that was listened to.
* @param listener The PropertyChangeListener to be removed.
*/
public void removePropertyChangeListener(String propertyName, PropertyChangeListener listener) {
changeSupport.removePropertyChangeListener(propertyName, listener);
}
/**
* Indicates whether the specified <code>object</code> is "equal to" this one.
* If both objects are non-null PersistentObjects their id's are compared for equality,
* otherwise they are not equal. If this object is compared to itself this returns true.
* If this objects id is null this returns false. This is intended to enforce object equality
* to be defined as the object id only, and as such this method is final.
*
* @param object The object with which to compare.
* @return True if this object is the same as the specified object; false otherwise.
*/
@Override
final public boolean equals(Object object) {
if(this == object) {
return true;
}
// If the object is null or not a PersistentObject return false.
// instanceof will return false if object is null.
if(!(object instanceof PersistentObject)) {
return false;
}
// If the id is missing, return false.
if(id == null) {
return false;
}
// Compare ids
return id.equals(((PersistentObject)object).getId());
}
/**
* Fire an existing PropertyChangeEvent to any registered listeners. No event is fired if the
* given event's old and new values are equal and non-null.
*
* @param e The property change event.
*/
public void firePropertyChange(PropertyChangeEvent e) {
changeSupport.firePropertyChange(e);
}
/**
* Report a boolean bound property update to any registered listeners. No event is fired if
* old and new are equal. This is merely a convenience wrapper around the more general
* firePropertyChange method that takes Object values.
*
* @param propertyName The name of the property that was changed.
* @param oldValue The old value of the property.
* @param newValue The new value of the property.
*/
public void firePropertyChange(String propertyName, boolean oldValue, boolean newValue) {
changeSupport.firePropertyChange(propertyName, oldValue, newValue);
}
/**
* Report an int bound property update to any registered listeners. No event is fired if old
* and new are equal. This is merely a convenience wrapper around the more general
* firePropertyChange method that takes Object values.
*
* @param propertyName The name of the property that was changed.
* @param oldValue The old value of the property.
* @param newValue The new value of the property.
*/
public void firePropertyChange(String propertyName, int oldValue, int newValue) {
changeSupport.firePropertyChange(propertyName, oldValue, newValue);
}
/**
* Report a bound property update to any registered listeners. No event is fired if old and
* new are equal and non-null. This is merely a convenience wrapper around the more
* general firePropertyChange method that takes PropertyChangeEvent value.
*
* @param propertyName The name of the property that was changed.
* @param oldValue The old value of the property.
* @param newValue The new value of the property.
*/
public void firePropertyChange(String propertyName, Object oldValue, Object newValue) {
changeSupport.firePropertyChange(propertyName, oldValue, newValue);
}
/**
* Gets the hash code of the id for this persistent object, unless its id is null, then get the
* original hash code. This is intended to enforce object identity to be defined as the
* object id only, and as such this method is final.
*
* @return The hash code of the id if it is not null, otherwise the original hash code.
*/
@Override
final public int hashCode() {
return id == null ? super.hashCode() : id.hashCode();
}
/**
* @inheritDoc
*/
@Override
public String toString() {
return this.getClass().getName() + "[id=" + id + "]";
}
}
The comment in the AbstractPersistentObject class describes why I have set up the equals and hashcode methods the way they are. If you want more about why/how that works, I got the idea from here:
I don't see how this would be causing my problem, but I certainly won't deny that it could be. Do you still think this is related?
Login
FAQ
Search
