Qu'est-ce que Clean Architecture ?
La Clean Architecture est une approche de conception logicielle proposée
par Robert C. Martin (Uncle Bob) qui vise à séparer les responsabilités en
différentes couches pour rendre le code :
✅ Testable
✅ Maintenable
✅ Indépendant des frameworks
✅ Facile à évoluer
Les 3 couches principales dans Clean Architecture (Flutter)
I-- Domaine (Domain Layer) : Cœur de l'application, contient la logique métier.
1. Entités (Entities) : Objets métiers (ex : User, Product).
2. Cas d'utilisation (Use Cases) : Contient la logique applicative
(ex: GetUserProfile, FetchProducts).
3. Repository abstraits (Interfaces) : Définit les contrats pour les données.
II-- Données (Data Layer) : Implémente les repository définis dans la couche
Domaine.
1-- Sources de données (Data Sources) :
• Locale (SQLite, SharedPreferences, Hive).
• Externe (API REST, GraphQL, Firebase).
2-- Modèles (DTOs) : Représentation des données pour le stockage/API.
III-- Présentation (Presentation Layer) : UI (Widgets Flutter) : Pages,
composants.
1-- Gestion d'état :
• Bloc (avec flutter_bloc).
• Provider (avec provider).
• Riverpod (alternative moderne).
• GetX (si préféré).
2-- ViewModels/Controllers : Relie les cas d'utilisation à l'UI.
Structure de dossiers typique dans Flutter
lib/
├── core/ # Utilitaires communs (erreurs, constantes, extensions)
├── domain/ # Couche Domaine
│ ├── entities/ # Entités métier
│ ├── repositories/ # Interfaces de repository
│ └── usecases/ # Cas d'utilisation
├── data/ # Couche Données
│ ├── datasources/ # Sources (locale, API)
│ ├── models/ # DTOs
│ └── repositories/ # Implémentations des repository
└── presentation/ # Couche Présentation
├── pages/ # Écrans
├── widgets/ # Composants UI
└── bloc/ # Gestion d'état (ou cubit, provider, etc.)
Ou bien
lib/
├── core/ # Code transverse à toute l'application
│ ├── constants/ # Constantes globales
│ ├── errors/ # Gestion des erreurs
│ ├── utils/ # Utilitaires (extensions, helpers)
│ └── widgets/ # Widgets réutilisables
│
├── data/ # Couche Données
│ ├── datasources/ # Sources (API, base locale)
│ ├── models/ # DTOs (JSON → Objets)
│ ├── repositories/ # Implémentations concrètes des dépôts
│ └── data.dart # Export des fichiers
│
├── domain/ # Couche Métier
│ ├── entities/ # Objets métiers
│ ├── repositories/ # Interfaces abstraites
│ ├── usecases/ # Cas d'utilisation
│ └── domain.dart # Export des fichiers
│
├── presentation/ # Couche UI
│ ├── pages/ # Écrans
│ ├── widgets/ # Composants UI spécifiques
│ ├── providers/ # Gestion d'état (Provider, Bloc, etc.)
│ └── presentation.dart # Export des fichiers
│
└── main.dart # Point d'entrée de l'app
Avantages de Clean Architecture dans Flutter
✔ Découplage : Changer une couche n’affecte pas les autres (ex: remplacer
une API par une base locale).
✔ Testabilité : On peut tester chaque couche indépendamment (Use Cases
sans UI, Repository sans API réelle).
✔ Maintenabilité : Le code est organisé et scalable.
✔ Réutilisabilité : La logique métier (Domaine) peut être réutilisée pour
d'autres projets (ex: web, mobile, desktop).
Exemple de flux dans Clean Architecture
• UI (Presentation) → Appelle un Bloc.
• Bloc → Exécute un Use Case.
• Use Case → Utilise un Repository.
• Repository (Data) → Récupère les données depuis une API ou une base
locale.
• Les données remontent sous forme d'Entités vers l'UI.
Package utiles pour Clean Architecture dans Flutter :
• Gestion d'état : flutter_bloc, riverpod, provider.
• Injection de dépendances : get_it, injectable.
• Navigation : go_router, auto_route.
• API HTTP : dio, http.
• Base de données locale : hive, isar, sqflite.
