Czy masz doświadczenie w pracy z projektami opartymi na czystej architekturze?

Tak, jest.

Podczas tworzenia oprogramowania z użyciem czystej architektury, korzystałem z następujących warstw:

• Warstwa domenowa: Zawiera logikę biznesową i encje. Nie zależy od innych warstw. Definiuje Use Cases (Interactors) i interfejsy repozytoriów.
• Warstwa danych: Implementuje interfejsy repozytoriów z warstwy danych. Zawiera pracę z danymi (sieci, bazy danych, SharedPreferences). Często używa repozytoriów do konwersji danych z zewnętrznych źródeł na encje domenowe.
• Warstwa prezentacji: Zawiera widoki (Fragment, Activity) i Presenter/ViewModel. Odpowiada za wyświetlanie danych i interakcję z użytkownikiem. Komunikuje się z Use Cases z warstwy domenowej.

Zależności między warstwami:

• Warstwa prezentacji zależy od warstwy domenowej.
• Warstwa danych zależy od warstwy domenowej.

Wzorce i zasady stosowane w czystej architekturze:

• SOLID: Szczególnie zasada odwracania zależności (Dependency Inversion Principle).
• Wstrzykiwanie zależności: Ułatwia testowanie i zarządzanie zależnościami (np. z Dagger, Koin).
• Wzorzec repozytorium: Abstrakcja nad źródłami danych.
• Use Cases (Interactors): Reprezentują konkretne operacje w logice biznesowej.

Przykład struktury projektu:

├── app
│   ├── build.gradle
│   └── src
│       └── main
│           ├── java
│           │   └── com
│           │       └── przyklad
│           │           └── mojaaplikacja
│           │               ├── data // Implementacje repozytoriów, źródła danych
│           │               │   ├── datasource
│           │               │   └── repository
│           │               ├── domain // Logika biznesowa, Use Cases, encje, interfejsy repozytoriów
│           │               │   ├── entity
│           │               │   ├── repository
│           │               │   └── usecase
│           │               └── presentation // Warstwa widoku, ViewModel/Presenter
│           │                   ├── ui
│           │                   └── viewmodel
│           └── res

Interakcja między warstwami:

1. Widok wywołuje metodę ViewModel.
2. ViewModel wywołuje odpowiedni Use Case (logika biznesowa).
3. Use Case korzysta z interfejsów repozytoriów z warstwy domenowej.
4. Implementacje repozytoriów (w warstwie danych) pobierają dane ze źródeł (sieć, baza danych).
5. Repozytoria konwertują dane na encje domenowe i zwracają je do Use Case.
6. Use Case przetwarza dane i zwraca wynik do ViewModel.
7. ViewModel aktualizuje dane wyświetlane na widoku.

Użycie czystej architektury pozwala na:

• Poprawę testowalności: Każda warstwa może być testowana izolowanie.
• Zwiększenie łatwości utrzymania: Zmiany w jednej warstwie minimalnie wpływają na inne.
• Zwiększenie elastyczności: Łatwiej wymieniać implementacje źródeł danych lub widoków UI.
• Zmniejszenie powiązań: Oddzielenie logiki biznesowej od szczegółów implementacji.