Les débutants doivent avoir beaucoup de confusion sur les modèles de conception. Aujourd'hui, c'est le week-end, j'ai donc pris le temps d'écrire un article sur le mode monobloc combiné au mode chaîne de commande pour créer le cœur du système. Peut-être pour certaines personnes, le contenu. de l'article est trop simple, c'est un tutoriel pour débutants, car le temps presse (je dois faire du shopping avec ma femme, haha), il y a des irrégularités dans la conception, des irrégularités dans l'écriture du code, des bugs, etc. les héros peuvent les signaler pour plus de commodité. Progressons ensemble. Mon niveau est limité.^_^
Je crois que tout le monde a lu de nombreux livres ou articles sur l'application de modèles de conception en PHP, mais peu d'entre eux donnent directement des exemples. confus après les avoir lus. Je pense que sans pratique de projet, il est difficile de comprendre la partie du modèle de conception.
Afin d'éviter que le code ne soit trop complexe, la gestion des exceptions et d'autres contenus ne sont pas ajoutés.
Pour les connaissances de base du mode singleton et du mode chaîne de commandes, vous pouvez le rechercher vous-même sur Google. Je n'entrerai pas dans les détails directement :
<?php.
/*
*@auteur : NoAngels
*@heure : 30 août 2008
*/
interfaceIRunAction{
//Récupère les méthodes définies dans la classe qui peuvent être exécutées dans l'APP
fonction statique LoadActions();
//La fonction d'entrée dans la classe est utilisée pour appeler d'autres fonctions de la classe
fonction runAction($action, $args);
}
/*
*Partie centrale du système APP
*/
classeAPP{
statique privée $__instance = null ;
static private $__commands = array();
$__flag privé statique = 1 ;
fonction privée __construct(){}
//La conception en mode monobloc obtient la seule instance de cette classe
fonction statique Load(){
if(self::$__instance == null) self::$__instance = nouvelle APP ;
return self::$__instance ;
}
//Ajouter un nom à $__instance d'APP. Chaque fois que vous ajoutez une nouvelle commande, vérifiez si une instance de cette classe a déjà été ajoutée.
// S'il y en a, ignorez l'opération. Sinon, ajoutez-la.
fonction publique addCommand($cmdName){
foreach(self::$__commandes en tant que $cmd){
if(strtolower(get_class($cmd)) == strtolower(get_class($cmdName))){
soi ::$__flag = 0;
casser;
}
}
if(self::$__flag == 1) self::$__commands[] = $cmdName;
soi ::$__flag = 1;
}
//La partie centrale de la conception du mode chaîne de commandes appelle la fonction d'entrée de l'instance
// Vérifiez d'abord si l'appel de cette opération est autorisé dans la classe. Sinon, cela provoquera une opération non définie et quittera.
fonction publique runCommand($action, $args){
soi ::$__flag = 0;
foreach(self::$__commandes en tant que $cmd){
if(in_array($action, $cmd->LoadActions())){
soi ::$__flag = 1;
$cmd->runAction($action, $args);
}
}
si(soi::$__flag == 0){
soi ::$__flag = 1;
exit("action non définie par action : $action");
}
}
//Pour supprimer une instance d'une classe, spécifiez simplement le nom de la classe.
fonction publique RemoveCommand($className){
foreach(self::$__commands as $key=>$cmd){
if(strtolower(get_class($cmd)) == strtolower($className)){
unset(self::$__commands[$key]);
}
}
}
//Pour que tout le monde teste pour voir si l'ajout et la suppression réussissent
fonction publique viewCommands(){
echo(count(self::$__commands));
}
}
// L'utilisateur de classe implémente l'interface IRunAction
L'utilisateur de classe implémente IRunAction{
//Définit les opérations pouvant être appelées
static private $__actions = array('addUser', 'modifyUser', 'removeUser');
//Obtenir les opérations qui peuvent être appelées. Dans le processus réel, ne vous contentez pas de vous aimer directement. $__actions est conçu comme un appel public.
//Vous devez concevoir une fonction LoadActions pour obtenir la valeur de $__actions
fonction publique statique LoadActions(){
retourner soi : $__actions ;
}
//Exécute la fonction spécifiée
fonction publique runAction ($ action, $ args) {
//Si vous ne comprenez pas comment utiliser cette fonction, veuillez vous référer au manuel.
call_user_func(array($this,$action), $args);
}
//Juste une fonction de test
fonction protégée addUser($name){
echo($nom);
}
}
//Utilisateur de type test
classe Test implémente IRunAction{
static private $__actions = array('addTest', 'modifyTest', 'removeTest');
fonction publique statique LoadActions(){
retourner soi : $__actions ;
}
fonction publique runAction ($ action, $ args) {
call_user_func(array($this,$action), $args);
}
fonction protégée addTest($name){
echo($nom);
}
}
//Ce qui suit est le code du test
APP :: Load () -> addCommand (nouvel utilisateur);
APP :: Load () -> addCommand (nouvel utilisateur);
APP :: Load () -> addCommand (nouvel utilisateur);
APP :: Load () -> addCommand (nouvel utilisateur);
APP::Load()->runCommand('addUser', 'NoAngels');
APP :: Load () -> addCommand (nouveau test);
APP::Load()->runCommand('addTest', null);
La classe APP est conçue en mode singleton, qui est la partie centrale du système, je pense que vous saurez en regardant le code qu'est la méthode Load. pour charger l'instance de classe APP, ce qui équivaut à La méthode statique getInstance dans certains livres a trois méthodes publiques : addCommand, runCommand et removeCommand est la partie principale du mode chaîne de commande. voir le code source pour l'implémentation spécifique. Le code est écrit très clairement. Je n'entrerai pas dans les détails ici.
Les classes User et Test implémentent l'interface IRunAction. Les deux classes définissent une variable privée statique $__actions, qui est un tableau qui contient des opérations qui peuvent être appelées par la fonction runCommand de l'APP.
Voici le processus en cours d'exécution du système :
Démarrage de l'APP.
-------addCommand, ajoutez la classe à laquelle l'opération à exécuter appartient à l'APP Si la classe ajoutée est conçue en mode singleton, vous pouvez ajouter addCommand(SingletonClass::Load()) comme suit. Sinon, vous pouvez l'ajouter comme suit Appelez
addCommand(new someClass)
-------runCommand.Exécuter les opérations.Par exemple, il y a une opération addUser dans la classe User.Je peux directement activer runCommand($acttion, $args). est une instance de l'une des classes. Si vous avez cette opération, appelez la fonction runAction de l'instance. Si vous n'ajoutez pas d'instance d'une certaine classe à l'aide de addCommand, vous serez invité à effectuer une opération non définie et à quitter.
Le runAction dans la classe User et la classe Test appelle call_user_func, une fonction très couramment utilisée. La fonction correspondante dans cette classe est appelée
Astuce : C'est la fin de l'explication et des exemples. Comment la comprenez-vous et comment utiliser cette idée ? Voyez simplement C'est votre propre compréhension que vous devez tout faire vous-même (ps : cela peut être transformé en un seul fichier d'entrée dans le framework. La mise en œuvre ou non de MVC dépend de ce que vous pensez.)