Migration Android vers Clean Architecture

Les applications Android traditionnelles souffrent souvent de problèmes de maintenabilité et de testabilité.

Ces limitations peuvent freiner le développement et compliquer la mise en œuvre de nouvelles fonctionnalités, rendant le code difficile à gérer.

La Clean Architecture propose une structure claire et modulaire qui améliore la maintenabilité et la testabilité, facilitant ainsi le développement futur.

Table de matière

Analyser les Modèles Ancien Android Adopter Clean Architecture Android Bénéfices de la Clean Architecture FAQ Conclusion

Formation Créer une Architecture Moderne pour Applications Android

Apprenez à construire des applications Android avec une architecture moderne et performante!

Nous allons explorer la migration d’une application Android classique, souvent basée sur des modèles comme MVVM (Model-View-ViewModel), vers la Clean Architecture . Nous allons souligner les raisons pour lesquelles ce changement est nécessaire, ainsi que les étapes pratiques pour effectuer cette migration.

Analyser les Modèles Ancien Android

Les Applications Android sans Architecture

Au début, les applications Android n’étaient pas construites avec une architecture particulière en tête. Les développeurs se concentraient principalement sur la partie graphique (UI), ce qui conduisait à des codes désorganisés et difficiles à maintenir.
Ce manque d’architecture a permis à des pratiques de développement peu rigoureuses de se répandre, ce qui a rendu les applications très hétérogènes et incohérentes.

Le Modèle MVVM

MVVM est un modèle où l’état des éléments graphiques comme les activités et les fragments est géré par un objet intermédiaire appelé ViewModel.
Le problème avec MVVM est que le ViewModel peut rapidement devenir surchargé de logique métier, le rendant difficile à maintenir et à tester.

Adopter Clean Architecture Android

La Clean Architecture , popularisée par Robert C. Martin (alias Uncle Bob), vise à créer des systèmes où les différents composants sont découplés les uns des autres, rendant le code plus maintenable et testable. La Clean Architecture est particulièrement utile pour les applications complexes où la séparation des préoccupations est cruciale.

Historique : La Clean Architecture a été popularisée par Robert C. Martin, également connu sous le nom d’Uncle Bob, un expert en ingénierie logicielle et l’un des pionniers dans la création de bonnes pratiques de développement. Elle est le fruit de l’évolution d’idées et de principes architecturaux issus de plusieurs autres approches, notamment l’Hexagonal Architecture (ou Ports and Adapters) de Alistair Cockburn, l’Onion Architecture de Jeffrey Palermo, et l’architecture Bounded Context de Domain-Driven Design (DDD) de Eric Evans.

Principes de Base de la Clean Architecture

Indépendance des Couches :Chaque couche de l’application (UI, domaine, données) est indépendante des autres, ce qui permet de modifier une couche sans affecter les autres.
Dépendance envers les Abstractions :Les couches supérieures dépendent des abstractions (interfaces), et non des implémentations concrètes.

Étapes de la Migration vers la Clean Architecture

Création du Modèle de DomaineDomain Layer :Cette couche contient la logique métier de l’application. Elle est totalement indépendante des autres couches (UI, données).Entities: Les objets métier purs, qui représentent les concepts clés de l’application.Use Cases: Les cas d’utilisation représentent les actions possibles sur le domaine. Chaque use case encapsule une action spécifique que l’utilisateur peut effectuer.

Exemple de Use Case :

				
					
data class Plage(val id : Int, val nom : String) interface GetPlageUseCase {
  suspend operator fun invoke() : List<Plage>
}

Création des Interfaces de RepositoryRepositories :Les repositories sont des abstractions qui encapsulent l’accès aux données. Dans la Clean Architecture, les repositories ne sont pas directement accessibles depuis la couche UI. Ils sont utilisés par les use cases pour fournir des données au ViewModel.Il est crucial de recréer ces interfaces dans la couche du domaine lors de la migration.

Exemple d’Interface de Repository :

				
					
interface PlageRepository { suspend fun getPlages() : List<Plage> }

Implémentation des Use Cases et des Repositories
- Une fois les interfaces définies, l’étape suivante consiste à implémenter les use cases et les repositories dans les couches appropriées.
- Le ViewModel ne devrait plus accéder directement aux données ou aux repositories. Au lieu de cela, il interagit avec les use cases, qui à leur tour utilisent les repositories pour obtenir les données nécessaires.

Une fois les interfaces définies, l’étape suivante consiste à implémenter les use cases et les repositories dans les couches appropriées.
Le ViewModel ne devrait plus accéder directement aux données ou aux repositories. Au lieu de cela, il interagit avec les use cases, qui à leur tour utilisent les repositories pour obtenir les données nécessaires.

Exemple d’Implémentation d’un Use Case :

				
					
class GetPlageUseCaseImpl(
    private val plageRepository : PlageRepository,
    private val coroutineContextProvider : CoroutineContextProvider)
    : GetPlageUseCase {
  override suspend fun invoke()
      : List<Plage> = withContext(coroutineContextProvider.IO) {
    plageRepository.getPlages()
  }
}

Migration du ViewModel
- Le ViewModel dans MVVM est souvent surchargé de responsabilités. Dans la Clean Architecture, le ViewModel doit être simplifié pour ne gérer que l’état de l’interface utilisateur et déléguer la logique métier aux use cases.
- Le ViewModel interagit avec les use cases pour déclencher des actions et obtenir des données.

Le ViewModel dans MVVM est souvent surchargé de responsabilités. Dans la Clean Architecture, le ViewModel doit être simplifié pour ne gérer que l’état de l’interface utilisateur et déléguer la logique métier aux use cases.
Le ViewModel interagit avec les use cases pour déclencher des actions et obtenir des données.

Exemple de ViewModel Simplifié :

				
					
class PlageViewModel(private val getPlageUseCase : GetPlageUseCase)
    : ViewModel() {
private
  val _plages =
      MutableLiveData<List<Plage>>() val plages : LiveData<List<Plage>> get() =
                                                      _plages fun loadPlages() {
    viewModelScope.launch {
      val result = getPlageUseCase() _plages.value = result
    }
  }
}

Mapping des Données

Question : Comment la couche de données et la couche UI utilisent-elles des objets différents, et quel est le rôle d’un mapper dans la transformation des objets entre ces couches ?

La couche de données peut manipuler des objets spécifiques à la base de données ou à l’API, tandis que la couche UI utilise des objets plus simples adaptés à l’affichage.
Un mapper est utilisé pour transformer les objets entre les différentes couches.

Exemple de Mapper :

				
					
data class PlageEntity(val id : Int,
                       val nom : String) fun PlageEntity.toDomainModel()
    : Plage {
  return Plage(id = this.id, nom = this.nom)
}

Bénéfices de la Clean Architecture

La migration d’une application Android vers la Clean Architecture nécessite une refonte structurelle, mais elle en vaut la peine. Elle permet de créer une application plus modulaire, testable et facile à maintenir. En suivant les étapes décrites, vous pouvez transformer un projet existant basé sur MVVM ou un autre modèle en une application robuste suivant les principes de la Clean Architecture.

Formez-vous gratuitement avec Alphorm !

Maîtrisez les compétences clés en IT grâce à nos formations gratuites et accélérez votre carrière dès aujourd'hui.

FAQ

Pourquoi migrer vers la Clean Architecture ?

Migrer vers la Clean Architecture permet d’obtenir un code plus modulaire, testable et facile à maintenir. Les applications avec une architecture claire sont mieux structurées, ce qui rend les mises à jour et l’ajout de nouvelles fonctionnalités plus simples. De plus, la séparation des préoccupations entre les couches améliore la détection des erreurs et la facilité de test, rendant le développement plus efficace.

Quels sont les défis de l'architecture MVVM ?

Un des principaux défis de l’architecture MVVM est la surcharge du ViewModel par la logique métier. Cela complique la maintenance et réduit la testabilité de l’application. En outre, l’accent excessif sur le couplage des éléments graphiques peut entraîner un code difficile à lire et à adapter, ce qui est problématique pour les applications complexes nécessitant des évolutions régulières.

Quelles sont les étapes de migration vers la Clean Architecture ?

La migration vers la Clean Architecture implique plusieurs étapes clés : création du modèle de domaine, définition des interfaces de repository, implémentation des use cases et des repositories, simplification du ViewModel, et utilisation de mappers pour transformer les données entre les couches. Chaque étape vise à établir une architecture bien structurée, avec des couches indépendantes et une dépendance envers les abstractions.

Comment simplifier le ViewModel dans la Clean Architecture ?

Dans la Clean Architecture, le ViewModel doit être simplifié pour gérer uniquement l’état de l’interface utilisateur. Il doit interagir avec des use cases pour exécuter la logique métier et obtenir les données nécessaires. Cela permet au ViewModel de rester léger et facile à tester, tout en améliorant la séparation des responsabilités au sein de l’application.

Quel est le rôle d'un mapper dans la Clean Architecture ?

Un mapper dans la Clean Architecture sert à transformer les objets entre la couche de données et la couche UI. Cela permet à chaque couche d’utiliser des objets adaptés à ses besoins spécifiques. Par exemple, les objets de base de données peuvent être convertis en objets de domaine plus simples pour l’affichage, assurant ainsi une meilleure séparation des préoccupations et facilitant la maintenance et l’évolution du code.

Conclusion

La migration vers la Clean Architecture offre de nombreux avantages pour le développement d’applications Android. Quelle stratégie adopteriez-vous pour maximiser les bénéfices de cette architecture dans votre projet actuel ?