Avez-vous une question? (216) 97 656 803 hajjriadh@gmail.com
Flutter

Architecture propre et gestion des erreurs

Organiser le code réseau en couches (service, repository, UI), gérer les erreurs et fonctionner hors connexion....

0 chapitres 0 QCM Accès gratuit

À propos de ce cours

Organiser le code réseau en couches (service, repository, UI), gérer les erreurs et fonctionner hors connexion.

Objectif : organiser le code réseau pour qu'il soit lisible, testable et capable de fonctionner hors connexion.

Pourquoi séparer ?

Jusqu'ici, nos écrans appelaient directement http.get. Sur une vraie application (une app de livraison a des dizaines d'écrans), cela devient vite ingérable : si l'URL de l'API change, il faut modifier tous les écrans. On sépare donc le code en couches, chacune avec un rôle unique.

Architecture en couches d'une application Flutter connectée
Figure — Architecture en couches d'une application Flutter connectée
L'écran demande « donne-moi les tâches » au repository, qui décide d'interroger l'API ou de lire le cache local (votre base SQLite du chapitre 22). Les données remontent sous forme de modèles, les erreurs sous forme d'exceptions claires.

Organisation des dossiers

lib/
├── models/          todo.dart, user.dart
├── services/        api_client.dart, todo_api_service.dart
├── repositories/    todo_repository.dart
├── screens/         todo_list_page.dart, todo_detail_page.dart
├── widgets/         error_view.dart, loading_view.dart
└── main.dart

1. Une exception métier claire

class ApiException implements Exception {
  final String message;
  final int? statusCode;
  ApiException(this.message, {this.statusCode});

  @override
  String toString() => message; // message lisible pour l'utilisateur
}

2. Le service : seule couche qui connaît HTTP

class TodoApiService {
  final http.Client _client;
  static const _baseUrl = 'https://jsonplaceholder.typicode.com';

  TodoApiService({http.Client? client}) : _client = client ?? http.Client();

  Future<List<Todo>> getTodos() async {
    try {
      final r = await _client
          .get(Uri.parse('$_baseUrl/todos?_limit=20'))
          .timeout(const Duration(seconds: 10));

      if (r.statusCode == 200) {
        final List data = jsonDecode(r.body);
        return data.map((e) => Todo.fromJson(e)).toList();
      }
      throw ApiException('Erreur du serveur', statusCode: r.statusCode);
    } on TimeoutException {
      throw ApiException('Le serveur ne répond pas, réessayez.');
    } on http.ClientException {
      throw ApiException('Vérifiez votre connexion internet.');
    } on FormatException {
      throw ApiException('Réponse du serveur invalide.');
    }
  }
}

(TimeoutException vient de dart:async. ) Le paramètre client optionnel permet de remplacer le vrai réseau par un faux client dans les tests (MockClient du package http/testing.dart).

3. Le repository : en ligne d'abord, cache ensuite

class TodoRepository {
  final TodoApiService api;
  final TodoDatabase db; // votre classe SQLite du chapitre 22

  TodoRepository(this.api, this.db);

  Future<List<Todo>> getTodos() async {
    try {
      final todos = await api.getTodos();
      await db.saveAll(todos);        // mise à jour du cache
      return todos;
    } on ApiException {
      final cached = await db.getAll();
      if (cached.isNotEmpty) return cached; // mode hors ligne
      rethrow;                         // ni réseau ni cache : on remonte l'erreur
    }
  }
}

C'est exactement ce que fait WhatsApp ou Gmail : sans réseau, vous voyez toujours vos derniers messages.

4. L'écran : simple et sans URL

_futureTodos = widget.repository.getTodos();
// ... puis le même FutureBuilder qu'en 24.5,
// en affichant snapshot.error.toString() (message clair d'ApiException)

Liste de contrôle des bonnes pratiques

  • Un timeout sur chaque requête.
  • Le Future créé dans initState, jamais dans build.
  • Les trois états (chargement, erreur avec Réessayer, données) plus l'état « vide ».
  • Des messages d'erreur compréhensibles, jamais une exception brute à l'écran.
  • Pagination pour les longues listes (?_page=2&_limit=20) avec chargement au défilement.
  • Un cache local pour le mode hors ligne quand c'est utile.
  • HTTPS, token dans flutter_secure_storage, aucune clé secrète dans l'app.
  • Logs réseau désactivés en production (kDebugMode).
  • Optionnel : vérifier la connectivité avec le package connectivity_plus pour afficher un bandeau « Hors ligne ».

Activité 24.8 — « Refactoring » (1 h)

  1. Reprenez le mini-blog de l'activité 24.5 et réorganisez-le selon l'arborescence ci-dessus (models, services, repositories, screens).
  2. Créez ApiException et faites en sorte qu'aucun écran n'importe plus package:http.
  3. Ajoutez un cache SQLite des posts (réutilisez votre code du chapitre 22). Testez : chargez les posts, passez en mode avion, relancez l'application. Les posts doivent s'afficher.
  4. Affichez un petit bandeau orange « Données hors ligne » quand les données viennent du cache.
  5. Bonus test : écrivez un test unitaire de TodoApiService avec MockClient qui simule une réponse 500 et vérifie qu'une ApiException est levée.

Cet article vous a-t-il aidé ?