1.4. Beginn der Entwicklung des MVC-Frameworks

Wir haben bereits ausführlich beschrieben, was unser Framework beinhalten soll. Nun ist es Zeit, unser Framework zu implementieren. Zunächst benötigen Sie einen Webserver. Sie können Denwer ausprobieren, müssen jedoch möglicherweise PHP aktualisieren.

Denwer mit PHP 5.5.20 können Sie von dieser Seite herunterladen:

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

Oder von GitHub:

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

Die Ausführung unseres Frameworks beginnt mit der Datei index.php, welche Instanzen aus dem Registry-Objekt zurückgibt, den benötigten Controller aufruft und ihm die Registry-Ergebnisse übergibt. Der Controller kann seinerseits die erforderlichen Modelle aufrufen.

Implementierung der Patterns

Es gibt mehrere Wege, die besprochenen Patterns zu implementieren. Wir wählen eine mögliche Variante, Sie können die Umsetzung später jederzeit ändern.

Los geht's: In einem der vorherigen Artikel haben wir die Struktur unseres Frameworks besprochen, deshalb müssen wir nur noch die entsprechenden Ordner gemäß dieser Struktur erstellen.

Erstellen Sie nun die Datei Registry/registry.class.php. In dieser Datei schreiben wir die Klasse für unser Registry-Objekt.

<?php
/**
 * Registry-Objekt
 * Implementiert das Registry- und Singleton-Pattern
 *
 */
class Registry {
     
    /**
     * Array unserer Objekte
     * @access private
     */
    private static $objects = array();
     
    /**
     * Array unserer Einstellungen
     * @access private
     */
    private static $settings = array();
     
    /**
     * Lesbarer Name unseres Frameworks
     * @access private
     */
    private static $frameworkName = 'Framework version 0.1';
     
    /**
     * Instanz unseres Registry
     * @access private
     */
    private static $instance;
     
    /**
     * Privater Konstruktor
     * @access private
     */
    private function __construct()
    {
     
    }
         
    /**
     * Singleton-Methode für Zugriff auf die Instanz
     * @access public
     * @return Registry
     */
    public static function singleton()
    {
        if( !isset( self::$instance ) )
        {
            $obj = __CLASS__;
            self::$instance = new $obj;
        }
         
        return self::$instance;
    }
     
    /**
     * Verhindert das Klonen des Objekts
     */
    public function __clone()
    {
        trigger_error( 'Cloning the registry is not permitted', E_USER_ERROR );
    }
     
    /**
     * Speichert ein Objekt im Registry
     * @param String $object Klassenname
     * @param String $key Schlüssel
     * @return void
     */
    public function storeObject( $object, $key )
    {
        require_once('objects/' . $object . '.class.php');
        self::$objects[ $key ] = new $object( self::$instance );
    }
     
    /**
     * Gibt ein Objekt aus dem Registry zurück
     * @param String $key Schlüssel
     * @return object
     */
    public function getObject( $key )
    {
        if( is_object ( self::$objects[ $key ] ) )
        {
            return self::$objects[ $key ];
        }
    }
     
    /**
     * Speichert eine Einstellung
     * @param String $data
     * @param String $key Schlüssel
     * @return void
     */
    public function storeSetting( $data, $key )
    {
        self::$settings[ $key ] = $data;
    }
     
    /**
     * Gibt eine Einstellung zurück
     * @param String $key Schlüssel
     * @return mixed
     */
    public function getSetting( $key )
    {
        return self::$settings[ $key ];
    }
     
    /**
     * Gibt den Namen des Frameworks zurück
     * @return String
     */
    public function getFrameworkName()
    {
        return self::$frameworkName;
    }
     
}
 
?>

Wie funktioniert unser Registry und wie speichert es Objekte?

• Objekte werden in einem Array gespeichert
• Wenn ein neues Objekt im Registry abgelegt wird, wird die Klassendatei geladen, eine Instanz erzeugt und dem Array hinzugefügt
• Objekte werden über den Schlüssel an die Methode getObject zurückgegeben

Wie wird verhindert, dass eine weitere Instanz des Registry-Objekts erstellt wird?

• Der Konstruktor ist private, sodass kein Objekt direkt erstellt werden kann
• Das Klonen des Objekts löst einen Fehler aus
• Wenn Sie von außerhalb Zugriff auf das Registry-Objekt benötigen, können Sie die statische Methode singleton() verwenden, also Registry::singleton(), um die Instanz zu erhalten.

Nun, da wir ein Registry haben, schreiben wir index.php, um unser Framework zu starten und auf das Registry zuzugreifen.

Index.php

index.php ist der Startpunkt unseres Frameworks.

Später fügen wir noch Suchmaschinen-freundliche URLs mit einer .htaccess-Datei hinzu. Für den Moment sehen wir uns den Code in index.php an:

<?php
/**
 * Framework
 * Framework Loader - zentrale Zugangsstelle zum Framework
 *
 */
  
// Session starten
session_start();
 
// Konstanten definieren
// Wurzelverzeichnis des Frameworks, damit es von überall aus zugreifbar ist
define( "APP_PATH", dirname( __FILE__ ) ."/" );
// Konstantante zum Schutz vor fremden Skripten
define( "FW", true );
 
/**
 * Autoload-Funktion
 * Lädt benötigten Controller automatisch
 * @param String Klassenname
 */
function __autoload( $class_name )
{
    require_once('Controllers/' . $class_name . '/' . $class_name . '.php' );
}
 
// Registry laden
require_once('Registry/registry.class.php');
$registry = Registry::singleton();
 
// Framework-Namen ausgeben, um zu testen, ob alles funktioniert
print $registry->getFrameworkName();
 
exit();
 
?>

Wenn alles korrekt ist, wird die Meldung ausgegeben:

Framework version 0.1

Wie funktioniert die index.php aktuell?

• Session wird gestartet, damit Daten im gesamten Framework gespeichert und abgerufen werden können
• Das Wurzelverzeichnis des Frameworks wird definiert, sodass das Framework auch in Unterordnern funktioniert
• Controller werden automatisch über __autoload geladen
• Die Registry-Klasse wird eingebunden
• Der Name des Frameworks wird ausgegeben