Co możesz powiedzieć o czystej architekturze?

Czysta architektura (Clean Architecture), spopularyzowana przez Roberta Martina ("Wujek Bob"), jest zbiorem zasad organizacji kodu, mających na celu tworzenie elastycznego, testowalnego i łatwego w utrzymaniu systemu.

Główne idee:

1. Podział na warstwy: Kod jest podzielony na koncentryczne kręgi, gdzie wewnętrzne warstwy zawierają logikę biznesową, a zewnętrzne szczegóły implementacji (UI, bazy danych, zewnętrzne API).
2. Zależność od wewnętrznych warstw: Warstwy zewnętrzne zależą od wewnętrznych, ale nie odwrotnie. Osiąga się to poprzez zasadę odwrócenia zależności.
3. Enkapsulacja: Każda warstwa ukrywa szczegóły swojej implementacji przed warstwami zewnętrznymi.
4. Testowalność: Logika biznesowa, znajdująca się w centralnych warstwach, nie zależy od zewnętrznych szczegółów, co czyni ją łatwo testowalną w izolacji.
5. Niezależność od frameworków: Główne zasady biznesu nie są powiązane z konkretnymi frameworkami, UI czy bazami danych.

Przykład struktury:

• Encje: Zawierają obiekty biznesowe i zasady (np. klasa User z logiką biznesową związaną z użytkownikiem).
• Przypadki użycia (Interactors): Zawierają specyficzną logikę biznesową aplikacji (np. GetUserUseCase). Orkiestrują interakcję między Encjami a interfejsami Gateway.
• Adaptery interfejsu: Adaptują dane z zewnętrznych źródeł do formatu zrozumiałego dla Przypadków Użycia i Encji (np. Presenters dla UI, implementacje Gateway dla baz danych).
• Frameworki i sterowniki: Zewnętrzna warstwa zawierająca frameworki (UI, bazy danych, serwisy internetowe).

Zasada odwrócenia zależności odgrywa kluczową rolę. Wewnętrzne warstwy definiują interfejsy (Gateway Interfaces), a zewnętrzne je implementują. Ilustracja tego na schemacie:

+-----------------+      +-------------------+      +--------------------+      +------------------------+
| Frameworks &    |----->|   Interface       |<-----|    Use Cases       |<-----|        Encje          |
| Sterowniki (UI, DB)|   |   Adaptery        |     |  (Interactors)     |     |  (Reguły biznesowe)  |
+-----------------+      |  (Prezentery,     |     |                    |     +------------------------+
                          |  Implementacje Gateway|  |                    |
                          +-------------------+     +--------------------+

Strzałki wskazują kierunek zależności. Wszystkie skierowane są do wewnątrz, do warstwy Encji.

W rozwoju Android, Czysta Architektura jest często realizowana z użyciem takich komponentów jak:

• Warstwa UI (Prezentacja): Activity, Fragment, ViewModel, logika UI. Zależy od Warstwy Domeny.
• Warstwa Domeny (Przypadki użycia): Logika biznesowa aplikacji. Nie zależy od innych warstw.
• Warstwa Danych: Źródła danych (sieci, bazy danych), repozytoria. Implementuje interfejsy zdefiniowane w Warstwie Domeny.

Przykład struktury:

root
├── app
│   ├── src
│   │   └── main
│   │       └── java
│   │           └── com
│   │               └── przyklad
│   │                   └── mojaaplikacja
│   │                       ├── prezentacja  // UI (ViewModel, Activities, Fragments)
│   │                       │   ├── ui
│   │                       │   └── viewmodel
│   │                       ├── domena      // Warstwa Domeny (Przypadki użycia, Encje, Interfejsy)
│   │                       │   ├── encja
│   │                       │   ├── repozytorium  // Interfejsy Domeny
│   │                       │   └── usecase
│   │                       └── dane        // Warstwa Danych (Repozytoria, Źródła danych, Maperki)
│   │                           ├── lokalne       // Lokalny źródło danych (Room)
│   │                           ├── zdalne      // Zdalne źródło danych (Retrofit)
│   │                           ├── mapper
│   │                           └── repozytorium  // Implementacje danych rozszerzające interfejsy domeny
│   └── build.gradle
└── build.gradle

Zalety:

• Testowalność: Logika biznesowa jest odizolowana i łatwa do przetestowania.
• Elastyczność: Łatwo wymieniać zewnętrzne zależności (np. przejście z Room na Realm).
• Utrzymanie: Jasny podział odpowiedzialności ułatwia zrozumienie i utrzymanie kodu.
• Niezależność od technologii: Logika biznesowa nie jest powiązana z konkretnymi frameworkami lub bibliotekami Androida.

Wady:

• Złożoność: Może być początkowo trudniejsza do zrozumienia i wdrożenia, szczególnie w małych projektach.
• Więcej kodu: Wymaga napisania większej liczby klas i interfejsów w porównaniu do prostszych architektur.

Ogólnie, Czysta Architektura jest potężnym podejściem do tworzenia skalowalnych i łatwych w utrzymaniu aplikacji Android, szczególnie dla projektów średniej i dużej złożoności. Sprzyja rozwojowi wokół logiki biznesowej, a nie szczegółów technicznych.