JPA-Zuordnungen in Spring Boot verstehen: Eins-zu-Eins-, Eins-zu-Viele-, Viele-zu-Eins- und Viele-zu-Viele-Beziehungen

Beim Erstellen von Anwendungen mit Spring Boot und JPA (Java Persistence API) ist die Verwaltung der Beziehungen zwischen Entitäten von entscheidender Bedeutung. Wenn Sie wissen, wie Sie diese Beziehungen effektiv abbilden, können Sie Ihre Daten präzise modellieren und effiziente Abfragen durchführen. In diesem Leitfaden untersuchen wir die verschiedenen Arten von JPA-Zuordnungen, die von Spring Boot unterstützt werden: Eins-zu-Eins, Eins-zu-Viele, Viele-zu-Eins und Viele-zu-Viele. Bietet Beispiele für unidirektionale und bidirektionale Zuordnungen.

Eins-zu-eins-Beziehung

Unidirektionales Eins-zu-Eins

In einer unidirektionalen Eins-zu-Eins-Beziehung verweist eine Entität auf eine andere, ohne dass die zweite Entität etwas über die erste weiß.

Beispiel:

// User.java
import javax.persistence.Entity;
import javax.persistence.Id;
import javax.persistence.OneToOne;

@Data
@Entity
public class User {
    @Id
    @GeneratedValue(stratergy = GenerationType.Identity)
    private Long id;
    private String username;

    @OneToOne(cascade = CascadeType.ALL)
    @JoinColumn(name = "fk_profile_id", referencedColumnName = "id")
    private Profile profile;

}

// Profile.java
import javax.persistence.Entity;
import javax.persistence.Id;

@Data
@Entity
public class Profile {
    @Id
    @GeneratedValue(stratergy = GenerationType.Identity)
    private Long id;
    private String bio;
}

Bidirektionales One-to-One

In einer bidirektionalen Eins-zu-Eins-Beziehung verweisen beide Entitäten aufeinander.

Beispiel:

// User.java
import javax.persistence.Entity;
import javax.persistence.Id;
import javax.persistence.OneToOne;

@Data
@Entity
public class User {
    @Id
    @GeneratedValue(stratergy = GenerationType.Identity)
    private Long id;
    private String username;

    @OneToOne(mappedBy = "user", cascade = CascadeType.ALL)
    private Profile profile;

}

// Profile.java
import javax.persistence.Entity;
import javax.persistence.Id;
import javax.persistence.OneToOne;
import javax.persistence.JoinColumn;

@Data
@Entity
public class Profile {
    @Id
    @GeneratedValue(stratergy = GenerationType.Identity)
    private Long id;
    private String bio;

    @OneToOne
    @JoinColumn(name = "user_id")
    private User user;
}

Eins-zu-Viele-Beziehung

Unidirektionale Eins-zu-Viele

In einer unidirektionalen Eins-zu-Viele-Beziehung verweist eine Entität auf eine Sammlung einer anderen Entität.

Beispiel:

// Author.java
import javax.persistence.Entity;
import javax.persistence.Id;
import javax.persistence.OneToMany;
import java.util.List;

@Entity
@Data
public class Author {
    @Id
    @GeneratedValue(stratergy = GenerationType.Identity)
    private Long id;
    private String name;

    @OneToMany(cascade = CascadeType.ALL)
    @JoinColumn(name = "fk_book_id", referencedColumnName = "id")
    private List<Book> books;
}

// Book.java
import javax.persistence.Entity;
import javax.persistence.Id;

@Entity
@Data
public class Book {
    @Id
    private Long id;
    private String title;
}

Bidirektionales One-to-Many

In einer bidirektionalen Eins-zu-Viele-Beziehung werden beide Entitäten aufeinander verwiesen.

Beispiel:

// Author.java
import javax.persistence.Entity;
import javax.persistence.Id;
import javax.persistence.OneToMany;
import javax.persistence.CascadeType;
import javax.persistence.FetchType;
import java.util.List;

@Entity
@Data
public class Author {
    @Id
    @GeneratedValue(stratergy = GenerationType.Identity)
    private Long id;
    private String name;

    @OneToMany(mappedBy = "author", cascade = CascadeType.ALL, fetch = FetchType.EAGER)
    private List<Book> books;

}

// Book.java
import javax.persistence.Entity;
import javax.persistence.Id;
import javax.persistence.ManyToOne;

@Entity
@Data
public class Book {
    @Id
    @GeneratedValue(stratergy = GenerationType.Identity)
    private Long id;
    private String title;

    @ManyToOne(name = "fk_author_id", referencedColumnName = "id")
    private Author author;
}

Viele-zu-Eins-Beziehung

Unidirektionales Viele-zu-Eins

In einer unidirektionalen Viele-zu-Eins-Beziehung verweisen mehrere Entitäten auf eine einzelne Entität.

Beispiel:

// Order.java
import javax.persistence.Entity;
import javax.persistence.Id;
import javax.persistence.ManyToOne;

@Entity
@Data
public class Order {
    @Id
    @GeneratedValue(stratergy = GenerationType.Identity)
    private Long id;
    private String description;

    @ManyToOne
    private Customer customer;

}

// Customer.java
import javax.persistence.Entity;
import javax.persistence.Id;

@Entity
@Data
public class Customer {

    @Id
    @GeneratedValue(stratergy = GenerationType.Identity)
    private Long id;
    private String name;

}

Bidirektionales Viele-zu-Eins

In einer bidirektionalen Viele-zu-Eins-Beziehung verfügt die referenzierte Entität über eine Sammlung der verweisenden Entitäten.

Beispiel:

// Order.java
import javax.persistence.Entity;
import javax.persistence.Id;
import javax.persistence.ManyToOne;

@Entity
@Data
public class Order {

    @Id
    @GeneratedValue(stratergy = GenerationType.Identity)
    private Long id;
    private String description;

    @ManyToOne
    private Customer customer;

}

// Customer.java
import javax.persistence.Entity;
import javax.persistence.Id;
import javax.persistence.OneToMany;
import java.util.List;

@Entity
@Data
public class Customer {
    @Id
    @GeneratedValue(stratergy = GenerationType.Identity)
    private Long id;
    private String name;

    @OneToMany(mappedBy = "customer")
    private List<Order> orders;

}

Many-to-Many-Beziehung

Unidirektionale Many-to-Many

In einer unidirektionalen Viele-zu-Viele-Beziehung hat jede Entität eine Sammlung der anderen, aber die Beziehung wird von keiner Seite explizit verwaltet.

Beispiel:

// Student.java
import javax.persistence.Entity;
import javax.persistence.Id;
import javax.persistence.ManyToMany;
import java.util.Set;

@Entity
@Data
public class Student {
    @Id
    @GeneratedValue(stratergy = GenerationType.Identity)
    private Long id;
    private String name;

    @ManyToMany
    private Set<Course> courses;

}

// Course.java
import javax.persistence.Entity;
import javax.persistence.Id;
import javax.persistence.ManyToMany;
import java.util.Set;

@Entity
@Data
public class Course {
    @Id
    @GeneratedValue(stratergy = GenerationType.Identity)
    private Long id;
    private String title;

    @ManyToMany
    private Set<Student> students;
}

Bidirektionale Many-to-Many

In einer bidirektionalen Viele-zu-Viele-Beziehung verweisen beide Entitäten aufeinander und die Beziehung wird explizit verwaltet.

Beispiel:

// Student.java
import javax.persistence.Entity;
import javax.persistence.Id;
import javax.persistence.ManyToMany;
import java.util.Set;

@Entity
@Data
public class Student {
    @Id
    @GeneratedValue(stratergy = GenerationType.Identity)
    private Long id;
    private String name;

    @ManyToMany(mappedBy = "students")
    private Set<Course> courses;
}

// Course.java
import javax.persistence.Entity;
import javax.persistence.Id;
import javax.persistence.ManyToMany;
import java.util.Set;

@Entity
@Data
public class Course {
    @Id
    @GeneratedValue(stratergy = GenerationType.Identity)
    private Long id;
    private String title;

    @ManyToMany
    private Set<Student> students;
}

Das obige ist der detaillierte Inhalt vonJPA-Zuordnungen in Spring Boot verstehen: Eins-zu-Eins-, Eins-zu-Viele-, Viele-zu-Eins- und Viele-zu-Viele-Beziehungen. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!