En-till-många- och många-till-många-relationer
Mappa @OneToMany, @ManyToMany och @JoinTable med kaskadtyper och hämtningsstrategier.
En-till-många- och många-till-många-relationer är en gratis lektion i Java Academy på CoddyKit. Detta är lektion 3 av 4. Ni kan läsa hela lektionen gratis nedan och sedan öva praktiskt i webbläsaren med en inbyggd kodredigerare och en AI-handledare som är tillgänglig dygnet runt. Den ingår i lärvägen för Java Academy, och Era framsteg synkroniseras mellan webben och CoddyKit-appen. Kursen i Java Academy innehåller totalt 4 lektioner.
Relationstyper i JPA
JPA stöder fyra relationstyper: @OneToOne, @OneToMany, @ManyToOne, @ManyToMany. Var och en mappas till begränsningar med främmande nycklar eller kopplingstabeller.
@ManyToOne: Ägarsidan
En many-to-one-relation (till exempel tillhör många Orders en User) mappas med @ManyToOne och en @JoinColumn för den främmande nyckeln.
@Entity
public class Order {
@ManyToOne(fetch = FetchType.LAZY)
@JoinColumn(name = "user_id", nullable = false)
private User user;
}@OneToMany: Den inversa sidan
Den inversa sidan (User har många Orders) använder @OneToMany(mappedBy = "user"). Attributet mappedBy pekar på fältet på ägarsidan som innehåller den främmande nyckeln.
@Entity
public class User {
@OneToMany(mappedBy = "user", cascade = CascadeType.ALL, orphanRemoval = true)
private List<Order> orders = new ArrayList<>();
}Hjälpmetod för dubbelriktad konsistens
Vid dubbelriktade associationer ska ni underhålla relationens båda sidor i en hjälpmetod, så att objektgrafen förblir konsistent innan flushning.
public void addOrder(Order order) {
orders.add(order);
order.setUser(this); // keep both sides in sync
}
public void removeOrder(Order order) {
orders.remove(order);
order.setUser(null);
}Cascadetyper
CascadeType.ALL vidarebefordrar alla åtgärder (persist, merge, remove, refresh, detach) från överordnad till underordnad entitet. PERSIST och MERGE är vanliga säkra val. REMOVE tar bort underordnade entiteter när den överordnade entiteten tas bort.
@OneToMany(mappedBy = "user",
cascade = {CascadeType.PERSIST, CascadeType.MERGE},
orphanRemoval = true)
private List<Order> orders;orphanRemoval: Automatisk borttagning av underordnade entiteter
orphanRemoval = true tar bort en underordnad entitet när den tas bort från den överordnade entitetens samling – även utan ett explicit anrop till entityManager.remove().
user.getOrders().remove(order); // triggers DELETE for the orphaned order on flush@ManyToMany med @JoinTable
En many-to-many-relation (till exempel mellan Student och Course) använder en kopplingstabell. Definiera den på ägarsidan med @JoinTable; den inversa sidan använder mappedBy.
@Entity
public class Student {
@ManyToMany
@JoinTable(
name = "student_course",
joinColumns = @JoinColumn(name = "student_id"),
inverseJoinColumns = @JoinColumn(name = "course_id"))
private Set<Course> courses = new HashSet<>();
}Extra kolumner i kopplingstabellen
När kopplingstabellen behöver extra kolumner (till exempel registreringsdatum) ska ni ersätta @ManyToMany med två @OneToMany-/ @ManyToOne-relationer och skapa en ny entitet som representerar kopplingstabellen.
@Entity
public class Enrollment {
@ManyToOne Student student;
@ManyToOne Course course;
private LocalDate enrolledAt;
}FetchType: LAZY kontra EAGER
Standard för hämtning: @ManyToOne och @OneToOne är EAGER (laddas direkt). @OneToMany och @ManyToMany är LAZY (laddas vid åtkomst). Använd alltid LAZY för samlingar för att undvika N+1-frågor.
// Always override to LAZY:
@ManyToOne(fetch = FetchType.LAZY)
@JoinColumn(name = "category_id")
private Category category;Problemet med N+1-frågor
Om ni får åtkomst till en lazy-samling i en loop körs en fråga per entitet (N+1). Lös problemet med JOIN FETCH i JPQL eller @EntityGraph för att ladda samlingen med en enda fråga.
// N+1 problem:
List<User> users = repo.findAll();
users.forEach(u -> u.getOrders().size()); // 1 + N queries!
// Fix:
@Query("SELECT u FROM User u LEFT JOIN FETCH u.orders")
List<User> findAllWithOrders();Set kontra List för samlingar
Använd Set för @ManyToMany (undviker dubbla rader i kopplingstabellen). Använd List för @OneToMany när ordningen är viktig. Använd aldrig List med @ManyToMany – Hibernate tvingas då ta bort och lägga till alla rader igen.
Snabb kontroll
Vad anger mappedBy i en @OneToMany-annotering?
Sammanfattning
Använd @ManyToOne+@JoinColumn på ägarsidan (med den främmande nyckeln). Använd @OneToMany(mappedBy=...) på den inversa sidan. Använd alltid LAZY för samlingar. Lös N+1 med JOIN FETCH. Använd en kopplingsentitet för many-to-many-relationer med extra kolumner.
Lär dig Java med en AI-lärare – gratis
Skriv och kör riktig kod i webbläsaren, få omedelbar hjälp av en AI-lärare dygnet runt och fortsätt där du slutade – på webben eller i appen.
- Kurser
- 104
- Lektioner
- 374
Vanliga frågor
Är lektionen ”En-till-många- och många-till-många-relationer” gratis?
Ja – hela texten till ”En-till-många- och många-till-många-relationer” kan läsas gratis här på webben. Om Ni vill öva interaktivt med en inbyggd kodredigerare och en AI-handledare som är tillgänglig dygnet runt och låsa upp resten av kursen i Java Academy, kan Ni uppgradera till CoddyKit PRO. Kursen i Java Academy innehåller totalt 4 lektioner.
Vad lär jag mig i ”En-till-många- och många-till-många-relationer”?
Mappa @OneToMany, @ManyToMany och @JoinTable med kaskadtyper och hämtningsstrategier. Ni övar på Java Academy med praktisk kod som körs direkt i webbläsaren, medan en AI-handledare som är tillgänglig dygnet runt svarar på Era frågor under lektionen.
Behöver jag någon erfarenhet för att börja lära mig Java Academy?
Du behöver inga förkunskaper. Utbildningen i Java Academy på CoddyKit är upplagd för allt från nybörjare till avancerade elever, så att du kan börja här eller från början och gå fram i din egen takt. Detta är lektion 3 av 4.
Hur lång tid tar lektionen ”En-till-många- och många-till-många-relationer”?
De flesta CoddyKit-lektioner tar cirka 5–10 minuter. Varje lektion är kort och interaktiv, så att du gör stadiga framsteg och kan fortsätta precis där du slutade – på webben eller i appen.
Kan jag skriva och köra kod i den här Java Academy-lektionen?
Ja. Varje Java Academy-lektion innehåller en inbyggd kodredigerare, så att du kan skriva och köra riktig kod direkt i webbläsaren och få omedelbar AI-feedback – utan lokal installation.
Alla lektioner i den här kursen
- Entitetsmappning med JPA-annotationer
- Spring Data-repositorier och frågemetoder
- En-till-många- och många-till-många-relationer
- Paginering, sortering och projektioner