A brief introduction to PHP's chain of responsibility programming model_php skills

Overview
The chain of responsibility pattern is an object behavior pattern. In the chain of responsibility pattern, many objects are connected to form a chain by each object's reference to its subordinate. The request is passed up the chain until an object in the chain decides to handle the request. The client that issued the request does not know which object in the chain ultimately handles the request, which allows the system to dynamically reorganize and allocate responsibilities without affecting the client

Definition of chain of responsibility model
Make multiple objects have the opportunity to process the request, thereby avoiding the coupling relationship between the sender and receiver of the request, connecting these objects into a chain, and passing the request along this chain until an object handles it It ends.

Advantages of the chain of responsibility model
The most significant advantage is to separate requests and processing. The requester does not need to know who is processing the request, and the processor does not need to know the entire request. The two are decoupled, improving the flexibility of the system.

Disadvantages of the chain of responsibility model
First is the performance issue. Each request is traversed from the head of the chain to the end of the chain. Especially when the chain is relatively long, performance is a problem. Second, debugging is not very convenient, especially when the chain is relatively long and has many links. Due to the similar recursive method, the logic may be more complicated during debugging.

The roles involved in the chain of responsibility model are as follows:

Abstract handler (Handler) role: defines an interface for processing requests. If necessary, the interface can define a method to set and return a reference to the next interface. This role is usually implemented by a PHP abstract class or interface. The aggregation relationship of the Handler class in the above figure gives the reference of the specific subclass to the next one. The abstract method handleRequest() standardizes the operation of the subclass to handle requests
Specific handler (ConcreateHandle) role: After receiving the request, the specific handler can choose to process the request or pass the request to the next party. Since the specific handler holds a reference to the next home, the specific handler can access the next home if needed

Let’s look at an example of chain of responsibility model programming in PHP:

  <&#63;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(); 
  &#63;> 

It can be seen from the code that the client creates two handler objects and specifies that the next handler object of the first handler object is the second handler object, but the second handler object has no next handler. The client then passes the request to the first handler object