Laravel Fundamentals

Setelah membangun framework mini di Section Framework Development , kita tahu persis pekerjaan apa yang disembunyikan oleh sebuah framework: mencocokkan rute, menjalankan middleware, sampai merender template. Laravel adalah framework full-stack paling banyak dipakai di ekosistem PHP, dan seluruh pekerjaan tersebut sudah dikemas menjadi produk matang dengan dokumentasi yang sangat lengkap. Pada chapter ini kita akan memasang Laravel, membedah struktur direktorinya, mengenal Artisan dan file .env, lalu memahami konsep facade secara jujur. Chapter ini menjadi fondasi bagi empat chapter Laravel berikutnya tentang routing, Eloquent, validation, dan authentication.

Filosofi Laravel #

Laravel pertama kali dirilis oleh Taylor Otwell pada tahun 2011 dan kini menjadi framework PHP dengan basis pengguna terbesar. Tujuan utamanya bukan sekadar menyediakan fitur, melainkan developer experience: sintaks yang ekspresif, konvensi yang konsisten, dan dokumentasi resmi yang rapi sehingga pemula pun bisa mengikuti. Banyak fitur Laravel sengaja dirancang agar kode aplikasi terbaca seperti kalimat berbahasa Inggris, misalnya Post::where('status', 'published')->latest()->get().

Prinsip kedua adalah convention over configuration. Class model Post otomatis terhubung ke tabel posts, controller otomatis ditemukan di namespace App\Http\Controllers, dan template otomatis dicari di folder resources/views. Kita hampir tidak menulis konfigurasi pemetaan karena Laravel sudah memilihkan konvensi yang wajar. Ketika konvensi bawaan tidak cocok, hampir semua perilaku tetap bisa ditukar lewat berkas konfigurasi.

Bandingkan dengan framework mini yang kita tulis sendiri: di sana setiap keputusan — format definisi rute, cara memuat middleware, lokasi template — kita tentukan sendiri dari nol. Laravel memberi kita keputusan default yang sudah teruji di jutaan aplikasi, sementara fondasi konseptualnya tetap sama: arsitektur MVC, front controller, dan pemisahan concern yang kita bahas di Memahami MVC .

Memasang Laravel dengan Composer #

Cara resmi memasang Laravel adalah melalui Composer yang sudah kita kenal di Section Composer dan Dependency Management. Perintah composer create-project mengunduh kerangka aplikasi Laravel beserta seluruh dependensinya, membuat salinan file .env awal, lalu menghasilkan kunci aplikasi (APP_KEY) secara otomatis. Versi Laravel terbaru membutuhkan PHP 8.2 atau lebih baru, jadi pastikan versi PHP di mesin Anda memenuhi syarat.

composer create-project laravel/laravel toko-buku

cd toko-buku
php artisan serve

Mari kita bedah kedua perintah di atas:

1. composer create-project laravel/laravel toko-buku: mengunduh kerangka aplikasi ke folder toko-buku/, menjalankan composer install, dan menyiapkan berkas konfigurasi awal.
2. php artisan serve: menjalankan development server lokal di http://127.0.0.1:8000. Konsepnya sama dengan php -S yang pernah kita pakai, tetapi dokumen root sudah diarahkan ke folder public/ sehingga kode aplikasi tidak pernah terekspos sebagai berkas statis.

Membuka http://127.0.0.1:8000 di browser akan menampilkan halaman sambutan Laravel. Untuk pengembangan serius, banyak pengembang juga memakai Laragon, Laravel Herd, Docker, atau virtual machine, tetapi php artisan serve cukup untuk seluruh materi di section ini.

Anatomi Direktori Proyek #

Sejak Laravel 11, struktur proyek dirampingkan: berkas kernel (app/Http/Kernel.php) dihapus dan pengaturan middleware serta exception dipindah ke bootstrap/app.php. Meski lebih ramping, peta direktori berikut tetap menjadi tempat kerja utama kita:

Dua folder yang paling sering kita sentuh adalah app/ untuk kode PHP aplikasi dan routes/ sebagai pintu masuk setiap permintaan. Folder public/ hanya berisi index.php (front controller) dan aset statis; web server hanya boleh mengarahkan dokumen root ke folder inilah. Sisa direktori seperti storage/ dan bootstrap/ berisi berkas hasil kompilasi, cache, dan log yang jarang kita ubah secara manual.

Artisan sebagai Asisten Baris Perintah #

Artisan adalah antarmuka CLI bawaan Laravel, dan sebagian besar alur kerja sehari-hari berpusat pada terminal. Perintah generator make:* menuliskan kerangka class untuk kita, sehingga kita fokus pada isi logika alih-alih boilerplate. Kerangka yang dihasilkan juga menyeragamkan penamaan dan lokasi berkas antar anggota tim.

php artisan make:controller HomeController
php artisan make:model Post --migration
php artisan route:list
php artisan migrate

Baris pertama membuat app/Http/Controllers/HomeController.php; baris kedua membuat model Post sekaligus berkas migrasi tabelnya dalam satu perintah. route:list menampilkan seluruh rute terdaftar beserta middleware-nya — alat debug pertama yang sebaiknya dibuka sebelum menyalakan browser. migrate menjalankan berkas migrasi yang belum diterapkan ke database, topik yang kita bedah tuntas di chapter Eloquent.

Konfigurasi dengan File .env #

Aplikasi Laravel membaca konfigurasi dari dua lapis. Lapis pertama adalah file .env di akar proyek yang menyimpan nilai berbeda antar lingkungan (laptop, staging, produksi). Lapis kedua adalah berkas PHP di folder config/ yang membaca nilai tersebut lalu menyediakannya bagi aplikasi lewat helper config().

APP_NAME="Toko Buku"
APP_ENV=local
APP_DEBUG=true

DB_CONNECTION=sqlite

Empat variabel pertama mengatur identitas dan perilaku aplikasi: nama aplikasi, lingkungan eksekusi (local atau production), dan apakah pesan error yang detail boleh ditampilkan. Variabel DB_CONNECTION=sqlite memilih driver database — ketika kelak bermigrasi ke MySQL, kita cukup mengganti nilainya menjadi mysql lalu menambah variabel DB_HOST, DB_DATABASE, DB_USERNAME, dan DB_PASSWORD di bawahnya. Berkas config/app.php membaca nilai-nilai tersebut dengan helper env() dan memberi nilai bawaan jika variabel tidak ada:

<?php
// potongan config/app.php
return [
    'name' => env('APP_NAME', 'Laravel'),
    'env' => env('APP_ENV', 'production'),
    'debug' => (bool) env('APP_DEBUG', false),
    'timezone' => 'UTC',
];

Di dalam kode aplikasi, kita membaca konfigurasi melalui config('app.name') — bukan env() langsung. Alasannya, pada produksi berkas konfigurasi sering di-cache menjadi satu berkas PHP sehingga panggilan env() di luar folder config/ akan mengembalikan null. Perhatikan juga bahwa database bawaan Laravel modern adalah SQLite — driver yang sama yang kita pakai sepanjang course ini — sehingga tidak ada server database eksternal yang perlu dipasang untuk belajar.

Memahami Facade #

API Laravel banyak dipanggil lewat facade seperti Route::get(), Cache::remember(), dan Auth::attempt(). Penampilannya seperti method static, tetapi facade sebenarnya bukan method static biasa. Facade adalah class kecil yang meneruskan panggilan tersebut ke objek nyata yang tersimpan di dalam service container — wadah dependency injection yang sama konsepnya dengan yang kita bangun di Dependency Container .

<?php
use Illuminate\Support\Facades\Cache;

// ambil dari cache, atau jalankan closure dan simpan hasilnya selama 1 jam
$jumlahTerlaris = Cache::remember('buku-terlaris', 3600, function () {
    return 10; // sebenarnya: hitung dari database
});

Panggilan Cache::remember(...) di atas diteruskan ke instance driver cache yang dibuat oleh container, misalnya driver database atau Redis. Facade hanya menyembunyikan langkah “ambil objeknya dulu” agar kode terasa ringkas. Kita bisa membuktikannya sendiri: method getFacadeRoot() mengembalikan objek asli di balik facade, dan kode Laravel sepenuhnya tetap berjalan tanpa facade karena semua layanan bisa di-inject lewat constructor.

Kelebihan facade adalah keringkasan — satu baris Cache::remember() menggantikan empat langkah pengecekan manual yang kita tulis di chapter caching. Kritik yang jujur perlu kita ketahui: facade menyembunyikan dependency dari signature method, sehingga pembaca kode tidak melihat bahwa sebuah class memakai cache. Untuk pengujian, Laravel menyediakan fake seperti Cache::fake() yang mengganti driver asli dengan tiruan in-memory, sehingga kode berbasis facade tetap mudah diuji.

Membangun Halaman Pertama #

Saatnya menyambungkan seluruh konsep di atas menjadi satu halaman utuh: rute, controller, dan template Blade. Kita daftarkan rute / di routes/web.php yang mengarah ke HomeController, lalu controller mengoper data ke template.

<?php
// routes/web.php
use App\Http\Controllers\HomeController;
use Illuminate\Support\Facades\Route;

Route::get('/', [HomeController::class, 'index'])->name('home');

<?php
// app/Http/Controllers/HomeController.php
namespace App\Http\Controllers;

class HomeController extends Controller
{
    public function index()
    {
        $buku = [
            ['judul' => 'Belajar PHP Dasar', 'penulis' => 'Budi'],
            ['judul' => 'Menguasai Laravel', 'penulis' => 'Siti'],
        ];

        return view('home', ['buku' => $buku]);
    }
}

<!-- resources/views/home.blade.php -->
<!DOCTYPE html>
<html lang="id">
<head>
    <meta charset="utf-8">
    <title>{{ config('app.name') }}</title>
</head>
<body>
    <h1>Selamat datang di {{ config('app.name') }}</h1>
    <ul>
        @foreach ($buku as $item)
            <li>{{ $item['judul'] }} — {{ $item['penulis'] }}</li>
        @endforeach
    </ul>
</body>
</html>

Mari kita telusuri alurnya baris demi baris:

1. Route::get('/', [HomeController::class, 'index']): mendaftarkan URI / sehingga permintaan GET ke halaman utama diteruskan ke method index() milik HomeController.
2. return view('home', ['buku' => $buku]): mencari template resources/views/home.blade.php dan mengoper array $buku sebagai variabel yang bisa dipakai template.
3. {{ config('app.name') }}: mencetak nilai konfigurasi sambil meng-escape HTML secara otomatis — perilaku yang sama dengan htmlspecialchars() dari chapter Output Escaping , sehingga risiko XSS sudah teratasi sejak baris pertama.
4. @foreach ... @endforeach: direktif Blade yang dikompilasi menjadi PHP foreach biasa; Blade pada akhirnya hanyalah template engine yang menghasilkan kode PHP.

Ekosistem di Sekitar Laravel #

Kekuatan Laravel tidak berhenti di framework intinya. Ekosistem first-party berikut menutup kebutuhan umum aplikasi nyata sehingga kita tidak menulis semuanya sendiri:

Seluruh alat di atas bersifat opsional — aplikasi kecil bisa berjalan hanya dengan framework inti dan Vite untuk aset. Pola “batteries included tapi dilepas pasang” ini memang disengaja: framework tetap ramping, sementara kebutuhan lanjutan tinggal memasang paket resmi yang dokumentasinya setara dokumentasi inti.

Ringkasan #

Kita telah memasang Laravel lewat composer create-project, memetakan direktori app/, routes/, dan resources/views/, memakai Artisan untuk menghasilkan kerangka class, membaca konfigurasi dua lapis .env dan config/, serta memahami facade sebagai pintu static menuju objek di service container. Halaman pertama kita juga menyatukan rute, controller, dan Blade dalam satu alur permintaan lengkap. Satu bagian dari alur itu — Route::get() — menyimpan jauh lebih banyak kemampuan daripada yang kita lihat, dan itulah topik chapter berikutnya: routing di Laravel.

Referensi #

• Instalasi Laravel
• Struktur Direktori Laravel
• Facade Laravel
• Template Blade