Avez-vous de l'expérience avec des projets réalisés selon une architecture propre?

Oui, il y en a.

Lors du développement avec une architecture propre, j'ai utilisé les couches suivantes :

• Couche Domaine : Contient la logique métier et les entités. Elle ne dépend pas des autres couches. Les Cas d'Utilisation (Interactors) et les interfaces de référentiels sont définis.
• Couche Données : Implémente les interfaces des référentiels de la Couche Données. Inclut la gestion des données (réseaux, bases de données, SharedPreferences). Souvent, des référentiels sont utilisés pour transformer les données provenant de sources externes en entités de domaine.
• Couche Présentation : Contient la Vue (Fragment, Activity) et le Presenter/ViewModel. Elle est responsable de l'affichage des données et de l'interaction avec l'utilisateur. Elle communique avec les Cas d'Utilisation de la Couche Domaine.

Dépendances entre les couches :

• La Couche Présentation dépend de la Couche Domaine.
• La Couche Données dépend de la Couche Domaine.

Patrons et principes appliqués dans une architecture propre :

• SOLID : Surtout le principe d'inversion des dépendances (Dependency Inversion Principle).
• Injection de dépendances : Pour faciliter les tests et la gestion des dépendances (par exemple, en utilisant Dagger, Koin).
• Pattern Repository : Abstraction des sources de données.
• Cas d'Utilisation (Interactors) : Représentent des opérations spécifiques dans la logique métier.

Exemple de structure du projet :

├── app
│   ├── build.gradle
│   └── src
│       └── main
│           ├── java
│           │   └── com
│           │       └── exemple
│           │           └── monapp
│           │               ├── data // Implémentations des référentiels, sources de données
│           │               │   ├── datasource
│           │               │   └── repository
│           │               ├── domain // Logique métier, Cas d'Utilisation, entités, interfaces de référentiels
│           │               │   ├── entity
│           │               │   ├── repository
│           │               │   └── usecase
│           │               └── presentation // Vue, ViewModel/Presenter
│           │                   ├── ui
│           │                   └── viewmodel
│           └── res

Interaction entre les couches :

1. La vue appelle la méthode du ViewModel.
2. Le ViewModel appelle le Cas d'Utilisation correspondant (logique métier).
3. Le Cas d'Utilisation accède aux interfaces des référentiels de la Couche Domaine.
4. Les implémentations des référentiels (dans la Couche Données) obtiennent des données des sources (réseau, base de données).
5. Les référentiels transforment les données en entités de domaine et les renvoient au Cas d'Utilisation.
6. Le Cas d'Utilisation traite les données et renvoie le résultat au ViewModel.
7. Le ViewModel met à jour les données affichées dans la vue.

L'utilisation d'une architecture propre permet :

• Améliorer la testabilité : Chaque couche peut être testée isolément.
• Augmenter la maintenabilité : Les changements dans une couche affectent minimalement les autres.
• Augmenter la flexibilité : Il est plus facile de remplacer les implémentations des sources de données ou des vues UI.
• Réduire le couplage : Séparer la logique métier des détails de l'implémentation.