Instructions for using PHP singleton mode combined with command chain mode_PHP tutorial

/*
*@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 using
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(){}
//Single-piece 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 Go to APP's $__instance. Every time you add a new command, check whether an instance of this class has been added before
//If so, 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 mode 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 and 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");
}
}
//Delete a class For instances, 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’s testing purposes See if the addition and deletion are successful
public function viewCommands(){
echo(count(self::$__commands));
}
}
//Class User implements the interface IRunAction
class User implements IRunAction{
//Define the operations that can be called
static private $__actions = array('addUser', 'modifyUser', 'removeUser');
//Get the operations that can be called , in the actual process, do not directly design your $__actions as a public call
// Instead, design a LoadActions function to obtain 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);
}
}
//Class Test is the same as User
class Test implements IRunAction{
static private $__actions = array('addTest', 'modifyTest', 'removeTest');
static public function LoadActions(){
return 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);