Os iniciantes devem estar muito confusos sobre os padrões de design. Hoje é fim de semana, então reservei um tempo para escrever um artigo sobre o modo de peça única combinado com o modo de cadeia de comando para criar o núcleo do sistema. do artigo é muito simples, este é um tutorial para iniciantes, porque o tempo está apertado (tenho que fazer compras com minha esposa, haha), há irregularidades no design, irregularidades na escrita do código, bugs, etc. heróis podem apontá-los por conveniência. Vamos progredir juntos. Meu nível é limitado. ^_^
Acredito que todos leram muitos livros ou artigos sobre a aplicação de padrões de design em PHP, mas poucos deles dão exemplos diretamente. confuso depois de lê-los, sinto que sem prática de projeto é difícil descobrir a parte do padrão de design.
Para evitar que o código seja muito complexo, o tratamento de exceções e outros conteúdos não são adicionados.
Para obter o conhecimento básico do modo singleton e do modo de cadeia de comando, você mesmo pode pesquisar no Google. Não entrarei em detalhes. Vejamos o exemplo diretamente:
<?php.
/*
*@autor:NoAngels
*@horário: 30 de agosto de 2008
*/
interfaceIRunAction{
//Obtém os métodos definidos na classe que podem ser executados no APP
função estática LoadActions();
//A função de entrada na classe é usada para chamar outras funções na classe
função runAction($ação, $args);
}
/*
*Parte principal do sistema APP
*/
classeAPP{
static privado $__instance = null;
static private $__comandos = array();
estático privado $__flag = 1;
função privada __construct(){}
//O design do modo de peça única obtém a única instância desta classe
função estática Carregar(){
if(self::$__instance == null) self::$__instance = novo APP;
retornar self::$__instance;
}
//Adicionar nomenclatura à instância $__do APP Cada vez que você adicionar um novo comando, verifique se uma instância desta classe foi adicionada antes.
//Se houver, ignore a operação. Caso contrário, adicione-a.
função pública addCommand($cmdNome){
foreach(self::$__comandos como $cmd){
if(strtolower(get_class($cmd)) == strtolower(get_class($cmdName))){
self::$__flag = 0;
quebrar;
}
}
if(self::$__flag == 1) self::$__commands[] = $cmdName;
self::$__flag = 1;
}
//A parte central do design do modo de cadeia de comando chama a função de entrada da instância
//Primeiro verifique se a chamada desta operação é permitida na classe. Caso contrário, ela solicitará uma operação indefinida e sairá.
função pública runCommand($action, $args){
self::$__flag = 0;
foreach(self::$__comandos como $cmd){
if(in_array($action, $cmd->LoadActions())){
self::$__flag = 1;
$cmd->runAction($action, $args);
}
}
if(self::$__flag == 0){
self::$__flag = 1;
exit("ação indefinida por ação: $action");
}
}
//Para deletar uma instância de uma classe, basta especificar o nome da classe.
função pública removeCommand($className){
foreach(self::$__commands as $key=>$cmd){
if(strtolower(get_class($cmd)) == strtolower($className)){
unset(self::$__comandos[$chave]);
}
}
}
//Para teste de todos para ver se a adição e exclusão foram bem-sucedidas
função pública viewCommands(){
echo(contagem(self::$__comandos));
}
}
//Classe Usuário implementa interface IRunAction
classe Usuário implementa IRunAction{
//Define operações que podem ser chamadas
static private $__actions = array('addUser', 'modifyUser', 'removeUser');
//Obtenha as operações que podem ser chamadas. No processo real, não apenas ame você diretamente. $__actions é projetado como uma chamada pública.
//Você deve projetar uma função LoadActions para obter o valor de $__actions
função pública estática LoadActions(){
return self::$__actions;
}
//Executa a função especificada
função pública runAction($ação, $args){
//Se você não entende como usar esta função, consulte o manual.
call_user_func(array($this,$action), $args);
}
//Apenas uma função de teste
função protegida addUser($nome){
eco($nome);
}
}
//Usuário tipo teste
classe Teste implementa IRunAction{
static private $__actions = array('addTest', 'modifyTest', 'removeTest');
função pública estática LoadActions(){
return self::$__actions;
}
função pública runAction($ação, $args){
call_user_func(array($this,$action), $args);
}
função protegida addTest($nome){
eco($nome);
}
}
//A seguir está o código de teste
APP::Load()->addCommand(novo usuário);
APP::Load()->addCommand(novo usuário);
APP::Load()->addCommand(novo usuário);
APP::Load()->addCommand(novo usuário);
APP::Load()->runCommand('addUser', 'NoAngels');
APP::Load()->addCommand(novo teste);
APP::Load()->runCommand('addTest', null);
A classe APP é projetada no modo singleton, que é a parte central do sistema, olhando o código, você saberá que o método Load é. para carregar a instância da classe APP, que é equivalente ao método estático getInstance em alguns livros. Ele possui três métodos públicos: addCommand, runCommand e removeCommand é também a parte principal do programa de inicialização do modo de cadeia de comando. . Consulte o código-fonte para a implementação específica. O código está escrito de forma muito clara.
As classes User e Test implementam a interface IRunAction. Ambas as classes definem uma variável privada estática $__actions, que é um array que contém operações que podem ser chamadas pela função runCommand do
APP
.
-------addCommand, adicione a classe à qual a operação a ser executada pertence ao APP. Se a classe adicionada for projetada usando o modo singleton, você pode adicionar addCommand(SingletonClass::Load()) da seguinte maneira. Caso contrário, você pode adicioná-lo da seguinte maneira Call
addCommand(new someClass)
-------runCommand. Executar operações. Por exemplo, há uma operação addUser na classe User que posso ativar diretamente runCommand($action, $args). é uma instância de uma das classes Se você tiver esta operação, chame a função runAction da instância. Se você não adicionar uma instância de uma determinada classe usando addCommand, será solicitada uma operação indefinida e sairá.
A runAction na classe User e na classe Test chama call_user_func, uma função muito comumente usada. A função correspondente nesta classe é chamada.
Dica: Este é o fim da explicação e dos exemplos. Basta ver É seu próprio entendimento que você deve fazer tudo sozinho (ps: pode ser transformado em um único arquivo de entrada no framework. Implementar ou não o MVC depende do que você pensa.)