Tutorial : Créer une application avec le Zend Framework – #3 Création des modèles et explication du MVC

Dans cet épisode, nous allons essayer ensemble de comprendre le MVC et son intéret dans une application internet et nous allons créer les modèles qui vont nous permettre d’effectuer des actions sur la base de donnée de notre application WatchMyDesk.

Plan de l’épisode #3

1. Explication du MVC.
2. Le MVC et le Zend Framework
3. Créations des modèles de base de données.
4. Conclusion.
5. Notes.

Explication du MVC

Selon Wikipédia, le MVC représente :

Le Modèle-Vue-Contrôleur (en abrégé MVC, de l’anglais Model-View-Controller) est une architecture et une méthode de conception qui organise l’interface homme-machine (IHM) d’une application logicielle.

Bon c’est pas super explicatif comme description, donc on va faire plus simple !

• Le modèle représente la passerelle vers une table de la base de donnée. Au lieu d’exécuter des commandes SQL à la main, on va créer une classe qui va représenter cette table et va nous donner la possibilité de sélectionner des éléments,  de mettre à jour la table, de supprimer un ou des éléments dans la table et d’ajouter des éléments dans la table.
• La vue permet d’afficher le résultat envoyer par le modèle et d’écouter tout les évenements que fait l’utilisateur sur votre site comme les liens, les boutons, les formulaires.
• Le contrôleur va mettre en relation les modèle et les vues afin de dire à la vue ce qu’elle doit afficher et dire au modèle ce qu’il doit faire.Si une action nécessite un changement des données, le contrôleur demande la modification des données au modèle et ensuite avertit la vue que les données ont changé pour qu’elle se mette à jour.

Le MVC est une base de conception vraiment pratique tant au niveau de la programmation, mais aussi car ce code est testable facilement et on peut revenir dans le code plus facilement que si cela était uniquement fait en procédural.

Simple non?

Le MVC et le Zend Framework.

Le framework de la société Zend vous permet d’utiliser directement le MVC simplement et efficacement ! Comme nous l’avons vu dans l’épisode 1 et dans la structure des dossiers, nous avons le dossier avec les contrôleurs, le dossier avec les modèles et le dossier avec les vues.

Avec le Zend Framework, il y a quelques conventions à suivre pour que tout cela soit opérationnel.

Pour les Controleurs :

• Le contrôler est une classe PHP.
• Le nom du contrôleur doit être obligatoirement LeNom suivis de Controller (par exemple : IndexController).
• Le Contrôler doit étendre du Zend_Controller_Action.
• Si on se trouve dans un module différent de celui par défaut, le nom de la classe change : LeModule_LeNomController.
• Toutes les actions du contrôleurs (les méthodes de la classe qui vont appeler les modèles) doivent être nommé : LeNomAction (toujours avoir le suffixe Action).

Pour les vues :

• Les vues sont triés par Controller, c’est à dire que pour un contrôleur Index, nous aurons notre vue dans le dossier monmodule/views/scripts/index/
• Le nom de la vue correspond au nom de l’action dans le contrôler, par exemple dans le contrôler IndexController, on a la méthode ListAction, la vue correspondante sera : monmodules/views/scripts/index/list.phtml.
• Nous pouvons bien évidemment choisir la vue à afficher dans le contrôleur

Exemple Concret :

class IndexController extends Zend_Controller_Action{
    public function listAction(){
    // ici je fait une requête pour récupérer ce que je veux
    }
}

Cette action sera donc appelable à partir de cette adresse : http://localhost/watchmydesk/index/list .
Avec le MVC, plus besoin de réécrire les urls avec un htaccess, c’est aussi simple que ça pour avoir des adresses propre et SEO friendly dans votre application.

Créations des modèles de base de données

Les modèles de base de données, comme dis précédemment vont être utilisés pour accéder à une table de notre base de donnée watchmydesk que nous avons créée dans l’épisode #2.

Comme les controleurs, les modèles sont des classes PHP qui étendent de Zend_Db_Table, ce qui leur permet d’avoir accès à des méthodes de mise à jour, suppression, sélection et d’insertion dans la base de donnée !
De plus, ce composant nous permet de gérer les associations dans la base de données.

Nous allons faire un rappel rapide sur les relations que nous avons dans notre base de données:

• Un membre peut avoir plusieurs bureaux, plusieurs commentaires et plusieurs votes.
• Un bureau a un seul utilisateur et peut avoir plusieurs votes, plusieurs commentaires et plusieurs photos
• Un bureaux peut avoir plusieurs associations grâce à la table de liaison bureaux_photos. Cette table servira à prévenir si la photo lié est la principale (celle à afficher).

Avec ce rappel fait, nous allons pouvoir commencer!

Le modèle Membres.php

class Model_DbTable_Membres extends Zend_Db_Table
{
    protected $_name = 'membres';
    protected $_primary = 'id';

    protected $_referenceMap = array(
        'Votes' => array(
	        'columns'           => 'id',
	        'refTableClass'     => 'Model_DbTable_Votes',
        ),
        'Bureaux' => array(
	        'columns'           => 'id',
	        'refTableClass'     => 'Model_DbTable_Bureaux',
        ),
        'Commentaires' => array(
        	'columns'           => 'id',
	        'refTableClass'     => 'Model_DbTable_Commentaires',
        )
    );

}

Oula, on se calme, ca veut dire quoi ce code là ! On va prendre sa respiration et regarder de plus près.
Comme dis précédemment, le modèle doit étendre de Zend_Db_Table. Nous lui indiquons aussi le nom de la table sur laquelle nous travaillons grâce à la variable protégée $_name, ici : membres. Ensuite nous lui indiquons la clef primaire de notre table grâce à la variable protégée $_primary, ici : id.

Le gros morceau de code qui suit, c’est la déclaration des relations dans la base de données. C’est grâce à cela que nous retrouverons les bureaux d’un membre ou les commentaires écrit par ce membre. Comme dis précédemment, un membre peut avoir plusieurs bureaux, plusieurs commentaires et plusieurs votes, on a donc bien ces trois éléments. C’est grâce à cette variable protégée $_referenceMap que nous pouvons indiquer les relations. Ils nous suffit de mettre la clef étrangère (ici nommé columns) ainsi que la classe qui va servir de référence pour exécuter les requêtes SQL dans la table dépendante.

Grâce à cette méthode, nous faisons abstraction de toutes les requêtes SQL à faire pour trouver les commentaires écrits par un des membres.

Continuons l’écriture de nos modèles .
Le modèle Bureaux.php

class Model_DbTable_Bureaux extends Zend_Db_Table
{
    protected $_name = 'bureaux';
    protected $_primary = 'id';

    protected $_referenceMap = array(
    	'Membre' => array(
    		'columns'		=> 'membre_id',
    		'refTableClass' => 'Model_DbTable_Membres'
    	),
    	'Commentaires' => array(
    		'columns'		=> 'id',
    		'refTableClass' => 'Model_DbTable_Commentaires'
    	)
    );
}

Le modèle Commentaires.php

class Model_DbTable_Commentaires extends Zend_Db_Table
{
    protected $_name = 'commentaires';
    protected $_primary = 'id';

    protected $_referenceMap = array(
        'Membres' => array(
	        'columns'           => 'membre_id',
	        'refTableClass'     => 'Model_DbTable_Membres',
        ),
        'Bureaux' => array(
	        'columns'           => 'bureau_id',
	        'refTableClass'     => 'Model_DbTable_Bureaux',
        )
    );

}

Le modèle Votes.php

class Model_DbTable_Votes extends Zend_Db_Table
{
    protected $_name = 'votes';
    protected $_primary = 'id';

    protected $_referenceMap = array(
        'Membres' => array(
	        'columns'           => 'membre_id',
	        'refTableClass'     => 'Model_DbTable_Membres',
        ),
        'Bureaux' => array(
	        'columns'           => 'bureau_id',
	        'refTableClass'     => 'Model_DbTable_Bureaux',
        )
    );

}

Le modèle Photos.php

class Model_DbTable_Photos extends Zend_Db_Table
{
    protected $_name = 'photos';
    protected $_primary = 'id';

    protected $_referenceMap = array(
        'Bureaux' => array(
	        'columns'           => 'id',
	        'refTableClass'     => 'Model_DbTable_Bureaux',
        )
    );

}

Le modèle BureauxPhotos.php

class Model_DbTable_BureauxPhotos extends Zend_Db_Table
{
    protected $_name = 'bureaux_photos';
    protected $_primary = 'id';

    protected $_referenceMap = array(
        'Bureaux' => array(
	        'columns'           => 'bureau_id',
	        'refTableClass'     => 'Model_DbTable_Bureaux',
        ),
        'Photos' => array(
	        'columns'           => 'photo_id',
	        'refTableClass'     => 'Model_DbTable_Photos',
        )
    );

}

Vous devez vous retrouver avec cette structure :

Voila ! Nous avons fait le gros du travail .
Nous allons voir maintenant si nos associations marche par des tests très rapides.
Il vous suffit d’ajouter plusieurs enregistrements dans votre base de données (plusieurs membres, plusieurs photos, plusieurs commentaires …).

Nous allons allez dans le répertoire /application/modules/frontend/controllers/, ouvrir de fichier IndexController.php et écrire cela :

class IndexController extends Zend_Controller_Action {
       public function indexAction(){
		$membres = new Model_DbTable_Membres(); // On instancie un modèle Membres.
		$user = $membres->find(1)->current(); // On récupère le premier utilisateur.
		Zend_Debug::dump($user->findModel_DbTable_Votes()); // On cherche les votes associés à l'utilisateur
		Zend_Debug::dump($user->findModel_DbTable_Commentaires()); // On cherche les commentaires associés à l'utilisateur
		$votes = new Model_DbTable_Votes();  // On instancie un modèle Votes.
		$vote = $votes->find(1)->current(); // On récupère le premier vote.
		Zend_Debug::dump($vote->findParentModel_DbTable_Membres()); // On cherche l'utilisateur qui à posté le commentaire

		$bureaux = new Model_DbTable_Bureaux(); // On instancie un modèle Bureaux.
		$bureau = $bureaux->find(2)->current(); // On récupère le second bureau.
		Zend_Debug::dump($bureau->findModel_DbTable_Commentaires()); // On cherche les commentaires associés au bureau.
		Zend_Debug::dump($bureau->findModel_DbTable_PhotosViaModel_DbTable_BureauxPhotos()); // On cherche les photos associées au bureau.
	}
}

Si tout fonctionne comme vous le souhaitez, vous avez réussis !

Conclusion

Dans cet épisode, vous avez vu comment fonctionne le MVC avec le Zend Framework et comment mettre en place et utiliser les modèles de base de données, ainsi que leur relations dans la base de donnée.
C’était un épisode assez intense au niveau apprentissage, et je pense qu’une bonne semaine pour se remettre ne fera pas de mal !

Je vous rappel que depuis peu, vous pouvez me suggérer des articles ou des vidéos sur la page de suggestion.
Bonne vacances à ceux qui en ont et à Lundi prochain !

Notes

• Si vous voulez un peu plus de précisions sur les requêtes SQL à partir des modèles avec le Zend Framework, je vous conseille la documentation à ce sujet.
• Malgré la longueur de cet article, il a été rédigé en une nuit pour cause d’absence durant le weekend. Veuillez donc m’excuser si vous trouvez des erreurs de codes, fautes d’orthographes. Si vous en trouvez, n’hésitez pas à me le faire savoir dans les commentaires !