Aller au contenu
Encyclopédie informatique Édition 2026

Les patrons de conception

Partie 2 sur 2

Niveau de lecture :

4Trois exemples en code

Les patrons sont souvent plus simples à lire dans un langage récent que dans le style lourd de 1995. Voici trois exemples en Python (voir le langage Python).

4.1Stratégie : choisir un comportement

Une boutique applique tantôt le tarif normal, tantôt le tarif des soldes. Plutôt qu’un empilement de if, on passe la règle en paramètre :

def tarif_normal(prix):
    return prix

def tarif_soldes(prix):
    return prix * 0.5

def total(panier, tarif):
    return sum(tarif(p) for p in panier)

print(total([10, 20], tarif_soldes))   # affiche 15.0

Ajouter un tarif revient à écrire une nouvelle fonction, sans toucher à total.

4.2Fabrique : créer sans dépendre du type exact

Un programme doit lire des fichiers de formats différents. Au lieu de répéter partout la question « quel format ? », on la pose à un seul endroit, dans une fabrique :

class LecteurCsv:
    def lire(self, chemin): ...

class LecteurJson:
    def lire(self, chemin): ...

def creer_lecteur(format):
    lecteurs = {"csv": LecteurCsv, "json": LecteurJson}
    return lecteurs[format]()      # un format inconnu lève une erreur

Le reste du programme appelle creer_lecteur("csv").lire(...) sans connaître les classes concrètes. Ajouter un format ne demande de modifier que la fabrique. Remarquez le dictionnaire fermé : un format qui n’y figure pas est refusé, ce qui compte pour la sécurité (voir « Le coin cyber »).

4.3Observateur : prévenir les intéressés

Un capteur de température prévient tous ceux qui se sont abonnés :

class Capteur:
    def __init__(self):
        self.abonnes = []
    def abonner(self, fonction):
        self.abonnes.append(fonction)
    def publier(self, valeur):
        for f in self.abonnes:
            f(valeur)

capteur = Capteur()
capteur.abonner(lambda t: print("écran :", t))
capteur.abonner(lambda t: print("journal :", t))
capteur.publier(21.5)    # chaque abonné reçoit 21.5

Le capteur ne sait pas qui l’écoute : on ajoute un abonné sans modifier le capteur.

Pour s’exercer

Exercice 2 : Remplacer une suite de if

Voici une fonction : if mode == "carte": ... elif mode == "virement": ... elif mode == "especes": .... Quel patron peut la remplacer, et quel avantage cela apporte-t-il ?

Voir la réponse

Le patron Stratégie : chaque mode de paiement devient une fonction ou une classe séparée, et la fonction principale appelle simplement celle qu’on lui donne. L’avantage : pour ajouter un mode, on ajoute une classe ou une fonction, sans modifier le reste du code, donc avec moins de risques de casser ce qui marche déjà.

Exercice 3 : Répartir en MVC

Dans une boutique en ligne, répartissez entre modèle, vue et contrôleur : (a) la règle « livraison gratuite au-dessus de 50 euros » ; (b) l’affichage du panier avec les prix ; (c) la réception du clic sur « ajouter au panier ».

Voir la réponse

(a) Le modèle : c’est une règle de gestion, qui concerne les données et le métier. (b) La vue : c’est l’affichage, ce que voit le client. (c) Le contrôleur : il reçoit l’action de l’utilisateur et demande au modèle de mettre à jour le panier, puis à la vue de se rafraîchir.

5D’autres familles de patrons

L’idée de patron a dépassé les 23 modèles de 1995. On parle de patrons d’architecture pour l’organisation d’un système entier : le modèle-vue-contrôleur, la séparation en couches, ou le découpage en petits services indépendants qui se parlent par le réseau (voir les microservices). Il existe des patrons pour les applications d’entreprise (accès aux bases de données, gestion des transactions), pour la programmation parallèle (qui fait quoi en même temps), et pour la sécurité (contrôle d’accès, journalisation, cloisonnement). Le principe reste identique : nommer une solution éprouvée, pour la retrouver et en parler.

6Les critiques et le bon usage

6.1Des patrons qui disparaissent avec le langage

En 1996, le chercheur Peter Norvig observe que seize des vingt-trois patrons du livre deviennent « invisibles » ou beaucoup plus simples dans des langages dynamiques comme Lisp : une fonction passée en paramètre (comme ci-dessus) remplace la stratégie, l’itérateur est intégré à la boucle for. Beaucoup de patrons compensent donc des limites des langages de l’époque (surtout C++ et Java). C’est une raison de les connaître comme des idées, plus que comme des recettes.

6.2Le singleton, patron controversé

Le singleton est devenu l’exemple d’abus : un objet unique accessible de partout est, en réalité, une variable globale déguisée. Il crée des dépendances cachées, complique les tests (on ne peut pas le remplacer par un faux) et pose des problèmes quand plusieurs tâches s’exécutent en parallèle. On lui préfère aujourd’hui l’injection de dépendances : on fournit explicitement à un objet ce dont il a besoin, au lieu de le laisser puiser dans un état global.

6.3Comment choisir ?

On ne part pas d’un patron pour chercher un problème, mais l’inverse. Trois questions aident : le problème se répète-t-il ? La solution actuelle est-elle pénible à modifier ? Le patron vise-t-il exactement cette difficulté (créer, assembler ou faire collaborer) ? Si une réponse est non, le patron n’est probablement pas le bon outil.

6.4Éviter la sur-conception

Le défaut le plus fréquent est d’appliquer des patrons avant d’en avoir besoin, par goût de l’élégance : le résultat est une forêt de classes pour un problème simple, plus difficile à lire que le code naïf qu’elle remplace. Une règle sage : écrire d’abord le code le plus simple qui marche, et ne refactoriser (réorganiser sans changer le résultat) vers un patron que quand la douleur apparaît, par exemple la troisième fois qu’on ajoute un cas dans une longue suite de if. Les méthodes agiles (voir les méthodes agiles) disent de même : ne construisez pas ce dont vous n’avez pas encore besoin.

6.5Les anti-patrons

À l’inverse des patrons, un anti-patron est une mauvaise solution fréquente : le « plat de spaghettis » (code enchevêtré), le « couteau suisse » (une classe qui fait tout), le copier-coller de code, ou l’optimisation prématurée. Les connaître aide à reconnaître les erreurs aussi sûrement que les patrons aident à reconnaître les solutions.

Sécurité de l’information

Le coin cyber

Cet article présente des principes de conception. Il ne contient aucune méthode d’attaque.

C.1Des patrons qui aident la sécurité

Plusieurs patrons servent directement la sécurité. Le proxy contrôle l’accès à un objet (vérifier les droits avant d’ouvrir). La façade réduit la surface exposée : on n’ouvre qu’une porte. La chaîne de responsabilité décrit les filtres successifs d’un serveur web : authentification, contrôle des droits, validation, journal (voir l’authentification). La stratégie permet de changer d’algorithme de chiffrement ou de hachage sans réécrire le programme, ce qui compte quand un algorithme devient vulnérable.

C.2Des patrons qui posent des questions

Le singleton partage un état entre toutes les tâches : sans précaution, deux tâches qui le modifient en même temps provoquent des erreurs difficiles à reproduire (une « condition de concurrence »), parfois exploitables. Une fabrique qui choisit la classe à créer d’après un nom reçu de l’extérieur (un fichier, une requête) peut laisser un tiers faire instancier ce qu’il veut : le nom doit venir d’une liste fermée. Enfin, empiler des couches accroît la surface à auditer.

C.3Idée reçue

« Un code qui applique des patrons est un code de qualité. » Faux. Un patron est un moyen, pas un but. On peut écrire un logiciel illisible avec vingt patrons bien appliqués, et un logiciel excellent sans en nommer un seul. La qualité se mesure à la lisibilité, aux tests, et à l’aisance avec laquelle on corrige une faille.

C.4Bonnes pratiques

Particulier

  • Apprendre les noms des patrons pour lire plus vite le code des autres.
  • Résister à l’envie de « faire joli » : le plus simple d’abord.

Organisation

  • Documenter les patrons utilisés dans l’architecture et les relire lors des revues de code.
  • Limiter l’état global partagé et tester les cas de concurrence.
  • Ne jamais créer d’objets à partir de noms fournis par l’utilisateur sans liste blanche.

Référentiels : Erich Gamma et al., Design Patterns, 1995 · OWASP (association qui publie des guides de sécurité des applications), Secure Design Principles · CWE-362 (concurrence) et CWE-470 (sélection non contrôlée de classe) dans le catalogue de MITRE.

Références

  1. Erich Gamma, Richard Helm, Ralph Johnson, John Vlissides, Design Patterns: Elements of Reusable Object-Oriented Software, Addison-Wesley, 1995.
  2. Christopher Alexander et al., A Pattern Language, Oxford University Press, 1977.
  3. Peter Norvig, Design Patterns in Dynamic Languages, 1996.
  4. Trygve Reenskaug, notes sur le modèle-vue-contrôleur, Xerox PARC, 1979.

Voir aussi

Citer cet article

« Les patrons de conception », Encyclopédie informatique, révision du 4 novembre 2026.