Les modèles de conception/patron de conception (Design pattern)

Les modèles de conception, aussi appel les patrons de conception ou encore les Design Pattern en anglais, permettent d'offrir des solutions génériques a des logiciels d'entreprise face au problème répétitif qu'un logiciel peut avoir à cause d'une mauvaise conception.

La solution apportée pour corriger le problème de conception repose essentiellement sur les idées décrites par la bande des quatre (GoF) : Erich Gamma, Richard Helm, Ralpha Johnson et John Vlissides. Ceux-ci ont écrit un livre en 1995 sous l'appellation «Design patterns. Catalogue des modèles de conception réutilisables» (ISBN: 2711786447). Ces 4 auteurs proposeront 23 règles allant devenir les bases d'un des modèles de conception les plus respectés.

Il existe également le GRASP (de l'abréviation de l'anglicisme «general responsibility assignment software patterns») de Craig Larman, lequel se révèle plus convivial avec les idées du MVC. En somme, il propose des lignes directrices pour attribuer la responsabilité aux classes et objets dans la conception orientée objet. Pour y arriver, il propose les différents modèles suivants : contrôleur, créateur, redirection, expert en information, haute cohésion, faible couplage, polymorphisme, variations protégées et la fabrication pure.

Patrons de création (Creational Patterns)

Ces patrons sont conçus pour simplifier l'instanciation d'objets. Ils aident à créer des objets tout en cachant la logique de création et en rendant le système plus indépendant des classes qu'il utilise.

• Abstract Factory : Fournit une interface pour créer des familles d'objets reliés ou dépendants sans spécifier leur classe concrète. Permet de créer des ensembles d'objets cohérents.
• Builder : Sépare la construction d'un objet complexe de sa représentation, permettant ainsi la création d'objets différents avec le même processus de construction.
• Factory Method : Définit une interface pour créer un objet, mais laisse aux sous-classes le soin de décider quelle classe instancier. Utilisé pour permettre aux classes de différer l'instanciation à leurs sous-classes.
• Prototype : Crée de nouveaux objets en copiant des objets existants, en évitant de passer par la classe du nouvel objet. Utilisé quand la création d'objets est coûteuse ou complexe.
• Singleton : Garantit qu'une classe n'a qu'une seule instance et fournit un point d'accès global à cette instance. Particulièrement utile pour gérer des objets globaux (exemple : une connexion à une base de données).

Patrons structurels (Structural Patterns)

Ces modèles concernent la manière dont les classes et les objets sont composés pour former des structures plus complexes, souvent en simplifiant les relations entre eux.

• Adapter : Permet à des interfaces incompatibles de travailler ensemble. Il convertit l'interface d'une classe en une autre interface attendue par le client.
• Bridge : Sépare une abstraction d'une implémentation afin qu'elles puissent évoluer indépendamment. Cela permet de découpler l'interface et l'implémentation.
• Composite : Permet de traiter des objets individuels et des groupes d'objets de manière uniforme. Il organise des objets en arborescence pour représenter des hiérarchies "partie-tout".
• Decorator : Ajoute dynamiquement des fonctionnalités supplémentaires à un objet en le plaçant dans une enveloppe (un "décorateur") étendant ses fonctionnalités.
• Facade : Fournit une interface simplifiée à un ensemble de classes complexes, réduisant ainsi la complexité pour les utilisateurs de l'API.
• Flyweight : Utilise le partage pour réduire le coût de création d'un grand nombre d'objets semblables. Il minimise l'utilisation de mémoire en partageant des parties des objets.
• Proxy : Fournit un substitut ou un intermédiaire pour contrôler l'accès à un autre objet. Un proxy peut être utilisé pour des raisons de sécurité, de gestion des ressources, ou pour différer l'exécution d'opérations coûteuses.

Patrons comportementaux (Behavioral Patterns)

Ces modèles concernent les interactions et la communication entre les objets, en particulier en termes de responsabilités et de flux d'exécution.

• Chain of Responsibility : Permet à plusieurs objets de traiter une requête, en passant la requête le long d'une chaîne jusqu'à ce qu'un objet la prenne en charge.
• Command : Encapsule une requête en tant qu'objet, permettant ainsi de paramétrer les clients avec des requêtes, de les mettre en file d'attente ou de les annuler.
• Interpreter : Fournit un moyen d'évaluer ou de traiter des expressions ou des langages de manière efficace. Utilisé pour concevoir des compilateurs ou des moteurs d'exécution pour des langages spécifiques.
• Iterator : Fournit un moyen d'accéder à chaque élément d'une collection d'objets de manière séquentielle sans exposer la structure interne de la collection.
• Mediator : Réduit les dépendances entre les objets en introduisant un médiateur centralisant et contrôlant la communication entre eux.
• Memento : Capture et externalise l'état interne d'un objet sans violer l'encapsulation, permettant de restaurer ultérieurement cet état.
• Observer : Permet à un objet de notifier d'autres objets de tout changement d'état sans connaître leur identité précise. Cela aide à décrire des relations d'abonnement/notification.
• State : Permet à un objet de changer son comportement lorsque son état change. Le modèle d'état favorise un design propre où la logique liée à chaque état est encapsulée dans une classe distincte.
• Strategy : Définit une famille d'algorithmes, encapsule chacun d'eux et permet de les interchanger dynamiquement selon les besoins. Les algorithmes peuvent ainsi être sélectionnés au moment de l'exécution.
• Template Method : Définit la structure d'un algorithme dans une méthode, tout en déléguant certains détails de son implémentation aux sous-classes.
• Visitor : Sépare un algorithme de la structure de l'objet sur lequel il opère. Cela permet d'ajouter de nouvelles opérations sans modifier les classes sur lesquelles elles opèrent.

Patron de conception spécialisé

• Patrons pour l'architecture logicielle
• Structure des applications complexes de manière cohérente
• Encadre les décisions de conception autour des besoins en mise à l'échelle, maintenabilité et performances
• Faciliter la communication autour de l'architecture globale grâce à des schémas bien connus.
• Patrons de conception spécialisés dans les architectures distribuées et d'infonuagique
• Circuit Breaker : Protège les systèmes distribués contre les défaillances en interrompant temporairement les appels à des services défaillants.
• Retry Pattern : En cas d'échec, réessaye des appels de service pour gérer les erreurs temporaires.
• Bulkhead Pattern : Isole les ressources pour éviter qu'une défaillance d'une partie n'affecte l'ensemble du système (courant dans les microservices).
• Service Discovery : Gère dynamiquement les instances de service dans les architectures distribuées.
• Sidecar Pattern : Déploie les fonctionnalités auxiliaires dans un conteneur séparé, comme le surveillance ou la gestion des configurations.
• Patrons de sécurité
• Access Token Pattern : Utilisé pour gérer l'authentification des utilisateurs et des systèmes.
• API Gateway : Fournit un point d'accès sécurisé aux microservices, souvent avec authentification et gestion des accès.
• Principle of Least Privilege : Assure que chaque partie du système n'a que les permissions minimales nécessaires.
• Secure Vault : Permet d'entreposer les données sensibles (mots de passe, clefs) dans un emplacement sécurisé.
• Patrons pour les interfaces utilisateurs et les applications Web
• MVVM (Model-View-ViewModel) : Isole la logique de l'interface utilisateur dans les applications, généralement dans les applications de bureau et mobiles.
• MVC (Model-View-Controller) : Sépare les données (modèle), l'interface utilisateur (vue) et la logique de contrôle.
• Flux / Redux : Utilisé pour la gestion d'état dans les applications React, Flux et Redux facilitent le suivi des états dans des interfaces dynamiques.
• Presenter Pattern : Isole la logique de présentation pour les composantes d'interface utilisateur réutilisables, courants dans le développement front-end mobile ou Web.
• Patrons spécialisés dans la gestion des données
• Data Transfer Object (DTO) : Utilisé pour transférer des données entre les couches d'une application ou entre des systèmes différents. Le DTO regroupe les données nécessaires dans un seul objet, réduisant ainsi le nombre d'appels de méthode ou de requêtes.
• Data Mapper : Sépare la logique de l'application et la base de données, en particulier dans les ORM.
• Repository Pattern : Interface pour interagir avec l'entreposage des données, souvent utilisé avec le Data Mapper.
• Unit of Work : Gère des transactions dans une session pour traiter plusieurs opérations sur la base de données.
• Aggregator Pattern : Combine plusieurs sources de données en une seule réponse, souvent utilisé dans les architectures distribuées.