Frage

Haben Sie eine gemeinsame Basisklasse für Hibernate Entitäten, das heißt ein MappedSuperclass mit id, Version und anderen gemeinsamen Eigenschaften? Gibt es irgendwelche Nachteile?

Beispiel:

@MappedSuperclass()
public class BaseEntity {

    private Long id;
    private Long version;
    ...

    @Id @GeneratedValue(strategy = GenerationType.AUTO)
    public Long getId() {return id;}

    public void setId(Long id) {this.id = id;}

    @Version
    public Long getVersion() {return version;}
    ...

    // Common properties
    @Temporal(TemporalType.TIMESTAMP)
    public Date creationDate() {return creationDate;}
    ...
}

@Entity
public class Customer extends BaseEntity {
    private String customerName;
    ...
}
War es hilfreich?

Lösung

Das funktioniert für uns in Ordnung. Neben der Identifikation und das Erstellungsdatum, haben wir auch ein geändertes Datum. Wir haben auch eine Zwischen TaggedBaseEntity , die implementiert eine markierbare Schnittstelle, weil einige unserer Web-Anwendung Entitäten haben Tags, wie Fragen auf Stack-Überlauf.

Andere Tipps

Die eine, die ich in erster Linie hashCode () zu implementieren ist und gleich (). Ich habe auch eine Methode, um ziemlich an das Unternehmen zu drucken. Als Antwort oben zu DR, können die meisten dieser außer Kraft gesetzt werden, aber in meiner Implementierung werden Sie mit einer ID vom Typ Lange fest.

public abstract class BaseEntity implements Serializable {

    public abstract Long getId();
    public abstract void setId(Long id);

    /**
     * @see java.lang.Object#hashCode()
     */
    @Override
    public int hashCode() {
        final int prime = 31;
        int result = 1;
        result = prime * result + ((getId() == null) ? 0 : getId().hashCode());
        return result;
    }

    /**
     * @see java.lang.Object#equals(Object)
     */
    @Override
    public boolean equals(Object obj) {
        if (this == obj)
            return true;
        if (obj == null)
            return false;
        if (getClass() != obj.getClass())
            return false;
        BaseEntity other = (BaseEntity) obj;
        if (getId() == null) {
            if (other.getId() != null)
                return false;
        } else if (!getId().equals(other.getId()))
            return false;
        return true;
    }

    /**
     * @see java.lang.Object#toString()
     */
    @Override
    public String toString() {
        return new StringBuilder(getClass().getSimpleName()).append(":").append(getId()).toString();
    }

    /**
     * Prints complete information by calling all public getters on the entity.
     */
    public String print() {

        final String EQUALS = "=";
        final String DELIMITER = ", ";
        final String ENTITY_FORMAT = "(id={0})";

        StringBuffer sb = new StringBuffer("{");

        PropertyDescriptor[] properties = PropertyUtils.getPropertyDescriptors(this);
        PropertyDescriptor property = null;
        int i = 0;
        while ( i < properties.length) {

            property = properties[i];
            sb.append(property.getName());
            sb.append(EQUALS);

            try {
                Object value = PropertyUtils.getProperty(this, property.getName());
                if (value instanceof BaseEntity) {
                    BaseEntity entityValue = (BaseEntity) value;
                    String objectValueString = MessageFormat.format(ENTITY_FORMAT, entityValue.getId());
                    sb.append(objectValueString);
                } else {
                    sb.append(value);
                }
            } catch (IllegalAccessException e) {
                // do nothing
            } catch (InvocationTargetException e) {
                // do nothing
            } catch (NoSuchMethodException e) {
                // do nothing
            }

            i++;
            if (i < properties.length) {
                sb.append(DELIMITER);
            }
        }

        sb.append("}");

        return sb.toString();
    }
}

würde ich nicht zögern, eine gemeinsame Basisklasse zu verwenden, nach allem, was der Punkt von O / R-Mapping ist.

Ich benutze gemeinsame Basisklassen auch, aber nur, wenn die Entitäten einige gemeinsame Eigenschaften zumindest teilen. Ich werde es nicht benutzen, wenn die ID der einzige gemeinsame Eigenschaft ist. Bis jetzt habe ich keine Probleme.

Es funktioniert gut für mich auch.

Beachten Sie, dass auch in dieser Entität einig Event-Listener / Abfangjäger wie Hibernate Envers einem oder jede kundenspezifische eines nach Ihrem Bedarf hinzufügen, so dass Sie: Verfolgen Sie alle Änderungen - - wissen, welche Benutzer aus der letzten Änderung - Update automatisch die letzte Änderung - Stellen Sie automatisch das erste Einführungsdatum Und ther Sachen ...

Lizenziert unter: CC-BY-SA mit Zuschreibung
Nicht verbunden mit StackOverflow
scroll top