Definition and usage of state pattern in PHP

This article mainly introduces the definition and usage of state mode in PHP. Interested friends can refer to it. I hope it will be helpful to everyone.

DefinitionState 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 role in the state patternAbstract state role (State): Define an interface or abstract class State to encapsulate the behavior corresponding to a specific state of the environment object
Concrete State (ConcreteState) role: Each state class implements a state of the environment (Context) Corresponding behavior
Environment (Context) role: Define the interface that the client is interested in, and retain an instance of a specific state class. An instance of this specific state class gives the current state of this environment object

Usage scenarioConsider the application of an online voting system to control that the same user can only cast one vote , if a user votes repeatedly and votes more than 5 times, it is determined to be malicious vote brushing. If a user votes more than 8 times, he needs to be added to the blacklist.

To use the state mode to implement, first of all, the various states of the voting process must be Defined, 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

 <?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 state mode
State and BehaviorThe so-called state of an object usually refers to the value of the attribute of the object instance; and 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, and call the functions corresponding to different states by maintaining changes in the state. That is to say, state and behavior are related, and their relationship can be described as: state determines behavior

Because the state is changed during runtime, because the behavior will also change according to the change of state during runtime Change

Environment and state processing objectsIn the state model, the environment (Context) is the object that holds the state, but the environment itself does not handle the behavior related to the state, but handles the state. The function of the state is delegated to the state processing class corresponding to the state.

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 be more convenient. Passing of 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 operation, nor is it responsible for which specific state processing object is used later

Summary: The above is the entire content of this article, I hope it can help Everyone’s learning helps.

Related recommendations:

php uses ftp to implement file upload and download functions

PHP implements arrays Detailed explanation of deduplication methods

Detailed explanation of commonly used methods for PHP mysqli transaction operations

The above is the detailed content of Definition and usage of state pattern in PHP. For more information, please follow other related articles on the PHP Chinese website!