🔗

Laporan Praktikum Pemrograman Web

Laravel Eloquent Relationship — Student, Major & Subject

Praktikum 8
Disusun Oleh
Ahmad Zahran
2411532004
Dosen Pengampu
Nurfiah, S.ST. M.Kom
Universitas Andalas · 2026

I. Pendahuluan

Dalam pengembangan aplikasi web berbasis database, hubungan antar tabel (relationship) merupakan konsep yang sangat fundamental. Laravel sebagai salah satu framework PHP yang populer menyediakan fitur Eloquent ORM (Object-Relational Mapping) yang memudahkan developer dalam mendefinisikan dan mengelola hubungan antar tabel secara elegan melalui pendekatan berbasis model.

Praktikum ini berfokus pada implementasi sistem manajemen akademik sederhana yang melibatkan tiga entitas utama: Mahasiswa (Student), Jurusan (Major), dan Mata Kuliah (Subject). Ketiga entitas tersebut saling berhubungan membentuk dua jenis relationship:

Major
1 ──── hasMany ────→ *
Student
Student
* ←── belongsToMany ──→ *
Subject
via tabel pivot: student_subject
One-to-Many Satu jurusan dapat memiliki banyak mahasiswa, namun setiap mahasiswa hanya terdaftar pada satu jurusan.
Many-to-Many Satu mahasiswa dapat mengambil banyak mata kuliah, dan satu mata kuliah dapat diambil oleh banyak mahasiswa. Dikelola melalui tabel pivot student_subject.

Praktikum ini juga memperkenalkan konsep Eager Loading sebagai solusi untuk mencegah masalah N+1 Query yang umum terjadi saat bekerja dengan data yang memiliki banyak relasi.

II. Tujuan Praktikum

1

Memahami konsep dan jenis-jenis relationship dalam Laravel Eloquent (One-to-Many dan Many-to-Many).

2

Membuat file migration dengan mendefinisikan foreign key dan tabel pivot.

3

Mengimplementasikan method relationship (hasMany, belongsTo, belongsToMany) pada masing-masing model.

4

Menggunakan Seeder untuk mengisi data awal (sample data) ke dalam database.

5

Membuat Controller dengan operasi CRUD lengkap yang memanfaatkan Eloquent Relationship.

6

Menggunakan Eager Loading (with()) untuk mengoptimalkan query data yang berelasi.

7

Menampilkan data relationship di dalam View menggunakan Blade Template Engine.

III. Langkah Kerja

Langkah 1 — Membuat Migration

Migration digunakan untuk mendefinisikan struktur tabel secara terprogram. Terdapat empat tabel yang perlu dibuat.

A. Tabel majors
php artisan make:migration create_majors_table

Isi file migration:

Schema::create('majors', function (Blueprint $table) { $table->id(); $table->string('name'); $table->timestamps(); });

Tabel ini menyimpan id dan name sebagai data jurusan.

B. Tabel students
php artisan make:migration create_students_table
Schema::create('students', function (Blueprint $table) { $table->id(); $table->string('nim')->unique(); $table->string('name'); $table->text('address'); $table->foreignId('major_id')->constrained('majors')->onDelete('cascade'); $table->timestamps(); });

Kolom major_id adalah foreign key yang merujuk ke tabel majors. Opsi onDelete('cascade') memastikan data mahasiswa ikut terhapus jika jurusannya dihapus.

C. Tabel subjects
php artisan make:migration create_subjects_table
Schema::create('subjects', function (Blueprint $table) { $table->id(); $table->string('name'); $table->integer('sks'); $table->timestamps(); });
D. Tabel Pivot student_subject
php artisan make:migration create_student_subject_table
Schema::create('student_subject', function (Blueprint $table) { $table->id(); $table->foreignId('student_id')->constrained('students')->onDelete('cascade'); $table->foreignId('subject_id')->constrained('subjects')->onDelete('cascade'); $table->timestamps(); $table->unique(['student_id', 'subject_id']); // Mencegah duplikasi });

Tabel pivot ini menjadi penghubung relasi Many-to-Many antara students dan subjects. Constraint unique mencegah satu mahasiswa mendaftar mata kuliah yang sama lebih dari sekali.

Jalankan Semua Migration
php artisan migrate
Langkah 2 — Membuat Model dengan Relationship
A. Model Major
php artisan make:model Major
protected $fillable = ['name']; // One Major has many Students public function students() { return $this->hasMany(Student::class); }
B. Model Student
php artisan make:model Student
protected $fillable = ['nim', 'name', 'address', 'major_id']; // Many Students belong to one Major public function major() { return $this->belongsTo(Major::class); } // Many Students belong to many Subjects public function subjects() { return $this->belongsToMany(Subject::class); }
C. Model Subject
php artisan make:model Subject
protected $fillable = ['name', 'sks']; // Many Subjects belong to many Students public function students() { return $this->belongsToMany(Student::class); }

Ringkasan Method Relationship

MethodDigunakan PadaArti
hasMany Major Satu jurusan punya banyak mahasiswa
belongsTo Student Mahasiswa milik satu jurusan
belongsToMany Student & Subject Relasi banyak ke banyak via pivot
Langkah 3 — Membuat Seeder

Seeder digunakan untuk mengisi database dengan data sampel awal.

A. MajorSeeder

Mengisi 4 data jurusan: Teknik Informatika, Sistem Informasi, Teknik Komputer, dan Manajemen Informatika.

B. SubjectSeeder

Mengisi 5 mata kuliah beserta jumlah SKS-nya.

C. StudentSeeder

Mengisi 5 data mahasiswa dan menghubungkan masing-masing ke 2–4 mata kuliah secara acak menggunakan method attach():

$subjects = Subject::inRandomOrder()->take(rand(2, 4))->pluck('id'); $student->subjects()->attach($subjects);
D. Update DatabaseSeeder & Jalankan Seeder

Daftarkan ketiga seeder secara berurutan:

$this->call([ MajorSeeder::class, SubjectSeeder::class, StudentSeeder::class, ]);
php artisan db:seed
Langkah 4 — Membuat Controller
Buat StudentController
php artisan make:controller StudentController

StudentController memiliki tujuh method utama:

MethodFungsi
index()Menampilkan semua mahasiswa dengan eager loading
show($id)Menampilkan detail satu mahasiswa
create()Menampilkan form tambah mahasiswa
store(Request $request)Menyimpan data mahasiswa baru + relasi subject via attach()
edit($id)Menampilkan form edit mahasiswa
update(Request $request, $id)Memperbarui data + sinkronisasi relasi subject via sync()
destroy($id)Menghapus mahasiswa + melepas semua relasi via detach()
Perbedaan Method Pengelola Pivot
attach()
Menambahkan relasi baru
sync()
Menyamakan relasi (hapus lama, tambah baru)
detach()
Menghapus semua relasi
Contoh Eager Loading

Digunakan untuk mencegah masalah N+1 Query:

$students = Student::with(['major', 'subjects'])->get();
Langkah 5 — Membuat Routes
Route Resource di routes/web.php
Route::resource('students', StudentController::class);

Satu baris ini secara otomatis menghasilkan seluruh route CRUD: index, create, store, show, edit, update, dan destroy.

Langkah 6 — Membuat Views

Dibuat tiga file view utama menggunakan Blade Template Engine:

A. layouts/app.blade.php

Layout utama yang menyertakan Bootstrap 5 dan navbar sebagai kerangka tampilan bersama.

B. students/index.blade.php

Menampilkan daftar mahasiswa dalam tabel, termasuk nama jurusan, daftar badge mata kuliah, dan total SKS yang dihitung langsung dari relasi:

<td>{{ $student->subjects->sum('sks') }}</td>
C. students/create.blade.php

Form untuk menambahkan mahasiswa baru, dengan dropdown jurusan (dari tabel majors) dan checkbox mata kuliah (dari tabel subjects).

IV. Hasil dan Kesimpulan

Hasil Praktikum

Melalui praktikum ini berhasil diimplementasikan sebuah sistem manajemen akademik sederhana berbasis Laravel yang mencakup seluruh fitur berikut:

  • Dua jenis relationship — One-to-Many (Major → Student) dan Many-to-Many (Student ↔ Subject) — berhasil diimplementasikan menggunakan Eloquent ORM.
  • Tabel pivot student_subject berhasil dibuat untuk mengelola relasi Many-to-Many dengan mencegah data duplikat.
  • Operasi CRUD lengkap dapat dilakukan pada data mahasiswa termasuk pengelolaan relasi mata kuliah menggunakan attach(), sync(), dan detach().
  • Eager Loading diterapkan untuk mengoptimalkan performa query dan menghindari masalah N+1 Query.
  • Seeder berhasil mengisi data sampel secara otomatis ke seluruh tabel yang saling berelasi.
Kesimpulan
  • Laravel Eloquent Relationship mempermudah pengelolaan hubungan antar tabel database tanpa perlu menulis query SQL secara manual, cukup dengan mendefinisikan method pada Model.
  • Relasi One-to-Many (hasMany / belongsTo) digunakan saat satu entitas memiliki banyak entitas lain, seperti satu jurusan yang memiliki banyak mahasiswa.
  • Relasi Many-to-Many (belongsToMany) dikelola melalui tabel pivot dan membutuhkan method attach(), sync(), serta detach() untuk mengelola data pada tabel pivot tersebut.
  • Eager Loading dengan with() sangat penting untuk mencegah masalah N+1 Query agar performa aplikasi tetap optimal saat mengambil data dengan banyak relasi.
  • Blade Template Engine memudahkan menampilkan data relasi secara langsung di view, termasuk agregasi seperti menghitung total SKS dari relasi subjects.
← Kembali ke Portofolio