Explication détaillée et mise en œuvre du modèle de chaîne de responsabilité dans la programmation orientée objet PHP

Explication détaillée et mise en œuvre du modèle de chaîne de responsabilité dans la programmation orientée objet PHP

Le modèle de chaîne de responsabilité est un modèle de conception comportementale qui permet aux demandes d'être transmises le long de la chaîne de traitement jusqu'à ce qu'un processeur soit en mesure de traiter la demande. De cette façon, différents processeurs peuvent être découplés, tandis que la chaîne de traitement peut être modifiée dynamiquement ou de nouveaux processeurs peuvent être ajoutés.

En PHP, l'utilisation de la programmation orientée objet peut mieux implémenter le modèle de chaîne de responsabilité. Les éléments suivants démontrent la méthode d'implémentation de ce modèle via un exemple simple de code.

1. Créez une classe de processeur abstraite

Tout d'abord, nous devons définir une classe abstraite «Handler» comme classe de base pour tous les gestionnaires de béton. Cette classe contient la méthode «manche ()» pour gérer la demande et la méthode `setNext ()» pour définir le gestionnaire suivant:

 abstract class Handler {
    protected $nextHandler;

    public function setNext(Handler $handler) {
        $this->nextHandler = $handler;
    }

    abstract public function handle(Request $request);
}

2. Implémentez la classe de gestionnaire spécifique

Ensuite, nous créons une classe de gestionnaire spécifique, héritant de la classe «Handler», et implémentons la méthode `Handle ()». Dans le traitement de la logique, si le processeur actuel ne peut pas traiter la demande, il transmet la demande au processeur suivant:

 class ConcreteHandler1 extends Handler {
    public function handle(Request $request) {
        if ($request->getType() == 'type1') {
            echo "Handled by ConcreteHandler1";
        } else {
            if ($this->nextHandler) {
                $this->nextHandler->handle($request);
            } else {
                echo "No handler can handle the request";
            }
        }
    }
}

3. Créez une autre classe de processeur spécifique

Nous créons une autre classe de processeur spécifique «ConcreteHandler2», qui gère les demandes de différents types que «ConcreteHandler1». Et le régler sur le gestionnaire suivant de `` ConcreteHandler1`:

 class ConcreteHandler2 extends Handler {
    public function handle(Request $request) {
        if ($request->getType() == 'type2') {
            echo "Handled by ConcreteHandler2";
        } else {
            if ($this->nextHandler) {
                $this->nextHandler->handle($request);
            } else {
                echo "No handler can handle the request";
            }
        }
    }
}

4. Créez une classe de demande

Afin de transmettre les informations de demande au processeur, nous avons besoin d'une classe «demande» pour encapsuler les données demandées. Il contient les informations de type de la demande de livraison dans la chaîne de traitement:

 class Request {
    protected $type;

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

    public function getType() {
        return $this->type;
    }
}

5. Testez le modèle de la chaîne de responsabilité

Enfin, nous pouvons tester la mise en œuvre du modèle de chaîne de responsabilité. Créez d'abord un objet de demande, puis créez deux objets de processeur et configurez la chaîne de traitement entre eux. Ensuite, passez la demande au premier gestionnaire et vérifiez le processus de traitement:

 $request = new Request('type2');
$handler1 = new ConcreteHandler1();
$handler2 = new ConcreteHandler2();

$handler1->setNext($handler2);
$handler1->handle($request);

Exécutez le code ci-dessus et la sortie est:

Géré par le bétonhandler2

Comme on peut le voir à partir du code de test, lorsque le type de demande est «type2», «ConcreteHandler2» peut gérer la demande, donc «géré par ConcreteHandler2» est sortie; Lorsque le type de demande est 'Type1', `` ConcreteHandler1` ne peut pas gérer la demande, donc la demande est transmise à `` ConcreteHandler2 '', et s'il n'y a pas de gestionnaire suivant, "aucun gestionnaire ne peut gérer la demande".

Résumer

Le modèle de la chaîne de responsabilité fournit une méthode de traitement de demande flexible grâce à la programmation orientée objet. Lors du traitement d'une demande, chaque processeur ne se soucie que du type de demande qu'il peut traiter. S'il ne peut pas être traité, la demande sera remise au processeur suivant. Ce mode débarque efficacement chaque processeur, améliorant ainsi l'évolutivité et le maintien du système.