Flutter Mobile Development · Leçon

Limites entre les couches domaine, données et présentation

Séparez les responsabilités en entités, référentiels et cas d’utilisation selon des règles strictes de dépendance.

Limites entre les couches domaine, données et présentation est une leçon Flutter Mobile Development gratuite sur CoddyKit. Ceci est la leçon 1 sur 4. Tu peux lire la leçon complète ci-dessous gratuitement — puis la pratiquer en direct dans le navigateur avec un éditeur de code intégré et un tuteur IA 24/7. Elle fait partie du parcours d'apprentissage Flutter Mobile Development, et ta progression se synchronise sur le web et l'application CoddyKit. Le cours Flutter Mobile Development comprend 4 leçons au total.

Certaines parties de cette leçon n'ont pas encore été traduites et s'affichent en anglais.

Why Layer Boundaries Matter

In a Flutter app of any real size, mixing UI, business rules, and data access into the same files turns every change into a regression risk. Clean Architecture splits the app into three layers:

Domain — pure business rules: entities and use cases. No Flutter, no HTTP, no Dart packages tied to I/O.
Data — implements repositories: API clients, databases, DTO mapping.
Presentation — widgets, state management (Bloc/Riverpod), and view models.

The single most important rule: dependencies point inward. Presentation and Data depend on Domain. Domain depends on nothing.

The Dependency Rule

The Domain layer is the stable core. It must never import from Data or Presentation. Think of it as a circle: arrows of dependency only ever point toward the center.

Presentation -> Domain (allowed)
Data -> Domain (allowed)
Domain -> Data (forbidden)
Domain -> Presentation (forbidden)

Because Domain owns the repository interfaces (abstractions), the Data layer that implements them depends inward. This is the Dependency Inversion Principle in action.

Domain Entities

An entity is a plain Dart object that models a core business concept. It carries no JSON parsing, no fromMap, no framework annotations. Keep it immutable and free of I/O concerns.

Notice this class imports nothing from Flutter or any network library. It is pure Dart and could compile in a console app.

class User {
  final String id;
  final String name;
  final String email;

  const User({
    required this.id,
    required this.name,
    required this.email,
  });

  User copyWith({String? name, String? email}) => User(
        id: id,
        name: name ?? this.name,
        email: email ?? this.email,
      );
}

void main() {
  const user = User(id: '1', name: 'Ada', email: 'ada@example.com');
  final renamed = user.copyWith(name: 'Ada L.');
  print('${renamed.id}: ${renamed.name} <${renamed.email}>');
}

Repository Interfaces Live in Domain

The Domain layer declares what data operations exist, not how they happen. It does this with an abstract class (interface). The Data layer provides the concrete implementation later.

This abstraction is the seam that lets Domain stay ignorant of HTTP, SQLite, or Firebase. The return types use Domain entities only.

abstract class UserRepository {
  Future<User> getUser(String id);
  Future<void> saveUser(User user);
}

class User {
  final String id;
  final String name;
  final String email;
  const User({required this.id, required this.name, required this.email});
}

Use Cases Orchestrate Business Rules

A use case (also called an interactor) represents one unit of application behavior, such as "fetch the profile of the signed-in user." It depends only on repository interfaces from Domain.

Keeping each use case as a single-responsibility class makes the business intent explicit and trivially testable with a fake repository.

class GetUser {
  final UserRepository repository;
  const GetUser(this.repository);

  Future<User> call(String id) => repository.getUser(id);
}

abstract class UserRepository {
  Future<User> getUser(String id);
  Future<void> saveUser(User user);
}

class User {
  final String id;
  final String name;
  final String email;
  const User({required this.id, required this.name, required this.email});
}

Data Layer: DTOs and Models

The Data layer introduces models (DTOs) that know how to serialize. A common pattern is to extend or map from the Domain entity, keeping JSON logic out of Domain entirely.

Here UserModel handles fromJson/toJson and exposes a toEntity() conversion so the rest of the app only ever sees the pure User.

class UserModel {
  final String id;
  final String name;
  final String email;

  const UserModel({required this.id, required this.name, required this.email});

  factory UserModel.fromJson(Map<String, dynamic> json) => UserModel(
        id: json['id'] as String,
        name: json['name'] as String,
        email: json['email'] as String,
      );

  Map<String, dynamic> toJson() => {'id': id, 'name': name, 'email': email};

  User toEntity() => User(id: id, name: name, email: email);
}

class User {
  final String id;
  final String name;
  final String email;
  const User({required this.id, required this.name, required this.email});
}

void main() {
  final model = UserModel.fromJson({'id': '7', 'name': 'Grace', 'email': 'g@x.io'});
  final entity = model.toEntity();
  print('Entity name: ${entity.name}');
}

Data Layer: Repository Implementation

The concrete repository lives in Data and implements the Domain interface. It wires together remote data sources, local caches, and DTO mapping. Note the implements UserRepository clause — the dependency points inward to Domain.

It returns User entities, never UserModel, so serialization details never leak upward.

class UserRepositoryImpl implements UserRepository {
  final UserRemoteDataSource remote;
  const UserRepositoryImpl(this.remote);

  @override
  Future<User> getUser(String id) async {
    final model = await remote.fetchUser(id);
    return model.toEntity();
  }

  @override
  Future<void> saveUser(User user) {
    final model = UserModel(id: user.id, name: user.name, email: user.email);
    return remote.putUser(model);
  }
}

abstract class UserRemoteDataSource {
  Future<UserModel> fetchUser(String id);
  Future<void> putUser(UserModel model);
}

Presentation Depends Only on Use Cases

The Presentation layer (a Bloc, Cubit, or Riverpod notifier) holds references to use cases, not to repositories or data sources. This keeps widgets decoupled from how data is fetched.

Below, a Cubit calls the GetUser use case and emits view state. It knows nothing about JSON or HTTP.

class UserCubit extends Cubit<UserState> {
  final GetUser getUser;
  UserCubit(this.getUser) : super(UserInitial());

  Future<void> load(String id) async {
    emit(UserLoading());
    try {
      final user = await getUser(id);
      emit(UserLoaded(user));
    } catch (e) {
      emit(UserError(e.toString()));
    }
  }
}

Mapping the Folder Structure

A feature-first layout makes boundaries visible on disk. Each feature owns its three layers:

lib/features/user/domain/ — entities, repositories (interfaces), usecases
lib/features/user/data/ — models, datasources, repositories (impl)
lib/features/user/presentation/ — cubit/bloc, pages, widgets

When a file in domain/ imports from data/, you have a boundary violation. Lint rules (e.g. import_lint or custom analysis_options.yaml bans) can enforce this automatically.

Error Handling Across Boundaries

Low-level exceptions (a SocketException, a 404) belong to the Data layer. Don't let them bubble up raw into Domain or Presentation. Convert them into domain-level Failure types so the UI reasons about meaning, not transport.

A common idiom is returning Either<Failure, T> (via the dartz package) from repositories, or throwing typed domain exceptions caught at the use-case edge.

sealed class Failure {
  const Failure(this.message);
  final String message;
}

class NetworkFailure extends Failure {
  const NetworkFailure() : super('No connection');
}

class NotFoundFailure extends Failure {
  const NotFoundFailure() : super('Resource not found');
}

String describe(Failure f) => switch (f) {
      NetworkFailure() => 'Check your internet.',
      NotFoundFailure() => 'We could not find that.',
      _ => 'Something went wrong.',
    };

void main() {
  print(describe(const NetworkFailure()));
  print(describe(const NotFoundFailure()));
}

Testing Each Layer in Isolation

Strict boundaries pay off in tests. Because a use case depends on an interface, you can inject a fake repository with zero network or Flutter test harness.

This test runs in plain Dart — no WidgetTester, no mock HTTP server — proving the Domain layer is genuinely decoupled.

abstract class UserRepository {
  Future<User> getUser(String id);
}

class User {
  final String id;
  final String name;
  const User({required this.id, required this.name});
}

class GetUser {
  final UserRepository repo;
  const GetUser(this.repo);
  Future<User> call(String id) => repo.getUser(id);
}

class FakeUserRepository implements UserRepository {
  @override
  Future<User> getUser(String id) async => User(id: id, name: 'Test User');
}

void main() async {
  final useCase = GetUser(FakeUserRepository());
  final user = await useCase('42');
  print(user.id == '42' && user.name == 'Test User'
      ? 'PASS'
      : 'FAIL');
}

Checkpoint: The Dependency Direction

Consider a Flutter feature using Clean Architecture. Where should the UserRepository abstract interface be declared, and which layer implements it?

Recap

You separated a Flutter feature into three layers with strict, inward-pointing dependencies:

Domain — pure entities, repository interfaces, and use cases; depends on nothing.
Data — DTO models with JSON logic, data sources, and repository implementations that map models to entities.
Presentation — Blocs/Cubits that call use cases and never touch serialization or HTTP.

Key takeaways: declare repository interfaces in Domain (Dependency Inversion), convert transport errors into domain Failures at the boundary, keep entities free of framework imports, and enforce the rules with folder structure plus lint bans. The reward is a codebase where each layer is independently testable and changes stay local.

Questions Fréquemment Posées

La leçon « Limites entre les couches domaine, données et présentation » est-elle gratuite ?

Oui — le texte complet de « Limites entre les couches domaine, données et présentation » est gratuit à lire ici sur le web. Pour la pratiquer de manière interactive (un éditeur de code intégré et un tuteur IA 24/7) et déverrouiller le reste du cours Flutter Mobile Development, passe à CoddyKit PRO. Le cours Flutter Mobile Development comprend 4 leçons au total.

Qu'est-ce que j'apprendrai dans « Limites entre les couches domaine, données et présentation » ?

Séparez les responsabilités en entités, référentiels et cas d’utilisation selon des règles strictes de dépendance. Tu pratiques Flutter Mobile Development avec du code pratique que tu exécutes directement dans le navigateur, et un tuteur IA 24/7 répond à tes questions au fur et à mesure que tu avances dans la leçon.

Dois-je avoir de l'expérience pour commencer Flutter Mobile Development ?

Aucune expérience préalable n'est requise. Flutter Mobile Development sur CoddyKit est structuré pour les débutants jusqu'aux apprenants avancés, donc tu peux commencer ici ou depuis le début et avancer à ton rythme. Ceci est la leçon 1 sur 4.

Combien de temps prend la leçon « Limites entre les couches domaine, données et présentation » ?

La plupart des leçons CoddyKit prennent environ 5–10 minutes. Chacune est courte et interactive, tu progresses régulièrement et tu repiques exactement où tu t'es arrêté sur le web et l'app.

Peux-tu écrire et exécuter du code dans cette leçon Flutter Mobile Development ?

Oui. Chaque leçon Flutter Mobile Development inclut un éditeur de code intégré, tu écris et exécutes du vrai code directement dans ton navigateur et tu reçois des retours IA instantanés — aucune configuration locale requise.

Toutes les leçons de ce cours

Limites entre les couches domaine, données et présentation
Injection de dépendances avec get_it et injectable
Structure de dossiers axée sur les fonctionnalités et monodépôts Melos
Either, types d’échec et gestion fonctionnelle des erreurs

← Retour à Flutter Mobile Development