Compréhension approfondie des modèles de conception PHP: de l'introduction à la maîtrise pratique

Commencer avec le modèle de conception PHP

Les modèles de conception sont des solutions largement éprouvées dans le développement de logiciels, qui peuvent nous aider à créer des structures de code maintenables, évolutives et hautement réutilisables. L'application de modèles de conception dans PHP peut non seulement améliorer la qualité du code, mais également rendre le système plus flexible lorsqu'il est confronté à des besoins commerciaux complexes.

Trois catégories de modèles de conception PHP

Les modèles de conception sont généralement divisés en trois catégories: type de création, type structurel et type de comportement. Chaque catégorie a des scénarios de mise au point et d'utilisation différents.

Mode de création

Le mode créatif est utilisé pour encapsuler le processus de création des objets, en découplant le code à partir de classes spécifiques. Les modèles de création courants comprennent:

• Modèle d'usine: créer des objets via des classes d'usine, sans s'appuyer directement sur des classes d'implémentation spécifiques.
• Modèle singleton: assurez-vous qu'une classe n'a qu'une seule instance dans l'application.

Mode structurel

Les modèles structurels se concentrent sur la combinaison des classes et des objets, visant à rendre le système plus flexible et facile à entretenir. Les modèles structurels communs comprennent:

• Mode adaptateur: permet aux classes incompatibles avec l'interface d'origine de fonctionner ensemble.
• Mode proxy: contrôlez l'accès à l'objet cible via la classe proxy.
• Mode décorateur: Ajoutez dynamiquement de nouvelles fonctionnalités à l'objet sans modifier la classe d'origine.

Modèles comportementaux

Le mode comportemental est utilisé pour décrire les méthodes de communication et les responsabilités entre les objets. Les modes principaux comprennent:

• Mode d'observateur: implémentez le mécanisme de publication / d'abonnement.
• Mode de stratégie: permet la commutation gratuite des algorithmes ou des comportements au moment de l'exécution.
• Modèle de méthode du modèle: définissez le squelette de l'algorithme et permettez aux sous-classes de réécrire des étapes spécifiques.

Cas pratique: application de mode de conception dans le système de paniers

Les exemples suivants montrent l'application pratique des modèles de conception dans les systèmes de paniers d'achat, y compris les modèles d'usine, les modèles d'agent et les modèles de politique.

Créer des objets de service à rabais à l'aide du mode d'usine

 interface DiscountServiceFactory {
  public static function create(): DiscountService;
}

class NormalDiscountService implements DiscountService {
  // ...
}

class PremiumDiscountService implements DiscountService {
  // ...
}

class DiscountServiceFactoryImpl implements DiscountServiceFactory {
  public static function create(): DiscountService {
    if (isPremiumCustomer()) {
      return new PremiumDiscountService();
    }
    return new NormalDiscountService();
  }
}

Grâce au modèle d'usine, nous pouvons créer des instances de service de réduction de manière flexible en fonction du type d'utilisateur sans s'appuyer directement sur des classes spécifiques.

Ajouter une fonction de journalisation à votre panier à l'aide du mode proxy

 class CartLoggerProxy extends Cart {
  private $logger;

  public function __construct(Cart $cart, Logger $logger) {
    parent::__construct();
    $this->cart = $cart;
    $this->logger = $logger;
  }

  public function addItem(Item $item): void {
    parent::addItem($item);
    $this->logger->log("Added item to cart");
  }

  // D'autres méthodes peuvent être étendues de la même manière
}

Le mode proxy améliore les fonctions de la classe d'origine via la couche intermédiaire (proxy), comme l'ajout de journalisation ou de contrôle d'autorisation.

Atteindre plusieurs calculs de réduction via le mode politique

 interface DiscountStrategy {
  public function calculateDiscount(Cart $cart): float;
}

class NoDiscountStrategy implements DiscountStrategy {
  public function calculateDiscount(Cart $cart): float {
    return 0;
  }
}

class FlatDiscountStrategy implements DiscountStrategy {
  private $discount;

  public function __construct(float $discount) {
    $this->discount = $discount;
  }

  public function calculateDiscount(Cart $cart): float {
    return $cart->getTotal() * $this->discount;
  }
}

// Appliquer la stratégie
$context = new DiscountContext();

if (isPremiumCustomer()) {
  $context->setStrategy(new PremiumDiscountStrategy());
} else {
  $context->setStrategy(new NoDiscountStrategy());
}

$discount = $context->calculateDiscount();

Le modèle de stratégie permet à différents algorithmes de réduction d'être commutés librement, améliorant ainsi la flexibilité et l'évolutivité du système.

Conclusion

Les modèles de conception ne sont pas seulement des compétences en programmation, mais aussi une sorte d'idée. En appliquant rationnellement les modèles d'usine, d'agent et de stratégie, nous pouvons rendre la structure du projet PHP plus claire et plus flexible, et maintenir une bonne maintenabilité dans des scénarios complexes. La maîtrise de ces modèles jettera une base solide pour votre parcours de développement PHP.