Développer une application conformément au modèle de conception MVC (Model-View-Controller) est typique de Java et semble incompréhensible et inutile par rapport à DroidScript. Pourquoi compliquer les choses ? MVC a acquis un halo de complexité et de « magie » grâce à l'utilisation de mots beaux mais incompréhensibles (concept, modèle, logique métier, modèle) et de démonstrations complexes dans le contexte de Java lors de son examen. Tout est beaucoup plus simple : MVC est l'un des modèles de conception dans lesquels supplémentaireséparation des codes en orienté objet environnement.
L'élément central du modèle MVC est le contrôleur - application régulière DroidScript, à partir duquel le code lié au balisage visuel et conception externe widgets, ainsi que les données et les méthodes d'accès à ceux-ci. Par données, nous sommes habitués à comprendre les informations stockées dans des tableaux, des fichiers, des bases de données. Mais dans le concept MVC, les données sont comprises dans sens large les mots sont tout ce qui n'est pas du code d'application :
- données externes provenant de fichiers et de bases de données - métadonnées, textes, graphiques, sons, musique, etc.
- données d'application internes - chaînes avec des étiquettes sur les boutons et autres commandes, texte dans Boîtes de dialogue, descriptions de style, constantes, graphiques générés par programme, etc.
Du point de vue de l'utilisateur, son travail avec l'application n'a pas changé lors de l'utilisation de MVC : il clique également sur les boutons, sélectionne les données et comment elles sont affichées. Les changements peuvent concerner installations ce travail. Et côté développement, les changements sont perceptibles : l'interaction entre les données et leur affichage dans le concept MVC a lieu via le contrôleur et sous son contrôle.
Commençons par un exemple simple d'utilisation de MVC dans une application à fichier unique.
Implémentation de fichier unique du modèle MVC
Prenons une application simple.
Function OnStart()( var _lay = app.CreateLayout("linear", "VCenter,FillXY"); var _btnShowVersion = app.CreateButton("Afficher la version", 0.3, 0.1); _btnShowVersion.SetBackColor("#66778976"); _btnShowVersion.SetMargins(0, 0.05, 0, 0); _btnShowVersion.SetOnTouch(function()( _btnShowVersion.SetText("Application Version 1.0"); )); _lay.AddChild(_btnShowVersion); app.AddLayout(_lay); )
À première vue, tout semble bon, mais supposons que vous deviez modifier la palette de couleurs de l'application et afficher les étiquettes en plusieurs langues. Cela entraînera des complications, car toutes les données de l'exemple présenté sont des valeurs fixes (littéraux). Cela réduit considérablement la flexibilité du code et complique son débogage et sa maintenance.
Un autre inconvénient est que les données - les étiquettes sur le bouton, le balisage - les méthodes d'affichage des widgets et l'action - le bloc de code qui change l'étiquette sur le bouton lorsqu'on clique dessus sont dans un seul bloc et dans un seul fichier. Autrement dit, pour modifier l'inscription, vous devez ouvrir ce fichier et accéder à l'intégralité du code de l'application. C'est comme si changer une roue de voiture nécessitait de démonter la carrosserie de la voiture pour accéder à tout ce qui se trouve à l'intérieur. Pour quoi? Lors du démontage de la carrosserie de la voiture, vous pouvez accidentellement attraper quelque chose et le mettre dans un état de non-fonctionnement. C'est aussi possible dans le code : j'ai voulu remplacer le nom de la ligne à un seul endroit, mais le remplacement s'est produit dans tout le fichier, ce qui a entraîné une dispersion d'erreurs. Ou je voulais juste changer la couleur du bouton, mais j'ai accidentellement accroché le code à côté et toute l'application a cessé de fonctionner.
L'un des objectifs du modèle MVC est précisément de restreindre l'accès : d'abord, le module (ou bloc de code) qui est à l'origine de l'erreur est déterminé, puis seul l'accès à celui-ci est donné. Pourquoi donner accès à l'électronique et au moteur de la voiture si vous devez changer la roue ?
Si le développement s'effectue dans un seul fichier, alors cela se passe souvent ainsi : de nouvelles fonctions sont mises en place, tout au début ou à la fin du code, ce qui conduit finalement à leur mixage. Ajoutez ici le mélange de code dans les fonctions elles-mêmes, et dans un mois, même avec des commentaires, il ne sera pas facile de tout comprendre.
Implémentons l'exemple présenté ci-dessus dans le contexte de MVC. Pour ce faire, tout le code doit être divisé et regroupé dans les blocs appropriés. L'ordre des blocs dans le code n'a pas d'importance, mais il vaut mieux s'en tenir à la logique : le contrôleur a besoin à la fois de données et d'éléments pour les afficher, il est donc placé en dernier. Au moment de l'affichage des données, celles-ci doivent exister. Le bloc modèle vient donc en premier :
- Modèle
- Performance
- Manette
//+++ méthodes publiques pour accéder aux données _obj.getVersion = function()( return _version; ) _obj.btnGetTitle = function()( return _titleShowVersion; ) // --- ouvrir méthodes d'accès aux données window.model = _obj; // ouvre l'accès à l'objet local ))(); //--- modèle //+++ vue (fonction ()( var _lay = app.CreateLayout("linear", "VCenter,FillXY"); var _btnShowVersion = app.CreateButton(window.model.btnGetTitle(), 0.3, 0.1); _btnShowVersion.name = "_btnShowVersion"; _btnShowVersion.SetBackColor("#66778976"); _btnShowVersion.SetMargins(0, 0.05, 0, 0); _lay.AddChild(_btnShowVersion); app.AddLay out(_lay) ;
))(); //--- view //+++ contrôleur (function(p_object)( var _obj = ; // méthode de recherche d'objet public _obj.findObjectById = function(p_name)( var _objectList = app.GetObjects(); for (var _i in _objectList)( if(_objectList[_i].name == p_name)( return _objectList[ _i]; ) ) return null; ) window.control = _obj; ))(); function OnStart()( var _buttonShowVersion = window.control.findObjectById("_btnShowVersion"); //+++ action _buttonShowVersion.SetOnTouch(function()( this.SetText(window.model.getVersion()); )); / / --- action ) //--- contrôleur
En raison de la séparation des fonctions, le code de l'application a augmenté plusieurs fois.
Dans un premier temps, toutes les variables sont rendues privées, et seulement à la fin, si nécessaire, l'accès à celles-ci est ouvert via l'objet fenêtre global, ce qui permet de se passer des variables globales.
L'exemple implémente une recherche de widget comme en Java, mais vous pouvez le faire plus facilement et rendre le code plus efficace en exposant l'objet via un tableau associatif global :
Window.controls = ;
window.controls.buttonShowVersion = _btnShowVersion;
Les données, leur affichage et leur réaction aux actions se trouvent dans des blocs différents, sans se mélanger les uns aux autres, ce qui facilite le travail du développeur. Plus il est facile de travailler avec les données et le code, moins ils auront d'erreurs, plus il est facile de déboguer, de maintenir et de faire évoluer.
Il n’est pas nécessaire de séparer ces trois composants les uns des autres. Il existe plusieurs variantes de MVC, ainsi que des implémentations incomplètes de ce modèle. Par exemple, vous pouvez séparer les données et combiner le code d'action avec des contrôles à l'aide de rappels anonymes.
Lorsqu'on travaille dans un environnement orienté objet, la séparation du code et des données est déjà présente dès le début : les données et les actions sont regroupées en classes, les objets interagissent entre eux via méthodes publiques etc. Grâce à MVC, il existe une séparation plus subtile et explicite du code et des données selon leurs fonctions principales.
Pour mieux comprendre les avantages de l'utilisation du modèle MVC, envisageons de diviser le code en fichiers distincts.
Implémentation en trois fichiers du modèle MVC
Séparation du code par différents fichiers utilisé pour plus opération pratique avec lui. Le grand nombre de petits fichiers que l'on voit dans les projets MVC pourrait jeter le doute sur cette affirmation, mais voir les fichiers est une chose et travailler avec eux en est une autre. À chaque instant, le développeur interagit avec un fichier parmi un petit ensemble d'entre eux. Pour ce faire, il est nécessaire d'avoir une bonne compréhension de la structure de l'organisation du projet et de surveiller en permanence les trois premiers fichiers- modèle, vue et contrôleur, afin de ne pas modifier accidentellement du code tiers. En raison des limitations de l'éditeur DroidScript, ce regroupement n'est possible que par noms de fichiers dans le répertoire racine, par exemple :
monprojet_model.js - modèle
monprojet_view.js - vue
monprojet_control.js - contrôleur
Vous trouverez ci-dessous un exemple de fractionnement du code de l'exemple précédent en fichiers.
monprojet_model.js - modèle(function()( var _obj = ; //+++ data var _version = "Application version 1.0"; //--- data //+++ string resource var _titleShowVersion = "Afficher la version"; //+++ ressource de chaîne _obj.getVersion = function()( return _version; ) _obj.btnGetTitle = function()( return _titleShowVersion; ) window.model = _obj; ))(); monprojet_view.js - vue(function ()( var _lay = app.CreateLayout("linear", "VCenter,FillXY"); var _btnShowVersion = app.CreateButton(window.model.btnGetTitle(), 0.3, 0.1); _btnShowVersion.name = "_btnShowVersion" ; _btnShowVersion.SetBackColor("#66778976"); _btnShowVersion.SetMargins(0, 0.05, 0, 0); _lay.AddChild(_btnShowVersion); app.AddLayout(_lay); ))(); monprojet_control.js - contrôleur app.LoadScript("monprojet_model.js"); app.LoadScript("monprojet_view.js");(function(p_object)( var _obj = ; // méthode de recherche d'objet _obj.findObjectById = function(p_name)( var _objectList = app.GetObjects(); for (var _i in _objectList)( if(_objectList[_i].name = = p_name)( return _objectList[ _i]; ) ) return null; ) window.control = _obj; ))(); function OnStart()( var _buttonShowVersion = window.control.findObjectById("_btnShowVersion"); //+++ action _buttonShowVersion.SetOnTouch(function()( this.SetText(window.model.getVersion()); )); / / --- action )Une division aussi simple du code en fichiers n’était pas facile. Pour ce faire, une connexion avec le modèle a été préalablement établie via la propriété publique de l'objet racine global - fenêtre.modèle, et la connexion avec la vue à travers tableau global _carteà travers la méthode app.GetObjects.
L'avantage de séparer le code en fichiers est qu'il est désormais possible de remplacer le code par un bloc entier, par exemple pour démarrage rapide projet pour implémenter un modèle simple, puis remplacer le fichier par un autre plus fonctionnel, mais avec le même nom et la même interface. Cette approche est utilisée, par exemple, lors de la réparation d'équipements. Si auparavant la réparation consistait en une recherche lente et minutieuse et en un remplacement des composants radio défectueux, les blocs standard sont désormais remplacés. Le coût de réparation d'une carte complexe est nettement plus élevé que son remplacement rapide.
De ce qui a été dit, il s'ensuit qu'une interface bien conçue peut simplifier considérablement l'intégration ultérieure des modules.
DANS Objets JavaScript passé par référence. Changer les propriétés d'un widget dans le contrôleur modifiera les propriétés la plupart widget. Théoriquement, il est possible de séparer les objets de vue des objets de code, comme cela se fait en Java, où les structures XML sont utilisées en premier, mais cela n'a pas beaucoup de sens pour deux raisons - l'absence d'un éditeur d'interface visuelle dans DroidScript et d'un ensemble limité de propriétés disponibles des objets API.
Implémentation multi-fichiers du modèle MVC
En fonction des tâches et de la complexité du projet, le détail de la séparation du code et des données, dans le cas général, peut être différent. Vous pouvez en outre séparer les données utilisateur des ressources, vous pouvez affiner les ressources par type, actions de groupe, etc. Mais l'éditeur DroidScript ne vous permet pas de travailler pleinement avec MVC.
Dénomination 5000 roubles
Nombre (GS 8225497)
Imitation d'un véritable billet de banque de la Banque de Russie de 1997
Papier. Ne luminescent pas sous la lumière UV
Méthode d'impression. Impression offset à plat - toutes les images. La reproduction des couleurs est déformée. Toutes les images ont un éclat caractéristique. Formé de points colorés. Aux endroits d'inflexions, on observe une perte de matière colorante.
SIGNES DE PROTECTION PUBLIQUE. FACE AVANT
Filigranes (1,2)
Imité par surimpression avec une substance blanche sur le recto. Les images de filigrane déformées sont visualisées en lumière réfléchie
Image latente (effet Kipp)(3)
Non reproduit
Fibres protectrices
Surimpression imitée. Dans les rayons UV, une lueur de couleurs vertes et rouges est observée.
Peinture changeante de couleur (4)
L'image des armoiries a un éclat accru. Effet OVI non reproduit
Élément MVC+(5)
Pas imité. Les franges moirées de l'effet MVC sont observées sous n'importe quel angle de vue ; affiché lors de la copie à partir de l’original.
Microperforation(6)
Simulé. Micro-perforations visibles en lumière réfléchie
Vernis changeant de couleur (7)
L'emblème de la Banque de Russie est recouvert de peinture dorée. L'effet de polarisation n'est pas reproduit.
Gaufrage incolore (8)
pas imité
Relief
pas imité
Dénomination 5000 roubles
Nombre (GS 8225497)
Imitation d'un véritable billet de banque de la Banque de Russie du modèle 1997.
SIGNES DE PROTECTION PUBLIQUE. VERSO
Microtextes(9,10)
Partiellement reproduit
Fil de sécurité(11)
Imitées avec une substance blanche sur la face avant, les sorties sont imitées par estampage à la feuille. Les sorties du thread de sécurité sont à peine distinguables.
CARACTÉRISTIQUES DE SÉCURITÉ LISIBLES PAR MACHINE
Protection lumineuse
Partiellement imité
Protection infrarouge
Partiellement imité
Protection magnétique
pas imité
Note. Selon les forces de l'ordre de la Fédération de Russie, un faux billet de banque a été saisi dans le territoire de Perm.
Matériel préparé IPK "InterCrim-presse".
Il existe des millions d’applications Web dispersées dans le monde Internet. Il y en a des très simples, il y a ceux où « l'architecte de la matrice se cassera la jambe ». Mais ils ont une chose en commun : MVC.
Le plus populaire modèle architectural dans le monde parmi les applications Web - model-view-controller (Model View Controller ou simplement MVC). Pour la première fois, il a été utilisé à la fin des années 70 du XXe siècle, dans des applications linguistiques Petite conversation. Et puis, il a été hébergé par des programmeurs Java et partagé pour le monde entier et tous les langages de programmation. PHP ne faisait pas exception. Aujourd’hui, seule une petite partie des programmeurs qui collectent du code PHP rare peut se permettre de ne pas se tourner vers MVC.
Il est devenu si populaire pour une raison. Il est simplement né pour créer des applications flexibles et évolutives, faciles à maintenir et à développer.
Le but de notre tutoriel est de montrer exemple simple comment fonctionne le modèle MVC.
Pour effectuer les tâches, vous aurez besoin des programmes suivants :
Remarques:
- Nous supposons que vous possédez des connaissances de base en PHP.
Modèle MVC
Maintenant, tout est en ordre. Tout d'abord, révélons le grand secret de l'abréviation, qui reflète évidemment le fait que l'application sera composée de trois parties en interaction :
- Modèle est responsable de la gestion des données, il enregistre et récupère les entités utilisées par l'application, généralement à partir de la base de données, et contient la logique implémentée dans l'application.
- Performance est responsable de l’affichage des données fournies par le responsable du traitement. Le concept de modèle est étroitement lié à la vue. Il vous permet de modifier apparence informations affichées. Dans une application Web, une vue est souvent implémentée sous forme de page HTML.
- Manette lie le modèle et la vue. Il reçoit une requête du client, analyse ses paramètres et accède au modèle pour effectuer des opérations sur les données de la requête. Les objets déjà composés proviennent du modèle. Ensuite, ils sont redirigés vers la vue, qui transmet la page générée au contrôleur, qui, à son tour, l'envoie au client.
Schématiquement, les flux de données dans ce modèle peuvent être représentés comme suit :
Entrée dans la réalité
Formulons enfin le vrai problème. Qu'on nous ordonne de construire un site internet réseau social. Il y a une petite sous-tâche dans cette tâche gigantesque : utiliser la base d'amis existante, s'assurer qu'ils sont consultés Liste complète, ainsi que des informations détaillées pour chaque ami.
Nous n'examinerons pas maintenant l'architecture de l'ensemble du réseau social. Nous ne prendrons qu'un petit sous-problème, imaginerons toute sa gravité et lui appliquerons le modèle MVC.
Dès que nous commençons à l'utiliser, nous pensons immédiatement : comment pouvons-nous organiser les scripts de notre solution pour que tout soit à portée de main ? Pour ce faire, nous placerons chacune des trois sections de notre système MVC dans des dossiers séparés et obtiendrons ainsi une structure de répertoires simple dans laquelle il est facile de trouver ce dont nous avons besoin. De plus, ces trois dossiers seront placés dans le répertoire lib, et nous le retirerons au dessus du répertoire racine www :
/lib --/controller ---- FrendCnt.php --/model ---- Frend.php ---- FrendList.php --/view ---- frendlist.php ---- frendone.php / www -- index.php -- .htaccess
Supprimer un catalogue lib(contenant le moteur de notre site) de l'annuaire web nous apporte plus de sécurité, rendant notre système inaccessible aux empiètements des mains espiègles des pirates.
Manette
Maintenant, tout est en ordre. Commençons avec manette, puisqu'il s'agit du premier des trois composants du modèle qui répond à la demande du client, l'analyse en éléments et initialise les objets du modèle. Après avoir traité les données par le modèle, celui-ci prend sa réponse et l'envoie à la couche de présentation.
Dans notre exemple simple, le contrôleur sera concentré dans une seule classe FrendCnt. Nous le décrirons plus en détail plus tard. Et maintenant un peu sur le point d'entrée de l'application Web - ce sera bien sûr un fichier index.php. Dans celui-ci, nous définirons un point de départ pour connecter nos scripts. Créons une instance du contrôleur et appelons sa méthode, qui commencera à traiter la requête HTTP et déterminera la marche à suivre.
Liste n°1 (fichier index.php) :
$baseDir = dirname(__FILE__) . "/.."; include_once($baseDir . "/lib/controller/FriendCnt.php"); $contrôleur = new FriendCnt(); $contrôleur->invoke();
Parlons maintenant du contrôleur. La nôtre est la classe FriendCnt. Vous avez déjà remarqué qu'une instance de cette classe est créée dans index.php. Il n’a qu’une seule méthode Invoke(), qui est appelée immédiatement après l’instanciation. Dans le constructeur du contrôleur, un objet est créé sur la base de la classe modèle - FrendList (liste d'amis) pour fonctionner avec des données.
Dans la fonction Invoke(), sur la base de la requête HTTP entrante, une décision est prise : quelles données sont requises du modèle. Ensuite, la méthode qui récupère les données est appelée. Ensuite, les modèles d'affichage sont connectés, auxquels les données sont transférées depuis le contrôleur. Notez que le contrôleur ne sait rien de la base de données ni de la façon dont la page est rendue.
Listing n°2 (fichier du contrôleur FriendCnt.php) :
Require_once($baseDir . "/lib/model/FriendList.php"); class FriendCnt ( public $oFriendList; public function __construct() ( $this->oFriendList = new FriendList(); ) public function Ensure() ( global $baseDir; $oFriendList = $this->oFriendList; if(isset($_GET ["key"])) ( $oFriendList->setKey($_GET["key"]); $oFriend = $oFriendList->fetch(); include $baseDir . "/lib/view/friendone.php"; ) else ( $aFriend = $oFriendList->fetch(); include $baseDir . "/lib/view/friendlist.php"; ) ) )
Modèle et entités
Modèle est une image de la réalité, à partir de laquelle seul ce qui est nécessaire à la résolution du problème est extrait. Le modèle se concentre sur la logique de résolution du problème principal. Beaucoup de gens appellent cela la logique métier, elle a une grande responsabilité :
- Sauvegarde, suppression, mise à jour des données de l'application. Ceci est mis en œuvre via des opérations de base de données ou via des appels à des services Web externes.
- Encapsulation de toute la logique applicative. Absolument toute la logique applicative, sans exception, doit être concentrée dans le modèle. Il n'est pas nécessaire de déplacer une partie de la logique métier vers le contrôleur ou la vue.
Notre modèle comprend deux scripts, chacun ayant sa propre classe définie. La classe centrale FriendList et la classe d'entité Friend. Dans la classe centrale, la manipulation des données a lieu : réception des données du responsable du traitement et traitement de celles-ci. La classe d'entité sert de conteneur pour transporter les données entre le modèle et la vue, et définit également leur format. Avec une bonne implémentation du modèle MVC, les classes d’entités ne doivent pas être mentionnées dans le contrôleur et ne doivent contenir aucune logique métier. Leur objectif est uniquement le stockage de données.
Dans la classe FriendList, qui travaille avec la liste d'amis, nous avons créé une fonction qui modélise l'interaction de cette classe avec la base de données. La méthode getFriendList() renvoie un tableau d'objets créés à partir de la classe Friend. Pour garantir la commodité de travailler avec les données, une fonction a également été créée qui indexe un tableau d'objets. Seules deux méthodes se sont avérées disponibles pour le contrôleur : setKey() - définit le champ clé par lequel les données détaillées sur un ami sont renvoyées ; fetch() - renvoie soit un objet spécifique, soit la liste complète des amis.
Listing n°3 (fichier modèle FriendList.php) :
Require_once($baseDir . "/lib/model/Friend.php"); class FriendList ( private $oneKey; fonction privée getFriendList() ( return array(new Friend("Alexander", "1985", " [email protégé]"), nouvel ami("Yuri", "1987", " [email protégé]"), nouvel ami("Alexeï", "1989", " [email protégé]"),); ) fonction privée getIndexedList() ( $list = array(); foreach($this->getFriendList() as $val) ( $list[$val->getKey()] = $val; ) return $list; ) fonction publique setKey($key) ( $this->oneKey = $key; ) fonction publique fetch() ( $aFriend = $this->getIndexedList(); return ($this->oneKey) ? $aFriend [$this->oneKey] : $aFriend; ) )
Selon l'implémentation des objets Entity, les données les concernant peuvent se présenter sous la forme d'un document XML ou d'un objet JSON.
Listing n°4 (fichier d'entité Friend.php) :
Ami de classe ( clé $ privée ; nom privé $ ; année privée de naissance ; $ e-mail privé ; fonction publique __construct ($ nom, $ année de naissance, $ e-mail) ( $this->key = md5($ nom . $ année de naissance . $ e-mail) ; $this->name = $name; $this->yearOfBirth = $yearOfBirth; $this->email = $email; ) fonction publique getKey() ( return $this->key; ) fonction publique getName() ( return $this->name; ) fonction publique getYearOfBirth() ( return $this->yearOfBirth; ) fonction publique getEmail() ( return $this->email; ) )
Performance
Nous devons maintenant présenter les données sous le meilleur jour possible pour l’utilisateur.
Il est maintenant temps de parler de la vue. En fonction de la tâche, les données peuvent être transmises à la vue dans différents formats: objets simples, documents XML, objets JSON, etc. Dans notre cas, un objet ou un tableau d'objets est transmis. Dans le même temps, nous ne nous sommes pas préoccupés de la sortie de la couche de base - en ce qui concerne le pied de page et l'en-tête de la page générée, ce code est répété dans les deux fichiers de vue. Mais pour notre petit exemple, cela n'a pas d'importance.
L'essentiel ici est de montrer que la vue est séparée du contrôleur et du modèle. Le contrôleur est responsable de la transmission des données du modèle à la vue.
Dans notre exemple, la vue ne contient que deux fichiers : pour l'affichage des informations détailléesà propos d'un ami et pour afficher une liste d'amis.
Listing n°5 (fichier d'affichage d'une liste d'amis friendlylist.php) :
| Nom | Année de naissance |
|---|---|
| getKey() ?>">getName() ?> | getYearOfBirth() ?> |
Listing n°6 (fichier d'affichage d'une liste d'amisfriendone.php) :
"; echo "Année de naissance : " . $oFriend->getYearOfBirth() . "
"; echo "E-mail : " . $oFriend->getEmail() . "
"; ?> Liste
Si vous transférez tout ce code sur un serveur Web, vous obtiendrez un micro-site non pas sur deux pages (à en juger par le nombre de fichiers consultés), mais déjà sur quatre. Le premier affichera une liste d'amis et les trois autres afficheront des informations détaillées sur chaque ami.
Nous pourrions implémenter une vue détaillée en utilisant AJAX, nous n'aurions alors qu'une seule page, et nous ferions partie de la vue via des objets JSON directement sur les ordinateurs clients. Il existe de nombreuses options pour cela.
Il s'agit d'un exemple simplifié d'application Web basée sur le modèle MVC. Mais déjà, vous pouvez y voir de nombreuses opportunités. Nous avons déjà attribué la flexibilité et l'évolutivité aux avantages. Des avantages supplémentaires seront la capacité de standardiser le codage, la facilité de détection et de correction des erreurs et l'entrée rapide de nouveaux développeurs dans le projet. De plus, vous pouvez modifier la façon dont les entités sont stockées dans votre application à l'aide de services Web tiers et de bases de données cloud. Parmi les inconvénients, seule une légère augmentation du volume des scripts peut être citée. Et donc, de solides atouts. Alors profitez de votre santé.
Voici les fichiers du projet, téléchargez et comparez :
Bien comment? Quelles pensées ? Commentez, ne soyez pas timide.
Principe MVC en programmation Web (Modèle - Vue - Contrôleur, Modèle - Vue (Vue) - Contrôleur) - l'une des idées les plus réussies à ce jour. Principe MVC intuitif au premier abord, mais pas très facile à approfondir. Voyons d’abord à quoi il est destiné.
Principe MVC, permet de séparer la mise en œuvre de la logique applicative, de l'apparence (interface graphique, GUI) et de l'interaction utilisateur.
Cela conduit à un code plus structuré, permet à des personnes plus spécialisées de travailler sur le projet, rend le code plus facile à maintenir, le rend plus logique et compréhensible. Un changement dans l’un des composants a un impact minime sur les autres. Vous pouvez connecter différents types, différents contrôleurs à un seul modèle.
D'un autre côté, cela nécessite plus de performances des machines d'exécution, mais ce n'est pas un gros problème ces derniers temps - des solutions de programmation de plus en plus complexes nécessitent un support, et les coûts de support dépasseront de loin les coûts d'équipements modernes plus puissants.
Principe MVC utilisé par presque tous les frameworks modernes.
Examinons de plus près les composants.
Modèle(Modèle) - contient ce qu'on appelle. "logique métier" - traitement et vérification des données, accès aux bases de données, représente la structure interne du système. Le modèle ne doit pas interagir directement avec l'utilisateur.
voir(Vue, Vue) décrit l'apparence de l'application.
Manette- un lien entre le modèle et la vue, reçoit les données de l'utilisateur, les transmet au modèle, reçoit le résultat traité et le transmet à la vue.
La relation peut être vue dans le diagramme :
Source de l'image : http://www.wikipedia.org Exigences des composants :
Des modèles:
- doit contenir des propriétés qui représentent des données spécifiques ;
- doit inclure une logique métier (par exemple, des règles de validation) pour garantir que les données répondent aux exigences ;
- peut contenir du code pour travailler avec des données.
- doit principalement contenir du balisage, tel que HTML, et du code PHP simple utilisé pour parcourir, formater et afficher les données ;
- ne doit pas accéder directement à la base de données. Les modèles devraient le faire ;
- ne doit pas accéder directement à $_GET , $_POST et aux autres variables obtenues à partir de la demande de l'utilisateur. Cette tâche doit être effectuée par le contrôleur. Les vues ne doivent être utilisées que pour styliser les données reçues du contrôleur et du modèle ;
- peut accéder directement aux propriétés et méthodes du contrôleur ou des modèles. Cependant, cela ne doit être fait qu'à des fins d'affichage des données.
- peut accéder à $_GET , $_POST et à d'autres variables PHP obtenues à partir de la demande de l'utilisateur ;
- peut créer et manipuler des instances de modèle. Par exemple, dans une action typique de mise à jour de modèle, le contrôleur peut d'abord instancier le modèle, puis le remplir avec les données de $_POST, et si le modèle a été enregistré avec succès, rediriger le navigateur de l'utilisateur vers la page du modèle créé. Il convient de noter que la sauvegarde du modèle lui-même doit être implémentée dans la classe model, et non dans le contrôleur ;
- ne doit pas contenir de requêtes SQL. Il est préférable de les conserver dans des modèles ;
- ne doit pas contenir de HTML ou autre balisage. Il mérite d'être exposé.
En plus du concept MVC, il en existe bien d'autres, par exemple SE DÉPLACER ( M vêtements, Ô les opérations, V vues et Eévents) - un peu comme une évolution MVC(tiré d'ici : http://habrahabr.ru/post/147038/), mais ces concepts sont moins courants.
