Wie definieren Sie Beziehungen zwischen Entitäten in Hibernate 4 und Spring mithilfe von Anmerkungen?

Verwenden von Anmerkungen zum Definieren von Beziehungen in Hibernate 4 und Spring

Unidirektionale Eins-zu-Eins-Beziehung

Um eine unidirektionale Beziehung zu erstellen -zu-eins-Beziehung verwenden Sie die Annotation @OneToOne für die besitzende Klasse. Konfigurieren Sie die Annotation @JoinColumn, um den Namen der Spalte anzugeben, die den Fremdschlüssel in der Tabelle der abhängigen Klasse enthält.

Beispiel:

<code class="java">public class Foo {
    private Long fooId;

    @OneToOne
    private Bar bar;
}

public class Bar {
    private Long barId;
    // No corresponding mapping to Foo.class
}</code>

Bidirektionale Eins-zu- Eine Beziehung

Für eine bidirektionale Eins-zu-Eins-Beziehung annotieren Sie beide Klassen mit @OneToOne. Verwenden Sie die Annotation @JoinColumn für die besitzende Klasse, um den Namen der Fremdschlüsselspalte anzugeben. Verwenden Sie in der abhängigen Klasse die Annotation @JoinColumn, um den Fremdschlüssel wieder der besitzenden Klasse zuzuordnen.

Beispiel:

<code class="java">public class Foo {
    private Long fooId;

    @OneToOne(cascade = CascadeType.ALL)
    @JoinColumn(name = "barId")
    private Bar bar;
}

public class Bar {
    private Long barId;

    @OneToOne(mappedBy = "bar")
    private Foo foo;
}</code>

Unidirektionale Eins-zu-Viele-Beziehung mit Benutzer- Verwaltete Join-Tabelle

Für eine unidirektionale Eins-zu-viele-Beziehung mithilfe einer benutzerverwalteten Join-Tabelle erstellen Sie eine Join-Tabellenklasse, die die Beziehung zwischen den beiden Klassen abbildet. Kommentieren Sie die Join-Tabelle mit @Entity und @Table und ordnen Sie die Spalten den Primärschlüsseln der übergeordneten und untergeordneten Klassen zu.

Beispiel:

<code class="java">public class Foo {
    private Long fooId;

    @OneToMany
    @JoinTable(name="FOO_BAR",
        joinColumns = @JoinColumn(name="fooId"),
        inverseJoinColumns = @JoinColumn(name="barId"))
    private List<Bar> bars;
}

public class Bar {
    private Long 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")
    private Bar bar;

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

Bidirektionale Eins-zu-Viele Beziehung mit Fremdschlüsselzuordnung

Für eine bidirektionale Eins-zu-viele-Beziehung mit Fremdschlüsselzuordnung versehen Sie die besitzende Klasse mit @OneToMany und die abhängige Klasse mit @ManyToOne. Verwenden Sie die Annotation @JoinColumn, um den Spaltennamen anzugeben, der den Fremdschlüssel in der abhängigen Klassentabelle enthält.

Beispiel:

<code class="java">public class Foo {
    private Long fooId;

    @OneToMany(mappedBy = "bar")
    private List<Bar> bars;
}

public class Bar {
    private Long barId;

    @ManyToOne
    @JoinColumn(name = "fooId")
    private Foo foo;
}</code>

Bidirektionale Viele-zu-Viele-Beziehung mit Hibernate -Verwaltete Join-Tabelle

Für eine bidirektionale Viele-zu-Viele-Beziehung mit einer im Ruhezustand verwalteten Join-Tabelle versehen Sie jede Klasse mit @OneToMany. Erstellen Sie eine Join-Tabellenklasse, die die Beziehung zwischen den beiden Klassen abbildet. Kommentieren Sie die Join-Tabelle mit @Entity und @Table und ordnen Sie die Spalten den Primärschlüsseln der übergeordneten und untergeordneten Klassen zu.

Beispiel:

<code class="java">public class Foo {
    private Long fooId;

    @OneToMany
    @JoinTable(name="FOO_BAR",
        joinColumns = @JoinColumn(name="fooId"),
        inverseJoinColumns = @JoinColumn(name="barId"))
    private List<Bar> bars;
}

public class Bar {
    private Long barId;

    @OneToMany
    @JoinTable(name="FOO_BAR",
        joinColumns = @JoinColumn(name="barId"),
        inverseJoinColumns = @JoinColumn(name="fooId"))
    private List<Foo> foos;
}</code>

Bidirektionale Many-to-Many Beziehung mit benutzerverwaltetem Join-Tabellenobjekt

Für eine bidirektionale m:n-Beziehung mit einem benutzerverwalteten Join-Tabellenobjekt erstellen Sie eine Join-Tabellenklasse, die die Beziehung zwischen den beiden Klassen abbildet. Kommentieren Sie die Join-Tabelle mit @Entity und @Table und ordnen Sie die Spalten den Primärschlüsseln der übergeordneten und untergeordneten Klassen zu. Kommentieren Sie jede Klasse mit @OneToMany und ordnen Sie die Felder der Join-Tabellenklasse zu.

Beispiel:

<code class="java">public class Foo {
    private Long fooId;

    @OneToMany(mappedBy = "bar")
    private List<FooBar> bars;
}

public class Bar {
    private Long 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.
}</code>

Bestimmen der Kaskadenrichtung

Hibernate kann Vorgänge in eine oder beide Richtungen kaskadieren in einer bidirektionalen Beziehung. Kaskadieren Sie Änderungen in die gewünschte Richtung, indem Sie die Annotation @OneToMany in der besitzenden Klasse markieren. Im Allgemeinen ist es ratsam, die Kaskaden auf der Eigentümerseite der Beziehung zu markieren.

Waisenentfernung

Waisenentfernung stellt sicher, dass verwaiste Objekte, die nicht mehr mit einem übergeordneten Objekt verknüpft sind, automatisch aus der Datenbank gelöscht werden. Aktivieren Sie die Waisenentfernung, indem Sie orphanRemoval = true für die @OneToMany-Annotation festlegen.

Umgang mit LazyInitializationException

LazyInitializationException tritt auf, wenn auf eine Entität zugegriffen wird, die eine verzögert abgerufene Sammlung enthält, bevor die Sammlung initialisiert wird. Um das Problem zu lösen, initialisieren Sie die Sammlung explizit mit Hibernate.initialize() oder verwenden Sie fetchType = FetchMode.EAGER für die @OneToMany-Annotation, um die Sammlung schnell zu laden.

Das obige ist der detaillierte Inhalt vonWie definieren Sie Beziehungen zwischen Entitäten in Hibernate 4 und Spring mithilfe von Anmerkungen?. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!