1.4. We beginnen met het schrijven van een MVC-framework

We hebben al genoeg besproken over wat ons framework moet bevatten, nu is het tijd om het te implementeren. Allereerst heb je een webserver nodig. Je kunt Denwer proberen, maar mogelijk moet je PHP bijwerken.

Je kunt Denwer met PHP 5.5.20 downloaden vanaf deze pagina:

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

of vanaf GitHub

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

De werking van ons framework begint met het bestand index.php, dat instanties uit het register retourneert, de juiste controller aanroept en de resultaten van het register aan deze controller doorgeeft. De controller op zijn beurt kan de modellen aanroepen die hij nodig heeft.

Implementatie van patronen

Er bestaan verschillende manieren om de patronen die we hebben besproken te implementeren. We zullen één van de mogelijke varianten kiezen, maar in de toekomst kun je de implementatie van een van de patronen aanpassen.

Laten we beginnen. In een van de vorige artikelen hebben we de structuur van ons framework besproken, dus nu moeten we mappen aanmaken volgens die structuur.

Maak nu het bestand Registry/registry.class.php aan. In dit bestand schrijven we de klasse van ons register.

<?php
/**
 * Registry object
 * Implementeert het Registry- en Singleton-patroon
 *
 */
class Registry {
     
    /**
     * Array met onze objecten
     * @access private
     */
    private static $objects = array();
     
    /**
     * Array met onze instellingen
     * @access private
     */
    private static $settings = array();
     
    /**
     * Menselijk leesbare naam van ons framework
     * @access private
     */
    private static $frameworkName = 'Framework version 0.1';
     
    /**
     * Instantie van ons register
     * @access private
     */
    private static $instance;
     
    /**
     * Constructor voor ons register
     * @access private
     */
    private function __construct()
    {
     
    }
         
    /**
     * Singleton-methode om toegang te krijgen tot het object
     * @access public
     * @return
     */
    public static function singleton()
    {
        if( !isset( self::$instance ) )
        {
            $obj = __CLASS__;
            self::$instance = new $obj;
        }
         
        return self::$instance;
    }
     
    /**
     * Voorkomt het klonen van ons object: genereert een E_USER_ERROR als dit gebeurt
     */
    public function __clone()
    {
        trigger_error( 'Cloning the registry is not permitted', E_USER_ERROR );
    }
     
    /**
     * Slaat een object op in ons register
     * @param String $object de naam van het object
     * @param String $key de sleutel voor de array
     * @return void
     */
    public function storeObject( $object, $key )
    {
        require_once('objects/' . $object . '.class.php');
        self::$objects[ $key ] = new $object( self::$instance );
    }
     
    /**
     * Haalt een object op uit ons register
     * @param String $key de sleutel in de array
     * @return object
     */
    public function getObject( $key )
    {
        if( is_object ( self::$objects[ $key ] ) )
        {
            return self::$objects[ $key ];
        }
    }
     
    /**
     * Slaat instellingen op in ons register
     * @param String $data
     * @param String $key de sleutel voor de array
     * @return void
     */
    public function storeSetting( $data, $key )
    {
        self::$settings[ $key ] = $data;
    }
     
    /**
     * Haalt instellingen op uit ons register
     * @param String $key de sleutel in de array
     * @return void
     */
    public function getSetting( $key )
    {
        return self::$settings[ $key ];
    }
     
    /**
     * Geeft de naam van het framework terug
     * @return String
     */
    public function getFrameworkName()
    {
        return self::$frameworkName;
    }
     
}
 
?>

Hoe werkt ons Register en hoe slaat het onze objecten op?

• Objecten worden opgeslagen in een array
• Wanneer een nieuw object aan het register wordt toegevoegd, wordt het bijbehorende klassebestand ingeladen, een instantie van het object aangemaakt en in de array geplaatst
• Objecten worden opgehaald door de sleutel van het object door te geven aan de methode getObject

Hoe wordt voorkomen dat er een andere kopie van het registerobject wordt aangemaakt?

• De constructor is private, wat voorkomt dat een object rechtstreeks wordt aangemaakt
• Het klonen van het object veroorzaakt een foutmelding
• Als je vanuit ons framework toegang wilt krijgen tot het Register-object, maar dat niet rechtstreeks kan vanuit het huidige bestand, kun je de statische methode singleton() (Registry::singleton()) gebruiken om de instantie van het Register op te halen.

Nu we het Register hebben, laten we index.php schrijven om het framework te starten en toegang te krijgen tot het Register.

Index.php

Index.php is het startpunt van ons framework.

Later voegen we de mogelijkheid toe om SEO-vriendelijke URL's te genereren via het .htaccess-bestand. Maar laten we voorlopig de code van index.php bekijken:

<?php
/**
 * Framework
 * Framework loader - fungeert als enkel toegangspunt tot het Framework
 *
 */
  
// start de sessie
session_start();
 
// definieer enkele constanten
// Definieer de root van het framework zodat we dit overal in scripts kunnen gebruiken
define( "APP_PATH", dirname( __FILE__ ) ."/" );
// Dit gebruiken we om te voorkomen dat scripts buiten ons framework worden aangeroepen
define( "FW", true );
 
/**
 * Magische autoload-functie
 * laat toe de benodigde controller op te roepen wanneer die nodig is
 * @param String de naam van de klasse
 */
function __autoload( $class_name )
{
    require_once('Controllers/' . $class_name . '/' . $class_name . '.php' );
}
 
// laad ons register
require_once('Registry/registry.class.php');
$registry = Registry::singleton();
 
// toon de naam van het framework om te controleren of alles werkt
print $registry->getFrameworkName();
 
exit();
 
?>

Als alles goed werkt, zou het bericht met de naam van ons framework moeten worden weergegeven:

Framework version 0.1

Laten we begrijpen hoe ons index.php momenteel werkt:

• De sessie wordt gestart zodat we overal in het framework gegevens kunnen opslaan en ophalen.
• We definiëren de hoofdmap van ons framework, wat ons toelaat om niet vanuit de root van de website te werken maar vanuit een submap.
• Controllers worden geladen via autoloading.
• De Registry-klasse wordt ingeladen.
• En de naam van ons framework wordt weergegeven.