Clean Architecture: Dari Spaghetti Code ke Kode yang Bisa Dibaca Ulang



Saya pernah menulis kode yang rasanya masuk akal saat itu. Logikanya jelas, alurnya rapi, nama variabelnya deskriptif. Tiga bulan kemudian saya buka lagi file yang sama, lalu mikir, “ini tadi mau ngapain sih?” Ya, ternyata saya sendiri juga bisa bingung sama kode buatan sendiri hehe.

Di proyek GPS tracker yang pernah saya tangani, satu function mengurus semuanya: baca database, ubah status dan posisi kendaraan, kirim notifikasi, lalu bikin laporan. Praktis? Awalnya mungkin. Setelah kodenya tumbuh, ya mulai terasa.

Mengenali “Spaghetti Code” #

Spaghetti code bukan istilah teknis formal. Istilah ini menggambarkan kode yang saling terikat dan sulit dipisahkan, seperti mie spaghetti yang sulit diambil sehelai tanpa menarik yang lain.

Kira-kira begini bentuk function-nya (pseudocode):

function handleUpdatePosition(request):
    // Langsung query ke database
    vehicle = db.query("SELECT * FROM vehicles WHERE id = ?", request.vehicleId)

    if not vehicle:
        return error("Vehicle not found")

    // Business logic campur di sini
    if vehicle.status == "inactive":
        vehicle.status = "active"
        vehicle.lastActivation = now()

    // Update posisi
    db.query("UPDATE positions SET lat = ?, lng = ?, time = ? WHERE vehicleId = ?",
             request.lat, request.lng, now(), request.vehicleId)

    // Kirim notifikasi langsung dari sini
    if vehicle.hasAlert:
        email.send(vehicle.ownerEmail, "Alert: " + vehicle.name)
        sms.send(vehicle.ownerPhone, "Alert from " + vehicle.name)

    // Generate laporan langsung
    report = generateDailyReport(vehicle)
    db.query("INSERT INTO reports ...", report)

    return success(vehicle)

Bisa dilihat? Satu function nangkap semua, baca database, olah logika bisnis, kirim email, kirim SMS, generate laporan. Saat itu kelihatannya praktis. Tapi coba bayangkan:

┌─────────────────────────────────────────────────┐
│              Spaghetti Flow                      │
│                                                  │
│  Request ──► [Database + Logic + Email + Report] │
│                         │                        │
│                         ▼                        │
│              Semua menyatu.                      │
│              Ubah satu, risiko semua goyah.      │
└─────────────────────────────────────────────────┘

Clean Architecture, Versi Ringkasnya #

Robert C. Martin (Uncle Bob) memopulerkan istilah “Clean Architecture”. Kalau diringkas, idenya begini: logika bisnis jangan bergantung pada detail teknis seperti database, framework, atau API. Biar kedengarannya tidak lebih rumit dari yang perlu.

Logika bisnis biasanya lebih stabil daripada detail teknis. Contohnya aturan menghitung jarak, menentukan kendaraan aktif, dan menetapkan batas kecepatan. Database, framework, dan cara mengirim email adalah detail yang bisa berubah.

Aturan Ketergantungan (Dependency Rule) #

┌──────────────────────────────────────────────────────┐
│                                                      │
│   ┌─────────────────────────────────────────────┐   │
│   │              Entity                          │   │
│   │   Aturan bisnis inti. Paling dalam.          │   │
│   │   Tidak tergantung apapun.                   │   │
│   │                                              │   │
│   │   ┌──────────────────────────────────────┐  │   │
│   │   │          Use Case                     │  │   │
│   │   │   Apa yang sistem lakukan.            │  │   │
│   │   │   Tergantung ke Entity, bukan ke DB.  │  │   │
│   │   │                                       │  │   │
│   │   │   ┌───────────────────────────────┐  │  │   │
│   │   │   │     Infrastructure             │  │  │   │
│   │   │   │   Database, API, Email, SMS.   │  │  │   │
│   │   │   │   Detail teknis. Paling luar.  │  │  │   │
│   │   │   └───────────────────────────────┘  │  │   │
│   │   └──────────────────────────────────────┘  │   │
│   └─────────────────────────────────────────────┘   │
│                                                      │
│   Arah panah: luar ──► dalam                       │
│   Luar tergantung pada dalam. Dalam TIDAK tergantung │
│   pada luar.                                        │
└──────────────────────────────────────────────────────┘

Panah hanya boleh mengarah ke dalam. Entity tidak tahu tentang database, dan Use Case tidak tahu cara mengirim email. Infrastructure menangani detail teknis.

Kalau kontrak repository tetap sama, mengganti MySQL dengan PostgreSQL tidak mengharuskan perubahan pada Entity atau Use Case. Implementasi di Infrastructure yang berubah.

Tiga Layer yang Penting #

Nah, biasanya pembagian tanggung jawabnya dijelaskan lewat tiga layer ini:

1. Entity, Aturan Bisnis Inti

Ini berisi aturan bisnis inti yang tidak bergantung pada teknologi tertentu. Di proyek GPS tracker, contohnya:

class Vehicle:
    id, name, status, currentSpeed, speedLimit

    function isSpeeding():
        return currentSpeed > speedLimit

    function activate():
        if status == "inactive":
            status = "active"
            lastActivation = now()

Di sini tidak ada database query, HTTP request, atau framework. Isinya aturan bisnis: apakah kendaraan speeding dan bagaimana mengaktifkannya.

2. Use Case, Apa yang Sistem Lakukan

Use case mendefinisikan apa yang dilakukan sistem, tanpa peduli bagaimana detailnya.

class UpdatePositionUseCase:
    function execute(vehicleId, lat, lng):
        // 1. Cari kendaraan
        vehicle = vehicleRepository.findById(vehicleId)
        if not vehicle:
            return error("Vehicle not found")

        // 2. Update posisi
        vehicle.updatePosition(lat, lng)

        // 3. Simpan
        vehicleRepository.save(vehicle)

        // 4. Kalau speeding, trigger alert
        if vehicle.isSpeeding():
            alertService.sendSpeedAlert(vehicle)

Use case memanggil vehicleRepository dan alertService, tetapi tidak tahu apakah implementasinya memakai MySQL atau PostgreSQL, atau mengirim alert lewat email atau SMS. Yang diketahuinya hanya “cari kendaraan”, “simpan”, dan “kirim alert”.

Selama kontrak repository tidak berubah, database dapat diganti tanpa mengubah use case.

3. Infrastructure, Detail Teknis

Di sinilah detail implementasi berada: database, API, framework, dan email service.

class MySQLVehicleRepository:
    function findById(id):
        row = db.query("SELECT * FROM vehicles WHERE id = ?", id)
        return Vehicle(id: row.id, name: row.name, ...)

    function save(vehicle):
        db.query("UPDATE vehicles SET lat = ?, lng = ? WHERE id = ?",
                 vehicle.lat, vehicle.lng, vehicle.id)
class EmailAlertService:
    function sendSpeedAlert(vehicle):
        email.send(
            to: vehicle.ownerEmail,
            subject: "Speed Alert: " + vehicle.name,
            body: vehicle.name + " is going " + vehicle.currentSpeed
        )

Ini bagian yang boleh berubah. Kalau mau ganti MySQL ke PostgreSQL, ubah di sini. Kalau mau ganti email ke WhatsApp, ubah di sini. Entity dan Use Case tidak tersentuh.

Coba Terapkan ke Contoh GPS Tracker #

Berikut versi “clean” dari kode spaghetti di awal:

Before: Spaghetti #

Satu function menangani semuanya: membaca database, menjalankan logika, mengirim notifikasi, dan membuat laporan.

After: Clean #

// === Entity: Vehicle ===
// (aturan bisnis murni, tidak tergantung apapun)

class Vehicle:
    function updatePosition(lat, lng):
        this.lat = lat
        this.lng = lng
        this.lastUpdate = now()

    function isSpeeding():
        return this.currentSpeed > this.speedLimit

// === Use Case: UpdatePosition ===
// (apa yang dilakukan, tanpa peduli bagaimana)

class UpdatePositionUseCase:
    function execute(vehicleId, lat, lng):
        vehicle = repository.findById(vehicleId)
        if not vehicle:
            return error("Not found")

        vehicle.updatePosition(lat, lng)
        repository.save(vehicle)

        if vehicle.isSpeeding():
            alertService.sendSpeedAlert(vehicle)

        return success(vehicle)

// === Infrastructure ===
// (detail teknis, boleh berubah kapanpun)

class MySQLVehicleRepository:
    function findById(id):
        return db.query("SELECT ...")

    function save(vehicle):
        db.query("UPDATE ...")

class EmailAlertService:
    function sendSpeedAlert(vehicle):
        email.send(...)

Apa yang Berubah? #

Aspek Spaghetti Clean
Test logika bisnis Perlu setup DB + email Cuma test Vehicle class
Ganti database Ubah semua query di mana-mana Ubah cuma repository
Ganti cara alert Cari di seluruh codebase Ubah cuma AlertService
Onboarding developer baru Baca satu function panjang Baca per layer, mulai dari Entity
Efek samping perubahan Domino effect Terisolasi per layer

Setiap layer bisa diuji sendiri: Vehicle tanpa database, UpdatePositionUseCase dengan mock repository, dan MySQLVehicleRepository secara terpisah.

Kalau Proyeknya Kecil Gimana? #

Mungkin kamu sedang berpikir, “Ini kan buat proyek gede. Skripsi saya cuma aplikasi kecil.” Bisa jadi. Untuk aplikasi kecil, Clean Architecture memang gampang jadi overkill. Tapi memisahkan logika bisnis dari urusan teknis tetap ada gunanya, apalagi kalau nanti kodenya perlu dites atau detail implementasinya berubah.

Saat menjelaskan rancangan skripsi, dosen mungkin bertanya “kenapa kamu design sistem seperti ini?” Jawaban “karena logika bisnis saya tidak tergantung pada database” lebih jelas daripada “karena tutorial yang saya ikuti seperti itu”.

Kapan Tidak Perlu Repot-repot #

Clean Architecture bukan silver bullet. Ada saatnya tidak perlu:

Jadi, pakai kalau kompleksitas proyeknya memang sudah minta begitu. Jangan cuma karena namanya kedengaran keren, nanti keburu sibuk bikin layer sebelum masalahnya ada hehe.

Yang Saya Catat #

Spaghetti code bisa kejadian #

Spaghetti code bisa muncul ketika kode terus tumbuh tanpa pembagian tanggung jawab yang jelas. Tidak perlu langsung panik atau menghakimi kode lama. Mulai saja dengan mencari bagian mana yang saling menempel.

Bedakan “apa” dan “bagaimana” #

Logika bisnis menjawab apa yang sistem lakukan. Database, API, dan framework adalah cara teknis untuk menjalankannya. Buat saya, pemisahan itu inti idenya.

Kalau susah dites, cek lagi pembagiannya #

Kesulitan menulis unit test bisa jadi tanda pembagian tanggung jawabnya perlu dilihat lagi. Di contoh ini, Entity dan Use Case bisa dites tanpa menghubungi database atau layanan email.

Ini alat, bukan aturan wajib #

Clean Architecture itu tool, bukan agama (saya ulang biar tidak ada yang bikin layer demi layer). Pahami idenya, lalu pakai kalau memang cocok dengan proyeknya.

Nah, Terus Gimana? #

Jadi, yang penting bukan banyaknya layer atau pattern yang fancy. Tujuannya supaya tanggung jawab tidak campur aduk, dan supaya beberapa bulan lagi kita masih bisa paham kode sendiri. Saya sendiri pernah gagal di bagian terakhir itu hehe.

Kalau penasaran seperti apa penerapannya di proyek nyata, termasuk migrasi PHP ke Go dengan 370+ endpoint, saya pernah menulis catatan terpisah.

Kalau ingin membahas penerapannya atau mencari bantuan, hubungi saya atau lihat layanan yang saya tawarkan.


Tag: catatan · arsitektur