Autorenarchiv

Wann sind Entitäten gleich?

Dies ist eine Frage, die einen regelmäßig in Diskussionen mit anderen Entwicklern verfallen lässt. Es gibt hier zwei Theorien, wann eine Entität gleich ist:

• Gleichheit der primären Schlüssel der Entitäten
• Gleichheit aller Attribute der Entitäten

Das Verständnis von relationalen Datenbanken und Entitäten lässt aber den zweiten Ansatz sinnlos erscheinen: Dort ist eindeutig geregelt, das zwei Entitäten gleich sind, wenn ihre Primärschlüssel gleich sind. Alles andere würde die Auffindbarkeit von Einträgen in der Datenbank unmöglich machen.

Unter dieser Prämisse verfolgen wir also den ersten Ansatz!

Vergleich in Java

Der Vergleich in Java ist einfach zu bewerkstelligen und erfolgt durch das Überschreiben der equals()-Methode. Wichtig hierbei ist auch daran zu denken, die hashCode()-Methode zu überschreiben. Dies wird von der Java-Dokumentation gefordert und kann ansonsten leicht zu Problemen führen (sogenannter equals()-Contract).

Wichtig bei einer sauberen Implementierung ist auch der Vergleich von nicht gespeicherten mit gespeicherten Objekten, da nicht gespeicherte Objekte noch keine ID haben.
Dies ist im Zusammenhang mit Hibernate wichtig, da hier Relationen normalerweise mit java.util.Set abgebildet werden.
Würde man lediglich einen Vergleich über den Primärschlüssel machen, wäre es nicht möglich zwei neue Entitäten einer solchen Relation hinzuzufügen bevor man speichert, da das Set kein Objekt doppelt beinhalten kann und dies über die equals()-Methode prüft.

Leider gibt es zu diesem Thema auch seitens Hibernate keinen eindeutigen Tipp, der mich zufrieden stellen konnte.

Lösung

Aus den oben geführten Überlegungen und Recherchen, ergibt sich die folgende Implementierung der Methoden hashCode() und equals().

Implementierung der hashCode-Methode:

public int hashCode() {
   if (getId() != null) {
      return getId().hashCode();
   } else {
      return System.identityHashCode(this);
   }
}

Implementierung der equals-Methode:

public boolean equals(Object obj) {
   boolean isEqual = false;
   if (obj == null) {
      isEqual = false;
   } else if (this == obj) {
      isEqual = true;
   } else if (!this.getClass().equals(obj.getClass())) {
      isEqual = false;
   } else {
     VO castObj = (VO) obj;
 
      EqualsBuilder builder = new EqualsBuilder();
      builder.append(
         this.getId() != null 
            ? this.getId() 
            : "sid_"+ System.identityHashCode(this),
         castObj.getId() != null 
            ? castObj.getId() 
            : "sid_"+ System.identityHashCode(castObj));
      isEqual = builder.isEquals();
   }
 
   return isEqual;
}

(Für den Vergleich wird hier der EqualsBuilder aus dem Projekt commons lang von Apache verwendet.)

Das Prinzip hier ist denkbar einfach: Für den Fall, dass eine Entität keinen Primärschlüssel hat, wird einfach ein “künstlicher Primärschlüssel” mit dem ursprünglichen Hash des Objektes selbst gebildet.
Ein Blick in der Java-API auf System.identityHashCode() erleichtert das Verständnis.