2022-11-15

Domain-Driven Design (DDD)

Apa itu Domain-Driven Development (DDD)

Domain-Driven Design (DDD) adalah sebuah metodologi pengembangan perangkat lunak yang memberikan prioritas pada pemahaman domain inti suatu sistem untuk membuat solusi perangkat lunak yang tangguh, mudah dipelihara, dan mudah beradaptasi. Pada inti DDD terdapat kolaborasi antara ahli domain dan pengembang perangkat lunak, yang memastikan bahwa perangkat lunak yang dihasilkan memodelkan masalah yang ingin diselesaikan.

Manfaat DDD

Terdapat beberapa keuntungan dalam menggunakan DDD dalam pengembangan perangkat lunak:

Menyelaraskan perangkat lunak dengan kebutuhan bisnis
DDD memastikan bahwa model perangkat lunak secara akurat merepresentasikan domain yang mendasari, sehingga membantu pengembang membuat perangkat lunak yang secara langsung mengatasi persyaratan bisnis.
Meningkatkan kemudahan pemeliharaan dan adaptasi
DDD mempromosikan pemisahan yang bersih antara konsep-konsep yang terkait, sehingga membuat perubahan, perluasan, atau refaktorisasi perangkat lunak menjadi lebih mudah ketika domain berkembang.
Memfasilitasi kolaborasi
Dengan menekankan pada komunikasi dan bahasa bersama, DDD mendorong kolaborasi antara ahli domain dan pengembang, sehingga dapat menghasilkan keputusan desain perangkat lunak yang lebih baik.

Terminologi Umum dalam DDD

Terdapat beberapa istilah umum dalam DDD:

Bahasa Universal

Bahasa bersama yang digunakan oleh ahli domain dan pengembang perangkat lunak untuk berkomunikasi dan berkolaborasi secara efektif. Bahasa universal memastikan bahwa semua pemangku kepentingan memiliki pemahaman yang sama tentang domain, konsep-konsep, dan aturan-aturannya.

Model Domain

Representasi dari konsep inti, aturan bisnis, dan hubungan dalam domain. Model domain menjadi dasar dari sistem perangkat lunak, memberikan informasi untuk desain dan implementasinya.

Konteks Terbatas

Area tertentu dari domain yang mandiri dengan model, bahasa, dan aturan yang khusus. Konteks terbatas mengelompokkan logika domain dan meminimalkan ketergantungan pada konteks lain, sehingga membuat sistem menjadi lebih mudah dipelihara dan dapat di-skala.

Pemetaan Konteks

Proses mengidentifikasi dan mendokumentasikan hubungan antar konteks terbatas. Pemetaan konteks membantu pengembang memahami bagaimana bagian-bagian sistem berinteraksi dan berkolaborasi.

Blok Bangunan dalam DDD

DDD mendefinisikan beberapa konsep tingkat tinggi yang dapat digunakan bersama-sama untuk membuat dan memodifikasi model domain.

DDD terms
EP32: REST vs. GraphQL

Entitas

Objek yang memiliki identitas unik dan siklus hidup dalam domain. Entitas sering merepresentasikan konsep inti dalam domain dan ditandai oleh status yang dapat berubah. Entitas dibedakan satu sama lain oleh identitas mereka, bahkan jika atribut-atribut mereka sebaliknya sama.

Objek Nilai

Objek nilai adalah objek yang tidak dapat diubah dan merepresentasikan aspek-aspek domain tetapi tidak memiliki identitas yang berbeda. Objek nilai sering digunakan untuk mendeskripsikan karakteristik atau atribut entitas. Objek nilai didefinisikan oleh propertinya, dan dua objek nilai dengan properti yang sama dianggap sama.

Aggregates

Aggregates are groups of related entities and value objects that form a single unit, with one entity serving as the aggregate root. The aggregate root is responsible for enforcing business rules and ensuring the consistency of the aggregate as a whole. Aggregates help to enforce invariants and maintain consistency within a specific context of the domain.

Repositori

Repositori bertanggung jawab untuk memberikan akses ke kumpulan agregat atau entitas, seringkali dengan mengabstraksi mekanisme penyimpanan data yang mendasari. Repositori bertindak sebagai jembatan antara model domain dan penyimpanan data, memungkinkan pengembang fokus pada logika domain tanpa harus khawatir tentang detail pengambilan dan penyimpanan data.

Faktori

Faktori bertanggung jawab untuk membuat dan mengumpulkan objek domain yang kompleks, seperti entitas dan agregat. Faktori mengelompokkan logika yang diperlukan untuk pembuatan objek, memastikan bahwa objek yang dihasilkan sesuai dengan aturan bisnis dan invarian domain.

Layanan

Layanan adalah operasi tanpa keadaan yang menyimpan logika domain yang tidak cocok secara alami dengan entitas, objek nilai, atau agregat. Layanan biasanya digunakan untuk menerapkan kasus penggunaan, mengkoordinasikan interaksi antara agregat, atau melakukan perhitungan atau validasi yang melibatkan beberapa objek domain.

Peristiwa Domain

Peristiwa domain merepresentasikan kejadian signifikan dalam domain yang menarik bagi bagian lain dari sistem. Peristiwa domain digunakan untuk mengomunikasikan perubahan status atau aturan bisnis antara komponen sistem yang berbeda, seringkali dengan cara yang terdekup. Peristiwa domain memungkinkan arsitektur yang lebih modular dan fleksibel dengan memungkinkan komponen bereaksi terhadap peristiwa tanpa terikat secara ketat pada sumber peristiwa tersebut.

Lapisan dalam DDD

DDD umumnya mengorganisasikan sistem perangkat lunak menjadi empat lapisan yang berbeda, masing-masing dengan tanggung jawabnya sendiri. Lapisan-lapisan ini adalah:

Lapisan Domain
Lapisan domain berisi logika bisnis inti dan mewakili inti dari sistem. Terdiri dari objek domain seperti entitas, objek nilai, agregat, dan peristiwa domain. Lapisan ini bertanggung jawab untuk memberlakukan aturan bisnis dan invarian, serta memastikan bahwa status sistem konsisten dengan kebutuhan domain.
Lapisan Aplikasi
Lapisan aplikasi terletak di atas lapisan domain dan bertanggung jawab untuk mengoordinasikan aktivitas dan mengelola aliran data antara domain dan lapisan lain. Lapisan ini seringkali berisi layanan aplikasi, yang mendefinisikan kasus penggunaan dan mengkoordinasikan interaksi antara objek domain dan komponen eksternal. Layanan aplikasi seringkali tidak memiliki keadaan dan tidak mengandung logika bisnis itu sendiri, melainkan mengalihkan tugas ke lapisan domain yang diperlukan.
Lapisan Infrastruktur
Lapisan infrastruktur menyediakan kemampuan teknis yang dibutuhkan untuk mendukung lapisan lain dari sistem. Ini termasuk komponen seperti repositori, mekanisme akses data, sistem pesan, dan integrasi layanan eksternal. Lapisan infrastruktur seringkali mengimplementasikan antarmuka atau abstraksi yang didefinisikan dalam lapisan domain atau aplikasi, memungkinkan lapisan-lapisan tersebut tetap fokus pada tanggung jawab intinya dan tetap terpisah dari pilihan teknologi spesifik.
Lapisan Presentasi (juga dikenal sebagai Lapisan User Interface)
Lapisan presentasi bertanggung jawab untuk mempresentasikan informasi kepada pengguna dan menangkap masukan pengguna. Ini dapat berupa antarmuka pengguna grafis (GUI), antarmuka baris perintah (CLI), atau bahkan API untuk sistem lain yang mengonsumsinya. Lapisan presentasi berkomunikasi dengan lapisan aplikasi untuk mengambil data, memulai tindakan, dan menampilkan hasil. Lapisan presentasi tidak boleh mengandung logika bisnis atau pengetahuan domain, karena hal itu akan melanggar prinsip pemisahan tanggung jawab.

Struktur direktori Python yang mengimplementasikan DDD

Struktur direktori Python yang mengimplementasikan prinsip DDD biasanya terlihat seperti berikut:

my_project/
│
├── app/                # Application layer
│   ├── services/
│   │   ├── __init__.py
│   │   ├── account_service.py
│   │   ├── order_service.py
│   │   └── ...
│   ├── views/
│   │   ├── __init__.py
│   │   ├── account_view.py
│   │   ├── order_view.py
│   │   └── ...
│   ├── __init__.py
│   ├── config.py
│   └── main.py
│
├── domain/            # Domain layer
│   ├── aggregates/
│   │   ├── __init__.py
│   │   ├── account.py
│   │   ├── order.py
│   │   └── ...
│   ├── entities/
│   │   ├── __init__.py
│   │   ├── customer.py
│   │   ├── product.py
│   │   └── ...
│   ├── value_objects/
│   │   ├── __init__.py
│   │   ├── address.py
│   │   ├── email.py
│   │   └── ...
│   ├── events/
│   │   ├── __init__.py
│   │   ├── account_events.py
│   │   ├── order_events.py
│   │   └── ...
│   ├── factories/
│   │   ├── __init__.py
│   │   ├── account_factory.py
│   │   ├── order_factory.py
│   │   └── ...
│   └── __init__.py
│
├── infrastructure/   # Infrastructure layer
│   ├── repositories/
│   │   ├── __init__.py
│   │   ├── account_repository.py
│   │   ├── order_repository.py
│   │   └── ...
│   ├── orm/
│   │   ├── __init__.py
│   │   ├── models.py
│   │   └── base.py
│   ├── messaging/
│   │   ├── __init__.py
│   │   ├── event_bus.py
│   │   └── ...
│   ├── __init__.py
│   └── settings.py
│
├── tests/           # Test suite
│   ├── unit/
│   │   ├── __init__.py
│   │   ├── test_account.py
│   │   ├── test_order.py
│   │   └── ...
│   ├── integration/
│   │   ├── __init__.py
│   │   ├── test_account_integration.py
│   │   ├── test_order_integration.py
│   │   └── ...
│   ├── __init__.py
│   └── conftest.py
│
├── .gitignore
├── README.md
└── requirements.txt

Struktur ini memisahkan lapisan-lapisan DDD seperti domain, aplikasi, dan lapisan infrastruktur. Ini juga mengorganisasikan blok-bangunan domain seperti agregat, entitas, objek nilai, peristiwa, dan faktori menjadi direktori yang didedikasikan. Suite pengujian diorganisir menjadi pengujian unit dan integrasi, memberikan cakupan untuk berbagai komponen dari sistem.