Hai esperienza con progetti realizzati con architettura pulita?

Sì, ci sono.

Durante lo sviluppo con architettura pulita, ho utilizzato i seguenti strati:

• Layer di Dominio: Contiene la logica di business e le entità. Non dipende da altri strati. Sono definiti Use Cases (Interactors) e le interfacce dei repository.
• Layer di Dati: Implementa le interfacce dei repository dal Layer di Dati. Include la gestione dei dati (reti, database, SharedPreferences). Spesso si usano repository per trasformare i dati da fonti esterne in entità di dominio.
• Layer di Presentazione: Contiene View (Fragment, Activity) e Presenter/ViewModel. È responsabile della visualizzazione dei dati e dell'interazione con l'utente. Comunica con i Use Cases del Layer di Dominio.

Dipendenze tra gli strati:

• Lo strato di Presentazione dipende dallo strato di Dominio.
• Lo strato di Dati dipende dallo strato di Dominio.

Pattern e principi applicati nell'architettura pulita:

• SOLID: Soprattutto il principio di inversione delle dipendenze (Dependency Inversion Principle).
• Iniezione delle dipendenze: Per facilitare i test e la gestione delle dipendenze (ad esempio, usando Dagger, Koin).
• Pattern Repository: Astrazione sulle fonti di dati.
• Use Cases (Interactors): Rappresentano operazioni specifiche nella logica di business.

Esempio di struttura del progetto:

├── app
│   ├── build.gradle
│   └── src
│       └── main
│           ├── java
│           │   └── com
│           │       └── esempio
│           │           └── miaapp
│           │               ├── data // Implementazioni dei repository, fonti di dati
│           │               │   ├── datasource
│           │               │   └── repository
│           │               ├── domain // Logica di business, Use Cases, entità, interfacce dei repository
│           │               │   ├── entity
│           │               │   ├── repository
│           │               │   └── usecase
│           │               └── presentation // Strato di vista, ViewModel/Presenter
│           │                   ├── ui
│           │                   └── viewmodel
│           └── res

Interazione tra gli strati:

1. La vista chiama il metodo del ViewModel.
2. Il ViewModel chiama il Use Case corrispondente (logica di business).
3. Il Use Case accede alle interfacce dei repository dello strato di Dominio.
4. Le implementazioni dei repository (nel Layer di Dati) ottengono dati dalle fonti (rete, database).
5. I repository trasformano i dati in entità di dominio e li restituiscono al Use Case.
6. Il Use Case elabora i dati e restituisce il risultato al ViewModel.
7. Il ViewModel aggiorna i dati che vengono mostrati alla View.

L'uso di un'architettura pulita permette:

• Migliorare la testabilità: Ogni strato può essere testato isolatamente.
• Aumentare la manutenibilità: Le modifiche in uno strato influenzano minimamente gli altri.
• Aumentare la flessibilità: È più facile sostituire le implementazioni delle fonti di dati o delle viste UI.
• Ridurre la dipendenza: Separare la logica di business dai dettagli di implementazione.