1.4. Iniziamo a scrivere il framework MVC

Abbiamo già descritto in dettaglio ciò che il nostro framework dovrebbe includere, ora è arrivato il momento di iniziare la sua implementazione. Prima di tutto, ti serve un server web. Puoi provare Denwer, ma potresti dover aggiornare la versione di PHP.

Puoi scaricare Denwer con PHP 5.5.20 da questa pagina:

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

oppure da GitHub:

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

Il funzionamento del nostro framework inizierà dal file index.php, che richiamerà le istanze dal registro, caricherà il controller necessario e gli passerà i risultati del registro. Il controller, a sua volta, potrà richiamare i modelli di cui ha bisogno.

Implementazione dei pattern

Esistono diversi modi per implementare i pattern che abbiamo discusso. Noi sceglieremo uno dei metodi possibili; in futuro potrai modificarne l’implementazione come preferisci.

Cominciamo. In uno degli articoli precedenti abbiamo analizzato la struttura del nostro framework, quindi dobbiamo creare le cartelle basandoci su quella struttura.

Ora crea il file Registry/registry.class.php. In questo file scriveremo la classe del nostro registro.

<?php
/**
 * Oggetto Registry
 * Implementa i pattern Registry e Singleton
 */
class Registry {
     
    /**
     * Array dei nostri oggetti
     * @access private
     */
    private static $objects = array();
     
    /**
     * Array delle impostazioni
     * @access private
     */
    private static $settings = array();
     
    /**
     * Nome leggibile del framework
     * @access private
     */
    private static $frameworkName = 'Framework version 0.1';
     
    /**
     * Istanza del registro
     * @access private
     */
    private static $instance;
     
    /**
     * Costruttore privato
     */
    private function __construct()
    {
    }
         
    /**
     * Metodo Singleton per ottenere l’istanza del registro
     * @access public
     */
    public static function singleton()
    {
        if( !isset( self::$instance ) )
        {
            $obj = __CLASS__;
            self::$instance = new $obj;
        }
        return self::$instance;
    }
     
    /**
     * Previene la clonazione dell’oggetto
     */
    public function __clone()
    {
        trigger_error( 'Cloning the registry is not permitted', E_USER_ERROR );
    }
     
    /**
     * Memorizza un oggetto nel registro
     */
    public function storeObject( $object, $key )
    {
        require_once('objects/' . $object . '.class.php');
        self::$objects[ $key ] = new $object( self::$instance );
    }
     
    /**
     * Restituisce un oggetto dal registro
     */
    public function getObject( $key )
    {
        if( is_object ( self::$objects[ $key ] ) )
        {
            return self::$objects[ $key ];
        }
    }
     
    /**
     * Memorizza un’impostazione
     */
    public function storeSetting( $data, $key )
    {
        self::$settings[ $key ] = $data;
    }
     
    /**
     * Ottiene un’impostazione
     */
    public function getSetting( $key )
    {
        return self::$settings[ $key ];
    }
     
    /**
     * Restituisce il nome del framework
     */
    public function getFrameworkName()
    {
        return self::$frameworkName;
    }
}
?>

Come funziona il nostro registro e come memorizza gli oggetti?

• Gli oggetti vengono memorizzati in un array.
• Quando un nuovo oggetto viene aggiunto al registro, il file della classe viene caricato, viene creata un’istanza dell’oggetto e memorizzata nell’array.
• L’oggetto può essere richiamato passando la chiave al metodo getObject.

Come si evita la creazione di un’altra istanza del registro?

• Il costruttore è privato, quindi non è possibile creare un’istanza direttamente.
• La clonazione dell’oggetto genera un errore.
• Se vuoi accedere al registro da qualsiasi parte del framework, puoi utilizzare il metodo statico singleton(): Registry::singleton().

Ora che abbiamo il nostro registro, scriviamo il file index.php per avviare il framework e accedere al registro.

Index.php

Index.php è il punto di ingresso del nostro framework.

In seguito aggiungeremo anche la possibilità di creare URL leggibili (SEO friendly) con l’aiuto del file .htaccess. Per ora analizziamo il codice di index.php:

<?php
/**
 * Framework
 * Loader del Framework - funge da punto di accesso unico al Framework
 */
  
session_start();

// Definizione delle costanti
define( "APP_PATH", dirname( __FILE__ ) ."/" );
define( "FW", true );

/**
 * Funzione magica di autoload
 * Carica automaticamente i controller necessari
 */
function __autoload( $class_name )
{
    require_once('Controllers/' . $class_name . '/' . $class_name . '.php' );
}

// Includiamo il registro
require_once('Registry/registry.class.php');
$registry = Registry::singleton();

// Stampiamo il nome del framework per verificarne il funzionamento
print $registry->getFrameworkName();

exit();
?>

Se tutto funziona correttamente, dovresti vedere il seguente messaggio:

Framework version 0.1

Analizziamo come funziona attualmente il nostro index.php:

• Avvia una sessione, in modo da poter leggere e scrivere dati da qualsiasi parte del framework.
• Definisce la cartella principale del framework, utile per eseguirlo anche in sottocartelle del sito.
• Carica i controller tramite autoload.
• Includiamo la classe del registro.
• Stampiamo il nome del framework per testarne il corretto funzionamento.