Le modèle MVC est très courant dans l’architecture des sites Web. Il nous permet de créer une application à trois niveaux, séparant les couches utiles du code, aidant les concepteurs et les développeurs à travailler ensemble et améliorant notre capacité à maintenir et à étendre les applications existantes.
Vue
« Vue » fait principalement référence au résultat final que nous envoyons au navigateur Web, tel que le code HTML généré par notre script. Lorsqu'on parle de vues, de nombreuses personnes pensent à des modèles, mais l'exactitude de l'appel de vues de solutions de modèles est discutable.
La chose la plus importante à propos d'une vue est probablement qu'elle doit être « consciente d'elle-même ». Lorsque la vue est rendue, ses éléments sont conscients de leur rôle dans le cadre plus large.
En prenant XML comme exemple, on peut dire que lorsque XML est analysé, l'API DOM possède de telles connaissances qu'un nœud dans l'arborescence DOM sait où il se trouve et ce qu'il contient. (Lorsqu'un nœud dans un document XML est analysé avec SAX, cela n'a de sens que lorsque le nœud est analysé.)
La plupart des schémas de modèles utilisent des langages procéduraux simples et des balises de modèle comme celle-ci :
<p>{some_text}</p ＞
＜p＞{some_more_text}＜/p＞
Ils n'ont aucune signification dans le document, tout ce qu'ils veulent dire c'est que PHP le remplacera par autre chose.
Si vous êtes d'accord avec cette description vague des vues, vous conviendrez également que la plupart des solutions de modèles ne séparent pas efficacement les vues et les modèles. La balise de modèle sera remplacée par tout ce qui est stocké dans le modèle.
Posez-vous quelques questions lorsque vous implémentez la vue : "Est-il facile de remplacer la vue entière ?" "Combien de temps faut-il pour implémenter une nouvelle vue ?" "Est-il facile de remplacer le langage de description de la vue ? (Par exemple, en utilisant SOAP dans la même vue Le document remplace le document HTML)"
Modèle (Modèle)
Le modèle représente la logique du programme. (Souvent appelée couche métier dans les programmes au niveau de l'entreprise)
En général, la tâche du modèle est de convertir les données d'origine en données contenant une signification, qui seront affichées par la vue. En règle générale, le modèle encapsulera les requêtes de données, peut-être via une classe de données abstraite (couche d'accès aux données) pour implémenter la requête. Par exemple, si vous souhaitez calculer les précipitations annuelles au Royaume-Uni (juste pour vous trouver un joli lieu de vacances), le modèle recevra les précipitations quotidiennes sur dix ans, calculera la moyenne et les transmettra à la vue.
Contrôleur (contrôleur)
signifie simplement que le contrôleur est la première partie de la requête HTTP entrante dans l'application Web. Il vérifie la requête reçue, telle que certaines variables GET, et formule les commentaires appropriés. Il est difficile de commencer à écrire du code PHP avant d'avoir écrit votre premier contrôleur. L'utilisation la plus courante est une structure comme l'instruction switch dans index.php :
<?php
commutateur ($_GET['viewpage']) {
cas "actualité":
$page=nouveau NewsRenderer ;
casser;
cas "liens":
$page=nouveau LinksRenderer ;
casser;
défaut:
$page=nouveau HomePageRenderer ;
casser;
}
$page->affichage();
?>
Ce code mélange du code procédural et orienté objet, mais pour les petits sites, c'est généralement le meilleur choix. Bien que le code ci-dessus puisse toujours être optimisé.
Les contrôleurs sont en fait des contrôles utilisés pour déclencher des liaisons entre les données du modèle et les éléments de vue.
Exemple
Voici un exemple simple utilisant le modèle MVC.
Nous avons d’abord besoin d’une classe d’accès à la base de données, qui est une classe ordinaire.
<?php
/**
* Une classe simple pour interroger MySQL
*/
classe DataAccess {
/**
*Privé
* $db stocke une ressource de base de données
*/
var $db;
/**
*Privé
* $query stocke une ressource de requête
*/
var $query; // Ressource de requête
//! Un constructeur.
/**
* Construit un nouvel objet DataAccess
* @param $host string nom d'hôte pour le serveur de base de données
* @param $user chaîne utilisateur du serveur de base de données
* @param $pass string mot de passe de l'utilisateur du serveur de base de données
* @param $db chaîne nom de la base de données
*/
fonction DataAccess ($hôte,$utilisateur,$pass,$db) {
$this->db=mysql_pconnect($host,$user,$pass);
mysql_select_db($db,$this->db);
}
//! Un accesseur
/**
* Récupère les ressources d'une requête et la stocke dans un membre local
* @param $sql chaîne la requête de base de données à exécuter
* @retour nul
*/
fonction récupérer ($sql) {
$this->query=mysql_unbuffered_query($sql,$this->db); // Effectuer une requête ici
}
//! Un accesseur
/**
* Renvoie un tableau associatif d'une ligne de requête
* @retour mixte
*/
fonction getRow() {
si ( $row=mysql_fetch_array($this->query,MYSQL_ASSOC) )
renvoie $ligne ;
autre
renvoie faux ;
}
}
?＞
Placez le modèle dessus.
<?php
/**
* Récupère les "produits" de la base de données
*/
classe ProduitModèle {
/**
*Privé
* $dao une instance de la classe DataAccess
*/
var $dao;
//! Un constructeur.
/**
* Construit un nouvel objet ProductModel
* @param $dbobject une instance de la classe DataAccess
*/
fonction ProductModel ($dao) {
$this-＞dao=& $dao;
}
//! Un manipulateur
/**
* Indique au $dboject de stocker cette requête en tant que ressource
* @param $start la ligne à partir de laquelle commencer
* @param $rows le nombre de lignes à récupérer
* @retour nul
*/
fonction listeProduits($start=1,$rows=50) {
$this->dao->fetch("SELECT * FROM products LIMIT ".$start.", ".$rows);
}
//! Un manipulateur
/**
* Indique au $dboject de stocker cette requête en tant que ressource
* @param $id une clé primaire pour une ligne
* @retour nul
*/
fonction listeProduit($id) {
$this->dao->fetch("SELECT * FROM products WHERE PRODUCTID='".$id."'");
}
//! Un manipulateur
/**
* Récupère un produit sous forme de tableau associatif à partir du $dbobject
* @retour mixte
*/
fonction getProduct() {
si ( $product=$this->dao->getRow() )
renvoyer $produit ;
autre
renvoie faux ;
}
}
?>
Une chose à noter est que l'interaction entre le modèle et la classe d'accès aux données ne dépasse jamais une ligne - aucune ligne multiple n'est envoyée, ce qui ralentira rapidement le programme. Le même programme n'a besoin de conserver qu'une seule ligne (Row) en mémoire pour la classe utilisant le schéma - le reste est donné à la ressource de requête enregistrée (ressource de requête) - en d'autres termes, nous laissons MYSQL conserver les résultats pour nous.
La prochaine étape est la vue - j'ai supprimé le code HTML pour économiser de l'espace, vous pouvez consulter le code complet dans cet article.
<?php
/**
* Lie les données du produit au rendu HTML
*/
classe ProductView {
/**
*Privé
* $model une instance de la classe ProductModel
*/
var $modèle;
/**
*Privé
* Le HTML rendu $output est stocké ici pour l'affichage
*/
var $output;
//! Un constructeur.
/**
* Construit un nouvel objet ProductView
* @param $model une instance de la classe ProductModel
*/
fonction ProductView ($modèle) {
$this->model=& $model;
}
//! Un manipulateur
/**
* Construit le haut d'une page HTML
* @retour nul
*/
function header () {
}
//! Un manipulateur
/**
* Construit le bas d'une page HTML
* @retour nul
*/
function footer() {
}
//! Un manipulateur
/**
* Affiche un seul produit
* @retour nul
*/
fonction produitItem($id=1) {
$this->model->listProduct($id);
while ( $product=$this->model->getProduct() ) {
// Lier les données au HTML
}
}
//! Un manipulateur
/**
* Construit une table de produits
* @retour nul
*/
fonction produitTable($rownum=1) {
$rowsperpage='20';
$this->model->listProducts($rownum,$rowsperpage);
while ( $product=$this->model->getProduct() ) {
// Lier les données au HTML
}
}
//! Un accesseur
/**
* Renvoie le HTML rendu
* @chaîne de retour
*/
affichage de la fonction () {
renvoie $this->output ;
}
}
?＞
Résumé : Le modèle MVC est très courant dans l'architecture de sites Web. Il nous permet de créer une application à trois niveaux, séparant les couches utiles du code, aidant les concepteurs et les développeurs à travailler ensemble et améliorant notre capacité à maintenir et à étendre les applications existantes. Cet article vous présentera l'implémentation du modèle MVC en PHP.
Mots clés : PHP MVC Modèle MVC Site Web PHP
Oracle vous aide à obtenir un aperçu précis de chaque lien logistique
Oracle vous aide à obtenir un aperçu précis de chaque lien logistique. Enfin, le contrôleur, nous implémenterons la vue en tant que sous-classe.
<?php
/**
* Contrôle l'application
*/
class ProductController étend ProductView {
//! Un constructeur.
/**
* Construit un nouvel objet ProductController
* @param $model une instance de la classe ProductModel
* @param $getvars les variables de la méthode HTTP GET entrante
*/
fonction ProductController ($model,$getvars=null) {
ProductView :: ProductView ($ modèle);
$this->en-tête();
commutateur ( $getvars['view'] ) {
cas "produit":
$this->productItem($getvars['id']);
casser;
défaut:
if ( vide ($getvars['rownum']) ) {
$this->productTable();
} autre {
$this->productTable($getvars['rownum']);
}
casser;
}
$this->footer();
}
}
?＞
Notez que ce n'est pas la seule façon d'implémenter MVC - par exemple, vous pouvez utiliser des contrôleurs pour implémenter des modèles et intégrer des vues en même temps. Ce n’est qu’une façon de démontrer le modèle.
Notre fichier index.php ressemble à ceci :
<?php
require_once('lib/DataAccess.php');
require_once('lib/ProductModel.php');
require_once('lib/ProductView.php');
require_once('lib/ProductController.php');
$dao=& new DataAccess ('localhost','user','pass','dbname');
$productModel=& nouveau ProductModel($dao);
$productController=& nouveau ProductController($productModel,$_GET);
echo $productController->display();
?＞
Beau et simple.
Nous avons quelques astuces pour utiliser les contrôleurs. En PHP, vous pouvez faire ceci :
$this->{$_GET['method']}($_GET['param']);
Une suggestion est que vous définissiez mieux la forme de l'espace de noms de l'URL du programme. (espace de noms), alors il sera plus standardisé, par exemple :
"index.php?class=ProductView&method=productItem&id=4"
Grâce à lui, nous pouvons traiter notre contrôleur comme ceci :
$view=new $_GET['class'];
$view->{$_GET['method']($_GET['id']);
Parfois, créer un contrôleur est difficile, par exemple lorsque vous faites un compromis entre vitesse de développement et adaptabilité. Un bon endroit pour s'inspirer est Java Struts du groupe Apache, dont les contrôleurs sont entièrement définis par des documents XML.