Blog

Controller adalah salah satu komponen paling sering ditulis di Laravel. Hampir setiap fitur butuh controller: dari menampilkan halaman, menyimpan data form, sampai mengembalikan JSON untuk API.

Artikel ini membahas cara membuat controller di Laravel 12: dari controller dasar, resource controller, sampai best practice yang dipakai tim profesional.

Membuat Controller Baru

Gunakan perintah Artisan:

php artisan make:controller ArticleController

File akan dibuat di app/Http/Controllers/ArticleController.php:

<?php

namespace AppHttpControllers;

use IlluminateHttpRequest;

class ArticleController extends Controller
{
    //
}

Tambahkan method sesuai kebutuhan. Misalnya untuk menampilkan daftar artikel:

public function index()
{
    $articles = Article::latest()->paginate(10);
    return view('articles.index', compact('articles'));
}

public function show(Article $article)
{
    return view('articles.show', compact('article'));
}

Resource Controller

Kalau Anda butuh semua operasi CRUD sekaligus, pakai flag --resource:

php artisan make:controller ArticleController --resource

Laravel akan generate 7 method sekaligus: index, create, store, show, edit, update, destroy.

Daftarkan ke route dengan satu baris:

Route::resource('articles', ArticleController::class);

Ini otomatis membuat route untuk semua aksi CRUD, tidak perlu daftar satu per satu.

API Resource Controller

Untuk API yang tidak butuh halaman form (create/edit), pakai flag --api:

php artisan make:controller Api/ArticleController --api

Hasilnya hanya 5 method: index, store, show, update, destroy. Tanpa create dan edit.

Route::apiResource('articles', ApiArticleController::class);

Dependency Injection di Controller

Laravel mendukung dependency injection lewat constructor. Ini cara yang direkomendasikan untuk inject service:

<?php

namespace AppHttpControllers;

use AppServicesArticleService;
use IlluminateHttpRequest;

class ArticleController extends Controller
{
    public function __construct(
        private ArticleService $articleService
    ) {}

    public function store(Request $request)
    {
        $validated = $request->validate([
            'title'   => 'required|string|max:255',
            'content' => 'required|string',
            'status'  => 'required|in:draft,published',
        ]);

        $article = $this->articleService->create($validated);

        return redirect()->route('articles.show', $article)
                         ->with('success', 'Artikel berhasil dibuat.');
    }
}

Middleware di Controller

Di Laravel 12, cara attach middleware ke controller berubah. Tidak lagi lewat constructor, tapi lewat method middleware() di route atau lewat static method di controller:

// Di routes/web.php
Route::resource('articles', ArticleController::class)
     ->middleware('auth');

// Atau partial — hanya method tertentu
Route::resource('articles', ArticleController::class)
     ->only(['store', 'update', 'destroy'])
     ->middleware('auth');

Kalau ingin lebih granular per-method, pakai route biasa:

Route::get('/articles', [ArticleController::class, 'index']);
Route::post('/articles', [ArticleController::class, 'store'])->middleware('auth');
Route::get('/articles/{article}', [ArticleController::class, 'show']);

Form Request untuk Validasi

Untuk controller yang lebih bersih, pindahkan validasi ke Form Request:

php artisan make:request StoreArticleRequest

<?php

namespace AppHttpRequests;

use IlluminateFoundationHttpFormRequest;

class StoreArticleRequest extends FormRequest
{
    public function authorize(): bool
    {
        return auth()->check();
    }

    public function rules(): array
    {
        return [
            'title'   => 'required|string|max:255',
            'content' => 'required|string|min:100',
            'status'  => 'required|in:draft,published',
        ];
    }
}

Gunakan di controller:

public function store(StoreArticleRequest $request)
{
    $article = Article::create($request->validated());

    return redirect()->route('articles.show', $article)
                     ->with('success', 'Artikel disimpan.');
}

Controller jadi lebih ringkas karena validasi sudah diurus Form Request.

Nested Resource Controller

Kalau ada relasi hierarkis, misalnya komentar yang dimiliki artikel, gunakan nested resource:

Route::resource('articles.comments', CommentController::class);

URL yang dihasilkan: /articles/{article}/comments/{comment}

Controller-nya otomatis menerima kedua model sebagai parameter:

public function store(Request $request, Article $article)
{
    $comment = $article->comments()->create([
        'body'    => $request->validated('body'),
        'user_id' => auth()->id(),
    ]);

    return redirect()->route('articles.show', $article);
}

Baca Juga

• Routing di Laravel: Panduan Lengkap dengan Contoh Kode
• Invokable Controller: Kapan Dipakai dan Bagaimana Cara Kerjanya

Butuh tim untuk membangun aplikasi web berbasis Laravel dari awal? Lihat layanan pengembangan aplikasi kami.

Baca Juga

• cara install Laravel 11 dari awal

Pada artikel ini kita akan membahas cara membuat controller di laravel 11 secara praktis, dari persiapan lingkungan hingga implementasi praktis dan best practice. Laravel sebagai framework PHP modern memudahkan pengelolaan arsitektur aplikasi dengan konsep controller, routing, dan dependency injection. Dalam konteks proyek nyata, memahami cara membangun controller yang bersih, terstruktur, dan maintainable adalah pondasi utama. Panduan ini dirancang untuk pemula hingga developer berpengalaman, dengan contoh kode yang bisa langsung dicoba di lingkungan lokal. Kami juga akan membahas bagaimana menjaga kode tetap scalable, mudah dites, dan mudah dipelihara seiring bertambahnya kompleksitas proyek. Kami menekankan bahwa praktik yang tepat saat membuat controller di laravel 11 akan mempercepat pengembangan, mengurangi bug, serta meningkatkan kemudahan kolaborasi antar tim.

Persiapan Lingkungan Laravel 11

Untuk memulai, pastikan lingkungan pengembangan sudah siap. Anda memerlukan PHP >= 8.1, Composer, dan Laravel 11. Instalasi bisa dilakukan melalui Composer create-project atau laravel/installer. Pastikan ekstensi yang diperlukan seperti PDO, BCMath, OpenSSL tersedia. Setelah itu, buat project baru:

composer create-project laravel/laravel blog-laravel11 "11.x"

Langkah ini menyiapkan fondasi MVC standar, sehingga Anda bisa mulai membangun membuat controller di laravel 11 dengan perintah Artisan. Bila Anda membutuhkan referensi langkah demi langkah, lihat Layanan Arrazy Inovasi untuk solusi terkait pengembangan web.

Selain itu, sebaiknya Anda merujuk juga pada Dokumentasi Laravel Resmi dan Dokumentasi PHP untuk memahami opsi konfigurasi serta best practice penerapan arsitektur pada proyek nyata.

Membuat Controller Pertama dengan Artisan

Setelah proyek siap, langkah selanjutnya adalah membuat controller pertama. Gunakan Artisan untuk meng-generate controller secara cepat:

php artisan make:controller HelloWorldController

Untuk sebuah API atau halaman berita, Anda juga bisa membuat membuat controller di laravel 11 dengan opsi resource:

php artisan make:controller ArticleController --resource

Berikut contoh struktur dasar controller yang bisa Anda adaptasi:

namespace App\Http\Controllers;

use App\Http\Controllers\Controller;
use Illuminate\Http\Request;

class HelloWorldController extends Controller
{
public function index()
{
return view('hello.index');
}
}

Pelajari bagaimana alur request menuju controller bisa divalidasi sederhana dengan Request type hinting, sehingga membuat controller di laravel 11 menjadi lebih elegan dan mudah di-test. Untuk referensi praktis, kunjungi Layanan Arrazy Inovasi.

Routing dan Pemanfaatan Controller

Setelah controller dibuat, ikuti langkah berikut untuk menghubungkannya dengan routing. Untuk halaman biasa:

// routes/web.php
use App\Http\Controllers\HelloWorldController;
Route::get('/hello', [HelloWorldController::class, 'index']);

Untuk struktur CRUD dengan resource controller:

Route::resource('articles', ArticleController::class);

Dengan routing yang terdefinisi, membuat controller di laravel 11 akan segera bisa diakses melalui URL. Jika Anda ingin solusi end-to-end, lihat Layanan Arrazy Inovasi Teknologi.

Resource Controller untuk CRUD

Resource controller memudahkan implementasi operasi Create, Read, Update, Delete. Dengan satu deklarasi, Laravel akan mengerti semua rute konvensional. Berikut contoh metode inti yang umum dipakai:

public function index() { ... }
public function show($id) { ... }
public function store(Request $request) { ... }
public function update(Request $request, $id) { ... }
public function destroy($id) { ... }

Contoh Struktur File Controller

Berikut contoh file Controller lengkap untuk Article dengan beberapa metode:

namespace App\\Http\\Controllers;

use App\\Http\\Controllers\\Controller;
use Illuminate\\Http\\Request;
use App\\Models\\Article;

class ArticleController extends Controller
{
public function index()
{
$articles = Article::all();
return view('articles.index', compact('articles'));
}

public function create()
{
return view('articles.create');
}

public function store(Request $request)
{
$data = $request->validate(['title' => 'required|string', 'content' => 'required']);
Article::create($data);
return redirect()->route('articles.index');
}

public function show(Article $article)
{
return view('articles.show', compact('article'));
}

public function edit(Article $article)
{
return view('articles.edit', compact('article'));
}

public function update(Request $request, Article $article)
{
$data = $request->validate(['title' => 'required|string', 'content' => 'required']);
$article->update($data);
return redirect()->route('articles.index');
}

public function destroy(Article $article)
{
$article->delete();
return redirect()->route('articles.index');
}
}

Dengan struktur seperti ini, membuat controller di laravel 11 tidak lagi menjadi pekerjaan yang menakutkan. Untuk mengecek integrasi dengan view dan model, bagian berikutnya akan membantu Anda memahami pola penggunaan view dan dependency injection.

Integrasi dengan View dan Dependency Injection

Controller di Laravel biasanya bekerja bersama View (Blade) dan model. Anda bisa mengembalikan data ke view dengan compact, atau menggunakan resource responses untuk API. Dependency Injection memudahkan pengambilan layanan (misalnya repository) tanpa membuat instance secara manual. Contoh sederhana:

public function index()
{
$items = Item::all();
return view('items.index', compact('items'));
}

Menyiapkan layanan khusus dapat dilakukan melalui constructor injection, sehingga logika bisnis tidak tertumpuk di controller. Jika Anda ingin solusi end-to-end, telusuri lebih lanjut di Layanan Arrazy Inovasi untuk memahami bagaimana arsitektur layanan dapat meningkatkan kualitas proyek Anda.

Praktik Terbaik dan Keamanan

Beberapa praktik terbaik saat membuat controller di laravel 11 meliputi:

– Memisahkan logika presentasi dari logika bisnis dengan menggunakan service class atau repository.

– Menggunakan Form Request untuk validasi agar controller tetap bersih.

– Mengunci akses dengan middleware sesuai kebutuhan (auth, role-based access, dll).

– Menjaga ukuran controller tetap kecil dengan membagi fungsi ke dalam kelas yang jelas.

– Menambahkan komentar yang relevan dan dokumentasi singkat di tiap metode penting. Pelajari bagaimana Laravel menangani request lifecycle melalui Dokumentasi Laravel Resmi untuk pemahaman yang lebih dalam.

Kalau Anda butuh dukungan implementasi nyata, Layanan Arrazy Inovasi siap membantu Anda—mulai dari pengembangan website hingga solusi integrasi ERP berbasis Laravel.

Di tengah tutorial ini, Anda juga bisa meninjau beberapa layanan utama yang relevan, seperti Jasa Pembuatan Website, Jasa Pembuatan Aplikasi Mobile, Jasa SEO, Jasa Pembuatan Chatbot, dan Jasa Website Sekolah untuk kebutuhan edukasi digital Anda.

Selain itu, untuk memperkaya referensi teknis Anda, lihat juga dokumentasi terbaru pada Dokumentasi PHP dan Dokumentasi Laravel Resmi sebagai pedoman standar industri.

Penutup yang Menginspirasi

Dengan memahami cara membuat controller di laravel 11 melalui pendekatan yang terstruktur, Anda akan lebih percaya diri mengelola proyek Laravel berukuran kecil maupun besar. Kunci utamanya adalah memulai dari konsep sederhana, lalu secara bertahap menambah kompleksitas dengan pola desain yang telah teruji. Jika Anda ingin mempercepat waktu implementasi, Layanan Arrazy Inovasi siap membantu Anda menyusun arsitektur aplikasi yang kuat bersama tim ahli kami.

Terima kasih telah mengikuti panduan ini. Semoga langkah demi langkah dalam tutorial ini membantu Anda memahami bagaimana membuat controller di laravel 11 secara praktis dan profesional. Jangan ragu untuk menjangkau tim kami untuk bantuan lebih lanjut.

Routing adalah pintu masuk semua request di Laravel. Sebelum request sampai ke controller atau logika apapun, dia harus melewati router dulu. Memahami cara kerja routing akan membuat kamu lebih mudah membangun struktur aplikasi yang rapi dan mudah di-maintain.

Konsep Dasar: Bagaimana Request Diproses

Saat browser mengirim request ke GET /posts, Laravel membaca file routes/web.php, mencari route yang cocok, lalu meneruskan ke handler yang ditentukan. Urutan ini tidak bisa dibalik.

Bentuk route paling sederhana:

// routes/web.php
Route::get('/posts', function () {
    return 'Daftar semua post';
});

// Atau langsung ke controller
Route::get('/posts', [PostController::class, 'index']);

HTTP Method yang Tersedia

Route::get('/posts', [PostController::class, 'index']);
Route::post('/posts', [PostController::class, 'store']);
Route::put('/posts/{id}', [PostController::class, 'update']);
Route::patch('/posts/{id}', [PostController::class, 'update']);
Route::delete('/posts/{id}', [PostController::class, 'destroy']);

Kalau mau handle lebih dari satu method sekaligus:

Route::match(['get', 'post'], '/form', [FormController::class, 'handle']);
Route::any('/webhook', [WebhookController::class, 'receive']);

Route Parameter

Parameter wajib — request harus menyertakan nilai ini:

Route::get('/users/{id}', function (string $id) {
    return "User ID: $id";
});

// Bisa langsung inject model (Route Model Binding)
Route::get('/users/{user}', function (User $user) {
    return $user; // otomatis cari User::find($id)
});

Parameter opsional — tambahkan ? dan nilai default:

Route::get('/posts/{slug?}', function (string $slug = 'semua') {
    return "Slug: $slug";
});

Tambahkan constraint untuk validasi parameter:

Route::get('/users/{id}', [UserController::class, 'show'])
    ->where('id', '[0-9]+');  // hanya menerima angka

Route::get('/posts/{slug}', [PostController::class, 'show'])
    ->where('slug', '[a-z0-9-]+');

Named Route

Named route memudahkan generate URL di dalam kode, tidak perlu hardcode string URL:

Route::get('/posts/{id}', [PostController::class, 'show'])
    ->name('posts.show');

// Generate URL dari nama
$url = route('posts.show', ['id' => 5]);
// Hasil: http://app.test/posts/5

// Redirect ke named route
return redirect()->route('posts.show', ['id' => 5]);

Route Group

Grup route berguna untuk menerapkan prefix, middleware, atau namespace secara serentak:

// Grup dengan prefix URL
Route::prefix('admin')->group(function () {
    Route::get('/dashboard', [AdminController::class, 'dashboard']);
    Route::get('/users', [AdminController::class, 'users']);
    // Accessible di: /admin/dashboard, /admin/users
});

// Grup dengan middleware
Route::middleware(['auth'])->group(function () {
    Route::get('/profile', [ProfileController::class, 'show']);
    Route::get('/settings', [SettingController::class, 'index']);
});

// Kombinasi keduanya
Route::middleware(['auth'])->prefix('dashboard')->group(function () {
    Route::get('/overview', [DashboardController::class, 'overview']);
});

Resource Route

Satu baris untuk membuat 7 route CRUD sekaligus:

Route::resource('posts', PostController::class);

Ini setara dengan:

GET     /posts              → index
GET     /posts/create       → create
POST    /posts              → store
GET     /posts/{post}       → show
GET     /posts/{post}/edit  → edit
PUT     /posts/{post}       → update
DELETE  /posts/{post}       → destroy

Kalau tidak butuh semua route:

// Hanya route tertentu
Route::resource('posts', PostController::class)
    ->only(['index', 'show']);

// Kecualikan route tertentu
Route::resource('posts', PostController::class)
    ->except(['create', 'edit']);

Melihat Semua Route yang Terdaftar

php artisan route:list

# Filter berdasarkan nama
php artisan route:list --name=posts

# Filter berdasarkan method
php artisan route:list --method=GET

Route Caching untuk Production

Di production, cache route agar lebih cepat:

php artisan route:cache

# Hapus cache (jalankan setelah ubah routes/)
php artisan route:clear

Baca juga: Membuat Controller di Laravel 12 dan Invokable Controller di Laravel.

Kalau kamu butuh tim untuk membangun aplikasi Laravel dari arsitektur awal sampai deployment, lihat layanan pengembangan aplikasi kami.

Ada satu fitur Laravel yang sering dilewatkan developer pemula: invokable controller. Padahal kalau dipakai di tempat yang tepat, kode jadi lebih bersih dan lebih mudah dibaca.

Artikel ini menjelaskan apa itu invokable controller, kapan sebaiknya dipakai, dan bagaimana cara implementasinya di Laravel 12.

Apa Itu Invokable Controller?

Invokable controller adalah controller yang hanya punya satu method: __invoke(). Karena hanya ada satu aksi, Anda tidak perlu menyebutkan nama method saat mendaftarkan route.

Ini berbeda dengan controller biasa yang bisa punya banyak method seperti index(), store(), update(), dll.

Buat invokable controller lewat Artisan:

php artisan make:controller ShowDashboardController --invokable

Hasilnya:

<?php

namespace AppHttpControllers;

use IlluminateHttpRequest;

class ShowDashboardController extends Controller
{
    public function __invoke(Request $request)
    {
        //
    }
}

Cara Mendaftarkan ke Route

Karena hanya ada satu aksi, cara daftarkan ke route cukup langsung pakai nama class-nya:

use AppHttpControllersShowDashboardController;

Route::get('/dashboard', ShowDashboardController::class);

Bandingkan dengan controller biasa yang harus sebut method-nya:

Route::get('/dashboard', [DashboardController::class, 'index']);

Lebih ringkas, dan route-nya lebih mudah dibaca, terutama kalau ada banyak route.

Contoh Kasus Nyata

Misalnya Anda punya halaman yang menampilkan laporan bulanan. Logikanya spesifik untuk satu tujuan, tidak perlu dibagi ke beberapa method:

<?php

namespace AppHttpControllersReports;

use IlluminateHttpRequest;
use AppHttpControllersController;
use AppModelsOrder;

class MonthlyReportController extends Controller
{
    public function __invoke(Request $request)
    {
        $month = $request->query('month', now()->month);
        $year  = $request->query('year', now()->year);

        $orders = Order::whereMonth('created_at', $month)
                       ->whereYear('created_at', $year)
                       ->with('customer')
                       ->get();

        return view('reports.monthly', compact('orders', 'month', 'year'));
    }
}

Route-nya:

Route::get('/reports/monthly', MonthlyReportController::class)
     ->middleware('auth')
     ->name('reports.monthly');

Rapi. Satu controller, satu tujuan.

Kapan Pakai Invokable Controller?

Invokable controller cocok untuk:

• Halaman yang hanya punya satu aksi (tampil laporan, proses webhook, generate PDF)
• Action handler — satu action spesifik yang tidak perlu dibundel dengan aksi lain
• Single-purpose endpoint yang ingin dipisah dari controller utama agar tidak membesar

Tidak cocok untuk resource yang punya banyak aksi CRUD. Untuk itu tetap pakai resource controller biasa.

Dependency Injection di Invokable Controller

Sama seperti controller biasa, Anda bisa inject service lewat constructor atau langsung di method __invoke():

<?php

namespace AppHttpControllers;

use AppServicesInvoiceService;
use IlluminateHttpRequest;

class GenerateInvoiceController extends Controller
{
    public function __construct(
        private InvoiceService $invoiceService
    ) {}

    public function __invoke(Request $request)
    {
        $validated = $request->validate([
            'order_id' => 'required|exists:orders,id',
        ]);

        $pdf = $this->invoiceService->generate($validated['order_id']);

        return response()->download($pdf);
    }
}

Baca Juga

• Membuat Controller di Laravel 12: Resource, Middleware, dan Best Practice
• Routing di Laravel: Panduan Lengkap dengan Contoh Kode

Kalau Anda butuh tim untuk membangun aplikasi web berbasis Laravel, dari arsitektur sampai deployment — lihat layanan pengembangan aplikasi kami.

Kamu baru mau mulai belajar Laravel 12 atau mau memulai project baru? Artikel ini memandu instalasi dari nol, mulai dari kebutuhan sistem, instalasi Laravel, sampai project pertama bisa jalan di browser.

Tidak ada yang dilewati. Setiap perintah dijelaskan kenapa dijalankan, bukan sekadar disalin.

Kebutuhan Sistem Sebelum Mulai

Pastikan versi PHP dan tools berikut sudah terpasang:

• PHP 8.2 atau lebih baru — Laravel 12 butuh minimal PHP 8.2
• Composer — package manager PHP, download di getcomposer.org
• Node.js + npm — untuk kompilasi asset frontend (Vite)
• Database — MySQL, PostgreSQL, atau SQLite

Cek versi PHP kamu:

php --version
# Harus menampilkan: PHP 8.2.x atau lebih baru

Instalasi Laravel 12 via Composer

Ada dua cara: lewat Laravel Installer atau langsung via Composer. Cara kedua lebih universal:

composer create-project laravel/laravel nama-project "12.*"
cd nama-project

Kalau mau pakai Laravel Installer (lebih cepat untuk project berikutnya):

# Install Laravel Installer sekali saja
composer global require laravel/installer

# Buat project baru
laravel new nama-project --using=laravel/12.x

Konfigurasi File .env

Setelah project dibuat, buka file .env di root project. Ini konfigurasi yang perlu diubah minimal:

APP_NAME=NamaAppKamu
APP_ENV=local
APP_KEY=                  # Akan diisi otomatis
APP_DEBUG=true
APP_URL=http://localhost

DB_CONNECTION=mysql
DB_HOST=127.0.0.1
DB_PORT=3306
DB_DATABASE=nama_database
DB_USERNAME=root
DB_PASSWORD=***

Generate application key: wajib dilakukan sekali saat setup:

php artisan key:generate

Perintah ini mengisi nilai APP_KEY di file .env secara otomatis. Key ini dipakai Laravel untuk enkripsi session dan cookie.

Menjalankan Migration

Laravel sudah menyertakan beberapa migration default (tabel users, sessions, cache, jobs). Jalankan semuanya sekaligus:

php artisan migrate

Kalau muncul error koneksi database, pastikan database yang kamu tulis di .env sudah dibuat terlebih dahulu:

# Di MySQL
CREATE DATABASE nama_database;

Jalankan Development Server

Laravel punya built-in development server lewat Artisan:

php artisan serve
# Akses di: http://127.0.0.1:8000

Atau kalau kamu pakai Vite untuk frontend (default di Laravel 12), jalankan keduanya di terminal berbeda:

# Terminal 1
php artisan serve

# Terminal 2
npm install
npm run dev

Struktur Folder yang Perlu Kamu Kenali

Tidak perlu hafal semua folder sekaligus. Ini yang paling sering dipakai:

app/
  Http/
    Controllers/    ← semua controller ada di sini
    Middleware/     ← middleware request
  Models/           ← Eloquent models
config/             ← konfigurasi aplikasi
database/
  migrations/       ← file migration tabel
routes/
  web.php           ← route untuk halaman web
  api.php           ← route untuk API
resources/
  views/            ← file Blade (template HTML)

Verifikasi Instalasi Berhasil

Buka http://127.0.0.1:8000 di browser. Kalau muncul halaman welcome Laravel dengan versi Laravel 12, instalasi berhasil.

Cek juga via Artisan:

php artisan --version
# Laravel Framework 12.x.x

Langkah Berikutnya

Setelah instalasi selesai, langkah selanjutnya:

Pelajari cara kerja routing: Routing di Laravel: Panduan Lengkap
Buat controller pertama: Membuat Controller di Laravel 12
Pahami migration: Migration di Laravel: Cara Kerja dan Semua Command


Kalau kamu sedang membangun project Laravel untuk client atau kebutuhan bisnis dan butuh tim yang berpengalaman, lihat layanan pengembangan aplikasi kami.






Baca Juga




panduan install Laravel 11