Modèle de programmation de chaîne de responsabilité PHP

Cet article présente principalement le modèle de programmation de chaîne de responsabilité de PHP, qui est également une convention de programmation largement utilisée par les équipes de développement. J'espère que cela aide tout le monde.

Vue d'ensemble
Le modèle de chaîne de responsabilité est un modèle de comportement d'objet. Dans le modèle de chaîne de responsabilité, de nombreux objets sont connectés pour former une chaîne par la référence de chaque objet à son descendant. La requête est transmise dans la chaîne jusqu'à ce qu'un objet de la chaîne décide de traiter la requête. Le client qui a émis la demande ne sait pas quel objet de la chaîne gère finalement la demande, ce qui permet au système de réorganiser et d'attribuer dynamiquement les responsabilités sans affecter le client

La définition du modèle de chaîne de responsabilité
donne à plusieurs objets la possibilité de traiter les demandes, évitant ainsi la relation de couplage entre l'expéditeur et le destinataire de la demande et connectant ces objets dans une chaîne et transmettant la demande le long de celle-ci. chaîne jusqu’à ce qu’un objet la manipule.

Avantages du modèle de chaîne de responsabilité
L'avantage le plus important est de séparer les demandes et le traitement. Le demandeur n'a pas besoin de savoir qui traite la demande et le processeur n'a pas besoin de connaître l'intégralité de la demande. Les deux sont découplés, ce qui améliore la flexibilité du système.

Inconvénients du modèle de chaîne de responsabilité
Le premier est le problème de performance. Chaque demande est parcourue de la tête de la chaîne jusqu'à la fin de la chaîne. relativement long, la performance est une question. Deuxièmement, le débogage n'est pas très pratique, surtout lorsque la chaîne est relativement longue et comporte de nombreux maillons. En raison de l'utilisation d'une méthode récursive, la logique peut être plus compliquée lors du débogage.

Les rôles impliqués dans le modèle de chaîne de responsabilité sont les suivants :

Rôle de gestionnaire abstrait (Handler) : définir une requête interface de traitement. Si nécessaire, l'interface peut définir une méthode pour définir et renvoyer une référence à l'interface suivante. Ce rôle est généralement implémenté par une classe abstraite ou une interface PHP. La relation d'agrégation de la classe Handler dans la figure ci-dessus donne la référence de la sous-classe spécifique au prochain home. La méthode abstraite handleRequest() standardise le fonctionnement de la sous-classe pour gérer la requête
Rôle de gestionnaire spécifique (ConcreateHandle) : Le un gestionnaire spécifique reçoit la demande. Enfin, vous pouvez choisir de traiter la demande ou de transmettre la demande à la partie suivante. Étant donné que le processeur spécifique détient une référence au processeur suivant, si nécessaire, le processeur spécifique peut visiter le processeur suivant

pour voir un exemple de programmation de modèle de chaîne de responsabilité PHP :

  <?php 
  /** 
   * 抽象处理者角色 
   * @author wzy 
   * 
   */ 
  abstract class Handle 
  { 

    /** 
     * 持有后继的责任对象 
     * 
     * @var object 
     */ 
    protected $successor; 
   
    /** 
     * 示意处理请求的方法，虽然这个示意方法是没有传入参素的 
     * 但实际是可以传入参数的，根据具体需要来选择是否传递参数 
     */ 
    public abstract function handleRequest (); 
   
    /** 
     * 取值方法 
     * 
     * @return object 
     */ 
    public function getSuccessor () 
    { 
      return $this->successor; 
    } 
   
    /** 
     * 赋值方法，设置后继的责任对象 
     * 
     * @param object $objsuccessor       
     */ 
    public function setSuccessor ($objsuccessor) 
    { 
      $this->successor = $objsuccessor; 
    } 
  } 
   
  /** 
   * 具体处理者角色 
   * 
   * @author wzy 
   *     
   */ 
  class ConcreateHandler extends Handle 
  { 
   
    /** 
     * 判断是否有后继的责任对象 
     * 如果有，就转发请求给后继的责任对象 
     * 如果没有，则处理请求 
     * 
     * @see Handle::handleRequest() 
     */ 
    public function handleRequest () 
    { 
      if ($this->getSuccessor() != null) { 
        echo "放过请求，将请求转发给后继的责任对象!<br>"; 
        $this->getSuccessor()->handleRequest(); 
      } else { 
        echo "处理请求，处理过程省略...<br>"; 
      } 
    } 
  } 
   
  /** 
   * 客户端代码 
   */ 
   
  // 组装责任链 
  $handle1 = new ConcreateHandler(); 
  $handle2 = new ConcreateHandler(); 
  $handle1->setSuccessor($handle2); 
   
  // 提交请求 
  $handle1->handleRequest(); 
  ?>

Comme le montre le code, le client crée deux objets gestionnaires et spécifie que la prochaine maison du premier objet gestionnaire est le deuxième objet gestionnaire, mais que le deuxième objet gestionnaire n'est pas la maison suivante. Le client transmet ensuite la requête au premier objet gestionnaire

Recommandations associées :

Programmation en mode état PHP

Implémentation du modèle PHP singleton

Modèle de méthode d'usine PHP

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!