Activity startup mode PHP singleton mode combined with command chain mode instructions

Maybe for some people, the content of the article is too simple. This is a tutorial for beginners. Because time is tight (I have to go shopping with my wife, haha), there are irregularities in design, irregularity in code writing, bugs, etc. I hope all the heroes will point it out so that we can make progress together. My level is limited. ^_^
I believe that everyone has read many books or articles about applying design patterns in PHP, but few of them directly give examples. , after reading most of them, I feel confused. Without project practice, it is difficult to figure out the design pattern part.
In order to avoid the code being too complex, exception handling and other contents are not added.
Single-piece mode and command chain mode For the basic knowledge, you can google it yourself. I won’t go into details. Let’s look at the example directly:

Copy the code The code is as follows:

/*
*@author:NoAngels
*@time :August 30, 2008
*/
interface IRunAction{
//Get the methods defined in the class that can be run in the APP
static function LoadActions();
//The entry function in the class calls other functions in the class Use
function runAction($action, $args);
}
/*
*The core part of APP class system
*/
class APP{
static private $__instance = null;
static private $__commands = array();
static private $__flag = 1;
private function __construct(){}
//Singleware mode design obtains the only instance of this class
static function Load(){
if(self::$__instance == null) self: :$__instance = new APP;
return self::$__instance;
}
//Add naming to $__instance of APP. Every time you add a new command, check whether an instance of this class has been added before
//If If there is, ignore the operation. If not, add it.
public function addCommand($cmdName){
foreach(self::$__commands as $cmd){
if(strtolower(get_class($cmd)) == strtolower(get_class($cmdName) ))){
self::$__flag = 0;
break;
}
}
if(self::$__flag == 1) self::$__commands[] = $cmdName;
self::$__flag = 1;
}
//The core part of the command chain pattern design calls the entry function of the instance
//First check whether the call to the operation is allowed in the class. If not, it will prompt an undefined operation to exit.
public function runCommand($action, $args ){
self::$__flag = 0;
foreach(self::$__commands as $cmd){
if(in_array($action, $cmd->LoadActions())){
self::$__flag = 1;
$cmd->runAction($action, $args);
}
}
if(self::$__flag == 0){
self::$__flag = 1;
exit("undefined action by action : $action");
}
}
//To delete an instance of a class, just specify the name of the class
public function removeCommand($className){
foreach(self::$__commands as $key=> ;$cmd){
if(strtolower(get_class($cmd)) == strtolower($className)){
unset(self::$__commands[$key]);
}
}
}
//For everyone Test to see if the addition and deletion are successful
public function viewCommands(){
echo(count(self::$__commands));
}
}
//Class User implements interface IRunAction
class User implements IRunAction{
// Define callable operations
static private $__actions = array('addUser', 'modifyUser', 'removeUser');
//Get the callable operations, don't directly love you in the actual process. $__actions is designed as a public call
//Instead, design a LoadActions function to get the value of $__actions
static public function LoadActions(){
return self::$__actions;
}
//Run the specified function
public function runAction($action, $args){
//If you don’t understand how to use this function, please refer to the manual
call_user_func(array($this,$action), $args);
}
//Just a test function
protected function addUser($name){
echo($name ; self::$__actions;
}
public function runAction($action, $args){
call_user_func(array($this,$action), $args);
}
protected function addTest($name){
echo( $name);
}
}
//The following is the test code
APP::Load()->addCommand(new User);
APP::Load()->addCommand(new User);
APP: :Load()->addCommand(new User);
APP::Load()->addCommand(new User);
APP::Load()->runCommand('addUser', 'NoAngels');
APP::Load()->addCommand(new Test);
APP::Load()->runCommand('addTest', null);


The APP class is designed using the singleton model, which is the core part of the system. I believe you will know by looking at the code that the Load method is to load the APP class instance, which is equivalent to the getInstance static method in some books. It has addCommand, runCommand, and removeCommand. A public method. runCommand is the core part. It is also the core startup program of the command chain mode. Please see the source code for the specific implementation. The code is already very clear, so I won’t go into details here.
Classes User and Test implement the interface IRunAction, which Both classes define a static private variable $__actions, which is an array, which contains operations that can be called by the APP's runCommand function.
The following is the running process of the system:
APP starts
------- addCommand, add the class to which the operation to be run belongs to the APP. If the added class is designed using the singleton mode, you can add addCommand(SingletonClass::Load()) as follows. Otherwise, you can adjust it as follows
addCommand(new someClass)
-------runCommand. Run operations. For example, there is an operation addUser in the User class. I can directly enable runCommand($acttion, $args). Loop through the $__commands array in the APP. If one of the classes If the instance has this operation, call the runAction function of the instance. If you do not add an instance of a certain class using addCommand, it will prompt an undefined operation and exit.
The runAction in class User and class Test calls call_user_func. The function used. Call the corresponding function in the class.
Tips: This is the explanation and examples. How you understand it and how to use this idea depends on your own understanding. You must do everything yourself. ( ps: It can be made into a single entry file in the framework. Whether to implement MVC or not depends on what you think.)
The actual operation effect is as follows:

Limited to Chinese language level, if you don’t understand anything, please contact me.
I will write some articles for you when I have time later.

The above introduces the Activity startup mode, PHP singleton mode and command chain mode usage instructions, including the Activity startup mode. I hope it will be helpful to friends who are interested in PHP tutorials.