hibernate => Hibernate Entity Relationships mit Anmerkungen

Parameter

Anmerkung	Einzelheiten
`@OneToOne`	Gibt eine Eins-zu-Eins-Beziehung zu einem entsprechenden Objekt an.
`@OneToMany`	Gibt ein einzelnes Objekt an, das vielen Objekten zugeordnet ist.
`@ManyToOne`	Gibt eine Auflistung von Objekten an, die einem einzelnen Objekt zugeordnet sind.
`@Entity`	Gibt ein Objekt an, das einer Datenbanktabelle zugeordnet ist.
`@Table`	Gibt an, welche Datenbanktabelle dieses Objekt ebenfalls abbildet.
`@JoinColumn`	Gibt an, in welcher Spalte ein Vorderschlüssel gespeichert ist.
`@JoinTable`	Gibt eine Zwischentabelle an, in der Fremdschlüssel gespeichert werden.

Bidirektional viele bis viele mit vom Benutzer verwaltetem Join-Tabellenobjekt

@Entity
@Table(name="FOO")
public class Foo {
    private UUID fooId;
    
    @OneToMany(mappedBy = "bar")
    private List<FooBar> bars;
}

@Entity
@Table(name="BAR")
public class Bar {
    private UUID barId;
    
    @OneToMany(mappedBy = "foo")
    private List<FooBar> foos;
}

@Entity
@Table(name="FOO_BAR")
public class FooBar {
    private UUID fooBarId;

    @ManyToOne
    @JoinColumn(name = "fooId")
    private Foo foo;

    @ManyToOne
    @JoinColumn(name = "barId")
    private Bar bar;

    //You can store other objects/fields on this table here.
}

Gibt eine bidirektionale Beziehung zwischen vielen Foo Objekten und vielen Bar Objekten an, wobei eine vom Benutzer verwaltete Zwischenverbindungstabelle verwendet wird.

Die Foo Objekte werden als Zeilen in einer Tabelle namens FOO gespeichert. Die Bar Objekte werden als Zeilen in einer Tabelle namens BAR gespeichert. Die Beziehungen zwischen Foo und Bar Objekten werden in einer Tabelle mit dem Namen FOO_BAR gespeichert. Es gibt ein FooBar Objekt als Teil der Anwendung.

Wird häufig verwendet, wenn Sie zusätzliche Informationen zum Join-Objekt speichern möchten, z. B. das Datum, an dem die Beziehung erstellt wurde.

Bidirektional viele bis viele mit verwalteter Hibernate-Join-Tabelle

@Entity
@Table(name="FOO")
public class Foo {
    private UUID fooId;
    
    @OneToMany
    @JoinTable(name="FOO_BAR",
        joinColumns = @JoinColumn(name="fooId"),
        inverseJoinColumns = @JoinColumn(name="barId"))
    private List<Bar> bars;
}

@Entity
@Table(name="BAR")
public class Bar {
    private UUID barId;
    
    @OneToMany
    @JoinTable(name="FOO_BAR",
        joinColumns = @JoinColumn(name="barId"),
        inverseJoinColumns = @JoinColumn(name="fooId"))
    private List<Foo> foos;
}

Gibt eine Beziehung zwischen vielen Foo Objekten zu vielen Bar Objekten mithilfe einer zwischengeschalteten Verknüpfungstabelle an, die Hibernate verwaltet.

Die Foo Objekte werden als Zeilen in einer Tabelle namens FOO gespeichert. Die Bar Objekte werden als Zeilen in einer Tabelle namens BAR gespeichert. Die Beziehungen zwischen Foo und Bar Objekten werden in einer Tabelle mit dem Namen FOO_BAR gespeichert. Dies impliziert jedoch, dass es kein FooBar Objekt als Teil der Anwendung gibt.

Bidirektionale Eins-zu-Viele-Beziehung unter Verwendung der Fremdschlüsselzuordnung

@Entity
@Table(name="FOO") 
public class Foo {
    private UUID fooId;
    
    @OneToMany(mappedBy = "bar")
    private List<Bar> bars;
}

@Entity
@Table(name="BAR")
public class Bar {
    private UUID barId;
    
    @ManyToOne
    @JoinColumn(name = "fooId")
    private Foo foo;
}

Gibt eine bidirektionale Beziehung zwischen einem Foo Objekt und vielen Bar Objekten mithilfe eines Fremdschlüssels an.

Die Foo Objekte werden als Zeilen in einer Tabelle namens FOO gespeichert. Die Bar Objekte werden als Zeilen in einer Tabelle namens BAR gespeichert. Der Fremdschlüssel wird in der BAR Tabelle in einer Spalte mit der Bezeichnung fooId .

Bidirektionale Eins-zu-Eins-Beziehung, verwaltet von Foo.class

@Entity
@Table(name="FOO")    
public class Foo {
    private UUID fooId;
    
    @OneToOne(cascade = CascadeType.ALL)
    @JoinColumn(name = "barId")
    private Bar bar;
}

@Entity
@Table(name="BAR")
public class Bar {
    private UUID barId;
    
    @OneToOne(mappedBy = "bar")
    private Foo foo;
}

Gibt eine bidirektionale Beziehung zwischen einem Foo Objekt und einem Bar Objekt mithilfe eines Fremdschlüssels an.

Die Foo Objekte werden als Zeilen in einer Tabelle namens FOO gespeichert. Die Bar Objekte werden als Zeilen in einer Tabelle namens BAR gespeichert. Der Fremdschlüssel wird in der FOO Tabelle in einer Spalte mit der Bezeichnung barId .

Beachten Sie, dass der Wert für mappedBy der Feldname im Objekt ist, nicht der Spaltenname.

Unidirektionale Eins-zu-Viele-Beziehung unter Verwendung der vom Benutzer verwalteten Join-Tabelle

@Entity
@Table(name="FOO")
public class Foo {
    private UUID fooId;
    
    @OneToMany
    @JoinTable(name="FOO_BAR",
        joinColumns = @JoinColumn(name="fooId"),
        inverseJoinColumns = @JoinColumn(name="barId", unique=true))
    private List<Bar> bars;
}

@Entity
@Table(name="BAR")
public class Bar {
    private UUID barId;

    //No Mapping specified here.
}

@Entity
@Table(name="FOO_BAR")
public class FooBar {
    private UUID fooBarId;

    @ManyToOne
    @JoinColumn(name = "fooId")
    private Foo foo;

    @ManyToOne
    @JoinColumn(name = "barId", unique = true)
    private Bar bar;

    //You can store other objects/fields on this table here.
}

Gibt eine unidirektionale Beziehung zwischen einem Foo Objekt und vielen Bar Objekten mithilfe einer vom Benutzer verwalteten Zwischenverknüpfungstabelle an.

Dies ähnelt einer ManyToMany Beziehung. Wenn Sie dem Ziel-Fremdschlüssel jedoch eine unique Einschränkung hinzufügen, können Sie erzwingen, dass es sich um OneToMany .

Beachten Sie, dass es keine Zuordnung von Bar Objekten zu Foo Objekten gibt. Bar können frei bearbeitet werden, ohne die Foo Objekte zu beeinflussen.

Wird in Spring Security häufig verwendet, wenn Sie ein User einrichten, das über eine Liste von Role , die von ihm ausgeführt werden können. Sie können einem Benutzer Rollen hinzufügen und entfernen, ohne sich um das Löschen von Role zu kümmern.

Unidirektionale Eins-zu-Eins-Beziehung

@Entity
@Table(name="FOO")
public class Foo {
    private UUID fooId;
    
    @OneToOne
    private Bar bar;
}

@Entity
@Table(name="BAR")
public class Bar {
    private UUID barId;
    //No corresponding mapping to Foo.class
}

Gibt eine unidirektionale Beziehung zwischen einem Foo Objekt und einem Bar Objekt an.

Die Foo Objekte werden als Zeilen in einer Tabelle namens FOO gespeichert. Die Bar Objekte werden als Zeilen in einer Tabelle namens BAR gespeichert.

Beachten Sie, dass es keine Zuordnung von Bar Objekten zu Foo Objekten gibt. Bar können frei bearbeitet werden, ohne die Foo Objekte zu beeinflussen.

Modified text is an extract of the original Stack Overflow Documentation

Lizenziert unter CC BY-SA 3.0

Nicht angeschlossen an Stack Overflow

hibernate
Hibernate Entity Relationships mit Anmerkungen

Suche…