PHP Blogger

Um eine Applikation schnell und einfach dynamisch um Funktionen zu erweitern kommen oft Hook- oder Callback-Funktionen zum Einsatz. Typo3 macht davon Gebrauch, die WordPress Entwickler lieben sie und auch bei Cake oder RubyOnRails kommen sie zum Einsatz.

Genau genommen sind Hook-Funktionen und Callback-Funktionen ein und das selbe. Sie werden aufgerufen, wenn eine bestimmte Aktion durchgeführt wird, wurde oder werden soll. Die zwei beliebtesten Typen von Hook-Funktionen sind folgende:

• Vererbte oder Abstrakte Funktionen: Eine gängige OOP Technik, bei der eine Funktion abstrakt oder mit einem Default-Verhalten definiert wird, das von einer Kind-Klasse übernommen oder überschrieben wird.
• Callback-Stack: Bei dieser Art registrieren sich Objekte bei einem Objekt, das den Callback-Funktionen-Stack verwaltet. Wird ein Ereignis ausgelöst, werden die zu dem Ereignis registrierten Objektfunktionen der Reihe nach aufgerufen.

Der Callback-Stack funktioniert so ähnlich wie das Observer-Muster. Zunächst nehmen wir aber die vererbbaren Hooks unter die Lupe. Hier erstmal eine einfache Basisklasse:

class File
{
    var $data; 

    function ReadFile($fn)
    {
        $tmp= file_get_contents($fn);
        $this->data= $tmp;
    } 

    function WriteFile($fn)
    {
        $tmp= $this->data;
        $fh= fopen($fn, 'w');
        $fwrite($fh, $tmp);
        $fclose($fh);
    }
}

Soweit, so gut. Bewusst werden die Daten erst mal in eine Temp-Variable gelesen. Denn die Hook-Funktionen fehlen ja noch. Wir fügen also folgende Funktionen der Basisklasse hinzu:

function &AfterOpen(&$data)
{
    return $data;
} 

function &BeforeSave(&$data)
{
    return $data;
}

Jetzt jetzt verändern wir in den beiden Hauptfunktionen die folgenden Funktionsaufrufe:

...
function ReadFile($fn)
{
    ...
    $this->data= $this->AfterOpen(&$tmp);
} 

function WriteFile($fn)
{
    $tmp= $this->BeforeSave(&$this->data);
    ...
}
...

Jetzt ist es wunderbar möglich, die Speicheroutine an eigene Dateistrukturen anzupassen. Einfach ein Kind der Klasse erschaffen und die Defaultfunktionen mit einer eigenen Implementierung überschreiben. Zum Beispiel so:

class PhpStructureFile extends File
{
    function &AfterOpen(&$data)
    {
        return unserialize($data);
    } 

    function &BeforeSave(&$data)
    {
        return serialize($data);
    }
}

Und schon ist es möglich, schnell und einfach eigene Dateitypen zu implementieren. Mit den Hook-Funktionen kann man noch viel mehr Unsinn treiben, welchen erfährst Du bald im nächsten Teil…