Clean Architecture Spring Boot Blog

Belajar Clean Architecture 

Panduan Sederhana

Clean Architecture (catatan: bedakan dengan clean code) adalah pola arsitektur perangkat lunak yang diciptakan oleh Uncle Bob (Robert C. Martin). Tujuannya adalah membuat sistem yang:

• Mudah diuji (testable)
• Mudah dipahami
• Mudah diubah (maintainable)
• Tidak bergantung pada framework, database, atau UI tertentu

Namun banyak developer yang ingin belajar clean architecture merasa bingung ketika pertama kali membaca struktur project. Hal ini wajar, karena pola Clean Architecture memiliki pemisahan layer yang cukup ketat.

Untuk mempermudah proses belajar, pendekatan terbaik adalah mempelajari pola arsitektur tersebut melalui contoh project kecil terlebih dahulu. Artikel ini menggunakan contoh aplikasi Blog sederhana dengan Clean Architecture di Java (Spring Boot) yang strukturnya hampir sama dengan yang digunakan pada project besar.

Dengan memahami contoh kecil ini terlebih dahulu, Anda akan jauh lebih mudah memahami struktur dan alur dependency pada project Clean Architecture skala besar

1. Konsep Dasar Clean Architecture

Clean Architecture memisahkan sistem ke dalam beberapa layer dengan aturan dependency yang sangat jelas.

Urutan Layer dari Paling Dalam ke Paling Luar

 Paling Dalam ──► Domain (Entities)
                   ↑
           Use Cases (Application Business Rules)
                   ↑
        Interface Adapters (Controllers, Presenters, Gateways)
                   ↑
      Frameworks & Drivers (Web, UI, Database, External Services)
 Paling Luar ────────────────────────────────────────────────►

Aturan paling penting:

Dependency selalu mengarah ke dalam (inward).

Aturan Dependency yang Harus Diingat (Dependency Rule)

“Source code dependency hanya boleh menunjuk ke dalam.” Artinya:

• Frameworks & Drivers → boleh tahu Interface Adapters
• Interface Adapters → boleh tahu Use Cases
• Use Cases → boleh tahu Entities
• Entities → tidak boleh tahu apa pun tentang layer di atasnya

Ini membuat kode menjadi:

• mudah diuji
• mudah dirawat
• tidak bergantung pada framework tertentu

2. Mengapa Kita Belajar dengan buat Blog?

Clean Architecture biasanya dipakai pada sistem besar dengan banyak modul, event processor, scheduler, repository, dan domain logic.

Jika langsung mempelajari project tersebut, kemungkinan besar Anda akan melihat:

• Banyak class
• Banyak dependency
• Domain logic yang kompleks

Karena itu kita menggunakan contoh aplikasi Blog sederhana untuk memahami struktur dasar yang sama, tetapi dalam skala kecil.

3. Struktur Blog dengan Clean Architecture

Berikut contoh struktur project yang sederhana namun mengikuti prinsip Clean Architecture.

com.example.blog
│
├── domain
│   ├── Article.java
│   ├── ArticleRepository.java
│   └── ArticleNotFoundException.java
│
├── usecase
│   ├── CreateArticleUseCase.java
│   ├── GetArticleUseCase.java
│   ├── UpdateArticleUseCase.java
│   └── DeleteArticleUseCase.java
│
├── adapter
│   ├── in
│   │   └── web
│   │       └── ArticleController.java
│   │
│   └── out
│       └── persistence
│           ├── ArticleEntity.java
│           ├── ArticleMapper.java
│           ├── SpringArticleRepo.java
│           └── ArticleRepoAdapter.java
│
└── config
    └── BeanConfig.java

Mari kita pahami setiap layer satu per satu.

4. Domain Layer (Core Business Logic)

Layer ini adalah inti dari aplikasi.

Karakteristiknya:

• Tidak bergantung pada framework
• Hanya berisi business rule
• Hanya menggunakan Java standard library

Contoh entity:

Article

Contoh interface repository:

ArticleRepository

Hal penting:

Repository di domain hanya berupa interface, bukan implementasi database.

Contoh:

public interface ArticleRepository {
    Article save(Article article);
    Optional<Article> findById(UUID id);
    List<Article> findAll();
    void deleteById(UUID id);
}

Kenapa begitu?

Karena domain tidak boleh tahu apakah data disimpan di:

• MongoDB
• PostgreSQL
• Redis
• API eksternal

5. Use Case Layer (Application Logic)

Layer ini berisi workflow aplikasi.

Contoh:

CreateArticleUseCase
GetArticleUseCase
UpdateArticleUseCase
DeleteArticleUseCase

Tugas UseCase:

• menerima input
• menjalankan business logic
• memanggil domain repository
• menghasilkan output

Contoh sederhana:

CreateArticleUseCase

Alurnya:

Controller → UseCase → Domain → Repository

UseCase hanya bergantung pada:

ArticleRepository (interface)

Bukan pada:

Spring Data
MongoRepository
JPA

Ini membuat UseCase mudah diuji tanpa database.

6. Interface Adapter Layer

Layer ini berfungsi sebagai jembatan antara dunia luar dan domain.

Di layer ini biasanya ada:

6.1 Controller

Menerima request HTTP.

Contoh:

POST /articles
GET /articles/{id}

Controller akan memanggil UseCase.

6.2 Repository Adapter

Karena Domain hanya mendefinisikan interface:

ArticleRepository

Maka kita membutuhkan adapter yang mengimplementasikan interface tersebut menggunakan Spring Data.

Contoh:

ArticleRepoAdapter implements ArticleRepository

Adapter ini akan menggunakan:

SpringArticleRepo yang merupakan interface Spring Data.

6.3 Mapper

Mapper digunakan untuk mengubah:

Domain Object ↔ Database Entity

Contoh:

Article ↔ ArticleEntity

7. Framework Layer

Layer paling luar berisi:

• Spring Boot
• MongoDB
• REST API
• configuration

Contohnya:

BeanConfig

Di sinilah dependency di-wire bersama.

8. Visualisasi Dependency

Diagram dependency dalam Clean Architecture:

Controller
  │
  ▼
UseCase
  │
  ▼
Domain
  ▲
  │
Repository Adapter
  │
  ▼
Spring Data Repository

Perhatikan:

• Dependency selalu mengarah ke Domain.

9. Bagaimana Pemula Baru Harus Memulai

Jika Anda ingin berkontribusi pada project dengan Clean Architecture , langkah terbaik adalah:

Step 1

Pahami konsep dasar:

• Domain
• UseCase
• Adapter
• Dependency rule

Step 2

Pelajari contoh kasus kecil terlebih dahulu.

Pastikan Anda memahami:

• bagaimana UseCase memanggil repository
• bagaimana controller memanggil UseCase
• bagaimana adapter menghubungkan database

11. Kesimpulan

Memahami Clean Architecture  secara langsung bisa terasa sulit bagi developer baru karena biasanya ukuran project yang terlanjur besar dan domain logic yang terlalu kompleks.

Pendekatan yang jauh lebih efektif adalah:

1. Pelajari Clean Architecture melalui contoh kecil
2. Gunakan Blog application sebagai latihan
3. Setelah itu baru membaca kode Project dengan Clean Architecture nya

Dengan metode ini, kontributor baru dapat:

• Memahami arsitektur lebih cepat
• Tidak bingung membaca struktur project
• Menulis kode yang konsisten dengan pola arsitektur yang ada

Hasilnya adalah proses kontribusi yang lebih cepat, lebih aman, dan lebih terstruktur.

Jika Anda sudah memahami contoh Blog ini, Anda siap untuk mulai membaca dan berkontribusi pada project dengan Clean Architecture  dengan lebih percaya diri.

12. Praktek 

Praktek membuat blog dengan Clean Architecture dan Spring Boot