Mein eigenes MVC-Framework: Die Config-Klasse und die Konfigurationsmöglichkeiten

Die Config-Klasse ist dazu da, wichtige Einstellungen aus verschiedenen Quellen an einem zentralen Punkt (-> Also wird es eine Singleton-Klasse) verfügbar zu machen. Sie kann momentan INI-Dateien parsen und Einstellungen aus PHP-Skripts übernehmen.

Neben getInstance (Singleton) gibt es 4 wichtige Methoden:

set($key, $value)
get($key)
exists($key)
readINI($path)

get() verwendet intern die exists()-Methode. readINI greift auf die set()-Methode zurück.
Denn wenn man Code, der oft benötigt wird, in kleine Methoden packt und diese in der Klasse verwendet, hat man erstens weniger Code, zweitens mehr Übersicht und drittens kann man eine Änderung schneller vornehmen.

Es sind nur 2 Eigenschaften vorhanden, von denen die erste die Instanz der Klasse speichert:

object $instance (private)
array $configuration (private)

Im Array $configuration werden sämtliche Einstellungen abgelegt. Natürlich ist diese Eigenschaft privat, denn den Inhalt geht nur die Klasse selbst etwas an.
Die Einstellungen werden so abgespeichert:

$configuration['EINSTELLUNGSNAME'] = ‘EINSTELLUNGSWERT’;

Das hat den großen Vorteil, dass es keine Einstellungen doppelt gibt.

Wie man sieht, ist die Klasse nicht besonders komplex und daher leicht zu implementieren.

set(), get() und exists()

Als erstes schreiben wir die 3 grundlegenden Methoden.

/**
   * @access public
   * @param string key
   * @param string value
   *
   * Speichert einen neuen Wert im Array ab.
   */
  public function set($key, $value)
  {
    $this->configuration[strtolower($key)] = $value;
  }

  /**
   * @access public
   * @param string key
   * @return mixed
   *
   * Gibt 0 zurück, wenn der Key nicht vorhanden ist.
   * Ansonsten wird der wert returned
   */
  public function get($key)
  {
    if($this->exists($key))
    {
      return $this->configuration[strtolower($key)];
    }
    else
    {
      return false;
    }
  }

  /**
   * @access public
   * @param string key
   * @return bool
   *
   * Prüft, ob ein Schlüssel im Array vorhanden ist.
   * Gibt je nach dem true oder false zurück.
   */
  public function exists($key)
  {
    if(isset($this->configuration[strtolower($key)]))
    {
      return true;
    }
    else
    {
      return false;
    }
  }

Eigentlich ist der Code selbsterklärend, deshalb gehe ich nicht näher darauf ein.

INI-Dateien zur Konfiguration nutzen

Wenn wir die Möglichkeit geben wollen, ini-Dateien zu parsen, können wir das ganz einfach tun:

/**
   * @access public
   * @param string path
   *
   * Liest eine Konfigurationsdatei ins array ein.
   */
  public function readINI($path)
  {
    if(file_exists($path))
    {
      $ini = parse_ini_file($path);
      foreach($ini as $key => $value)
      {
        $this->set($key, $value);
      }
    }
    else
    {
      throw new FW_Exception("Die ini-Datei existiert nicht!");
    }
  }

PHP nimmt uns die ganze Arbeit mit parse_ini_file() ab. Statt etlichen Zeilen mit komplizierten regulären Ausdrücken brauchen wir nur eine einzige.
parse_ini_file() liefert uns ein Array zurück, welches wir mit einer foreach-Schleife durchlaufen können.
Jedes Element des Arrays wird mit

$this->set($key, $value);

in $configuration abgelegt.

Falls die in $file angegebene Datei nicht existiert, wird eine Exception vom Typ FW_Exception geworfen.

Vollständiger Code

Bevor ich zeige, wie man die Klasse verwendet, folgt hier der komplette Code:

/**
 * @licence See: /licence.txt
 */ 

/**
 * @author Simon Hessner
 * @version 1
 * @package MVC-Framework
 *
 * Singleton-Klasse
 * FW_Config ist eine Klasse, die die Einstellungen für das Framework und für die
 * einzelnen Projekte enthält.
 * Sie kann INI-Dateien parsen und die Einstellungen auslesen
 * Auch ein manuelles Setzen ist möglich.
 */
final class FW_Config
{
  /**
   * @access private
   * @var object intance
   * Speichert die Instanz (Singleton)
   */
  private static $instance = null;

  /**
   * @access private
   * @var array configuration
   * Speichert alle Einstellungen
   */
  private $configuration = array();

  /**
   * @access private
   * Singleton-Konstruktor
   */
  private function __construct()
  {
  }

  /**
   * @access private
   * Singleton __clone-Interzeptormethode
   */
  private function __clone()
  {
  }

  /**
   * @access public
   * @return object
   *
   * Methode zum Erzeugen des einzigen Config-Objektes
   */
  public static function getInstance()
  {
    if(self::$instance === null)
    {
      self::$instance = new FW_Config();
    }
    return self::$instance;
  }

  /**
   * @access public
   * @param string path
   *
   * Liest eine Konfigurationsdatei ins array ein.
   */
  public function readINI($path)
  {
    if(file_exists($path))
    {
      $ini = parse_ini_file($path);
      foreach($ini as $key => $value)
      {
        $this->set($key, $value);
      }
    }
    else
    {
      throw new FW_Exception("Die ini-Datei existiert nicht!");
    }
  }

  /**
   * @access public
   * @param string key
   * @param string value
   *
   * Speichert einen neuen Wert im Array ab.
   */
  public function set($key, $value)
  {
    $this->configuration[strtolower($key)] = $value;
  }

  /**
   * @access public
   * @param string key
   * @return mixed
   *
   * Gibt 0 zurück, wenn der Key nicht vorhanden ist.
   * Ansonsten wird der wert returned
   */
  public function get($key)
  {
    if($this->exists($key))
    {
      return $this->configuration[strtolower($key)];
    }
    else
    {
      return false;
    }
  }

  /**
   * @access public
   * @param string key
   * @return bool
   *
   * Prüft, ob ein Schlüssel im Array vorhanden ist.
   * Gibt je nach dem true oder false zurück.
   */
  public function exists($key)
  {
    if(isset($this->configuration[strtolower($key)]))
    {
      return true;
    }
    else
    {
      return false;
    }
  }
}

Die Anwendung der Klasse in einem Projekt

Die Klasse kann sehr einfach verwendet werden:

$conf = FW_Config::getInstance();
$conf->set("www_root", "http://localhost/MVC/netdevelopers/www");
$conf->set("project_classes", "../classes");
$conf->set("project_controllers", $conf->get("project_classes")."/Controller");
$conf->readINI("../config.ini");

In diesem Beispiel werden die Einstellungen www_root, project_classes, project_controllers und sämtliche Einstellungen aus der config.ini gelesen.
Die Config.ini sieht bei mir so aus:

debugger_file_logging = 1
debugger_screen_logging = 1
debugger_log_file = ../logfile.txt
debugger_handle_unimportant = 1

Wie man sieht, enthält sie nur Einstellungen zum Verhalten des Debuggers, welcher das Thema des nächsten Kapitels ist.

Übrigens wird FW_Config auch in base_config.php verwendet:

$config = FW_Config::getInstance();
$config->set("fw_path", dirname(__FILE__));
$config->set("fw_class_path", $config->get("fw_path")."/classes");

Hier wird fw_path und fw_class_path eingestellt. Diese 2 Einstellungen sind zwingend in jedem Projekt erforderlich und auch in jedem Projekt gleich. Darum stehen sie auch global in base_config.php.

Weiter zum Debugger

Keine verwandten Beiträge gefunden.

(1 Stimme, durchschnittlich 5.00 / 5)

Loading ...

Dieser Artikel wurde von Simon verfasst.
Gelesen: 2664x heute: 6x

Dieser Artikel wurde am Samstag, Oktober 18th, 2008 um 02:05 in den Kategorien Mein MVC-Framework geschrieben. Du kannst die Kommentare über den Feed (RSS 2.0) beobachten. Du kannst eine Antwort hinterlassen, oder einen Trackback von deiner Seite setzen.