Java Academy · Pelajaran

Relasi One-to-Many dan Many-to-Many

Petakan @OneToMany, @ManyToMany, dan @JoinTable dengan jenis kaskade dan strategi pengambilan data

Relasi One-to-Many dan Many-to-Many adalah pelajaran Java Academy gratis di CoddyKit. Ini adalah pelajaran 3 dari 4. Kamu bisa membaca pelajaran lengkapnya di bawah secara gratis — lalu praktikkan langsung di browser dengan editor kode bawaan dan tutor AI 24/7. Ini adalah bagian dari jalur belajar Java Academy, dan progresmu tersinkronisasi di web dan aplikasi CoddyKit. Kursus Java Academy mencakup 4 pelajaran total.

Jenis Relasi dalam JPA

JPA mendukung empat jenis relasi: @OneToOne, @OneToMany, @ManyToOne, @ManyToMany. Masing-masing memetakan ke batasan kunci asing atau tabel penghubung.

@ManyToOne: Sisi Pemilik

Relasi banyak-ke-satu (misalnya, banyak Order dimiliki oleh satu User) dipetakan dengan @ManyToOne dan @JoinColumn untuk kunci asing.

@Entity
public class Order {
    @ManyToOne(fetch = FetchType.LAZY)
    @JoinColumn(name = "user_id", nullable = false)
    private User user;
}

@OneToMany: Sisi Invers

Sisi invers (User memiliki banyak Order) menggunakan @OneToMany(mappedBy = "user"). Atribut mappedBy menunjuk ke bidang pada sisi pemilik yang menyimpan FK.

@Entity
public class User {
    @OneToMany(mappedBy = "user", cascade = CascadeType.ALL, orphanRemoval = true)
    private List<Order> orders = new ArrayList<>();
}

Pembantu Konsistensi Dua Arah

Dalam asosiasi dua arah, pertahankan kedua sisi relasi melalui metode pembantu agar graf objek tetap konsisten sebelum pembilasan.

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);
}

Jenis Propagasi

CascadeType.ALL meneruskan semua operasi (menyimpan, menggabungkan, menghapus, menyegarkan, melepaskan) dari entitas induk ke entitas anak. PERSIST dan MERGE merupakan pilihan aman yang umum. REMOVE menghapus entitas anak saat entitas induk dihapus.

@OneToMany(mappedBy = "user",
           cascade = {CascadeType.PERSIST, CascadeType.MERGE},
           orphanRemoval = true)
private List<Order> orders;

orphanRemoval: Penghapusan Anak Otomatis

orphanRemoval = true menghapus entitas anak saat entitas tersebut dihapus dari koleksi induk — bahkan tanpa entityManager.remove() secara eksplisit.

user.getOrders().remove(order); // triggers DELETE for the orphaned order on flush

@ManyToMany dengan @JoinTable

Relasi banyak-ke-banyak (misalnya, Student dan Kursus) menggunakan tabel penghubung. Definisikan tabel tersebut pada sisi pemilik dengan @JoinTable; sisi invers menggunakan 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<>();
}

Kolom Tambahan pada Tabel Penghubung

Jika tabel penghubung memerlukan kolom tambahan (misalnya, tanggal pendaftaran), ubah @ManyToMany menjadi dua relasi @OneToMany / @ManyToOne dengan entitas baru yang merepresentasikan tabel penghubung.

@Entity
public class Enrollment {
    @ManyToOne Student student;
    @ManyToOne Course course;
    private LocalDate enrolledAt;
}

FetchType: LAZY vs EAGER

Pemuatan default: @ManyToOne dan @OneToOne bersifat EAGER (dimuat segera). @OneToMany dan @ManyToMany bersifat LAZY (dimuat saat diakses). Selalu gunakan LAZY untuk koleksi guna menghindari kueri N+1.

// Always override to LAZY:
@ManyToOne(fetch = FetchType.LAZY)
@JoinColumn(name = "category_id")
private Category category;

Masalah N+1 Query

Mengakses koleksi lazy di dalam perulangan menjalankan satu kueri untuk setiap entitas (N+1). Perbaiki dengan JOIN FETCH dalam JPQL atau @EntityGraph agar koleksi dimuat dalam satu kueri.

// 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 vs List untuk Koleksi

Gunakan Set untuk @ManyToMany (menghindari baris penghubung duplikat). Gunakan List untuk @OneToMany jika urutan penting. Jangan pernah menggunakan List dengan @ManyToMany — Hibernate akan menghapus dan menyisipkan kembali semua baris.

Pemeriksaan Singkat

Apa yang ditunjukkan oleh mappedBy dalam anotasi @OneToMany?

Ringkasan

Gunakan @ManyToOne+@JoinColumn pada sisi pemilik (FK). Gunakan @OneToMany(mappedBy=...) pada sisi invers. Selalu gunakan LAZY untuk koleksi. Perbaiki N+1 dengan JOIN FETCH. Gunakan entitas penghubung untuk relasi banyak-ke-banyak dengan kolom tambahan.

Pertanyaan yang Sering Diajukan

Apakah pelajaran “Relasi One-to-Many dan Many-to-Many” gratis?

Ya — teks lengkap “Relasi One-to-Many dan Many-to-Many” gratis dibaca di sini di web. Untuk praktiknya secara interaktif (editor kode bawaan dan tutor AI 24/7) dan buka sisa kursus Java Academy, upgrade ke CoddyKit PRO. Kursus Java Academy mencakup 4 pelajaran total.

Apa yang akan aku pelajari di “Relasi One-to-Many dan Many-to-Many”?

Petakan @OneToMany, @ManyToMany, dan @JoinTable dengan jenis kaskade dan strategi pengambilan data Kamu berlatih Java Academy dengan kode praktik yang langsung kamu jalankan di browser, dan tutor AI 24/7 menjawab pertanyaanmu saat kamu mengerjakan pelajaran ini.

Apakah aku perlu pengalaman untuk memulai Java Academy?

Tidak diperlukan pengalaman sebelumnya. Java Academy di CoddyKit dirancang untuk pemula hingga pelajar tingkat lanjut, jadi kamu bisa memulai di sini atau dari awal dan belajar sesuai kecepatan kamu sendiri. Ini adalah pelajaran 3 dari 4.

Berapa lama pelajaran “Relasi One-to-Many dan Many-to-Many” memakan waktu?

Sebagian besar pelajaran CoddyKit memakan waktu sekitar 5–10 menit. Setiap pelajaran ringkas dan interaktif, jadi kamu membuat kemajuan stabil dan melanjutkan dari tempat kamu tinggalkan di web dan aplikasi.

Bisakah aku menulis dan menjalankan kode dalam pelajaran Java Academy ini?

Ya. Setiap pelajaran Java Academy menyertakan editor kode bawaan, jadi kamu menulis dan menjalankan kode nyata langsung di browser dan mendapatkan umpan balik AI instan — tidak diperlukan penyiapan lokal.

Semua pelajaran dalam kursus ini

← Kembali ke Java Academy