Startseite >> Blog mit PHP

Blog mit PHP

Rubrik: PHP, zu den Kommentaren

Wie programmiere ich einen Blog in PHP? Diese Frage habe ich mir vor einer Weile gestellt, als ich mit der Planung dieser Seite begann. Eigentlich ist ein Weblog ja nichts anderes als eine News-Seite, so hieß das früher mal. Zumindest aus technischer Sicht, der Inhalt hebt sich evtl. von dein reinen News ab.

Da ich schon länger mit PHP programmiere und schon einige Seite mit PHP4 programmiert habe, wollte ich dieses Projekt endlich mal ordentlich objektorientiert umsetzen. Das läuft vermutlich beim ersten Versuch wiedermal nicht ganz optimal, aber man lernt ja dazu.

Als erstes habe ich meine vorhandene Bibliothek mit neuen PHP-Büchern erweitert. Es ist zwar auch möglich, sich im Web weiter zu bilden, ich persönlich halte aber von einem echten Buch aus echtem Papier deutlich mehr, als von irgendwelchen Frickel-Tutorials. Ein zweiter Aspekt für mich war, dass ich kein Framework, wie z.B. das Zend Framework, nutzen wollte. Die ganzen nützlichen Dinge, die man fertig vorfindet, wollte ich gern selbst programmieren.

Die beiden Bücher, die ich mir zugelegt habe, sind Professionelle PHP 5-Programmierung von George Schlossnagle und PHP Design Patterns von Stephan Schmidt. Gerade das zweite Buch, PHP Design Patterns, gefällt mir besonders gut, da hier der strukturelle Aufbau einer objektorientierten Software erläutert wird. Es gibt zwar kein durchgehendes Beispiel, aber einige Patterns kann man an verschiedenen Stellen gut einsetzen.

In diesem ersten Teil der Artikelreihe möchte ich zwei meiner Klassen vorstellen, die grundlegende Aufgaben übernehmen, die eigentlich in jedem PHP-Webprojekt benötigt werden.

So habe ich für die Verwaltung meiner Konfiguration eine Klasse Settings geschrieben. Diese Klasse liest die Konfiguration aus einer ini-Datei und bietet lediglich eine get()-Funktion zur Ermittlung der konfigurierten Werte. Kleiner Tipp zur Sicherheit: Du solltest sicher stellen, dass der Webserver ini-Dateien nicht ausliefert, ansonsten bist du geliefert. Also, per htaccess den Zugriff auf die Datei bzw. das Verzeichnis sperren!

(Hinweis: Wie immer sind meine Code-Beispiele nur eine Möglichkeit unter vielen und erheben keinen Anspruch auf Korrektheit)

<?php
/**
 * Klasse zur Repräsentation der Anwendungskonfiguration.
 * 
 * Die Konfiguration ist in einer ini-Datei gespeichert.
 * Diese wird in einen Array geladen - die Werte werden
 * dann über die get()-Funktion abgerufen. 
 */

class Settings{

    protected 
$settings = array();

    
/**
     * Dem Konstruktor der Klasse kann der Speicherort
     * der config-Datei übergeben werden.
     */
    
public function __construct($ini_file 'config.ini'){
        if(!
file_exists($ini_file)){
            throw new 
FileNotFound_Exception();
        }
        
$this->settings parse_ini_file($ini_filetrue);
    }
    
    
/**
     * Abrufen eines Wertes aus der Konfiguration
     */
    
public function get($variable){
        list(
$part$key) = explode('.'$variable);
        if(!isset(
$this->settings[$part][$key])){
            throw new 
SettingNotDefined_Exception();
        }
        return 
$this->settings[$part][$key];
    }
}
?>

Eine zweite Klasse, die eine zentrale Rolle spielt, ist die Klasse Registry. Diese Klasse ist als Singleton programmiert und kann in jeder Schicht der Anwendung (MVC) abgerufen werden. Es gibt halt immer Dinge, die man nicht in eine der Schichten einer Applikation einordnen kann, sondern in mehreren Schichten verfügbar sein müssen. Eine Registry-Klasse, in der solche Dinge wie die Datenbankverbindung oder auch die Settings-Klasse registriert werden können, ist da sehr hilfreich.

Die Registry ist im Prinzip sehr allgemein gehalten - jede Art von Information oder Objekt kann in ihr gespeichert werden. Für Objekte, die bei jedem Seitenaufruf auf jeden Fall gebraucht werden, habe ich spezielle Zugriffsmethoden geschrieben. Dies ist z.B. die Datenbankverbindung oder die Settings-Klasse. Diese Klassen werden bei jedem Seitenaufrug instanziert und in der Registry registriert.

<?php
/**
 * Klasse als zentralen Zugriffspunkt für Objekte und Informationen
 */

class Registry{
    
    
/**
     * Instanz dieser Klasse (Singleton)
     */
    
protected static $instance null;
    
    
/**
     * die in der Registry registrierten Werte
     */
    
protected $values = array();
    
    
/**
     * spezieller Schlüssel für die Konfiguration der Anwendung.
     * Hierfür existieren auch spezielle Zugriffsfunktionen.
     */
    
const KEY_SETTINGS 'settings';
    const 
KEY_DBH 'dbh';
    const 
KEY_SMARTY 'smarty';
    
    
/**
     * Liefert eine Instanz dieser Klasse
     */
    
public static function getInstance(){
        if(
self::$instance === null){
            
self::$instance = new Registry();
        }
        return 
self::$instance;
    }
    
    
/**
     * Konstruktor ist protected (Singleton)
     * Instanz nur über Registry::getInstance();
     */
    
protected function __construct(){}
    
    
/**
     * Klonen von außen nicht möglich (Singleton)
     * Instanz nur über Registry::getInstance();
     */
    
protected function __clone(){}
    
    
/**
     * Neuen Wert in der Registry ablegen
     */
    
public function register($key$value){
        
$this->values[$key] = $value;
    }
    
    
/**
     * Wert aus der Registry löschen
     */
    
public function unregister($key){
        if(isset(
$this->values[$key])){
            unset(
$this->values[$key]);
        }
    }
    
    
/**
     * Testen, ob ein Wert zu einem gegebenen Schlüssel registriert ist.
     */
    
public function has($key){
        if(isset(
$this->values[$key])){
            return 
true;
        }
        return 
false;
    }
    
    
/**
     * Wert aus der Registry abfragen
     */
    
public function get($key){
        if(
$this->has($key)){
            return 
$this->values[$key];
        }
        return 
null;
    }
    
    
    
/**
     * Funktion zum Registrieren der Settings
     */
    
public function registerSettings(Settings $settings){
        
$this->register(self::KEY_SETTINGS$settings);
    }
    
    
/**
     * Funktion zum Registrieren der Datenbankverbindung
     */
    
public function registerDbh(DB_Connection $dbh){
        
$this->register(self::KEY_DBH$dbh);
    }
    
    
/**
     * Funktion zum Registrieren der Smarty-Klasse
     */
    
public function registerSmarty(View_Smarty $smarty){
        
$this->register(self::KEY_SMARTY$smarty);
    }
    
    
/**
     * Funktion zum Abfragen der Settings
     */
    
public function getSettings(){
        return 
$this->get(self::KEY_SETTINGS);
    }
    
    
/**
     * Funktion zum Abfragen der Datenbankverbindung
     */
    
public function getDbh(){
        return 
$this->get(self::KEY_DBH);
    }
    
    
/**
     * Funktion zum Abfragen der Smarty-Klasse
     */
    
public function getSmarty(){
        return 
$this->get(self::KEY_SMARTY);
    }
}

?>

Die beiden Klassen werden bei jedem Seitenaufruf instanziert. Ein extra Skript (heißt bei mir basics.php) von jeder Seite per require_once() abgearbeitet. Benutzt werden die Klassen folgendermaßen:

Ausschnitt aus basics.php:

<?php
/**
 * Registry initialisieren
 */
$registry Registry::getInstance();

/**
 * Settings erzeugen und gleich registrieren
 */
try{
    
$settings = new Settings($document_root 'conf/config.ini');
}catch(
FileNotFound_Exception $e){
    
// Fehlerbehandlung
}
$registry->registerSettings($settings);
?>

Benutzung an beliebiger Stelle in der Anwendung:

<?php
$registry 
Registry::getInstance();
$settings $registry->getSettings();
try{
    
$value $settings->get('nice.value');
}catch(
SettingNotDefined_Exception $e){
    
// Fehlerbehandlung
}
?>

So, dies war Teil 1 meiner kleinen Rundreise durch meine eigene Seite. Ich hoffe, dass ich die Zeit finde, noch viele weitere technische Erklärungen zur Blogprogrammierung zu schreiben.

yigg

0 Kommentare zu: Blog mit PHP

Einen Kommentar schreiben






Captcha

Buch-Box

PHP Design Patterns
Ein wunderbares Buch über die objektorientierte Software-Entwicklung. Es wird von einfachen Pattern wie Singleton und Factory über Struktur- und Verhaltensmuster bis hin zu Patterns für den Enterprise-Bereich alles behandelt. Ich kenne kein vergleichbar gutes PHP-Buch über Software-Design.
Mehr Informationen bei:
Amazon.de

Professionelle PHP 5-Programmierung
Entwicklerleitfaden für große Webprojekte mit PHP 5

Umfangreiches Buch über alle möglichen (auch fortgeschrittenen) Themen, mit denen man bei der Webentwicklung konfrontiert wird. U.a. Tests, Caching, Performance, aber zum Beispiel auch Standalone-Skripte.
Mehr Informationen bei:
Amazon.de

Beiträge nach Rubrik
Amazon.de: Bestseller RSS