Los principiantes deben tener mucha confusión sobre los patrones de diseño. Hoy es fin de semana, así que me tomé un tiempo para escribir un artículo sobre el modo de pieza única combinado con el modo de cadena de comandos para crear el núcleo del sistema. El artículo es demasiado simple, este es un tutorial para principiantes, porque el tiempo apremia (tengo que ir de compras con mi esposa, jaja), hay irregularidades en el diseño, irregularidades en la escritura del código, errores, etc. Espero que todos. Los héroes pueden señalarlos por conveniencia. Avancemos juntos. Mi nivel es limitado. ^_^
Creo que todos han leído muchos libros o artículos sobre la aplicación de patrones de diseño en PHP, pero pocos dan ejemplos directos. Estoy confundido después de leerlos. Siento que sin práctica en el proyecto, es difícil entender la parte del patrón de diseño.
Para evitar que el código sea demasiado complejo, no se agregan manejo de excepciones ni otros contenidos.
Para obtener conocimientos básicos sobre el modo singleton y el modo de cadena de comandos, puede buscarlo en Google. No entraré en detalles. Veamos el ejemplo directamente:
<?php.
/*
*@autor:NoAngels
*@hora: 30 de agosto de 2008
*/
interfazIRunAction{
//Obtener los métodos definidos en la clase que se pueden ejecutar en la APP
función estática LoadActions();
//La función de entrada en la clase se usa para llamar a otras funciones en la clase
función ejecutarAcción($acción, $args);
}
/*
*Parte central del sistema APP
*/
claseAPP{
estática privada $__instancia = nulo;
estático privado $__comandos = matriz();
privado estático $__flag = 1;
función privada __construct(){}
//El diseño en modo de pieza única obtiene la única instancia de esta clase
función estática Carga(){
if(self::$__instance == null) self::$__instance = nueva APLICACIÓN;
return self::$__instancia;
}
//Agregar nombre a $__instance de APP Cada vez que agrega un nuevo comando, verifique si se ha agregado una instancia de esta clase antes.
//Si lo hay, ignora la operación. Si no, agrégalo.
función pública addCommand($cmdName){
foreach(self::$__comandos como $cmd){
if(strtolower(get_class($cmd)) == strtolower(get_class($cmdName))){
self::$__bandera = 0;
romper;
}
}
if(self::$__flag == 1) self::$__commands[] = $cmdName;
self::$__bandera = 1;
}
// La parte central del diseño del modo de cadena de comandos llama a la función de entrada de la instancia
// Primero verifique si se permite llamar a esta operación en la clase. De lo contrario, solicitará una operación indefinida y saldrá.
función pública runCommand($acción, $args){
self::$__bandera = 0;
foreach(self::$__comandos como $cmd){
if(in_array($acción, $cmd->LoadActions())){
self::$__bandera = 1;
$cmd->runAction($acción, $args);
}
}
si(self::$__bandera == 0){
self::$__bandera = 1;
exit("acción indefinida por acción: $acción");
}
}
//Para eliminar una instancia de una clase, simplemente especifique el nombre de la clase.
función pública removeCommand($nombredeclase){
foreach(self::$__comandos como $key=>$cmd){
if(strtolower(get_class($cmd)) == strtolower($className)){
unset(self::$__commands[$key]);
}
}
}
//Para que todos prueben para ver si la adición y eliminación son exitosas
función pública viewCommands(){
echo(count(self::$__commands));
}
}
//El usuario de clase implementa la interfaz IRunAction
clase Usuario implementa IRunAction{
//Definir operaciones que se pueden llamar
estático privado $__acciones = array('addUser', 'modifyUser', 'removeUser');
// Obtenga las operaciones que se pueden llamar en el proceso real, no solo lo ame directamente. $__actions está diseñado como una llamada pública.
//Deberías diseñar una función LoadActions para obtener el valor de $__actions
función pública estática LoadActions(){
return self::$__acciones;
}
//Ejecuta la función especificada
función pública ejecutarAcción($acción, $args){
//Si no comprende cómo utilizar esta función, consulte el manual.
call_user_func(array($this,$action), $args);
}
//Solo una función de prueba
función protegida addUser($nombre){
eco($nombre);
}
}
//Usuario tipo prueba
clase Prueba implementa IRunAction{
estático privado $__acciones = array('addTest', 'modifyTest', 'removeTest');
función pública estática LoadActions(){
return self::$__acciones;
}
función pública ejecutarAcción($acción, $args){
call_user_func(array($this,$action), $args);
}
función protegida addTest($nombre){
eco($nombre);
}
}
//El siguiente es el código de prueba.
APLICACIÓN::Cargar()->addCommand(nuevo usuario);
APLICACIÓN::Cargar()->addCommand(nuevo usuario);
APLICACIÓN::Cargar()->addCommand(nuevo usuario);
APLICACIÓN::Cargar()->addCommand(nuevo usuario);
APLICACIÓN::Load()->runCommand('addUser', 'NoAngels');
APLICACIÓN::Cargar()->addCommand(nueva prueba);
APP::Load()->runCommand('addTest', null);
La clase APP está diseñada en modo singleton, que es la parte central del sistema, creo que al mirar el código sabrás que es el método Load. para cargar la instancia de la clase APP, que es equivalente al método estático getInstance en algunos libros. Tiene tres métodos públicos: addCommand, runCommand y removeCommand. También es el programa de inicio principal del modo de cadena de comandos. Consulte el código fuente para la implementación específica. El código está escrito de manera muy clara. No entraré en detalles aquí.
Las clases Usuario y Prueba implementan la interfaz IRunAction. Ambas clases definen una variable privada estática $__actions, que es una matriz que contiene operaciones que pueden ser llamadas por la función runCommand de la APLICACIÓN.
El siguiente es el proceso de ejecución del sistema:
Inicio de la APLICACIÓN.
-------addCommand, agregue la clase a la que pertenece la operación a ejecutar a la APLICACIÓN. Si la clase agregada está diseñada usando el modo singleton, puede agregar addCommand(SingletonClass::Load()) de la siguiente manera. De lo contrario, puede agregarlo de la siguiente manera: llame
a addCommand(new someClass)
-------runCommand. Ejecute operaciones. Por ejemplo, hay una operación addUser en la clase Usuario. Si la hay, puedo habilitar runCommand($acttion, $args). es una instancia de una de las clases. Si tiene esta operación, llame a la función runAction de la instancia. Si no agrega una instancia de una determinada clase usando addCommand, se le solicitará una operación indefinida y saldrá.
runAction en la clase Usuario y la clase Prueba llama a call_user_func, una función muy utilizada. Se llama a la función correspondiente en esta clase.
Consejo: Aquí termina la explicación y los ejemplos. Solo mire. Según su propio entendimiento, debe hacer todo usted mismo (p.d.: se puede convertir en un archivo de entrada única en el marco. La implementación o no de MVC depende de lo que piense).