Voyage au pays des Patterns
Voyage au pays des Patterns
Programming, Design Patterns, Application Design · notes
Voir tous les documents en génie logiciel
Fiche de révisionRésumé
Rédigée à partir de ce document, puis vérifiée avant publication.
Les design patterns en programmation sont des solutions réutilisables à des problèmes courants rencontrés lors de la conception d'applications. Cet article explore leur importance à travers un exemple d'application de gestion d'articles et de news, en présentant les besoins fonctionnels et les différentes étapes de conception. Les étudiants apprendront comment les design patterns peuvent améliorer la structure et la maintenabilité d'un système.
Les besoins fonctionnels de notre application de gestion d'articles et de news sont simples. Les auteurs doivent pouvoir rédiger et publier leurs écrits. En cas de publication simultanée, un mécanisme de gestion des priorités doit être mis en place pour choisir quel article publier. Les utilisateurs doivent également pouvoir rechercher et lire les articles qui les intéressent. Un mécanisme de tolérance aux pannes doit être intégré, ainsi qu'un système d'exportation au format XML pour assurer la compatibilité avec d'autres outils.
La conception initiale se compose de plusieurs classes : Livrable, Catalogue, Article et News. Chaque classe a des méthodes associées, telles que Publier(), Afficher(), et ExporterEnXML(). Cependant, cette conception présente des défauts, notamment un couplage fort entre les classes et une faible cohésion des méthodes. Par exemple, la classe Livrable gère des responsabilités techniques qui devraient être déléguées à d'autres classes.
Pour améliorer la conception, nous allons appliquer plusieurs design patterns. Le premier est le pattern État, qui permet de gérer le comportement du Catalogue en fonction de son état (par exemple, RienAPublier ou PublicationPlanifiee). Cela permet de déléguer la responsabilité de l'ajout d'un Livrable à une classe d'état, rendant le système plus flexible et évolutif.
Le pattern État permet de gérer le comportement d'un objet en fonction de son état interne. Dans notre cas, le Catalogue délègue l'ajout d'un Livrable à la classe d'état actuelle. Cela permet d'ajouter de nouveaux états sans modifier le code existant, facilitant ainsi l'évolution du système.
Le choix de la prochaine publication peut être géré par le pattern Stratégie. Ce pattern permet de définir une famille d'algorithmes, de les encapsuler et de les rendre interchangeables. Ainsi, nous pouvons choisir la stratégie de publication sans impacter le reste de l'application.
Le pattern Stratégie permet de sélectionner dynamiquement une méthode d'algorithme à utiliser. Dans notre application, cela signifie que nous pouvons choisir comment publier les articles (par exemple, FIFO, pondéré, ou priorité aux articles). Cela offre une flexibilité dans la gestion des publications.
Dans la conception initiale, chaque objet métier avait la responsabilité d'exporter ses données au format XML. Cela crée un couplage fort et rend difficile l'évolution du format d'export. Pour résoudre ce problème, nous appliquons le pattern Visiteur, qui permet de séparer l'algorithme d'exportation de la structure des objets métier.
Le pattern Visiteur permet de définir de nouvelles opérations sans modifier les classes des éléments sur lesquels il opère. Dans notre cas, le Catalogue et les Livrables accueillent un Visiteur qui s'occupe de l'exportation. Cela permet de gérer plusieurs formats d'exportation sans modifier les objets métier.
Pour parcourir les Livrables, nous pouvons utiliser le pattern Itérateur. Ce pattern permet de traverser une collection d'objets sans exposer la structure interne de la collection. Cela garantit que les utilisateurs ne peuvent pas modifier la collection directement, préservant ainsi l'encapsulation.
Le pattern Itérateur fournit une interface pour parcourir une collection d'objets. Dans notre application, chaque collection de Livrables aura son propre Itérateur, ce qui permet de parcourir les objets en lecture seule tout en maintenant la sécurité de l'encapsulation.
Pour améliorer la traçabilité des interactions entre l'utilisateur et le système, nous introduisons le pattern Façade. Ce pattern simplifie l'accès aux fonctionnalités essentielles et réduit le couplage entre les différentes couches de l'application.
Le pattern Façade offre une interface simplifiée pour interagir avec un ensemble de classes. Dans notre cas, la classe GestionDesPublications sert de point d'entrée pour gérer les publications, masquant la complexité sous-jacente du système.
Pour notifier les changements d'état des Livrables, nous appliquons le pattern Observateur. Ce pattern permet à un objet de notifier d'autres objets de tout changement d'état, facilitant ainsi la mise à jour des interfaces utilisateur ou des tableaux de bord.
Le pattern Observateur permet à un objet (l'Observable) de notifier plusieurs autres objets (les Observateurs) de changements d'état. Cela est particulièrement utile dans les applications où plusieurs composants doivent réagir à des événements.
Un design pattern est une solution réutilisable à un problème courant dans la conception de logiciels. Il fournit un cadre pour résoudre des problèmes spécifiques de manière efficace.
Les design patterns améliorent la maintenabilité, la flexibilité et la réutilisabilité du code. Ils aident également à standardiser les solutions, facilitant la communication entre développeurs.
Le choix d'un design pattern dépend du problème à résoudre et du contexte de l'application. Il est important d'analyser les besoins fonctionnels et les contraintes techniques avant de sélectionner un pattern approprié.
Le pattern État gère le comportement d'un objet en fonction de son état interne, tandis que le pattern Stratégie encapsule des algorithmes interchangeables. Les deux patterns utilisent la délégation, mais leur application et leur sémantique diffèrent.
Le pattern Observateur permet à un objet de notifier d'autres objets lorsque son état change. Les Observateurs s'abonnent à l'Observable et reçoivent des notifications lorsqu'un changement se produit, facilitant ainsi la mise à jour des composants dépendants.