PHP state mode programming

What is PHP state mode programming? This article mainly introduces the detailed explanation of state mode programming in PHP, which is conducive to team collaboration programming. I hope it will be helpful to everyone.

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 roles in the state pattern
Abstract 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 the environment The behavior corresponding to a state of (Context)
Environment (Context) role: Define the interface that the client is interested in, and retain an instance of a specific state class. Instances of this specific state class give the current state of this environment object

Usage scenarios
Consider the application of an online voting system. To control the same user, only Cast a vote. If a user votes repeatedly and votes more than 5 times, it will be judged as 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 voting process Various states are defined and can be roughly divided into four states according to the above description: 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);

Reviewing the state patternState and behavior

The so-called object State 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 pattern is to separate the behavior of the state. By maintaining changes in status, functions corresponding to different statuses are called. 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 objects
In the state model, the environment (Context) is an object that holds the state, but the environment itself does not handle state-related behaviors, but The function of processing the state is delegated 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 It will be more convenient to pass 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

Related recommendations:

PHP Design Patterns Simple Factory Pattern

The difference between factory pattern and singleton pattern in PHP design pattern

PHP Polymorphism and Dynamic Binding

The above is the detailed content of PHP state mode programming. For more information, please follow other related articles on the PHP Chinese website!