Anfänger müssen eine Menge Verwirrung über Designmuster haben. Heute ist das Wochenende, also habe ich mir etwas Zeit genommen, um einen Artikel über den Einzelstückmodus in Kombination mit dem Befehlskettenmodus zu schreiben, um den Kern des Systems zu erstellen Der Artikel ist zu einfach, dies ist ein Tutorial für Anfänger, weil die Zeit knapp ist (ich muss mit meiner Frau einkaufen gehen, haha), es Unregelmäßigkeiten im Design, Unregelmäßigkeiten beim Code-Schreiben, Fehler usw. gibt. Ich hoffe, alles Helden können der Einfachheit halber darauf hinweisen. Mein Niveau ist begrenzt. ^_^
Ich glaube, dass jeder viele Bücher oder Artikel über die Anwendung von Designmustern in PHP gelesen hat, aber nur wenige davon geben Beispiele Nach dem Lesen bin ich verwirrt und habe das Gefühl, dass es ohne Projektpraxis schwierig ist, den Teil des Entwurfsmusters herauszufinden.
Um zu vermeiden, dass der Code zu komplex wird, werden Ausnahmebehandlung und andere Inhalte nicht hinzugefügt.
Für die Grundkenntnisse des Singleton-Modus und des Befehlskettenmodus können Sie es selbst googeln. Ich werde nicht direkt auf das Beispiel eingehen:
<?php
/*
*@author:NoAngels
*@Zeit: 30. August 2008
*/
interfaceIRunAction{
//Ruft die in der Klasse definierten Methoden ab, die in der APP ausgeführt werden können
statische Funktion LoadActions();
// Die Eingabefunktion in der Klasse wird zum Aufrufen anderer Funktionen in der Klasse verwendet
Funktion runAction($action, $args);
}
/*
*Kernbestandteil des APP-Systems
*/
classAPP{
static private $__instance = null;
static private $__commands = array();
static private $__flag = 1;
private Funktion __construct(){}
//Einzelstückmodus-Design erhält die einzige Instanz dieser Klasse
statische Funktion Load(){
if(self::$__instance == null) self::$__instance = new APP;
return self::$__instance;
}
//Benennung zu $__instance von APP hinzufügen. Überprüfen Sie jedes Mal, wenn Sie einen neuen Befehl hinzufügen, ob zuvor eine Instanz dieser Klasse hinzugefügt wurde.
//Wenn ja, ignorieren Sie den Vorgang. Wenn nicht, fügen Sie ihn hinzu.
öffentliche Funktion addCommand($cmdName){
foreach(self::$__commands as $cmd){
if(strtolower(get_class($cmd)) == strtolower(get_class($cmdName))){
self::$__flag = 0;
brechen;
}
}
if(self::$__flag == 1) self::$__commands[] = $cmdName;
self::$__flag = 1;
}
// Der Kernteil des Befehlskettenmodus-Designs ruft die Eingabefunktion der Instanz auf
//Überprüfen Sie zunächst, ob der Aufruf dieser Operation in der Klasse zulässig ist. Andernfalls wird eine undefinierte Operation angezeigt und beendet.
öffentliche Funktion 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("undefinierte Aktion für Aktion: $action");
}
}
//Um eine Instanz einer Klasse zu löschen, geben Sie einfach den Namen der Klasse an.
öffentliche Funktion removeCommand($className){
foreach(self::$__commands as $key=>$cmd){
if(strtolower(get_class($cmd)) == strtolower($className)){
unset(self::$__commands[$key]);
}
}
}
//Für alle, die testen möchten, ob das Hinzufügen und Löschen erfolgreich ist
öffentliche Funktion viewCommands(){
echo(count(self::$__commands));
}
}
//Klasse Benutzer implementiert die Schnittstelle IRunAction
Klasse Benutzer implementiert IRunAction{
//Aufrufbare Operationen definieren
static private $__actions = array('addUser', 'modifyUser', 'removeUser');
// Holen Sie sich die Operationen, die im eigentlichen Prozess aufgerufen werden können. $__actions ist als öffentlicher Aufruf konzipiert.
//Sie sollten eine LoadActions-Funktion entwerfen, um den Wert von $__actions zu erhalten
statische öffentliche Funktion LoadActions(){
return self::$__actions;
}
//Führen Sie die angegebene Funktion aus
öffentliche Funktion runAction($action, $args){
//Wenn Sie nicht verstehen, wie diese Funktion verwendet wird, lesen Sie bitte das Handbuch.
call_user_func(array($this,$action), $args);
}
//Nur eine Testfunktion
geschützte Funktion addUser($name){
echo($name);
}
}
//Testähnlicher Benutzer
Klasse Test implementiert IRunAction{
static private $__actions = array('addTest', 'modifyTest', 'removeTest');
statische öffentliche Funktion LoadActions(){
return self::$__actions;
}
öffentliche Funktion runAction($action, $args){
call_user_func(array($this,$action), $args);
}
geschützte Funktion addTest($name){
echo($name);
}
}
//Das Folgende ist der Testcode
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);
Die APP-Klasse ist im Singleton-Modus entworfen, der den Kern des Systems darstellt, wenn Sie sich den Code ansehen zum Laden der APP-Klasseninstanz, die in einigen Büchern der statischen Methode getInstance entspricht. Sie verfügt über drei öffentliche Methoden: addCommand, runCommand und runCommand. Dies ist auch der Kern des Startprogramms des Befehlskettenmodus . Bitte sehen Sie sich den Quellcode für die spezifische Implementierung an. Der Code ist sehr klar geschrieben.
Die Klassen User und Test implementieren die Schnittstelle IRunAction. Beide Klassen definieren eine statische private Variable $__actions, die ein Array ist, das Operationen enthält, die von der runCommand-Funktion der APP aufgerufen werden können.
Das Folgende ist der laufende Prozess des Systems:
APP-Start
-------addCommand, fügen Sie der APP die Klasse hinzu, zu der die auszuführende Operation gehört. Wenn die hinzugefügte Klasse im Singleton-Modus entworfen wurde, können Sie addCommand(SingletonClass::Load()) wie folgt hinzufügen. Andernfalls können Sie es wie folgt hinzufügen: Rufen Sie
addCommand(new someClass)
auf.
-------runCommand. Zum Beispiel gibt es eine Operation addUser in der APP ist eine Instanz einer der Klassen. Wenn Sie über diese Operation verfügen, rufen Sie die runAction-Funktion der Instanz auf. Wenn Sie keine Instanz einer bestimmten Klasse mit addCommand hinzufügen, werden Sie zur Eingabe einer undefinierten Operation und zum Beenden aufgefordert.
Die runAction in der Klasse User und der Klasse Test ruft call_user_func auf, eine sehr häufig verwendete Funktion.
Tipp: Dies ist das Ende der Erklärung und der Verwendung dieser Idee. Sehen Sie einfach, es ist Ihr eigenes Verständnis, dass Sie alles selbst machen müssen (ps: Es kann in einer einzigen Eintragsdatei im Framework gemacht werden. Ob Sie MVC implementieren oder nicht, hängt von Ihrer Meinung ab.)