Patron État

Fait partie de la section Programmation Orientée Objet du Journey PHP de Coddy — leçon 79 sur 91.

Le State Pattern est un patron de conception comportemental qui permet à un objet de modifier son comportement lorsque son état interne change. Au lieu d'utiliser des conditions complexes pour gérer différents états, vous encapsulez chaque état dans sa propre classe et déléguez le comportement à l'objet d'état actuel.

Pensez à un distributeur automatique. Il se comporte différemment selon qu'il attend de l'argent, qu'il a reçu un paiement ou qu'il distribue un produit.

Chaque état possède ses propres règles concernant les actions autorisées. Le patron de conception État (State Pattern) modélise cela en créant une classe pour chaque état.

<?php
interface OrderState {
    public function proceed(Order $order): string;
    public function getStatus(): string;
}

class PendingState implements OrderState {
    public function proceed(Order $order): string {
        $order->setState(new ProcessingState());
        return "Order moved to processing";
    }
    
    public function getStatus(): string {
        return "Pending";
    }
}

class ProcessingState implements OrderState {
    public function proceed(Order $order): string {
        $order->setState(new ShippedState());
        return "Order has been shipped";
    }
    
    public function getStatus(): string {
        return "Processing";
    }
}

class ShippedState implements OrderState {
    public function proceed(Order $order): string {
        return "Order already shipped";
    }
    
    public function getStatus(): string {
        return "Shipped";
    }
}

La classe de contexte détient une référence à l'état actuel et lui délègue les appels :

<?php
class Order {
    private OrderState $state;
    
    public function __construct() {
        $this->state = new PendingState();
    }
    
    public function setState(OrderState $state): void {
        $this->state = $state;
    }
    
    public function proceed(): string {
        return $this->state->proceed($this);
    }
    
    public function getStatus(): string {
        return $this->state->getStatus();
    }
}

$order = new Order();
echo $order->getStatus() . "\n";
echo $order->proceed() . "\n";
echo $order->getStatus() . "\n";
echo $order->proceed() . "\n";
echo $order->getStatus();

Sortie :

Pending
Order moved to processing
Processing
Order has been shipped
Shipped

Le State Pattern élimine les instructions switch complexes et rend l'ajout de nouveaux états simple. Chaque classe d'état est responsable de savoir quel état suit, ce qui permet de garder la logique organisée et facile à maintenir.

Défi

Facile

Construisons un système de flux de travail de documents en utilisant le State Pattern. Les documents dans un système de gestion de contenu passent par différentes étapes — brouillon, révision et publié — chaque étape ayant ses propres règles sur les actions autorisées et sur ce qui se passe lorsque vous essayez de faire avancer le document.

Vous organiserez votre code sur quatre fichiers :

DocumentState.php — Définissez une interface DocumentState qui établit le contrat pour tous les états de document. Elle doit avoir deux méthodes : publish(Document $document): string pour tenter de faire avancer le document, et getStatus(): string pour retourner le nom de l'état actuel.
States.php — Incluez l'interface DocumentState et créez trois classes d'état qui l'implémentent :
- DraftState — Lorsque publish() est appelée, elle fait passer le document à ReviewState et retourne "Document sent for review". Son statut est "Draft".
- ReviewState — Lorsque publish() est appelée, elle fait passer le document à PublishedState et retourne "Document published". Son statut est "Under Review".
- PublishedState — Lorsque publish() est appelée, elle retourne "Document is already published" sans changer d'état. Son statut est "Published".
Document.php — Incluez le fichier States et créez une classe Document qui agit comme contexte. Votre document doit :
- Accepter un titre dans son constructeur et commencer dans l'état DraftState
- Avoir une méthode setState(DocumentState $state): void pour changer l'état actuel
- Avoir une méthode publish(): string qui délègue à la méthode publish() de l'état actuel
- Avoir une méthode getStatus(): string qui retourne le statut de l'état actuel
main.php — Incluez le fichier Document. Vous recevrez une entrée : le nombre de fois qu'il faut appeler publish() sur le document.
Créez un Document avec le titre "My Article". Tout d'abord, affichez le statut initial. Ensuite, appelez publish() le nombre de fois spécifié, en affichant le résultat de chaque appel sur une nouvelle ligne. Enfin, affichez le statut final.

Format de sortie :
```
Status: [initial status]
[publish result 1]
[publish result 2]
...
Status: [final status]
```

Chaque classe d'état sait quel état vient ensuite dans le flux de travail, gardant la logique de transition organisée et facile à modifier. Ajouter un nouvel état comme "Archived" signifierait simplement créer une nouvelle classe et mettre à jour les transitions concernées.

Aide-mémoire

Le State Pattern (Patron d'état) est un patron de conception comportemental qui permet à un objet de changer son comportement lorsque son état interne change en encapsulant chaque état dans sa propre classe.

Définissez une interface d'état que toutes les classes d'état implémenteront :

<?php
interface OrderState {
    public function proceed(Order $order): string;
    public function getStatus(): string;
}

Créez des classes d'état concrètes qui implémentent l'interface :

<?php
class PendingState implements OrderState {
    public function proceed(Order $order): string {
        $order->setState(new ProcessingState());
        return "Order moved to processing";
    }
    
    public function getStatus(): string {
        return "Pending";
    }
}

class ProcessingState implements OrderState {
    public function proceed(Order $order): string {
        $order->setState(new ShippedState());
        return "Order has been shipped";
    }
    
    public function getStatus(): string {
        return "Processing";
    }
}

class ShippedState implements OrderState {
    public function proceed(Order $order): string {
        return "Order already shipped";
    }
    
    public function getStatus(): string {
        return "Shipped";
    }
}

Créez une classe de contexte qui détient une référence à l'état actuel et lui délègue les appels :

<?php
class Order {
    private OrderState $state;
    
    public function __construct() {
        $this->state = new PendingState();
    }
    
    public function setState(OrderState $state): void {
        $this->state = $state;
    }
    
    public function proceed(): string {
        return $this->state->proceed($this);
    }
    
    public function getStatus(): string {
        return $this->state->getStatus();
    }
}

Exemple d'utilisation :

$order = new Order();
echo $order->getStatus() . "\n";  // Pending
echo $order->proceed() . "\n";     // Order moved to processing
echo $order->getStatus() . "\n";   // Processing
echo $order->proceed() . "\n";     // Order has been shipped
echo $order->getStatus();          // Shipped

Le State Pattern élimine les instructions switch complexes et rend l'ajout de nouveaux états simple. Chaque classe d'état est responsable de savoir quel état vient ensuite.

Essayez vous-même

<?php

require_once 'Document.php';

// Lire l'entrée - nombre de fois qu'il faut appeler publish()
$n = intval(trim(fgets(STDIN)));

// TODO: Créer un Document avec le titre "My Article"

// TODO: Afficher le statut initial au format : "Status: [status]"

// TODO: Appeler publish() n fois, en affichant chaque résultat sur une nouvelle ligne

// TODO: Afficher le statut final au format : "Status: [status]"

?>