Tutorial laravel kali ini kita akan membahas apa itu middleware, memahami middleware di laravel 12 adalah kunci untuk membangun aplikasi web yang aman, terstruktur, dan berperforma tinggi. Sebagai pengembang Backend atau Programer yang ingin menguasai best practice dalam ekosistem PHP, mengoptimalkan aliran permintaan HTTP melalui middleware adalah keahlian yang tak terhindarkan.
Bayangkan setiap permintaan (request) yang masuk ke aplikasi Laravel Anda seperti penumpang di bandara. Sebelum bisa naik pesawat (mencapai logika utama aplikasi/controller), mereka harus melewati serangkaian pos pemeriksaan: pemeriksaan tiket, keamanan, imigrasi, dan mungkin juga lounge VIP. Middleware dalam Laravel adalah ‘pos pemeriksaan’ digital ini.
Middleware menyediakan mekanisme yang mudah dan elegan untuk memfilter atau memeriksa permintaan HTTP yang masuk ke aplikasi Anda. Mereka dapat memeriksa apakah pengguna terautentikasi, melakukan logging, atau menambahkan header tertentu ke respons yang akan dikirim kembali. Singkatnya, middleware bertindak sebagai jembatan antara permintaan pengguna dan logika bisnis Anda.
Di Laravel 12, arsitektur middleware telah disempurnakan. Meskipun konsep intinya tetap sama, pemahaman tentang cara Membuat Middleware, mengaplikasikannya, dan cara kerjanya dalam siklus hidup permintaan menjadi sangat penting. Tutorial kali ini akan memandu Anda secara mendalam, mulai dari konsep dasar hingga teknik lanjutan, memastikan Anda dapat mengimplementasikan middleware dengan efisien dan profesional.
Apa Itu Middleware dan Perannya dalam Siklus Hidup Laravel
Secara konseptual, middleware adalah lapisan yang dilewati oleh semua permintaan HTTP yang masuk. Setiap middleware bertanggung jawab untuk melakukan tugas tertentu dan kemudian memutuskan apakah akan meneruskan permintaan ke middleware berikutnya (jika ada) atau langsung ke kontroler (jika itu middleware terakhir), atau bahkan menghentikan permintaan sepenuhnya (misalnya, mengembalikan respons redirect atau error).
Filter Permintaan (Request Filter)
Fungsi utama dari middleware adalah sebagai filter permintaan (Request Filter). Middleware dapat bertindak sebelum permintaan mencapai controller (pre-middleware) dan setelah controller memprosesnya tetapi sebelum respons dikirimkan kembali ke klien (post-middleware).
- Pre-Middleware: Middleware ini berjalan sebelum controller. Contoh umum adalah otentikasi (memeriksa apakah pengguna sudah login). Jika pengguna belum login, middleware akan mengalihkan (redirect) pengguna ke halaman login dan permintaan tidak akan pernah mencapai controller.
- Post-Middleware: Middleware ini berjalan setelah permintaan diproses oleh controller. Ini sering digunakan untuk memodifikasi objek respons yang akan dikirim kembali. Contohnya adalah menambahkan header HTTP tertentu, seperti Cache-Control atau CORS (Cross-Origin Resource Sharing).
Struktur Dasar Middleware
Setiap middleware yang Anda buat terletak di direktori app/Http/Middleware dan mengimplementasikan metode handle.
Struktur Metode handle
Metode ini menerima dua argumen:
- $request: Instance dari Illuminate\Http\Request, mewakili permintaan HTTP yang masuk.
- $next: Closure yang mewakili permintaan masuk. Jika Anda memanggil $next($request), Anda mengizinkan permintaan untuk diteruskan lebih jauh ke aplikasi.
use Closure;
use Illuminate\Http\Request;
use Symfony\Component\HttpFoundation\Response;
class EnsureUserIsAuthenticated
{
/**
* Handle an incoming request.
*
* @param \Closure(\Illuminate\Http\Request): (\Symfony\Component\HttpFoundation\Response) $next
*/
public function handle(Request $request, Closure $next): Response
{
if (! auth()->check()) {
return redirect('/login'); // Menghentikan request, Pre-Middleware
}
return $next($request); // Meneruskan request, Berlanjut ke Controller
}
}Perhatikan $next($request) di atas. Semua kode sebelum $next($request) dijalankan saat permintaan masuk (pre-middleware), dan semua kode setelah $next($request) dijalankan saat respons keluar (post-middleware).
Membuat Middleware di Laravel 12
Untuk membuat middleware baru di laravel 12, Anda dapat menggunakan perintah Artisan yang cepat dan mudah.
1. Perintah Artisan
Jalankan perintah berikut di terminal Anda:
php artisan make:middleware CheckUserRole
Perintah ini akan membuat file CheckUserRole.php di dalam direktori app/Http/Middleware.
2. Implementasi Logika: Studi Kasus Role Checker
Mari kita buat middleware yang memastikan bahwa hanya pengguna dengan peran (role) tertentu yang dapat mengakses rute:
// app/Http/Middleware/CheckUserRole.php
namespace App\Http\Middleware;
use Closure;
use Illuminate\Http\Request;
use Symfony\Component\HttpFoundation\Response;
class CheckUserRole
{
public function handle(Request $request, Closure $next, string $role): Response
{
// Pastikan pengguna terautentikasi dan memiliki peran yang sesuai
if (! $request->user() || $request->user()->role !== $role) {
// Menghentikan request dan mengembalikan status 403 (Forbidden)
abort(403, 'Akses Ditolak: Anda tidak memiliki peran yang diperlukan.');
}
return $next($request);
}
}
Studi Kasus: Middleware ini menerima parameter $role (misalnya ‘admin’, ‘editor’, ‘guest’). Ini adalah contoh bagaimana middleware dapat menerima argumen, memberikan fleksibilitas yang luar biasa.
Menggunakan Middleware di Laravel: Penerapan Fleksibel
Setelah middleware dibuat, langkah selanjutnya adalah mendaftarkan dan Menggunakan middleware di laravel. Laravel menawarkan beberapa cara untuk menerapkannya, dari global hingga spesifik per rute.
1. Pendaftaran Middleware (Bootstrap/App.php)
Pada Laravel 12 (dan versi modern), pendaftaran dan konfigurasi middleware dipusatkan di file bootstrap/app.php di dalam chain of command withMiddleware.
A. Global Middleware (Dijalankan di Setiap Permintaan)
Untuk menjalankan middleware pada setiap permintaan HTTP ke aplikasi Anda (misalnya, TrimStrings atau EncryptCookies), tambahkan ke bagian global di bootstrap/app.php:
// bootstrap/app.php
use App\Http\Middleware\CheckForMaintenanceMode; // Contoh Middleware Kustom Anda
return Application::configure(basePath: dirname(__DIR__))
// ... konfigurasi lainnya ...
->withMiddleware(function (Middleware $middleware) {
$middleware->global([
// Laravel default global middleware...
\Illuminate\Cookie\Middleware\EncryptCookies::class,
// ...
// Tambahkan middleware global kustom Anda
CheckForMaintenanceMode::class,
]);
// ... pendaftaran middleware lainnya ...
})->create();B. Route Middleware (Alias)
Ini adalah cara paling umum untuk menggunakan middleware di laravel. Anda memberikan alias pendek untuk sebuah kelas middleware, dan kemudian menggunakannya pada rute atau grup rute tertentu.
Di bootstrap/app.php, daftarkan alias Anda:
// bootstrap/app.php
use App\Http\Middleware\CheckUserRole; // Middleware yang baru kita buat
return Application::configure(basePath: dirname(__DIR__))
// ...
->withMiddleware(function (Middleware $middleware) {
// ... $middleware->global([ ... ]);
$middleware->alias([
'auth.role' => CheckUserRole::class,
'verified' => \App\Http\Middleware\EnsureEmailIsVerified::class,
// ... alias bawaan atau kustom lainnya
]);
})->create();
2. Penerapan Middleware pada Rute
Setelah didaftarkan, Anda dapat menggunakan middleware alias Anda pada rute atau grup rute.
A. Pada Rute Tunggal
use Illuminate\Support\Facades\Route;
// Hanya Admin yang bisa mengakses rute ini (Pre-Middleware)
Route::get('/admin/dashboard', [AdminController::class, 'index'])
->middleware('auth.role:admin');
Perhatikan sintaks auth.role:admin. Ini adalah cara Anda meneruskan argumen (admin) ke metode handle di dalam middleware CheckUserRole.
B. Pada Grup Rute
// Semua rute dalam grup ini harus dilalui oleh middleware 'auth' (default Laravel)
Route::middleware(['auth', 'verified'])->group(function () {
Route::get('/profile', [UserController::class, 'profile']);
Route::post('/settings', [UserController::class, 'updateSettings']);
});
3. Middleware pada Controller
Anda juga dapat mendefinisikan middleware langsung di dalam Controller. Untuk Laravel 12, best practice adalah menggunakan trait HasMiddleware dan metode statis middleware().
// app/Http/Controllers/PostController.php
namespace App\Http\Controllers;
use Illuminate\Routing\Controllers\HasMiddleware;
use Illuminate\Routing\Controllers\Middleware;
class PostController extends Controller implements HasMiddleware
{
/**
* Get the middleware that should be assigned to the controller.
*/
public static function middleware(): array
{
return [
// Menerapkan middleware 'auth' ke SEMUA metode di controller ini
'auth',
// Menerapkan middleware 'log' HANYA ke metode 'index'
new Middleware('log', only: ['index']),
// Menerapkan middleware 'throttle:60,1' (rate limit) ke SEMUA kecuali metode 'show'
new Middleware('throttle:60,1', except: ['show']),
];
}
// ... metode index(), show(), dll.
}
Menggunakan metode middleware() pada controller seperti ini adalah cara yang sangat bersih dan mudah dibaca untuk mengelola middleware pada controller.
Studi Kasus Lanjutan & Best Practice Middleware
1. Middleware yang Dapat Diakhiri (Terminable Middleware)
Terkadang, Anda perlu melakukan beberapa pekerjaan setelah respons HTTP telah dikirimkan ke browser pengguna. Misalnya, Anda ingin menyimpan data statistik ke database atau mengirim notifikasi. Ini adalah peran dari Terminable Middleware.
Implementasi
- Buat middleware Anda mengimplementasikan interface Illuminate\Contracts\Http\TerminableMiddleware.
- Definisikan metode terminate(Request $request, Response $response).
// app/Http/Middleware/LogRequestStats.php
use Illuminate\Http\Request;
use Symfony\Component\HttpFoundation\Response;
use Illuminate\Contracts\Http\TerminableMiddleware;
class LogRequestStats implements TerminableMiddleware
{
public function handle(Request $request, Closure $next): Response
{
// 1. Logika Pre-Middleware (sebelum Controller)
return $next($request);
}
public function terminate(Request $request, Response $response): void
{
// 2. Logika Post-Response (setelah Respons dikirim)
$duration = microtime(true) - LARAVEL_START;
\Log::info("Request [{$request->url()}] finished in {$duration} seconds.");
// Simpan statistik ke database tanpa menahan respons pengguna
}
}
Ini meningkatkan performa secara signifikan karena pengguna tidak perlu menunggu proses tambahan yang memakan waktu.
2. Prioritas Middleware (Route Groups)
Ketika beberapa middleware diterapkan, penting untuk memahami urutan eksekusinya. Middleware grup (misalnya web atau api) memiliki urutan eksekusi yang ditentukan di bootstrap/app.php.
Anda dapat menentukan prioritas yang jelas untuk memastikan middleware penting (seperti CSRF atau otentikasi) dijalankan terlebih dahulu. Ini dilakukan di dalam withMiddleware di bootstrap/app.php:
// bootstrap/app.php
// ...
->withMiddleware(function (Middleware $middleware) {
// ... alias dan global ...
$middleware->priority([
\Illuminate\Cookie\Middleware\EncryptCookies::class, // Prioritas TINGGI
\Illuminate\Session\Middleware\StartSession::class,
\Illuminate\View\Middleware\ShareErrorsFromSession::class,
\Illuminate\Foundation\Http\Middleware\ValidateCsrfToken::class,
\Illuminate\Routing\Middleware\ThrottleRequests::class, // Prioritas RENDAH
\Illuminate\Routing\Middleware\SubstituteBindings::class,
\Illuminate\Auth\Middleware\Authenticate::class, // Prioritas RENDAH
]);
})
// ...
Selalu pastikan middleware keamanan (seperti ValidateCsrfToken) memiliki prioritas yang lebih tinggi daripada middleware yang menjalankan logika bisnis.