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

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 you have read many books or articles about applying design patterns in php, but it is very difficult to understand. Few examples are given directly, and most of them feel confused after reading it. Without project practice, it is difficult to understand the design pattern part.

In order to avoid the code being too complicated, no exception handling, etc. are added. Content.
For the basic knowledge of singleton mode and command chain mode, you can google it yourself. I won’t go into details. Let’s look at the example directly:

Copy 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 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);

The APP class is designed using the singleton model, which is the core part of the system. I believe you can see 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, There are three public methods of removeCommand. 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 are implemented Interface IRunAction, 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 startup
-------addCommand, add the class to which the operation to be run belongs to the APP. If the added class is designed in singleton mode, you can add addCommand(SingletonClass: :Load()). Otherwise, you can adjust it as follows:

addCommand(new someClass)
-------runCommand. Run the operation. 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 an instance of a certain class has the operation, call the runAction function of the instance. If you have not added an instance of a certain class using addCommand, It prompts that the operation is undefined and exits.
The runAction in class User and class Test calls call_user_func, a very commonly used function. The corresponding function in this class is called.

Tips: The explanation and examples are here Now, how you understand it and how to use this idea depends on your own understanding. Everything must be done by yourself. (ps: It can be made into a single entry file in the framework. Whether you implement MVC or not is up to you. What do you think?)

The actual operation effect is as follows:

Limited to Chinese level, if you don’t understand anything, please contact me.
I will tell you when I have time. Write some articles.

http://www.bkjia.com/PHPjc/319414.htmlwww.bkjia.comtruehttp: //www.bkjia.com/PHPjc/319414.htmlTechArticleMaybe for some people, the content of the article is too simple. This is a tutorial for beginners because of the time required. It's urgent (I have to go shopping with my wife, haha), and there are irregularities in design and code writing...