[Chr!s]

Ein simples Caching System mittels Dateien

Ein kurzes Vorwort
Diese Tutorial zeigt eine von sicherlich mehreren Methoden, wie man bestimmte Werte wie Daten aus einer Datenbank (Arrays oder Objekte), aber auch statische Inhalte, wie z.B. komplette Seiten bzw. einzele Teilbereiche mittels PHP und Dateien cachen kann. Der PHPCode ist eine PHP4 Klasse. Ganz einfach aus dem Grund, weil zu viele Leute noch PHP4 auf ihren Servern laufen haben und ich Fragen zu "warum geht der Code nicht" einfach vorgreifen wollte. Zum besseren Verständnis habe ich die Klasse und die Methoden auf deutsch dokumentiert. Am Ende dieses Tutorials sind noch 2 Beispiele angegeben, um die Klasse zu testen.

Inhaltsverzeichnis

1. Grundlegende Überlegungen zum Thema Caching
2. Aufbau der Caching-Klasse
3. Die Caching-Funktionen im Detail
4. Zwei einfache Anwendungsbeispiele
5. Ein kurzes Schlusswort

[Chr!s]

1. Grundlegende Überlegungen zum Thema Caching
Was ist dieses "Caching" eigentlich und wozu brauche ich es?
Die Art des Cachings, die in diesem Tutorial angesprochen wird, wird dazu benutzt um den eigenen Server zu entlasten. Jede etwas größere Seite (Communities, aber auch Blogs etc) ist meistens so konzepiert, dass sie dynamische Inhalte und/oder Daten benötigt, beispielsweise aus einer Datenbank wie MySQL. Je mehr und komplexer diese Abfragen sind, desto mehr muss der dahinterstehende Server selbstverständlich arbeiten. Das Caching kann dem Server diese Arbeit abnehmen, indem es bestimmte Inhalte, die nicht jedesmal neu geladen werden müssen, statisch abspeichert (z.B. in einer Datei) und daraus ausliest.

Dabei wird eine maximale Lebensdauer dieser Cachedaten angegeben. Beim überschreiten dieser Zeit, werden diese gecachten Daten gelöscht, erneut aus der Datenbank ausgelesen und in den Cache geschrieben. Es gibt aber auch die Möglichkeit die Daten solange im Cache zu behalten, bis sie geändert werden (z.B. bei gecachten News ein neuer Newseintrag vom Admin).

Dazu ein kleines Beispiel:
In einer großen Community (> 1000 User) hat jeder User ein eigenes Profil. Erfahrungsgemäß ändert ein User sein Profil nicht sehr oft. Hier wäre ein optimaler Punkt, das Caching einzusetzen. Das Profil wird also gecached, und so lange im Cache behalten, bis der User sein Profil ändert. Tut er dies, so wird der Cache einfach neu beschrieben und wieder so lange behalten, bis dieser User wieder etwas ändert. So erstpart man dem Server eine (oder mehr) komplexe Abfragen an die Datenbank, denn meistens sind die Userprofile gespickt mit Daten, die verteilt in der Datenbank liegen (z.B. Username, Alter, Bilder, Usergruppe, etc), denn Profile werden viel öfter aufgerufen, als dass sie geändert werden.

[Chr!s]

2. Aufbau der Caching-Klasse
Nun aber zum konkreten PHPCode.
Wie in dem Vorwort schon beschrieben, werde ich die Klassen so schreiben, dass Sie kompatibel zu PHP4 sind, da diese Version doch noch auf vielen Servern vorhanden ist. Um alle oben genannten Funktionen umzusetzen, werden folgende Methoden benötigt:

PHP-Code:

<?php
error_reporting(E_ALL);
ini_set('display_errors', true);

class Cache {
        // Gibt an, ob die Dateinamen mit sha1 gehasht werden  sollen, oder nicht
        var $bHashFilenamesSHA1 = true;

        // Die Lebenszeit in Sekunden (1800 Sekunden = 30 Minuten)
        var $iDefaultLifetime = 1800;

        // Der Pfad zu den Cache-Dateien (absolut oder relativ)
        var $sCachePath = './cache/';

        // Die Dateierweiterung für die Cache-Dateien (z.B. ".cache")
        var $sFileExtension = '.cache';

        // Konstruktor der Klasse
        function Cache()

        // Löscht abgelaufene Cache-Einträge
        function cleanUpCache()

        // Löscht einen bestimmten Cache-Eintrag
        function deleteCache()

        // Gibt den Dateinamen zu einer Cache-Datei zurück
        function getFileName()

        // Liest Daten aus dem Cache, sofern dieser existiert und noch gültig ist
        function readCache()

        // Lösch alle im Cache vorhandenen Daten
        function truncateCache()

        // Schreibt die Daten in den Cache
        function writeCache()
}
?>

[Chr!s]

3. Die Caching-Funktionen im Detail
Bevor ich auf die Funktionen im Einzelnen eingehe, werde ich noch etwas über die allgemein Funktionalität dieser Cache-Klasse eingehen.
Der Klasse ist es egal, was für Daten ihr zum Cachen gegeben werden. Seien es Arrays, Objekte, reiner Text, HTML (was ja "reinem" Text entspricht). Durch das Einsetzen der Funktion serialize() bzw unserialize() werden die übergebenen Daten in ein einheitliches Format gebracht und im Cache gespeichert. Dabei wird jedem Eintrag ein Timestamp ("Zeitstempel" in Sekunden) angehängt, welcher angibt, wie lange der Eintrag haltbar ist (die sog. lifetime).

Machen wir uns zuerst an den Konstruktor der Klasse, die Funktion Cache().
Diese Funktion braucht weder Parameter noch sonst etwas, sie dient lediglich dazu, den angegebenen Cache-Pfad mittels der Funktion realpath() zu einem absoluten Pfad umzuwandeln. Einige Betriebtssysteme ärgern sich über relative Pfadangaben ( wie z.B. './cache/' anstatt von '/etc/home/user123/script/cache/' ) oder streiken gar komplett. Nun aber an die Funktion:

PHP-Code:

<?php
        /**
         * Konstruktor der Klasse
         *
         */
        function Cache() {
                // Wandelt den eingegebenen Pfad in einen absoluten Pfad um
                $this -> sCachePath = realpath($this -> sCachePath);
        }
?>

Dem ist eigentlich auch nicht mehr hinzuzufügen (ist ja auch noch nicht so komplex ).
Um nun nicht jedesmal sämtliche Pfadangaben usw tippen zu müssen, hab ich eine kleine Helfer-Funktion erstellt, die einem jedesmal den benötigten Dateinamen inklusive Pfadangabe zurückgibt. Falls gewünscht, wird der Cache-Name mittels der Funktion sha1() gehasht. Diese Methode trägt den Namen getFileName.

PHP-Code:

<?php
        /**
         * Gibt den Dateinamen inklusive Pfadangabe zurück
         * Auf Wunsch wird dieser Dateiname mittels der Funktion sha1() gehasht.
         *
         * @param string $sCacheName
         * @return string
         */
        function getFileName($sCacheName) {
                $sFileIdentifier = ($this -> bHashFilenamesSHA1 === true) ? sha1($sCacheName) : $sCacheName;
                return $this -> sCachePath . DIRECTORY_SEPARATOR . $sFileIdentifier . $this -> sFileExtension;
        }
?>

Nun kommen wir zu eine der Hauptmethoden der Cache-Klasse. Schließlich würde ohne diese Methode gar nichts gehen: Sie liest die Daten aus dem Cache.
Nun, so simpel ist das Ganze dann doch wieder nicht, schließlich müssen ein paar Problemfälle durchgegangen werden, bevor der Cache wirklich gelesen werden kann. Dabei hat die Methode zwei Möglichkeiten, einen Wert zurückzugeben: false, wenn das Vorhaben gescheitert ist, und mixed (also entweder ein string, ein array, ein Objekt ..), wenn die Funktion erfogreich war und die Daten lesen konnte. Ich werde diese Funktion hier Schritt für Schritt durchgehen, mit ein paar Worten zu jedem Abschintt. Fangen wir also an, mit der Methode namens readCache().

PHP-Code:

<?php
        /** 
         * Liest die Daten aus dem Cache, falls diese existieren
         * und noch gültig sind.
         *
         * @param string $sCacheName
         * @return boolean (if not succeeded) | mixed (if succeeded)
         */
        function readCache($sCacheName) {
                // Leere Cache-Eintrag-Namen sind nicht erlaubt :-)
                if(trim($sCacheName) == '') {
                        return false;
                }

                // Der Cache-Name ist also nicht leer, nun wird
                // der Dateiname inklusive Pfad generiert
                $sFileName = $this -> getFileName($sCacheName);

                // Nun müssen wir prüfen, ob die Datei überhaupt
                // existiert.. Wenn nicht, wird die Funktion abgebrochen
                // und false zurückgegeben.
                if(file_exists($sFileName) === false) {
                        return false;
                }

                // Hier müssen wir prüfen, ob die Datei lesbar ist.
                // Wenn nicht, wird die Funktion ebenfalls abgebrochen
                // und false zurückgegeben.
                if(is_readable($sFileName) === false) {
                        return false;
                }
?>

Bis dahin war es noch nicht wirklich schwer, oder?
Jetzt haben wir schonmal geprüft, ob die Datei wirklich da ist, und sie lesbar ist. Jetzt steht uns eigentlich nichts mehr im Weg.
Öffnen wir nun diese Datei, und lesen deren Inhalt aus:

PHP-Code:

<?php
                $rHandle = @fopen($sFileName, 'r');
                if(is_resource($rHandle) === false) {
                        // Falls troztdem etwas schiefgegangen ist,
                        // gib wieder false zurück
                        return false;
                }

                // Jetzt haben wir die Datei geöffnet, nun sperren wir sie
                flock($rHandle, LOCK_SH);

                // Nun lesen wir die Daten aus ..
                $sData = '';
                while(!feof($rHandle)) {
                        $sData .= fread($rHandle, 4096);
                }

                // und schließen diese Datei wieder (wichtig!).
                fclose($rHandle);
?>

Mittels der Funktion flock() sperren wir die Datei kurzzeitig. Um weiteres nachzulesen, schaut bitte im Manual unter dem gegebenen Link nach.

Die hauptsächliche Arbeit findet nun in den nächsten Codezeilen statt.
Hier werden die Cache-Daten wieder ent-serialisiert ( unserialize() ). Wie bereits am Anfang des Tutorials beschrieben, wird an jede Cache-Datei ein Timestamp angehängt, der die Lebensdauer des Cache-Eintrages angibt. Dieser muss nun ausgelesen werden, und es muss geprüft werden, ob der Cache-Eintrag überhaupt noch gültig ist. Wenn ja, kann er zurückgegeben werden - wenn nicht, wird der Cacheeintrag gelöscht, und die Methode wird false als Rückgabewert liefern:

PHP-Code:

<?php
                // Nun ent-serialisieren wir die gegebenen Daten
                $mData = @unserialize($sData);

                // Falls beim ent-serialisieren etwas schiefgelaufen ist,
                // oder der aktuelle Zeitstempel bereits größer als der
                // im Cache ist (d.h. der Cache ist verfallen) wird
                // die Datei gelöscht, und es wird false zurückgegeben.
                if(!$mData or time() > $mData[0]) {
                        // Delete that file and return false
                        $this -> deleteCache($sCacheName);
                        return false;
                }
?>

Und wenn dann letztendlich alles gut gelaufen ist, brauchen wir die Daten nur noch zurückzugeben:

PHP-Code:

<?php
                return $mData[1];
        }
?>

Ab diesem Punkt sind wir fähig, die gespeicherten Cache-Daten auszulesen. Doch das nützt selbstverständlich nicht viel, wenn wir dieselbigen nicht schreiben können. Kommen wir nun zu unserer Methode, die genau diese Arbeit übernimmt: Die Methode writeCache().
Diese hat die Aufgabe, die übergebenen Daten (sofern welche vorhanden sind) zu serialisieren ( serialize() ) und in den Cache zu schreiben. Optional kann dabei die speziell für diesen Cache-Block gewünschte Lebensdauer angegeben werden.

PHP-Code:

<?php
        /**
         * Schreibt die übergebenen Daten in den Cache
         *
         * @param string $sCacheName
         * @param mixed $mData
         * @param integer $iLifetime ( in seconds )
         * @return boolean
         */
        function writeCache($sCacheName, $mData, $iLifetime = -1) {
?>

Auch hier benötigen wir wieder einige Prüfroutinen um festzustellen, ob die übergebenen Daten gültig und/oder überhaupt vorhanden sind:

PHP-Code:

<?php
                if(is_int($iLifetime) === false or $iLifetime < 0) {
                        // Falls der übergebene Lebensdauer-Wert keine Zahl
                        // ist oder kleiner Null, wird der standardmäßige Wert
                        // genommen
                        $iLifetime = $this -> iDefaultLifetime;
                }

                // Hier wird wieder der Dateiname zusammengebaut
                $sFileName = $this -> getFileName($sCacheName);
?>

So weit, so gut.
Im nächsten Schritt werden wir die Datei versuchen zu öffnen. Falls dies misslingt, wird die Funktion den boolschen Werrt false zurückgeben. Gelingt es die Datei zu öffnen oder gar neu anzulegen, wird die Datei gesperrt (sodass kein anderer Prozess in diesem Moment auf die Datei zugreifen kann), und mittels der Funktion ftruncate() geleert:

PHP-Code:

<?php
                // Wir versuche die Datei zu öffnen
                $rHandle = @fopen($sFileName, 'a');

                // Falls dies nicht gelungen ist, geben wir false zurück
                if(is_resource($rHandle) === false) {
                        return false;
                }

                // Danach sperren wir die Datei, um eventuelle
                // race-conditions zu vermeiden
                flock($rHandle, LOCK_EX);

                // Nun leeren wir die Datei
                ftruncate($rHandle, 0);
?>

Nun werden die übergebenen Daten ($mData) mittels der Funktion serialize() zu einem String serialisiert:

PHP-Code:

<?php
                $sSerializedData = serialize(array( (time() + $iLifetime), $mData));
?>

Hier wird deutlich, wie das Verfallsdatum angehängt wird: Es wird ein Array mit dem ersten Element als Verfallszeit generiert. Hinten daran wird der restliche Code einfach angehängt. Wir erinnern uns an die Methode readCache(), wo wir in dem ArrayElement $mData[0] das Verfallsdatum stehen haben, und die gecachten Dateien mit $mData[1] zurückgeben. Genau diese Aufteilung geschieht nämlich hier. Der Rest der Methode ist keine große Kunst mehr. Wir müssen lediglich die Daten in der Cache-Datei speichern, die Datei schließen, und true zurückgeben, wenn alles funktioniert hat:

PHP-Code:

<?php
                // Nun schreiben wir die neuen Cache-Daten
                // (oder versuchen es zumindest)
                if(@fwrite($rHandle, $sSerializedData) === false) {
                        // Sollte hier an dieser Stelle ein Fehler auftreten,
                        // wird false zurückgegeben
                        return false;
                }

                fclose($rHandle);
                return true;
        }
?>

Nun wird es allerdings schon etwas aufwändiger. Die nächte Methode cleanUpCache ist wie der Name schon dazu sagt da, den Cache aufzuräumen. Sie sucht nach abgelaufenen Cache-Einträgen (bzw Dateien) und löscht diese. Dadurch, dass jede Cache-Datei eine eigene Lebensdauer haben kann, muss die Funktion jede einzelne Cache-Datei öffnen und deren Lebenszeit auslesen. Ein einheitliches Prüfen mit der Funktion filemtime() ist aus diesem Grund nicht möglich. Hier die dokumentierte Funktion:

PHP-Code:

<?php
        /**
         * Säubert die Cache-Daten
         *     - Sucht nach alten, abgelaufenen Cache-Daten und entfernt diese
         *     - Gibt die Anzahl der gelöschten Cache-Einträge zurück
         *
         * @return integer
         */
        function cleanUpCache() {
                // Suche nach allen Dateien, die zum Cache gehören
                $aFiles = glob($this -> sCachePath . DIRECTORY_SEPARATOR . '*' . $this -> sFileExtension);

                // Falls keine Dateien verfübar sind 
                if(count($aFiles) < 1) {
                        // gib 0 zurück (0 Dateien wurden entfernt)
                        return 0;
                }

                $iCounter = 0;
                // Nun, es gibt mindestens eine Datei ...
                foreach($aFiles as $sFileName) {
                        // Datei versuchen zu öffnen ..
                        $rHandle = @fopen($sFileName, 'r');
                        if(is_resource($rHandle) === false) {
                                continue;
                        }

                        // Da die Verbindung nun steht, wird diese Datei
                        // tempoär gesperrt
                        flock($rHandle, LOCK_SH);

                        // Lesen wir die Daten ein ...
                        $sData = '';
                        while(!feof($rHandle)) {
                                $sData .= fread($rHandle, 4096);
                        }

                        $mData = @unserialize($sData);
                        if(!$mData) {
                                // Es ist wohl etwas schief gelaufen,
                                // weiter mit der nächsten Datei
                                continue;
                        }

                        if(time() + $this -> iDefaultLifetime > $mData[0]) {
                                // Die Lebenszeit ist abgelaufen,
                                // also wird dieser Cache-Eintrag gelöscht
                                fclose($rHandle);
                                if($this -> deleteCache($sFileName, true) === true) {
                                        $iCounter ++;
                                }
                        }

                        else {
                                // Die Datei ist noch gültig,
                                // weiter mit der nächsten Datei
                                fclose($rHandle);
                        }

                }

                // Jetzt nur noch die Anzahl der gelöschten Dateien
                // zurückgeben, fertig.
                return $iCounter;
        }
?>

Diese Funktion ist einfach dafür gedacht, etwas aufzuräumen. Es gibt noch eine weitere Methode die uns ermöglicht, aufzuräumen: Die Methode truncateCache(). Diese geht allerdings nicht so behutsam vor wie cleanUpCache(). truncateCache() löscht sämtliche Cache-Dateien und nimmt keine Rücksicht auf das Verfallsdatum. Dementsprechen ist diese auch relativ einfach gestrickt:

PHP-Code:

<?php
        /**
         * Diese Funktion löscht jedliche Cache-Einträge, die zu finden sind 
         * und nimmt dabei keine Rücksicht auf die Verfallsdaten
         * der jeweiligen Dateien.
         *
         * @return integer
         */
        function truncateCache() {
                // Suche nach allen Dateien, die zum Cache gehören
                $aFiles = glob($this -> sCachePath . DIRECTORY_SEPARATOR . '*' . $this -> sFileExtension);

                // Falls keine Dateien verfübar sind ..
                if(count($aFiles) < 1) {
                        // .. geben wir 0 zurück (integer), denn die Funktion
                        // gibt die Anzahl der gelöschten Dateien zurück
                        return 0;
                }

                // gib 0 zurück (0 Dateien wurden entfernt)
                $iCounter = 0;

                // Nun, es gibt mindestens eine Datei ...
                foreach($aFiles as $sFileName) {
                        // Jetzt prüfen wir nicht, ob der Eintrag gültig ist
                        // oder nicht - sondern löschen ihn einfach :-)
                        if($this -> deleteCache($sFileName, true) === true) {
                                $iCounter ++;
                        }

                }

                // Zuletzt geben wie die Anzahl der gelöschten
                // Dateien zurück
                return $iCounter;
        }
?>

Alle ungültigen Cache-Einträge zu löschen ist ja schön und gut, und sicherlich auch einmal praktisch, doch was, wenn man nur einen bestimmten Cache-Eintrag löschen möchte? Richtig, dazu brauch es einer anderen Funktion, der Funktion deleteCache().
Diesmal müssen wir aber nicht prüfen, ob der Cache-Eintrag schon abgelaufen ist, denn das spielt hier keine Rolle. Wir müssen lediglich die Datei löschen, sofern sie überhaupt existiert.

PHP-Code:

<?php
        /**
         * Löscht einen existierenden Cache-Eintrag
         *
         * @param string $sCacheName
         * @param boolean $bIsFileName
         * @return boolean
         */
        function deleteCache($sCacheName, $bIsFileName = false) {
                // Falls der übergebene Wert kein Dateiname ist,
                // muss dieser erst generiert werden
                if($bIsFileName === false) {
                        $sFileName = $this -> getFileName($sCacheName);
                }

                else {
                        // Ansonsten kann der Name 1:1 übernommen werden
                        $sFileName = $sCacheName;
                }

                // Löscht die Datei und gibt bei Erfolg "true",
                // bei Misserfolg "false" zurück.
                return @unlink($sFileName);
        }
?>

Eine Prüfung, ob die Datei existiert, ist hier unnötig. Ein eventuell auftretender Fehler wird hier absichtlich unterdrückt. Eventuelle Fehlerbehandlung sollte zusätzlich eingebaut werden. Der boolsche Wert $bIsFileName ist standardmäßig auf false, wird aber unter bestimmten Umständen in der Methode cleanUpCache() zu true gesetzt. Nämlich genau dann, wenn der Dateiname bereits gebildet wurde.

Was wir natürlich nicht vergessen dürfen ist, die Klasse zu beenden:

PHP-Code:

<?php
}
?>

Und somit haben wir unsere komplette kleine Cache-Klasse fertig.
Sicherlich lässt sich diese noch ausbauen, aber für ein kleines und simples System müsste diese Ausführung ausreichen.

[Chr!s]

4. Zwei einfache Anwendungsbeispiele
Selbstverständlich kann ich diese Klasse nicht einfach so auf sich beruhen lassen. Deshalb hier zwei kleine Anwendungsbeispiele, einmal für Daten wie Text, HTML, etc, und einmal eins für Arrays, Objekte, was auch immer.

Beispiel 1:

PHP-Code:

<?php
// In diesem Beispiel prüfen wir, ob ein CacheEintrag mit dem Namen
// "einTestCacheEintrag" vorhanden ist.
// Wenn ja, wird dieser der Variable $sContent übergeben -
// wenn nicht, wird diese Variable mit den benötigten Daten gefüllt
// (beispielsweise aus der Datenbank), und anschließend in den Cache
// geschrieben.
$oCache = new Cache;
$sCacheName = 'einTestCacheEintrag';

if ( ($sContent = $oCache -> readCache($sCacheName)) === false) {
        $sContent = '<h2>Ich bin der Testeintrag. Ich werde aus der Datenbank geholt, oder von sonst woher.</h2>';
        $oCache -> writeCache($sCacheName, $sContent);
        echo 'Der Cache-Eintrag zu ' . $sCacheName . ' existiert nicht (mehr) und wurde daher neu angelegt.<br />';
}

else {
        echo 'Der Cache-Eintrag zu ' . $sCacheName . ' existiert und wurde ausgelesen.<br />';
}

echo $sContent;
?>

Beispiel 2:

PHP-Code:

<?php
$oCache = new Cache;
$sCacheName = 'staticUserData';

if( ($aStaticUserData = $oCache -> readCache($sCacheName)) === false) {
        // Es existiert (noch) kein Cache-Eintrag.
        // Diese Daten sind nur simuliert, sollten aus der Datenbank kommen,
        // oder aus deine XML Datei, oder oder oder ...
        $aStaticUserData = array('iRegisteredUser' => 1029,
                                 'sCommunityName' => 'Meine Community',
                                 'aLast10DaysCounterStatistics' => array('iYesterday' => 1234,
                                                                         'iDayBeforeYesterday' => 1392,
                                                                         'iThreeDaysAgo' => 928));

        // Diese Informationen werden nun in den Cache geschrieben,
        // und zwar mit einer Lebensdauer von 24 Stunden
        // (60 Sekunden * 60 Minuten * 24 Stunden)
        $oCache -> writeCache($sCacheName, $aStaticUserData, (60 * 60 * 24));

        echo 'Der Cache-Eintrag zu ' . $sCacheName . ' existiert nicht (mehr) und wurde daher neu angelegt.<br />';
}

else {
        echo 'Der Cache-Eintrag zu ' . $sCacheName . ' existiert und wurde ausgelesen.<br />';
}

echo '<pre>';
print_r($aStaticUserData);
echo '</pre>';
?>

[Chr!s]

5. Ein kurzes Schlusswort
Ich wäre sehr dankbar für jedliches Feedback, sowohl Lob, als auch Kritik sind herzlichst Willkommen.