Manuel de référence → Hoa_Controller, introduction

Chapitre 11. Hoa_Controller, introduction

Dans un modèle de conception Modèle-Vue-Contrôleur, la couche centrale est la couche contrôleur.

Pour bien comprendre le fonctionnement des applications basées sur des architectures n-tiers, on propose de lire l'Annexe B, Introduction à l'architecture n-tiers. Cet annexe permettra de mieux comprendre comment on en est arrivé à ce type d'architecture, et introduira les trois niveaux d'abstraction d'une application. La couche contrôleur peut s'apparenter à la logique application, la couche de traitement.

Le contrôleur de Hoa est composé de différentes parties que l'on se forcera d'expliquer ci-dessous. On commence par donner les explications sur le fonctionnement du contrôleur frontal.

Vue d'ensemble de l'architecture

Pour bien comprendre comment fonctionnent toutes les couches entre-elles, on va tout d'abord définir quelques termes et expliquer quelle architecture les applications doivent adopter avec le MVC de Hoa.

Les différents contrôleurs

Dans le MVC de Hoa, on ne rencontre pas une seule sorte de contrôleur, mais trois sortes de contrôleurs.

Contrôleur du processus

Quand une application se lance, on va toujours appeler la couche contrôleur du MVC. C'est cette couche qui va distribuer les tâches. La couche contrôleur est basée sur le contrôleur frontal. Il est important de bien comprendre que le contrôleur frontal ne sert qu'à faciliter le démarrage de l'application. C'est lui qui va donner les directives, instancier tous les objets en jeux, les imbriquer etc.

Contrôleur de l'application

Viennent ensuite les contrôleurs de l'application. Les contrôleurs de l'application correspondent bien à la notion de logique application, de traitement des tâches.

Il ne faut pas confondre les contrôleurs d'application avec le contrôleur frontal, ils n'ont pas le même but. Le contrôleur frontal initialise et lance les contrôleurs de l'application.

Parmi les contrôleurs de l'application, on peut noter encore deux parties : les contrôleurs primaires et secondaires. Les contrôleurs secondaires sont une sub-division des contrôleurs primaires. En effet, lorsqu'un contrôleur contient trop d'actions, il est envisageable pour des questions de performances et d'espace mémoire de partager ce contrôleur en plusieurs autres. Ces autres sont appelés contrôleurs secondaires. Un contrôleur primaire peut avoir plusieurs contrôleurs secondaires.

Ainsi, les actions sont réparties dans le contrôleur primaire et le ou les contrôleur(s) secondaire(s).

Les modèles sont des dataObjects

Les modèles sont — en quelque sorte — chargés d'extraire les données et de les présenter aux contrôleurs.

Il y a différente manière de concevoir les modèles. Hoa a décidé d'utiliser les modèles comme des objets de données (data objects). Un objet de données ne devrait en théorie comporter que des attributs de classe et quelques méthodes. Un objet de données étend un paquetage du framework et lors de son instanciation, ses paramètres servent à configurer le paquetage étendu. Ainsi, une fois le modèle instancié, on peut appeler les méthodes du modèle (ou du paquetage étendu) pour seulement récupérer les données, pas besoin d'effectuer des traitements.

Le modèle se contente de proposer/de mettre à disposition, les données de façon exploitable aux contrôleurs.

La couche vue

La couche vue propose juste une représentation de l'application. Elle contient des variables qui sont définies par le contrôleur (primaire ou secondaire). Aucun calcul n'est fait et ne doit être fait dans la vue, ce travail étant réservé aux contrôleurs.

Démarrage rapide

On propose de faire un démarrage rapide avant de commencer les explications plus en profondeur. L'apprentissage se fera alors à partir d'un exemple. Cet exemple nous permettra de comprendre plus facilement ce qu'est un contrôleur, une action etc.

Préparons l'arborescence

Dans un premier temps, il faut organiser son application. On commence alors par créer une bonne arborescence :

Application/
    Controller/
    Model/
    View/
        MyTheme/
Hoa_Framework/
index.php

On voit ici que Hoa_Framework/ est le dossier qui contient Hoa, index.php est votre fichier d'amorçage^[12], et enfin Application/ est notre application. Cette application contient trois dossiers : Controller/ pour les contrôleurs, Model/ pour les modèles, et View/ pour les vues.

On notera que le dossier View/ contient déjà un dossier MyTheme/ qui est le thème par défaut.

Hoa propose cette architecture par défaut, mais il faudra toujours garder à l'esprit que cette architecture peut être totalement modifiée. On le verra plus tard.

Un premier fichier d'amorçage

L'application est lancée depuis un fichier d'amorçage, ou bootstrap, souvent index.php. On propose ceci :

<?php
 
/**
 * On redéfinit les chemins d'inclusions.
 */
set_include_path('./'              . PATH_SEPARATOR .
                 './Application'   . PATH_SEPARATOR .
                 './Hoa_Framework' . PATH_SEPARATOR .
                 get_include_path());
 
/**
 * On appelle le fichier principal du Framework.
 */
require_once 'Framework.php';
 
/**
 * On inclue le contrôleur frontal.
 */
import('Controller.Front');
 
/**
 * On demande une instance du
 * contrôleur frontal.
 */
$controller = Hoa_Controller_Front::getInstance();
 
/**
 * On lance le dispatch.
 */
$controller->dispatch();

Deux lignes suffisent pour lancer le MVC.

Un premier contrôleur

Maintenant que le bootstrap est prêt, on va pouvoir créer notre premier contrôleur. La logique nous impose que ce soit le contrôleur index ; on le place dans Application/Controller/IndexController.php :

<?php
 
/**
 * Contrôleur de l'index.
 */
class IndexController extends Hoa_Controller_Action_Standard {
 
    /**
     * Méthode qui initialise le contrôleur.
     */
    public function init ( ) {
 
        $this->view->init = 'Je suis initialisé.';
    }
 
    /**
     * Action Index du contrôleur Index,
     * soit l'action par défaut.
     */
    public function IndexAction ( ) {
 
        $this->view->titre        = 'Page d\'accueil';
        $this->view->introduction = 'Bienvenue sur votre site ;-).';
 
        echo $this->view->render();
    }
}

Une première vue

Une fois le contrôleur terminé, il faut associer une vue à son action. Pour ça, on écrit le fichier Application/View/MyTheme/IndexView/IndexAction.phtml :

<h1><?php echo $this->titre; ? ></h1>
 
<p><?php echo $this->introduction; ? ></p>
<p>(état du contrôleur : <em><?php echo $this->init; ? ></em>)</p>

On note qu'il n'est pas correct d'afficher de l'HTML sans DocType, ni en-tête, ni corps etc. On propose alors d'écrire un fichier Application/View/MyTheme/FrontLayout.phtml :

<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.1//EN"
                      "http://www.w3.org/TR/xhtml11/DTD/xhtml11.dtd">
 
<html xmlns="http://www.w3.org/1999/xhtml" xml:lang="fr">
 
<head>
  <title>Test — Hoa Framework</title>
  <meta http-equiv="content-type"        content="application/xhtml+xml; charset=utf-8" />
  <meta http-equiv="content-script-type" content="text/javascript; charset=utf-8" />
  <meta http-equiv="content-style-type"  content="text/css; charset=utf-8" />
</head>
 
<body id="top">
 
<?php echo $this->_page; ? >
 
</body>
 
</html>

On notera que la vue de l'action est appelée à travers la variable $this->_page, on expliquera tout ça après.

Un premier site

Il ne nous reste maintenant qu'à apprécier le résultat. Pour cela, il suffit de se rendre sur la page d'index de notre application :

http://localhost/index.php

On devrait voir :

<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.1//EN"
                      "http://www.w3.org/TR/xhtml11/DTD/xhtml11.dtd">
 
<html xmlns="http://www.w3.org/1999/xhtml" xml:lang="fr">
 
<head>
  <title>Test — Hoa Framework</title>
  <meta http-equiv="content-type"        content="application/xhtml+xml; charset=utf-8" />
  <meta http-equiv="content-script-type" content="text/javascript; charset=utf-8" />
  <meta http-equiv="content-style-type"  content="text/css; charset=utf-8" />
</head>
 
<body id="top">
 
<h1>Page d'accueil</h1>
 
<p>Bienvenue sur votre site ;-).</p>
<p>(état du contrôleur : <em>Je suis initialiasé.</em>)</p>
 
</body>
 
</html>

Une seconde action

Pour se persuader de la rapidité d'un MVC une fois le système mis en place, on va modifier le contrôleur de l'index pour ajouter une action, et on y accédera en modifiant l'URL :

<?php
 
/**
 * Contrôleur de l'index.
 */
class IndexController extends Hoa_Controller_Action_Standard {
 
    // Le même code qu'avant.
 
    /**
     * On ajoute l'action Truc au module Index.
     */
    public function TrucAction ( ) {
 
        $this->view->citation = 'Je suis Truc, l\'Action Truc';
 
        echo $this->view->render();
    }
}

On vient de créer une nouvelle action, il faut donc créer une nouvelle vue (Application/View/MyTheme/IndexView/TrucAction.phtml) :

<h1>Action truc</h1>
 
<p>Truc nous dit : <q><?php echo $this->citation; ?  ></q>.</p>

Afficher tel ou tel contrôleur

On a donc deux contrôleurs et deux vues (une pour chaque contrôleur), on va donc pouvoir afficher l'une ou l'autre.

On se sert des URLs pour arriver à nos fins. Pour accéder au contrôleur par défaut, on peut y aller depuis cette adresse :

http://localhost/index.php?module=index&action=index

Pour accéder au contrôleur Index et à l'action Truc, on peut y aller depuis cette adrese :

http://localhost/index.php?module=index&action=truc

Par défaut, le contrôleur et l'action sont fixés à index, on peut donc omettre la variable module dans l'adresse. Ainsi, on accédera également à l'action Truc de cette façon :

http://localhost/index.php?action=truc

On remarque qu'une fois l'architecture du MVC mise en place, il est très facile d'ajouter des contrôleurs et des actions. On remarque également le module correspond au contrôleur choisi et que l'action correspond à une méthode dans ce contrôleur. Les applications restent donc très organisées.

On verra par la suite que l'architecture, tout comme les variables URL, ou encore les valeurs par défaut, peuvent être modifiées à partir de paramètres passés au contrôleur frontal. On verra également que l'on peut changer de routeur pour réécrire les adresses, et donc, améliorer le référencement, la lisibilité etc.

^[12]Fichier d'amorçage est une traduction de bootstrap en anglais. On utilisera le terme anglais dans la suite.

Menu

Table des matières