Modèle de conception de stratégie

Le modèle de conception de stratégie est un modèle de conception comportemental qui permet de sélectionner le comportement d'un algorithme au moment de l'exécution.

Au lieu de implémenter plusieurs variantes d'un algorithme dans une seule classe, il vous permet de définir une famille d'algorithmes, d'encapsuler chacun dans sa propre classe et de les rendre interchangeables.

Composants du modèle de stratégie (UML) :

1. Classe de contexte : conserve une référence à un objet de stratégie et interagit avec lui via une interface commune.

   • Exemple : La classe Utilisateur interagit avec différentes stratégies de qualité et d'AdPolicy.

2. Interface de stratégie : définit une interface commune pour toutes les stratégies concrètes.

   • Exemple : Quality et ADPolicies sont des interfaces abstraites définissant le comportement.

3. Stratégies concrètes : implémentez l'interface Stratégie avec des algorithmes spécifiques.

   • Exemple : FreeUserQuality, PremiumUserQuality, BasicUserQuality, FreeUserAdPolicy, etc.

Quand utiliser le modèle de stratégie

Utilisez le modèle de stratégie lorsque les avantages de la flexibilité et de la maintenabilité l'emportent sur les frais généraux liés à la gestion de plusieurs classes de stratégie.

1. De nombreux algorithmes :

   • Lorsque vous devez définir plusieurs variantes d'un algorithme ou d'un comportement au sein d'une seule classe.
   • Exemple : Définition de la qualité vidéo pour différentes formules d'abonnement (Free, Basic, Premium).

2. Décisions d'exécution :

   • Lorsque le comportement d'une classe doit changer dynamiquement en fonction des entrées de l'utilisateur ou d'autres conditions d'exécution.
   • Exemple : Sélection d'algorithmes de compression (ZIP, RAR, 7z) au moment de l'exécution.

3. Évitez l'utilisation excessive des instructions if ou switch :

   • Remplacez la logique conditionnelle par des classes de stratégie interchangeables.
   • Exemple : traitement des paiements (carte de crédit, PayPal, UPI) sans blocage massif if-else.

4. Encapsulation des variations :

   • Encapsulez les variations de l'algorithme dans des classes distinctes pour garder la classe de contexte propre.
   • Exemple : stratégies de journalisation (ConsoleLogger, FileLogger, RemoteLogger).

5. Principe ouvert/fermé :

   • Assurez-vous que le système est ouvert à l'extension mais fermé à la modification en ajoutant de nouvelles stratégies sans modifier le code existant.
   • Exemple : Ajout d'un nouveau type d'utilisateur (EnterpriseUserQuality) dans l'exemple de système.

Exemple:

from abc import ABC, abstractmethod
from enum import Enum

# Enum for User Types
class UserType(Enum):
    FREE = 0
    BASIC = 1
    PREMIUM = 2

# Strategy Interface for Quality
class Quality(ABC):
    @abstractmethod
    def get_quality(self):
        pass

# Strategy Interface for Ad Policy
class AdPolicy(ABC):
    @abstractmethod
    def has_ads(self):
        pass

# Concrete Strategy for Quality
class FreeUserQuality(Quality):
    def get_quality(self):
        return ['SD']

class BasicUserQuality(Quality):
    def get_quality(self):
        return ['SD', 'HD']

class PremiumUserQuality(Quality):
    def get_quality(self):
        return ['SD', 'HD', 'UHD']

# Concrete Strategy for Ad Policy
class FreeUserAdPolicy(AdPolicy):
    def has_ads(self):
        return True

class BasicUserAdPolicy(AdPolicy):
    def has_ads(self):
        return True

class PremiumUserAdPolicy(AdPolicy):
    def has_ads(self):
        return False

# Context Class
class User:
    def __init__(self, user_type: UserType, quality: Quality, ad_policy: AdPolicy):
        self.user_type = user_type
        self.quality = quality
        self.ad_policy = ad_policy

    def get_quality(self):
        return self.quality.get_quality()

    def has_ads(self):
        return self.ad_policy.has_ads()

# Usage
free_user = User(UserType.FREE, FreeUserQuality(), FreeUserAdPolicy())
basic_user = User(UserType.BASIC, BasicUserQuality(), BasicUserAdPolicy())
premium_user = User(UserType.PREMIUM, PremiumUserQuality(), PremiumUserAdPolicy())

print("Free User Quality:", free_user.get_quality())  # ['SD']
print("Free User Ads:", free_user.has_ads())          # True

print("Premium User Quality:", premium_user.get_quality())  # ['SD', 'HD', 'UHD']
print("Premium User Ads:", premium_user.has_ads())          # False

Avantages du modèle de stratégie :

1. Flexibilité : les algorithmes peuvent être échangés au moment de l'exécution sans modifier la classe de contexte.
2. Extensibilité : de nouvelles stratégies peuvent être ajoutées sans modifier le code existant.
3. Lisibilité et maintenance : réduit l'encombrement dans la classe principale en déléguant la logique à des classes de stratégie spécifiques.
4. Adhésion aux principes SOLID : soutient particulièrement le principe ouvert/fermé.

Inconvénients du modèle de stratégie :

1. Complexité accrue : introduit des classes et des objets supplémentaires à gérer.
2. Frais généraux : si le nombre de stratégies est faible ou rarement modifié, le modèle peut ajouter une complexité inutile.

Exemples supplémentaires

1. Algorithmes de tri : utilisation dynamique de différentes stratégies de tri (par exemple, QuickSort, MergeSort, BubbleSort).
2. Calcul de la remise : application de différentes stratégies de remise (FlatDiscount, PercentageDiscount) en fonction du type d'utilisateur.
3. Mécanismes d'authentification : basculement entre différentes méthodes d'authentification (OAuth, JWT, BasicAuth).

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!