Lors de vos premières applications PHP vous vous êtes sans doute senti obligé de créer un fichier .php par page et un certain nombre de dossiers pour regrouper divers fichiers
Au fil du temps votre application ne cesse de grossir et devient rapidement difficile à maintenir. Le plus douloureux arrive lorsque vous n'avez pas touché à votre application depuis plusieurs semaines et que vous devez retrouver comment vous l'aviez géré.
Cette méthode n'est pas pratique lorsque vous êtes seul à travailler dessus et devient totalement ingérable lorsque vous êtes plusieurs développeurs.
Globalement, nous pourrons accéder à une fonction directement en saisissant une URL. (une URL = une fonction à appeler)
Pour pallier à ce problème, l'architecture MVC (Model-View-Controller) a été créée et Zend Framework la gère comme un chef !
Dans une application Zend Framework, la partie MVC est située dans un dossier à part, nommé par défaut application.
Trois sous-dossiers controllers, views et models ont des noms explicites quant à leur contenu :
Dans le dossier controllers, le fichier IndexController.php contient le contrôleur principal de l’application, c’est-à dire celui qui est appelé par défaut.
Le fichier index.phtml, dans views/index, correspond à la vue du contrôleur principal. En fait, il s’agit de la vue de l’action index (nom du fichier) du contrôleur index (nom du dossier contenant).
Le fichier html/index.php est ce que l’on appelle un bootstrap ou « fichier d’amorçage ». C’est vers ce fichier que toutes les requêtes HTTP sont redirigées, mis à part celles des fichiers statiques (images, CSS, JavaScript...).
La requête HTTP passe d’abord par le contrôleur frontal qui est instancié dans le bootstrap (html/index.php). Ce contrôleur frontal va déterminer quel contrôleur et quelle action doivent être appelés. C’est ainsi, par exemple, que le contrôleur réservations est instancié et que l’action exporter est appelée.
Techniquement, un contrôleur est une classe, et l’action une méthode de cette dernière.
Correction de l'exercice 1
On créé les dossiers nécessaires au fonctionnement de notre architecture MVC
On va rediriger le nom de domaine zendsite.com vers notre serveur, bien entendu vous ne deviendrez propriétaire de ce nom de domaine, seul votre ordinateur redirigera vers l'IP de votre serveur.
Si votre navigateur web se trouve sous Windows, vous devez ouvrir le fichier hosts qui se trouve dans C:\Windows\System32\drivers\etc\host avec votre éditeur texte habituel.
Si votre navigateur web se trouve sous Mac ou Linux, vous devez ouvrir le fichier hosts qui se trouve dans /etc/host avec votre éditeur texte habituel.
En prenant soin de changer l'IP pour celle de votre serveur.
Maintenant nous devons signaler au serveur que les requetes arrivant depuis le domaine zendsite.com devront être redirigées vers le dossier /www/htdocs/sitezend/html/.
Le nom de domaine zendsite.com devrait maintenant nous rediriger vers le dossier html/ de notre serveur dans le lequel nous allons placer notre bootstrap que nous allons voir maintenant.
<?php
require_once 'Zend/Loader/Autoloader.php';
$loader = Zend_Loader_Autoloader::getInstance();
$loader->setFallbackAutoloader(true);
// Appel du contrôleur frontal,
// qui se charge de traiter la requête
Zend_Controller_Front::run('../application/controllers');
<?php
// La classe correspondant au contrôleur index
// (contrôleur par défaut)
class IndexController extends Zend_Controller_Action
{
// L’action index
public function indexAction()
{
}
}
On remarque qu'en chargeant notre bootstrap, la vue est affichée
Correction de l'exercice 4
Pour pouvoir utiliser des contrôleurs, nous devons indiquer à notre serveur que nous ne ferons pas appel à de véritables dossiers présents sur le serveur mais que nous utiliserons la requête HTTP comme moyen de communication avec Zend.
Pour se faire, nous utilisons un .htaccess que nous allons créer :
<?php
class LoginController extends Zend_Controller_Action
{
public function indexAction ()
{
}
public function loginAction ()
{
}
public function logoutAction ()
{
}
}
On créé le dossier login qui regroupera les vues de notre contrôleur fraîchement créé :
On test en chargeant http://www.zendsite.com/login/mdpoublie/ depuis notre navigateur :
Correction de l'exercice 6
Dans Zend, les données superglobales GET, POST, COOKIE, SERVER, ENV se récupèrent avec getRequest()
On commence par envoyer la variable param contenant les variables prenom et nom définis en GET :
public function mdpoublieAction ()
{
$G_nom = $this->getRequest()->nom;
$G_prenom = $this->getRequest()->prenom;
$this->view->param = $G_prenom.' '.$G_nom;
}
Dans notre vue, on affiche le paramètre param défini dans notre action.
<?php echo $this->param; ?>
On appel notre action dans le navigateur en indiquant nos paramètres GET http://www.zendsite.com/login/mdpoublie/prenom/paul/nom/danilo/
Pour aller encore plus vite nous pouvons utiliser getParam() pour récupérer les paramètres :
public function mdpoublieAction ()
{
$G_nom = $this->getParam("nom");
$G_prenom = $this->getParam("prenom");
$this->view->param = $G_prenom.' '.$G_nom;
}
Il est nécessaire de maintenir dans l'esprit que le nom de propriété (clé du tableau des superglobales) est assorti à une superglobale dans un ordre spécifique de priorité : 1. GET, 2. POST, 3. COOKIE, 4. SERVER, 5. ENV.
Correction de l'exercice 7
Le principe est exactement le même qu'avec les paramètres GET.
On commence par compléter notre vue avec notre formulaire :
Il est possible de factoriser des traitements communs effectués en début ou en fin de plusieurs actions grâce aux méthodes d’initialisation et de post-dispatching :
la méthode init() est appelée à la construction du contrôleur d’action.
la méthode preDispatch() est appelée avant chaque action.
la méthode postDispatch() est appelée après chaque action.
Dans notre contrôleur login on ajoute la méthode suivante :
public function init()
{
$this->view->TitrePage = "Titre de ma page";
}
On charge http://www.zendsite.com/login/mdpoublie/ pour vérifier le titre de la page est bien défini :
Correction de l'exercice 9
Il est courant que chaque page comporte des parties communes, telles que l'en-tête et le pied de page, le menu et les styles CSS. Zend_Layout va nous permettre de créer un gabarit qui nous évitera de dupliquer du code HTML d’une vue à l’autre.
Pour simplifier notre apprentissage, considérons que l’application ne comporte qu'un seul gabarit de page. Mais que cela ne nous limite pas dans l’absolu, il est bien sûr possible d’avoir plusieurs gabarits utilisés séparément ou en même temps.
Notre gabarit est composé de 4 parties principales :
Les paramètres situés dans la balise <head> de la page.
L'en-tête (header) de la page, comportant le titre et le formulaire de login.
Le contenu de la page (body), comprenant les données générées par la vue du contrôleur.
Le pied de page (footer), qui contiendra simplement une information de type copyright ou une signature.
Nous allons utiliser un gabarit pour notre méthode login.
Pour cela, on indique dans la fonction init() de la méthode login que nous utiliserons le gabarit layout.phtml situé dans application/views/login/
Notez la présence des appels $this->head*() qui sont des aides permettant d’écrire les données spécifiques contenues dans la balise <head> de l’application. Il existe des méthodes head*() spécifiques à différents types de balises : headMeta(), headLink(), headTitle(), headStyle()...
On peut déjà tester notre gabarit en affichant la source de http://www.zendsite.com/login/ :
Nous allons maintenant créer notre header et notre footer :
Pour cela rien de bien compliqué, nous allons commencer par créer un dossier common/ dans views/scripts/ qui contiendra les vues communes à nos pages
Notez la présence de la fonction escape(), par défaut, elle utilise la fonction PHP htmlspecialchar() pour l'échappement. Cependant, en fonction de votre environnement, vous souhaitez peut-être un échappement différent. Utilisez la méthode setEscape() au niveau du contrôleur pour dire à Zend_View quelle méthode de rappel ("callback") elle doit utiliser.
Il nous reste maintenant à appeler le header depuis notre gabarit (layout). Pour cela nous allons utiliser la méthode $this->partial().
Avec partial, le contexte de la vue n'est pas celui du gabarit, d'où l'importance de transmettre les paramètres dynamiques, ce que nous avons fait avec le titre de la page :
Pour vérifier son bon fonctionnement, revenons à notre contrôleur login et notre méthode mdpoublie et nous allons lui demander de nous retourner les paramètres GET nom et prenom comme vu précédemment
public function mdpoublieAction ()
{
$P_prenom = $this->getParam("prenom");
$P_nom = $this->getParam("nom");
$this->view->param = $P_prenom.' '.$P_nom;
}
Adaptons notre vue afin qu'elle nous retourne uniquement la variable param
<?php echo $this->param; ?>
Il nous reste plus qu'à utiliser notre navigateur pour vérifier le tout :
Nous pouvons constater que nos paramètres sont bien affichés ainsi que le gabarit qui va avec.
Aucun commentaire:
Enregistrer un commentaire