Detailed explanation of state mode programming in PHP_php skills

Definition
State pattern, also known as Pattern of Objects for State, state pattern is the behavior pattern of objects. The state pattern allows an object to change its behavior when its internal state changes. This object looks like it has changed its class

UML diagram

Main characters in status mode
Abstract state role (State): Define an interface or abstract class State to encapsulate the behavior corresponding to a specific state of the environment object
ConcreteState role: Each state class implements the behavior corresponding to a state of the environment (Context)
Context role: Defines the interface that the client is interested in and retains an instance of a specific state class. An instance of this concrete state class gives the current state of this environment object

Usage scenarios
Consider the application of an online voting system. It is necessary to control that the same user can only cast one vote. If a user votes repeatedly and votes more than 5 times, it will be judged as malicious vote brushing. If the user votes more than 8 times, he needs to be added to the blacklist.

To use the state mode to implement, you must first define the various states of the voting process. According to the above description, it can be roughly divided into four states: normal voting, malicious voting, and blacklist voting. Then create a voting management object (equivalent to Context)

UML diagram

Sample code

 <&#63;php 
  
 /** 
  * 抽象状态类 
  * @author wzy 
  * 
  */ 
 interface VoteState 
 { 
  
  /** 
   * 需要实现的公共方法 
   */ 
  public function vote (); 
 } 
  
 /** 
  * 具体状态——正常投票 
  * 
  * @author wzy 
  *   
  */ 
 class NormalVoteState implements VoteState 
 { 
  
  public function vote () 
  { 
   echo "这是一个正常投票!"; 
  } 
 } 
  
 /** 
  * 具体状态——恶意投票 
  * 
  * @author wzy 
  *   
  */ 
 class RepeatVoteState implements VoteState 
 { 
  
  public function vote () 
  { 
   echo "这是一个恶意投票!"; 
  } 
 } 
  
 /** 
  * 具体状态——黑名单投票 
  * 
  * @author wzy 
  *   
  */ 
 class BlockVoteState implements VoteState 
 { 
  
  public function vote () 
  { 
   echo "这是一个黑名单投票!"; 
  } 
 } 
  
 /** 
  * Context角色 
  */ 
 class VoteManager 
 { 
  
  /** 
   * 投票数量 
   * 
   * @var int 
   */ 
  private $vote_count; 
  
  /** 
   * 状态类实例 
   * 
   * @var object 
   */ 
  private $voteInstance; 
  
  /** 
   * 构造函数，初始化成员属性 
   * 
   * @param int $count    
   */ 
  public function __construct ($count = 1) 
  { 
   $this->vote_count = $count; 
  } 
  
  /** 
   * 客户端调用的接口函数 
   */ 
  public function setState ($count) 
  { 
   if (! is_null($count)) { 
    $this->vote_count = $count; 
   } 
   if ($this->vote_count < 5) { 
    $this->voteInstance = new NormalVoteState(); 
   } else 
    if ($this->vote_count < 8) { 
     $this->voteInstance = new RepeatVoteState(); 
    } else { 
     $this->voteInstance = new BlockVoteState(); 
    } 
    
   $this->voteInstance->vote(); 
  } 
 } 
  
 /** 
  * 模拟客户端操作 
  */ 
  
 $object = new VoteManager(); 
 $object->setState(1); 
 echo "<br>"; 
 $object->setState(6); 
 echo "<br>"; 
 $object->setState(10); 

Review Status Mode
Status and Behavior
The so-called state of an object usually refers to the value of the attribute of the object instance; and the behavior refers to the function of the object. To be more specific, most behaviors can be mapped to methods

The function of the state mode is to separate the behavior of the state. By maintaining the change of the state, the functions corresponding to the different states are called. In other words, state and behavior are related, and their relationship can be described as: state determines behavior

Since the state is changed during runtime, the behavior will also change according to the change of state during runtime

Environment and status processing objects
In the state mode, the environment (Context) is the object that holds the state, but the environment itself does not handle the behavior related to the state, but delegates the function of processing the state to the state processing class corresponding to the state for processing

In specific state processing, it is often necessary to obtain the data of the environment (Context) itself. You can consider using abstract classes instead of interfaces, which may make it more convenient to transfer parameters

The client generally only interacts with the environment (Context). The client can use the state object to configure an environment (Context). Once the configuration is completed, it no longer needs to deal with the state object. The client is usually not responsible for state maintenance during runtime, nor is it responsible for which specific state processing object is used subsequently