1.4. Commencer à écrire un framework MVC

Nous avons déjà suffisamment décrit ce que notre framework doit contenir, il est temps de le réaliser. Pour commencer, vous avez besoin d’un serveur web. Vous pouvez essayer Denwer, mais il se peut que vous deviez mettre à jour PHP.

Vous pouvez télécharger Denwer avec PHP 5.5.20 depuis cette page :

https://drupalbook.org/ru/drupal/denwer-obnovlenie-php

ou depuis GitHub :

https://github.com/levmyshkin/denwer-php-5.5.20

Le fonctionnement de notre framework commencera avec le fichier index.php, qui retourne des instances depuis le registre, appelle le contrôleur nécessaire et lui transmet les résultats du registre. Le contrôleur peut à son tour appeler les modèles dont il a besoin.

Implémentation des patterns

Il existe plusieurs façons différentes d’implémenter les patterns que nous avons discutés. Nous en choisirons une, et à l’avenir vous pourrez changer l’implémentation de n’importe quel pattern.

Commençons, dans un de nos articles précédents nous avons étudié la structure de notre framework, donc nous devons créer les dossiers en fonction de cette structure.

Créez maintenant le fichier Registry/registry.class.php. Dans ce fichier, nous écrirons la classe de notre registre.

<?php
/**
 * Objet Registre
 * Implémente le pattern Registre et Singleton
 *
 */
class Registry {
     
    /**
     * Tableau de nos objets
     * @access private
     */
    private static $objects = array();
     
    /**
     * Tableau de nos paramètres
     * @access private
     */
    private static $settings = array();
     
    /**
     * Nom lisible de notre framework
     * @access private
     */
    private static $frameworkName = 'Framework version 0.1';
     
    /**
     * Instance de notre registre
     * @access private
     */
    private static $instance;
     
    /**
     * Constructeur pour notre registre
     * @access private
     */
    private function __construct()
    {
     
    }
         
    /**
     * Méthode singleton pour accéder à l’objet
     * @access public
     * @return
     */
    public static function singleton()
    {
        if( !isset( self::$instance ) )
        {
            $obj = __CLASS__;
            self::$instance = new $obj;
        }
         
        return self::$instance;
    }
     
    /**
     * Empêche la copie de notre objet : déclenche une erreur E_USER_ERROR si cela se produit
     */
    public function __clone()
    {
        trigger_error( 'Le clonage du registre n’est pas permis', E_USER_ERROR );
    }
     
    /**
     * Stocke un objet dans notre registre
     * @param String $object le nom de l’objet
     * @param String $key la clé pour le tableau
     * @return void
     */
    public function storeObject( $object, $key )
    {
        require_once('objects/' . $object . '.class.php');
        self::$objects[ $key ] = new $object( self::$instance );
    }
     
    /**
     * Récupère un objet depuis notre registre
     * @param String $key la clé du tableau
     * @return object
     */
    public function getObject( $key )
    {
        if( is_object ( self::$objects[ $key ] ) )
        {
            return self::$objects[ $key ];
        }
    }
     
    /**
     * Stocke une configuration dans notre registre
     * @param String $data
     * @param String $key la clé pour le tableau
     * @return void
     */
    public function storeSetting( $data, $key )
    {
        self::$settings[ $key ] = $data;
    }
     
    /**
     * Récupère une configuration dans notre registre
     * @param String $key la clé dans le tableau
     * @return void
     */
    public function getSetting( $key )
    {
        return self::$settings[ $key ];
    }
     
    /**
     * Récupère le nom du framework
     * @return String
     */
    public function getFrameworkName()
    {
        return self::$frameworkName;
    }
     
     
}
 
?>

Comment fonctionne notre Registre et comment stocke-t-il nos objets ?

• Les objets sont stockés dans un tableau
• Quand un nouvel objet est ajouté au registre, le fichier de la classe est inclus, une instance est créée et ajoutée au tableau
• L’objet est retourné en passant la clé à la méthode getObject

Comment empêcher la création d’une autre copie de l’objet registre ?

• Le constructeur est private, ce qui empêche la création directe d’un objet
• Le clonage de l’objet déclenche une erreur
• Pour accéder à l’objet registre depuis notre framework, et si ce n’est pas possible depuis le fichier actuel, vous pouvez utiliser la méthode statique singleton (Registry::singleton()) pour obtenir une instance du Registre.

Maintenant que nous avons le Registre, écrivons index.php pour lancer le framework et accéder au Registre.

Index.php

Index.php est le point d’entrée de notre framework.

Nous ajouterons plus tard la possibilité de créer des URLs propres (URL rewriting) grâce au fichier .htaccess. Pour l’instant, examinons le code de index.php :

<?php
/**
 * Framework
 * Chargeur du framework - agit comme point d’accès unique au Framework
 *
 */
  
// Démarrage de session
session_start();
 
// Définition de quelques constantes
// Définit la racine du framework pour y accéder facilement depuis n’importe quel script
define( "APP_PATH", dirname( __FILE__ ) ."/" );
// Nous utiliserons cela pour éviter les appels de scripts hors de notre framework
define( "FW", true );
 
/**
 * Fonction magique d’autochargement
 * Permet d’appeler le contrôleur nécessaire lorsqu’il est requis
 * @param String nom de la classe
 */
function __autoload( $class_name )
{
    require_once('Controllers/' . $class_name . '/' . $class_name . '.php' );
}
 
// Inclusion du registre
require_once('Registry/registry.class.php');
$registry = Registry::singleton();
 
// Affiche le nom du framework pour vérifier que tout fonctionne
print $registry->getFrameworkName();
 
exit();
 
?>

Si tout est correct, le message suivant doit s’afficher :

Framework version 0.1

Examinons comment fonctionne notre index.php pour le moment :

• La session est démarrée pour pouvoir enregistrer et récupérer des données n’importe où dans le framework.
• Nous définissons le dossier racine de notre framework, ce qui permet de fonctionner correctement même en dehors de la racine du site.
• Les contrôleurs sont chargés via l’autochargement.
• La classe Registre est incluse.
• Et nous affichons le nom de notre framework.