Laravel 9 adalah framework PHP yang powerful dan elegan, ideal untuk mengembangkan aplikasi web modern. Salah satu kemampuan dasar yang wajib dikuasai adalah CRUD (Create, Read, Update, Delete). Dalam tutorial ini, kita akan belajar tutorial membuat aplikasi CRUD dengan Laravel 9, langkah demi langkah, dari awal hingga akhir. Siapkan secangkir kopi, dan mari kita mulai!
Daftar Isi
- Pendahuluan: Mengapa Laravel 9 untuk CRUD?
- Persiapan Lingkungan Pengembangan Laravel 9
- Membuat Proyek Laravel 9 Baru
- Membuat Model dan Migrasi Database
- Konfigurasi Database dan Migrasi
- Membuat Controller untuk Mengelola Data
- Membuat Route untuk Menangani Request
- Membuat View dengan Blade Template Engine
- Implementasi Fitur Create (Membuat Data Baru)
- Implementasi Fitur Read (Membaca Data)
- Implementasi Fitur Update (Memperbarui Data)
- Implementasi Fitur Delete (Menghapus Data)
- Validasi Data dan Keamanan
- Kesimpulan dan Langkah Selanjutnya
Pendahuluan: Mengapa Laravel 9 untuk CRUD?
Mengapa kita memilih Laravel 9 untuk tutorial membuat aplikasi CRUD ini? Jawabannya sederhana: Laravel 9 menawarkan berbagai keunggulan yang memudahkan proses pengembangan. Beberapa di antaranya:
- Sintaks yang Elegan: Laravel dikenal dengan sintaksnya yang bersih dan mudah dibaca, membuat kode lebih mudah dipahami dan dipelihara.
- ORM Eloquent: Eloquent ORM menyediakan cara yang mudah dan intuitif untuk berinteraksi dengan database. Kita tidak perlu menulis query SQL yang rumit.
- Blade Template Engine: Blade memungkinkan kita membuat tampilan (view) dengan mudah dan efisien, dengan fitur-fitur seperti templating, layouts, dan components.
- Middleware dan Keamanan: Laravel menyediakan middleware yang kuat untuk menangani otentikasi, otorisasi, dan berbagai aspek keamanan lainnya.
- Komunitas yang Besar: Dengan komunitas yang besar, kita dapat dengan mudah menemukan solusi untuk masalah yang mungkin muncul.
- Fitur CRUD Otomatis dengan Artisan: Laravel menyediakan Artisan, sebuah command-line interface (CLI) yang memungkinkan kita membuat model, controller, dan migrasi dengan mudah.
Dengan semua keunggulan ini, Laravel 9 menjadi pilihan yang sangat baik untuk membuat aplikasi CRUD. Mari kita mulai!
Persiapan Lingkungan Pengembangan Laravel 9
Sebelum memulai tutorial membuat aplikasi CRUD dengan Laravel 9, kita perlu mempersiapkan lingkungan pengembangan terlebih dahulu. Pastikan Anda telah menginstal:
-
PHP: Laravel 9 membutuhkan PHP versi 8.0 atau lebih tinggi. Anda bisa mengunduhnya dari php.net. Pastikan juga ekstensi PHP yang dibutuhkan oleh Laravel telah aktif. Ekstensi-ekstensi penting tersebut adalah
BCMath,Ctype,Fileinfo,JSON,Mbstring,OpenSSL,PDO,Tokenizer,XML,curldanZIP. -
Composer: Composer adalah dependency manager untuk PHP. Gunakan Composer untuk menginstal dan mengelola dependencies Laravel. Anda bisa mengunduhnya dari getcomposer.org.
-
Database: Anda bisa menggunakan MySQL, PostgreSQL, SQLite, atau database lain yang didukung oleh Laravel. Pastikan database server Anda sudah berjalan. Contoh, jika menggunakan XAMPP, pastikan service MySQL sudah running.
-
Text Editor atau IDE: Gunakan text editor atau IDE favorit Anda untuk menulis kode. Beberapa pilihan populer adalah Visual Studio Code, Sublime Text, dan PHPStorm.
-
Node.js dan NPM (opsional): Node.js dan NPM (Node Package Manager) diperlukan jika Anda ingin menggunakan Laravel Mix untuk mengelola assets seperti CSS dan JavaScript. Anda bisa mengunduhnya dari nodejs.org.
Setelah semua persiapan selesai, mari kita lanjut ke langkah berikutnya.
Membuat Proyek Laravel 9 Baru
Sekarang kita akan membuat proyek Laravel 9 baru. Buka terminal atau command prompt Anda, dan jalankan perintah berikut:
composer create-project laravel/laravel crud-app
cd crud-appPerintah ini akan membuat direktori baru bernama crud-app dan menginstal semua dependencies Laravel 9 di dalamnya. Tunggu hingga proses instalasi selesai.
Setelah instalasi selesai, kita bisa menjalankan server pengembangan Laravel dengan perintah:
php artisan serveBuka browser Anda dan kunjungi http://localhost:8000. Jika Anda melihat halaman selamat datang Laravel, berarti proyek Anda berhasil dibuat!
Membuat Model dan Migrasi Database
Dalam tutorial membuat aplikasi CRUD ini, kita akan membuat aplikasi sederhana untuk mengelola data Posts. Oleh karena itu, kita perlu membuat model dan migrasi database untuk tabel posts.
Gunakan Artisan untuk membuat model dan migrasi secara bersamaan:
php artisan make:model Post -mPerintah ini akan membuat dua file:
app/Models/Post.php: ModelPostuntuk berinteraksi dengan tabelposts.database/migrations/<timestamp>_create_posts_table.php: File migrasi untuk membuat tabelposts.
Buka file migrasi (database/migrations/<timestamp>_create_posts_table.php) dan modifikasi skema tabel posts sesuai dengan kebutuhan Anda. Contoh:
<?php
use IlluminateDatabaseMigrationsMigration;
use IlluminateDatabaseSchemaBlueprint;
use IlluminateSupportFacadesSchema;
return new class extends Migration
{
/**
* Run the migrations.
*
* @return void
*/
public function up()
{
Schema::create('posts', function (Blueprint $table) {
$table->id();
$table->string('title');
$table->text('content');
$table->timestamps();
});
}
/**
* Reverse the migrations.
*
* @return void
*/
public function down()
{
Schema::dropIfExists('posts');
}
};Dalam contoh ini, kita membuat tabel posts dengan kolom id, title, content, created_at, dan updated_at. Sesuaikan kolom-kolom ini sesuai dengan kebutuhan aplikasi Anda.
Konfigurasi Database dan Migrasi
Sebelum menjalankan migrasi, kita perlu mengkonfigurasi koneksi database. Buka file .env di root direktori proyek Anda, dan modifikasi variabel-variabel berikut sesuai dengan konfigurasi database Anda:
DB_CONNECTION=mysql
DB_HOST=127.0.0.1
DB_PORT=3306
DB_DATABASE=crud-app
DB_USERNAME=root
DB_PASSWORD=Pastikan Anda telah membuat database dengan nama crud-app di server database Anda.
Setelah konfigurasi database selesai, jalankan migrasi untuk membuat tabel posts:
php artisan migrateJika migrasi berhasil, Anda akan melihat pesan sukses di terminal. Sekarang, tabel posts telah dibuat di database Anda.
Membuat Controller untuk Mengelola Data
Selanjutnya dalam tutorial membuat aplikasi CRUD dengan Laravel 9 ini, kita akan membuat controller untuk mengelola data Posts. Gunakan Artisan untuk membuat controller:
php artisan make:controller PostController --resourcePerintah ini akan membuat file app/Http/Controllers/PostController.php. Opsi --resource akan membuat controller dengan method-method standar untuk CRUD:
index(): Menampilkan daftar semuaPosts.create(): Menampilkan form untuk membuatPostbaru.store(): MenyimpanPostbaru ke database.show($id): Menampilkan detailPostdengan ID tertentu.edit($id): Menampilkan form untuk mengeditPostdengan ID tertentu.update($id): MemperbaruiPostdengan ID tertentu di database.destroy($id): MenghapusPostdengan ID tertentu dari database.
Buka file app/Http/Controllers/PostController.php dan implementasikan method-method tersebut. Kita akan mengisinya satu per satu di bagian-bagian selanjutnya.
Membuat Route untuk Menangani Request
Setelah membuat controller, kita perlu membuat route untuk menangani request ke controller tersebut. Buka file routes/web.php dan tambahkan route berikut:
<?php
use AppHttpControllersPostController;
use IlluminateSupportFacadesRoute;
/*
|--------------------------------------------------------------------------
| Web Routes
|--------------------------------------------------------------------------
|
| Here is where you can register web routes for your application. These
| routes are loaded by the RouteServiceProvider within a group which
| contains the "web" middleware group. Now create something great!
|
*/
Route::resource('posts', PostController::class);Route resource secara otomatis akan membuat route-route berikut:
| Method | URI | Action | Route Name |
|---|---|---|---|
| GET | /posts | index | posts.index |
| GET | /posts/create | create | posts.create |
| POST | /posts | store | posts.store |
| GET | /posts/{post} | show | posts.show |
| GET | /posts/{post}/edit | edit | posts.edit |
| PUT/PATCH | /posts/{post} | update | posts.update |
| DELETE | /posts/{post} | destroy | posts.destroy |
Dengan route ini, kita dapat mengakses method-method controller PostController melalui URL yang sesuai.
Membuat View dengan Blade Template Engine
Dalam tutorial membuat aplikasi CRUD Laravel 9 ini, kita akan membuat view menggunakan Blade template engine. Buat direktori resources/views/posts untuk menyimpan view-view terkait Posts.
Kita akan membuat beberapa file view:
index.blade.php: Menampilkan daftar semuaPosts.create.blade.php: Menampilkan form untuk membuatPostbaru.show.blade.php: Menampilkan detailPostdengan ID tertentu.edit.blade.php: Menampilkan form untuk mengeditPostdengan ID tertentu.
Contoh index.blade.php:
<!DOCTYPE html>
<html>
<head>
<title>Daftar Post</title>
</head>
<body>
<h1>Daftar Post</h1>
<a href="{{ route('posts.create') }}">Buat Post Baru</a>
<table>
<thead>
<tr>
<th>Judul</th>
<th>Konten</th>
<th>Aksi</th>
</tr>
</thead>
<tbody>
@foreach ($posts as $post)
<tr>
<td>{{ $post->title }}</td>
<td>{{ $post->content }}</td>
<td>
<a href="{{ route('posts.show', $post->id) }}">Lihat</a>
<a href="{{ route('posts.edit', $post->id) }}">Edit</a>
<form action="{{ route('posts.destroy', $post->id) }}" method="POST">
@csrf
@method('DELETE')
<button type="submit">Hapus</button>
</form>
</td>
</tr>
@endforeach
</tbody>
</table>
</body>
</html>Contoh create.blade.php:
<!DOCTYPE html>
<html>
<head>
<title>Buat Post Baru</title>
</head>
<body>
<h1>Buat Post Baru</h1>
<form action="{{ route('posts.store') }}" method="POST">
@csrf
<div>
<label for="title">Judul:</label>
<input type="text" id="title" name="title">
</div>
<div>
<label for="content">Konten:</label>
<textarea id="content" name="content"></textarea>
</div>
<button type="submit">Simpan</button>
</form>
</body>
</html>Buat file view lainnya (show.blade.php dan edit.blade.php) dengan struktur yang serupa. Sesuaikan tampilan dan elemen form sesuai dengan kebutuhan Anda.
Implementasi Fitur Create (Membuat Data Baru)
Sekarang, mari kita implementasikan fitur Create. Pada PostController, implementasikan method create() dan store():
<?php
namespace AppHttpControllers;
use AppModelsPost;
use IlluminateHttpRequest;
class PostController extends Controller
{
/**
* Display a listing of the resource.
*
* @return IlluminateHttpResponse
*/
public function index()
{
$posts = Post::all();
return view('posts.index', compact('posts'));
}
/**
* Show the form for creating a new resource.
*
* @return IlluminateHttpResponse
*/
public function create()
{
return view('posts.create');
}
/**
* Store a newly created resource in storage.
*
* @param IlluminateHttpRequest $request
* @return IlluminateHttpResponse
*/
public function store(Request $request)
{
$request->validate([
'title' => 'required',
'content' => 'required',
]);
Post::create($request->all());
return redirect()->route('posts.index')
->with('success','Post berhasil ditambahkan.');
}
// ... (method lainnya)
}Method create() menampilkan view posts.create yang berisi form untuk membuat Post baru. Method store() menerima data dari form, memvalidasinya, dan menyimpannya ke database menggunakan model Post. Setelah berhasil disimpan, pengguna akan diarahkan kembali ke halaman posts.index.
Implementasi Fitur Read (Membaca Data)
Selanjutnya, kita akan mengimplementasikan fitur Read. Pada PostController, implementasikan method index() dan show():
<?php
namespace AppHttpControllers;
use AppModelsPost;
use IlluminateHttpRequest;
class PostController extends Controller
{
// ... (method sebelumnya)
/**
* Display the specified resource.
*
* @param AppModelsPost $post
* @return IlluminateHttpResponse
*/
public function show(Post $post)
{
return view('posts.show',compact('post'));
}
// ... (method lainnya)
}Method index() mengambil semua data Posts dari database dan menampilkannya di view posts.index. Method show() menerima ID Post sebagai parameter, mengambil data Post dengan ID tersebut dari database, dan menampilkannya di view posts.show.
Implementasi Fitur Update (Memperbarui Data)
Mari kita implementasikan fitur Update. Pada PostController, implementasikan method edit() dan update():
<?php
namespace AppHttpControllers;
use AppModelsPost;
use IlluminateHttpRequest;
class PostController extends Controller
{
// ... (method sebelumnya)
/**
* Show the form for editing the specified resource.
*
* @param AppModelsPost $post
* @return IlluminateHttpResponse
*/
public function edit(Post $post)
{
return view('posts.edit',compact('post'));
}
/**
* Update the specified resource in storage.
*
* @param IlluminateHttpRequest $request
* @param AppModelsPost $post
* @return IlluminateHttpResponse
*/
public function update(Request $request, Post $post)
{
$request->validate([
'title' => 'required',
'content' => 'required',
]);
$post->update($request->all());
return redirect()->route('posts.index')
->with('success','Post berhasil diperbarui.');
}
// ... (method lainnya)
}Method edit() menerima ID Post sebagai parameter, mengambil data Post dengan ID tersebut dari database, dan menampilkannya di view posts.edit yang berisi form untuk mengedit Post. Method update() menerima data dari form, memvalidasinya, dan memperbarui data Post di database. Setelah berhasil diperbarui, pengguna akan diarahkan kembali ke halaman posts.index.
Implementasi Fitur Delete (Menghapus Data)
Terakhir, kita akan mengimplementasikan fitur Delete. Pada PostController, implementasikan method destroy():
<?php
namespace AppHttpControllers;
use AppModelsPost;
use IlluminateHttpRequest;
class PostController extends Controller
{
// ... (method sebelumnya)
/**
* Remove the specified resource from storage.
*
* @param AppModelsPost $post
* @return IlluminateHttpResponse
*/
public function destroy(Post $post)
{
$post->delete();
return redirect()->route('posts.index')
->with('success','Post berhasil dihapus.');
}
}Method destroy() menerima ID Post sebagai parameter, mengambil data Post dengan ID tersebut dari database, dan menghapusnya dari database. Setelah berhasil dihapus, pengguna akan diarahkan kembali ke halaman posts.index.
Validasi Data dan Keamanan
Validasi data sangat penting untuk memastikan data yang disimpan ke database valid dan konsisten. Kita telah menggunakan validasi sederhana di method store() dan update() pada PostController. Namun, Anda bisa menambahkan validasi yang lebih kompleks sesuai dengan kebutuhan aplikasi Anda.
Selain validasi, keamanan juga merupakan aspek penting dalam pengembangan aplikasi web. Pastikan Anda selalu menggunakan fitur-fitur keamanan yang disediakan oleh Laravel, seperti:
- CSRF Protection: Laravel secara otomatis menyediakan perlindungan terhadap serangan Cross-Site Request Forgery (CSRF).
- Input Sanitization: Bersihkan input pengguna untuk mencegah serangan SQL injection dan XSS.
- Authentication and Authorization: Gunakan fitur otentikasi dan otorisasi Laravel untuk mengontrol akses ke resource aplikasi Anda.
Kesimpulan dan Langkah Selanjutnya
Selamat! Anda telah berhasil menyelesaikan tutorial membuat aplikasi CRUD dengan Laravel 9. Anda telah belajar cara membuat model, migrasi, controller, route, dan view. Anda juga telah mengimplementasikan fitur Create, Read, Update, dan Delete.
Langkah selanjutnya adalah:
- Meningkatkan Tampilan: Percantik tampilan aplikasi Anda dengan CSS dan JavaScript.
- Menambahkan Fitur Tambahan: Tambahkan fitur-fitur lain yang Anda butuhkan, seperti pagination, search, dan filtering.
- Deploy ke Server: Deploy aplikasi Anda ke server agar dapat diakses oleh pengguna lain.
- Mempelajari Lebih Lanjut: Terus pelajari fitur-fitur Laravel lainnya dan praktik terbaik dalam pengembangan web.
Semoga tutorial membuat aplikasi CRUD dengan Laravel 9 ini bermanfaat bagi Anda. Selamat berkarya!
