Patron État

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

Le pattern State 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.

Imagine 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 modèle State représente 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 contient une référence vers 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 pattern State élimine les instructions switch tentaculaires et facilite l’ajout de nouveaux états. Chaque classe d’état est chargée de savoir quel est l’état suivant, ce qui permet de garder une logique organisée et facile à maintenir.

Défi

Facile

Construisons un système de workflow de documents en utilisant le modèle State. Les documents d’un système de gestion de contenu passent par différentes étapes : brouillon, révision et publication, chaque étape ayant ses propres règles concernant les actions autorisées et ce qui se produit lorsque vous essayez de faire avancer le document.

Vous organiserez votre code dans quatre fichiers :

DocumentState.php : définissez une interface DocumentState qui établit le contrat pour tous les états de document. Elle doit comporter deux méthodes : publish(Document $document): string pour tenter de faire avancer le document, et getStatus(): string pour renvoyer 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 renvoie "Document sent for review". Son statut est "Draft".
- ReviewState : lorsque publish() est appelée, elle fait passer le document à PublishedState et renvoie "Document published". Son statut est "Under Review".
- PublishedState : lorsque publish() est appelée, elle renvoie "Document is already published" sans modifier l’état. Son statut est "Published".
Document.php : incluez le fichier States et créez une classe Document qui joue le rôle de contexte. Votre document doit :
- accepter un titre dans son constructeur et commencer dans l’état DraftState
- posséder une méthode setState(DocumentState $state): void pour modifier l’état actuel
- posséder une méthode publish(): string qui délègue à la méthode publish() de l’état actuel
- posséder une méthode getStatus(): string qui renvoie le statut de l’état actuel
main.php : incluez le fichier Document. Vous recevrez une entrée : le nombre de fois où appeler publish() sur le document.
Créez un Document avec le titre "My Article". Commencez par afficher le statut initial. Ensuite, appelez publish() le nombre de fois indiqué, 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 est l’état suivant dans le workflow, ce qui permet de garder la logique des transitions organisée et facile à modifier. Ajouter un nouvel état tel que "Archived" consisterait simplement à créer une nouvelle classe et à mettre à jour les transitions concernées.

Essayez vous-même

<?php

require_once 'Document.php';

// Lire l'entrée - nombre de fois à 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]"

?>