SOLID Principles dalam Pemrograman: Panduan Lengkap

Kalau Anda pernah membaca kode yang sekilas terlihat berjalan baik, tetapi sulit dipahami atau diubah, masalahnya belum tentu ada pada bahasa pemrogramannya. Bisa jadi, masalahnya ada pada desain kode, dan di sinilah SOLID Principles berperan penting.

SOLID adalah kumpulan lima prinsip desain dalam pemrograman berorientasi objek yang membantu developer mengelola kompleksitas codebase, terutama ketika aplikasi terus berkembang. Menariknya, kelima prinsip ini awalnya tidak dirumuskan sekaligus. Robert C. Martin mengembangkannya dalam berbagai pembahasan desain software, sebelum Michael Feathers menyusun inisialnya menjadi akronim SOLID sekitar tahun 2004.

Melalui artikel ini, Anda akan memahami SOLID dengan bahasa yang lebih sederhana, mulai dari sejarah singkat hingga penjelasan lima prinsipnya beserta contoh penerapannya. Anda tidak hanya menghafal kepanjangannya, tetapi juga memahami masalah yang ingin diselesaikan oleh setiap prinsip.

Ringkasan Cepat

• SOLID adalah akronim 5 prinsip desain software untuk membuat kode lebih mudah dipelihara dan fleksibel.
• Kelima prinsipnya yaitu SRP, OCP, LSP, ISP, DIP.
• Menurut ringkasan sejarah publik, Robert C. Martin memperkenalkan prinsip-prinsip ini (paper 2000), dan akronim SOLID dipopulerkan kemudian.

Apa Itu SOLID Principles?

SOLID principles adalah kumpulan lima prinsip desain dalam pemrograman berorientasi objek (OOP) yang membantu membuat kode lebih mudah dipahami, dikembangkan, diuji, dan dirawat. Kelima prinsip ini berfokus pada bagaimana kode disusun agar perubahan pada satu bagian tidak mudah menimbulkan masalah di bagian lain.

SOLID terdiri dari:

• S — Single Responsibility Principle (SRP)
• O — Open/Closed Principle (OCP)
• L — Liskov Substitution Principle (LSP)
• I — Interface Segregation Principle (ISP)
• D — Dependency Inversion Principle (DIP)

SOLID memang banyak digunakan dalam OOP, tetapi prinsipnya dapat menjadi panduan untuk memikirkan desain software secara lebih luas. Yang perlu diingat, SOLID bukan aturan yang harus diterapkan secara kaku pada setiap kode. Prinsip ini lebih tepat digunakan sebagai panduan untuk mengelola kompleksitas sesuai kebutuhan proyek.

5 Prinsip Dasar SOLID yang Wajib Anda Ketahui

1. SRP (Single Responsibility Principle)

SRP secara sederhana berarti satu kelas atau modul sebaiknya memiliki satu tanggung jawab utama atau satu alasan utama untuk berubah.

Tujuannya agar sebuah kelas tidak menangani terlalu banyak pekerjaan sekaligus.

Misalnya, jangan membuat satu kelas yang menangani:

• Logika bisnis.
• Akses database.
• Pembuatan laporan.
• Format tampilan.

Lebih baik pisahkan tanggung jawab tersebut ke beberapa komponen, misalnya:

• OrderService untuk logika pesanan.
• OrderRepository untuk akses data.
• InvoiceRenderer untuk membuat tampilan invoice.

Dengan begitu, perubahan pada laporan tidak harus menyentuh logika bisnis pesanan.

Tanda SRP mulai bermasalah:

• Satu file sudah sangat panjang.
• Satu kelas mengurus banyak hal yang tidak berkaitan.
• Perubahan kecil pada satu fitur ikut memengaruhi fitur lain.

2. OCP (Open/Closed Principle)

OCP berarti kode sebaiknya terbuka untuk dikembangkan, tetapi tidak perlu terus-menerus dimodifikasi ketika fitur baru ditambahkan.

Contohnya adalah sistem pembayaran. Daripada membuat satu blok kode dengan banyak kondisi seperti:

if payment == "bank":
    ...
else if payment == "ewallet":
    ...
else if payment == "credit_card":
    ...

Anda bisa membuat abstraksi PaymentMethod, lalu menyediakan implementasi seperti:

• BankTransfer
• EWallet
• CreditCard

Ketika metode pembayaran baru ditambahkan, Anda cukup membuat implementasi baru tanpa mengubah logika yang sudah stabil.

OCP berguna untuk menghindari:

• if-else yang semakin panjang.
• Perubahan berulang pada kode yang sudah stabil.
• Risiko fitur baru merusak fitur lama.

3. LSP (Liskov Substitution Principle)

LSP berarti objek turunan harus dapat menggantikan objek induknya tanpa mengubah perilaku yang diharapkan dari program.

Contoh sederhananya adalah hubungan Bird dan Penguin.

Jika kelas Bird memiliki fungsi fly(), lalu Penguin dibuat sebagai turunannya, muncul masalah karena penguin tidak bisa terbang.

Daripada memaksakan hubungan tersebut, desain kelasnya perlu diperbaiki agar kemampuan terbang tidak menjadi kewajiban semua jenis burung.

Tanda LSP bermasalah:

• Subclass harus melempar error untuk method yang seharusnya bisa digunakan.
• Subclass memiliki aturan yang jauh lebih sempit dibanding parent class.
• Kode yang menggunakan parent class tiba-tiba rusak ketika menerima subclass.

Intinya, jangan menggunakan inheritance hanya karena hubungan antarobjek terlihat mirip. Pastikan objek turunannya benar-benar bisa digunakan sebagai pengganti objek induknya.

4. ISP (Interface Segregation Principle)

ISP menyarankan agar class tidak dipaksa bergantung pada interface yang memiliki terlalu banyak method yang sebenarnya tidak dibutuhkan.

Misalnya, Anda memiliki interface Employee yang berisi:

• work()
• manage()
• hire()
• fire()

Masalahnya, tidak semua jenis karyawan membutuhkan seluruh fungsi tersebut.

Daripada membuat satu interface besar, lebih baik pisahkan menjadi interface yang lebih spesifik, misalnya:

• Worker
• Manager
• Recruiter

Dengan cara ini, setiap class hanya menggunakan fungsi yang memang dibutuhkan.

Tanda ISP mulai bermasalah:

• Interface memiliki terlalu banyak method.
• Banyak class memiliki method kosong.
• Banyak implementasi hanya berisi NotImplemented.

5. DIP (Dependency Inversion Principle)

DIP berfokus pada hubungan antarbagian dalam aplikasi. Prinsip ini menyarankan agar kode tingkat tinggi tidak bergantung langsung pada detail implementasi tingkat rendah. Keduanya sebaiknya bergantung pada abstraksi.

Contohnya, UserService sebaiknya tidak langsung bergantung pada MySQLClient.

Sebagai gantinya, UserService dapat bergantung pada interface seperti UserRepository.

Strukturnya menjadi:

UserService
     ↓
UserRepository
     ↓
MySQLRepository

Dengan pendekatan ini, Anda dapat mengganti database atau implementasi repository tanpa harus mengubah logika utama UserService.

Manfaat DIP antara lain:

• Testing lebih mudah karena dependency dapat diganti dengan mock atau stub.
• Coupling antarbagian lebih rendah.
• Pergantian teknologi atau vendor lebih mudah dilakukan.

Tabel Ringkas SOLID

Kapan SOLID Sebaiknya Digunakan?

SOLID paling terasa manfaatnya ketika aplikasi terus berkembang dan perubahan kode terjadi cukup sering. Misalnya pada produk yang sudah berjalan lama, backend service, atau aplikasi dengan banyak fitur dan anggota tim.

SOLID dapat membantu ketika:

• Fitur baru sering ditambahkan.
• Banyak developer mengerjakan codebase yang sama.
• Testing menjadi semakin penting.
• Aplikasi memiliki banyak dependency seperti database dan API eksternal.
• Perubahan pada satu bagian sering memengaruhi bagian lain.

Sebaliknya, tidak semua proyek membutuhkan abstraksi yang kompleks. Untuk proof of concept, skrip sederhana, atau program sekali pakai, menerapkan semua prinsip SOLID secara berlebihan justru dapat membuat kode lebih rumit.

Jadi, SOLID sebaiknya digunakan secara selektif sesuai kebutuhan proyek, bukan sekadar untuk membuat kode terlihat lebih “rapi”.

Checklist Menerapkan SOLID Tanpa Over-Engineering

Anda tidak perlu langsung melakukan refactor besar-besaran. Mulailah dari masalah yang paling sering muncul.

Coba gunakan checklist berikut:

• SRP: pecah kelas atau file yang memiliki terlalu banyak tanggung jawab.
• OCP: pertimbangkan strategy atau polymorphism jika if-else terus bertambah.
• LSP: periksa kembali inheritance yang membuat subclass tidak dapat berperilaku seperti parent.
• ISP: pecah interface yang memiliki terlalu banyak method.
• DIP: gunakan dependency injection agar kode utama tidak terlalu bergantung pada implementasi tertentu.

Dengan pendekatan bertahap, SOLID dapat membantu membuat codebase lebih mudah dirawat tanpa harus menambahkan abstraksi yang sebenarnya belum diperlukan.

Belajar SOLID Sekaligus Praktik di Server

Memahami SOLID akan lebih mudah jika langsung dipraktikkan melalui mini-project. Anda bisa mencoba membuat aplikasi sederhana, melakukan refactor, menjalankan automated testing, hingga melakukan deployment sendiri.

Untuk kebutuhan development seperti ini, VPS Murah dari Rumahweb menggunakan teknologi KVM dengan resource terisolasi, SSD storage, DDoS protection, dua availability zone, aktivasi instan, serta dukungan 24/7. Rumahweb juga mencantumkan SLA uptime 99,9% dan sertifikasi ISO 27001.

FAQ

Berikut beberapa pertanyaan umum tentang SOLID Principles.

Kesimpulan

SOLID Principles bukanlah aturan kaku yang harus diterapkan secara berlebihan, melainkan panduan desain arsitektur perangkat lunak untuk mencegah kerumitan kode saat skala proyek terus membesar. Implementasi SOLID membantu menciptakan basis kode (codebase) yang fleksibel dan tangguh terhadap perubahan sistem di masa depan.

Secara praktis, prinsip ini diterapkan dengan memisahkan tanggung jawab setiap modul, memanfaatkan abstraksi yang tepat, menjaga konsistensi perlakuan terhadap keterturunan (inheritance), membagi antarmuka (interface) sesuai kebutuhan spesifik, serta mengurangi ketergantungan langsung pada rincian implementasi teknis.

Referensi

• Wikipedia: SOLID