3.2 Cache 

PEAR::Cache ist ein sehr flexibler, leistungsfähiger Cache, der in vielen PEAR-Paketen Verwendung findet und Sie auf vielfältige Weise unterstützen kann.

Cache kann verschiedene Arten von Informationen zwischenspeichern. Zum Ablegen der Daten können Sie sowohl auf Dateien als auch auf Datenbanken zurückgreifen.

Cache besteht aus verschiedenen Klassen, die auf unterschiedliche Anwendungsfälle spezialisiert sind. Jeder der Konstruktoren erwartet als ersten Parameter den Typ des Speichercontainers, der genutzt werden soll. Der Container ist der Ort, an dem die gecachten Daten gespeichert werden. Als zweiten Parameter erwarten die Konstruktoren jeweils ein assoziatives Array mit Parametern.

Zurzeit haben Sie die Möglichkeit, die Daten in den folgenden Containern zu speichern:

• file Die Daten wurden in einer Datei abgelegt. Für das Array mit Optionen können Sie den Schlüssel cache_dir nutzen, um zu definieren, in welchem Verzeichnis die Dateien abgelegt werden sollen. Mit dem Array-Element filname_prefix können Sie ein Präfix übergeben, das allen Dateien vorangestellt wird.

• db Mit db wird PEAR::DB zum Ablegen der Daten genutzt. Mit dem Schlüssel dsn muss in dem Options-Array eine gültige DSN übergeben werden, mit der die Datenbank angesprochen werden kann. Des Weiteren können Sie mit cache_table einen Tabellennamen angeben, wenn die Tabelle nicht cache heißen sollte.

• mdb Mit dieser Auswahl wird PEAR::MDB zum Verbindungsaufbau zur Datenbank genutzt. Als Parameter müssen Sie im Array-Element dsn einen gültigen DSN oder ein Array mit Optionen übergeben, wie PEAR::MDB es akzeptiert.

• phplib Wenn Sie phplib als Container nutzen, geht das System davon aus, dass der Datenbankabstraktionslayer der PHPLIB genutzt werden soll. In diesem Fall muss in dem nachfolgenden Array der Schlüssel db_class den Namen der Datenbank-Klasse enthalten. Des Weiteren können Sie optional mit dem Element db_file den Namen einer Datei übergeben, in der die Klasse definiert ist.

• dbx Dieser Container ist vorgesehen, um die dbx-Funktionen von PHP zu nutzen. Als Optionen benötigt er die Felder module, host, db, username und password. module definiert, welcher Datenbanktyp genutzt werden soll. Als Wert ist einer der Strings 'mysql', 'odbc', 'mssql', 'fbsql', 'sybase_ct', 'oci8' oder 'sqlite' [Erst ab PHP 5 verfügbar. ] zulässig. host enthält den Namen oder die IP des Servers und db den Namen der Datenbank. username und password müssen die korrekten Angaben für eine Authentifikation enthalten. Zusätzlich können Sie noch den Schlüssel cache_table nutzen, um den Namen der Tabelle zu definieren.

• trifile trifile benötigt keine weiteren Parameter. Auch hier werden die Daten in Form von Dateien abgelegt. Allerdings ist trifile für die Nutzung mit reinen Textdaten gedacht, da die Daten ohne Rücksicht auf Kodierung oder Ähnliches abgelegt werden.

Zusätzlich ist es noch möglich, die Daten im Shared Memory abzulegen, was aber keine großen Vorteile mit sich bringt. Bei diesem Paket resultiert hieraus kein Geschwindigkeitsvorteil. Die Nutzung von Dateien ist hier effektiver.

Möchten Sie einen der Datenbank-Layer nutzen, stellt sich natürlich die Frage, wie die Tabelle aussehen muss, mit der gearbeitet wird. Für eine MySQL-Datenbank könnte die Tabelle mit diesem Befehl angelegt werden:

CREATE TABLE cache ( 
  id          CHAR(32) NOT NULL DEFAULT '', 
  cachegroup  VARCHAR(127) NOT NULL DEFAULT '', 
  cachedata   BLOB NOT NULL DEFAULT '', 
  userdata    VARCHAR(255) NOT NULL DEFAULT '', 
  expires     INT(9) NOT NULL DEFAULT 0, 
 
  changed     TIMESTAMP(14) NOT NULL, 
 
  INDEX (expires), 
  PRIMARY KEY (id, cachegroup) 
)

Listing 3.3 SQL-Befehl zum Anlegen der Cache-Tabelle

In anderen Datenbanken sollte die Tabelle natürlich einen identischen Aufbau haben. Der Befehl sollte für die meisten Datenbankarchitekturen aber genauso nutzbar sein.

In den nachfolgenden Beispielen werde ich immer den Container file nutzen, da der Zugriff auf Dateien sehr effizient ist.

Die Arbeit mit der Klasse Cache gestaltet sich ähnlich wie die mit anderen Cache-Klassen. Zuerst wird geprüft, ob die gewünschten Daten bereits im Cache vorhanden sind. Ist das der Fall, werden sie ausgelesen und an den Client geschickt. Sind die Daten nicht im Cache oder veraltet, werden sie neu generiert, im Zwischenspeicher abgelegt und an den Client geschickt.

Nachdem Sie ein Cache-Objekt abgeleitet haben, benötigen Sie eine eindeutige ID. Darüber werden die einzelnen Einträge im Cache angesprochen und verwaltet. Die ID wird auf Basis einer Vorgabe, die Sie tätigen, von der Methode generateId() erstellt. Die Vorgabe sollte sich natürlich nicht ändern und eindeutig sein. Hierzu bietet sich beispielsweise der Name der Datei an.

Mit dieser ID können Sie dann, mithilfe der Methode save(), Daten im Cache ablegen. save() bekommt die ID, den Inhalt, der gespeichert werden soll, und die Zeit übergeben, wie lange der Eintrag gültig sein soll. Die Zeit wird als Anzahl von Sekunden übergeben.

Um zu prüfen, ob die gewünschten Daten bereits im Speicher liegen und noch gültig sind, stehen isCached() und isExpired() zur Verfügung. Beide Methoden liefern true oder false zurück.

Wenn Sie feststellen, dass die Daten schon gespeichert und noch gültig sind, können Sie diese mit der Methode get() wieder aus dem Cache auslesen.

Ein Anwendungsbeispiel finden Sie in Listing 3.4.

require_once('Cache.php'); 
 
// Dies waere im Ernstfall das eigentliche Programm 
function umfangreich() 
{ 
   return date('H:i:s'); 
} 
 
// Optionen fuer den Container 
$opts= array ( 
            'cache_dir'       => 'cache', 
            'filename_prefix' => 'cache_' 
       );_$ret_ 
// Neues Objekt ableiten 
$cache = new Cache('file',$opts); 
// File-Locking einschalten 
$cache->fileLocking=true; 
 
// ID generieren 
$id = $cache->generateID($_SERVER['PHP_SELF']); 
 
// Daten im Cache und gueltig? 
if (false === $cache->isCached($id) || 
    true === $cache->isExpired($id)) 
{  // Daten nicht gueltig -> neu generieren 
   $content = umfangreich(); 
   $res=$cache->save($id, $content, 10); 
   if (true===Cache::isError($res)) 
   { 
      die ($res->getMessage()); 
   } 
} 
else 
{  // Daten im Cache sind noch gueltig -> auslesen 
   $content = $cache->get($id); 
   if (true===Cache::isError($content)) 
   { 
      die ($content->getMessage()); 
   } 
} 
echo $content;

Listing 3.4 Nutzung der Klasse Cache

Wenn Sie den Container file nutzen, ist es möglich, dass Sie der Eigenschaft fileLocking den Wert true zuweisen. Damit wird sichergestellt, dass die Datei gesperrt wird, wenn ein Script darauf zugreift. Das verhindert, dass ein Script versucht, den Cache zu aktualisieren, während ein anderes gerade die Datei liest und dann eventuell beschädigte Daten erhält.

Listing 3.4 ist recht umfangreich und »ordentlich« programmiert. Da es bei der Nutzung eines Caches aber um Performance geht, wäre auch diese gekürzte Variante denkbar:

// Inkludieren von Cache.php und Setzen der Optionen 
$cache = new Cache('file',$opts); 
$cache->fileLocking=true; 
 
$id = $cache->generateID($_SERVER['PHP_SELF']); 
 
if (!$content=$cache->get($id)) 
{ 
   $content = umfangreich(); 
   $cache->save($id, $content, 10); 
} 
echo $content;

In dieser Variante wird einfach versucht, die Cache-Datei auszulesen. Kann sie nicht gelesen werden, gibt die Methode false zurück, und somit wird der Körper der if-Abfrage ausgeführt.

Die Abfrage von Fehlern zu unterlassen ist natürlich nicht unproblematisch, und solange Sie die Applikation nicht ausführlich getestet haben, sollten Sie immer auf Fehler prüfen.

Um eine Applikation ausführlich testen zu können, kann es hilfreich sein, wenn Sie das Caching ausschalten können. Um zu verhindern, dass Daten im Zwischenspeicher abgelegt werden, rufen Sie die Methode setCaching() mit dem Werte false auf.

Die Methode remove() kann einen einzelnen Eintrag aus dem Cache löschen, dessen ID sie als Parameter übergeben bekommt. Um alle Daten auf einmal zu löschen, können Sie flush() nutzen.

Die letzte Methode ist garbageCollection(). Sie ist die Müllabfuhr des Systems und sorgt dafür, dass veraltete Cache-Einträge entfernt werden. Allerdings ist sie ein wenig gewöhnungsbedürftig.

Rufen Sie die Methode auf, so erfüllt sie ihre Aufgabe nur mit einer gewissen prozentualen Wahrscheinlichkeit. Das heißt, sie löscht also nicht garantiert die veralteten Einträge. Die Idee dahinter ist, dass die Performance des Systems nicht leiden soll. Um die Wahrscheinlichkeit festzulegen, mit der die Garbage-Collection wirklich ausgeführt werden soll, ist die Eigenschaft gc_probability vorgesehen. Legen Sie in dieser Eigenschaft den Wert 30 ab, so beträgt die Wahrscheinlichkeit, dass die Daten entfernt werden, 30  %. Um zu forcieren, dass die Daten gelöscht werden, können Sie garbageCollection() auch die Konstante true übergeben. Die zweite Eigenschaft, die das Verhalten der Methode beeinflusst, ist gc_maxlifetime, die normalerweise die Zahl 86400 enthält. Hier ist die Anzahl der Sekunden abgelegt, die ein Eintrag maximal im Cache verbleiben darf.

Das Paket kennt noch einige Klassen, die für spezielle Anwendungsfälle ausgelegt sind. Da diese alle von der Klasse Cache abgleitet sind, erben sie natürlich auch die dort enthaltenen Methoden.

3.2.1 Cache_Function 

Die Klasse Cache_Function ist darauf spezialisiert, mit Funktionen umzugehen, und deutlich einfacher zu handhaben als Cache. Die ID generiert die Klasse selbst. Und zwar nutzt sie die Namen der Funktion und die übergebenen Parameter als Grundlage, um die ID zu erstellen. Hängt das Verhalten der Funktion nur von den Parametern ab, können Sie die Daten also beliebig lange wiederverwenden. Darüber hinaus ist es auch möglich, aus anderen Scripts auf denselben Cache zuzugreifen, solange dort dieselben Funktionen genutzt werden.

Der Konstruktor akzeptiert dieselben Parameter wie der Konstruktor von Cache. Zusätzlich können Sie als dritten Parameter aber noch angeben, wie lange die gecachte Information gültig sein soll. Übergeben Sie keine Parameter, nutzt die Klasse automatisch den file-Container und belässt die Daten mindestens 3600 Sekunden im Cache.

Die Klasse benötigt nur eine Methode: call(). Ihr werden der Name der Funktion und alle Parameter übergeben, die für den Aufruf benötigt werden.

require_once('Cache/Function.php'); 
 
function addiere ($zahl1, $zahl2) 
{ 
   echo 'Berechnung erfolgt jetzt<br />'; 
   $erg=$zahl1+$zahl2; 
   return "$zahl1 + $zahl2 = $erg"; 
} 
 
$opts= array ( 
            'cache_dir'       => 'cache', 
            'filename_prefix' => 'cache_' 
       ); 
 
$cache = new Cache_Function('file',$opts,10); 
$res = $cache->call('addiere', 1,3); 
echo $res;

Listing 3.5 Nutzung der Klasse Cache_Function

Die Methode call() übernimmt das komplette Cache-Management für Sie. Sie ruft entweder die Funktion neu auf und speichert die Werte, oder sie liest die Informationen aus dem Cache und gibt sie zurück.

Interessant dabei ist, dass sowohl direkte Ausgaben mit echo, print oder Ähnlichem als auch Rückgabewerte der Funktion abgefangen werden. Direkte Bildschirmausgaben gibt call() wieder direkt aus.

Die Methode kann übrigens auch mit Methoden, ja sogar mit Aufrufen von statischen Methoden umgehen. Möchten Sie die Methode foo() des Objekts $bar aufrufen, nutzen Sie call("$bar->foo()");. Bei einer statischen Methode nutzen Sie die Syntax, die für einen statischen Aufruf üblich ist, also z. B. "myClass::foo()".

3.2.2 Cache_Graphics 

Die Klasse Cache_Graphics ist der Spezialist für den Umgang mit Grafiken. Grafiken dynamisch mit PHP zu erstellen ist teilweise recht beliebt, um Buttons oder Ähnliches zu generieren. Da die Belastung des Servers dabei aber recht hoch ist, macht es Sinn, solche Grafiken zu cachen. Hierbei kennt Cache_Graphics zwei Vorgehensweisen. Die erste Variante ist, mit Links zu arbeiten. In dem Fall wird die Grafik auf der Festplatte abgelegt, und das Paket gibt Ihnen einen Link zurück, der direkt in ein <img>-Tag eingebunden werden kann.

Der Konstruktor dieser Klasse akzeptiert keine Parameter. Um das Verzeichnis zu definieren, in dem die Cache-Dateien abgelegt werden sollen, ist die Methode setCacheDir() implementiert.

Die einzelnen Grafik-Dateien werden auch hier auf Basis einer ID verwaltet, die mit generateId() erstellt werden kann. Die Methode erwartet hierbei einen eindeutigen Bezeichner, der als Grundlage für die Erstellung der ID dient. Wenn Sie in einem anderen Script denselben Bezeichner nutzen, wird auch auf denselben Eintrag im Cache zugegriffen. Daher bietet es sich an, die ID auf Basis einer eindeutigen Kombination von Daten wie Größe der Grafik, Beschriftung oder Farben zu generieren. Der zweite Parameter, den die Methode benötigt, ist der Typ der Grafik. Das Paket selbst unterstützt die Dateitypen 'gif', 'jpg', 'png' und 'wbmp'. Allerdings setzt das voraus, dass diese Formate auch von der Version der GD-Bibliothek unterstützt werden.

Die erste Variante, die ich Ihnen vorstellen möchte, ist die Nutzung von Links, um auf die gespeicherten Inhalte zuzugreifen. In diesem Fall ist die Methode setCacheURL() auch hilfreich. Die Methoden, die einen Pfad liefern, geben normalerweise nur einen relativen Pfad aus Sicht des Scripts zurück. Benötigen Sie einen absoluten Pfad, können Sie mit setCacheURL() einen String definieren, der dem Dateinamen vorangestellt wird.

getImageLink() ist die Methode, die Ihnen den Link auf die Grafik-Datei zurückgibt. Die Methode gibt Ihnen ein Array zurück. Im ersten Feld ist der relative Pfad zur Datei enthalten. Der Inhalt des zweiten Feldes hängt davon ab, ob Sie die Methode setCacheURL() aufgerufen haben. Haben Sie sie nicht aufgerufen, ist hier nur der Dateiname enthalten. Andernfalls ist der Dateiname inklusive der Vorgaben enthalten, die Sie an setCacheURL() übergeben haben.

Sollte die Datei noch nicht im Cache liegen, wird false zurückgegeben.

Wenn die Grafik noch nicht im Zwischenspeicher abgelegt ist, erstellen Sie diese wie gewohnt. Allerdings rufen Sie keine der Funktionen wie imagepng() oder imagejpg() auf, die die Grafik ausgibt. Nachdem Sie die Grafik im Speicher aufgebaut haben, nutzen Sie die Methode cacheImageLink(). Sie bekommt die ID des Eintrags übergeben und als zweiten Parameter eine Referenz auf die Ressource des Bildes im Speicher. Der dritte Parameter ist wiederum der Typ der Datei.

Die Methode macht zwei Dinge: Zum Ersten erstellt sie die Grafik und legt sie auf der Festplatte ab. Zum Zweiten liefert sie direkt den Pfad auf die neu erstellte Datei zurück, so dass Sie diesen Verweis auch sofort in der Datei nutzen können.

require_once('Cache/Graphics.php'); 
 
// Parameter fuer die Grafik 
$text='Hallo Welt'; 
$width=100; 
$height=50; 
 
// Ableiten eines neuen Objekts 
$cache = new Cache_Graphics(); 
// Pfad, in dem die Daten abgelegt werden sollen 
$cache->setCacheDir('cache'); 
// URL, die einem Teil der Links vorangestellt wird 
$cache->setCacheURL('http://www.example.com'); 
 
// ID generieren 
$id = $cache->generateID($text.$width.$height.__FILE__,'png'); 
 
// Link auf die Datei auslesen. Ist die Datei nicht im Cache, 
// neu anlegen. 
if (!($link=$cache->getImageLink($id,'png'))) 
{ 
   $img = imagecreate($width, $height); 
   if (false == $img) 
   { 
      die ("Konnte Bild nicht anlegen"); 
   } 
   $bg_color = imagecolorallocate($img, 255, 255, 255); 
   $txt_color = imagecolorallocate($img, 200, 20, 20); 
   imagestring($img, 3, 5, 5, $text, $txt_color); 
   // Grafik auf Platte schreiben und Link auslesen 
   $link = $cache->cacheImageLink($id,&$img,'png'); 
} 
// Ausgabe des img-Befehls 
echo "<img src='$link[0]' />"; 
// $link[0] enthaelt 
// cache/graphics/graphics_09c2ebeb6402a995280c0f2.png 
// $link[1] enthaelt 
// http://www.example.com/graphics_09c2ebeb6402a995280c0f2.png

Listing 3.6 Nutzung von Cache_Graphics

Möchten Sie die Datei direkt ausgeben, also keinen Link in einer HTML-Datei verwenden, können Sie die Methoden getImageLink() und cacheImageLink() durch die Methoden getImage() und cacheImage() ersetzen. Die Methoden, die dieselben Parameter erwarten, geben die komplette Grafik zurück, die Sie dann direkt an den Browser schicken können.

3.2.3 Cache_Output 

Cache_Output ist darauf ausgelegt, die Ausgabe einer ganzen Seite »abzufangen« und zwischenzuspeichern. Der Konstruktor dieser Klasse akzeptiert dieselben Parameter wie der Konstruktor der Klasse Cache.

Die Verwaltung der einzelnen Einträge findet auch hier über eine ID statt, die wiederum mit der Methode generateID() erstellt wird.

Zu Beginn der Seite nutzen Sie in diesem Fall die Methode start(). Diese bekommt die ID übergeben und gibt entweder die Daten aus dem Cache oder false zurück. Bekommen Sie Daten übergeben, können Sie diese ausgeben lassen und das Script beenden. Andernfalls arbeiten Sie das Script ganz normal ab und rufen nach dem Ende des eigentlichen Scripts eine der Methoden end(), endPrint() oder endGet() auf. end() bekommt die Anzahl der Sekunden übergeben, wie lange der Eintrag gültig sein soll, und gibt den neuen Cache-Inhalt als Rückgabewert zurück. Diesen können Sie dann manuell ausgeben oder weiterverarbeiten. Die Methode endPrint() bekommt auch die Zeit in Sekunden übergeben, wie lange der Eintrag gültig sein soll. Sie speichert die Daten in dem entsprechenden Container, gibt diese aber gleichzeitig aus, so dass Sie das nicht mehr manuell machen müssen. Die letzte Methode, endGet(), gibt Ihnen die Daten nur zurück und speichert sie nicht. Die Idee ist, dass Sie die Daten dann noch weiterverarbeiten können, um sie danach mit save() im Speichercontainer abzulegen.

require_once('Cache/Output.php'); 
 
// Optionen 
$opts = array('cache_dir' => 'cache', 
               'filename_prefix' => 'cache_' 
          ); 
 
// Objekt ableiten 
$cache = new Cache_Output('file', $opts); 
// ID auf Basis des Dateinamens und $_GET erstellen 
$id = $cache->generateID(__FILE__.$_GET['user']); 
 
// Koennen die Daten aus dem Cache geholt werden? 
if ($data = $cache->start($id)) 
{  // Ja, Daten konnten gelesen werden 
   // => Daten ausgeben und Script beenden 
   echo $data; 
   exit(); 
} 
 
// Hier kommt das eigentliche Script, das normalerweise 
// natuerlich viel umfangreicher waere 
echo "Hallo $_GET[user] es ist ".date('H:i:s')." Uhr"; 
 
// Daten ausgeben und gleichzeitig speichern 
$cache->endPrint(10);

Listing 3.7 Die Nutzung von Cache_Output

3.2.4 Cache_OutputCompression 

Die Klasse Cache_OutputCompression verhält sich weitgehend so wie Cache_Output. Der große Unterschied ist hierbei nur, dass die Klasse versucht, die Daten für die Übertragung zum Client zu komprimieren. Die meisten Browser sind heutzutage in der Lage, Daten, die gzip-komprimiert sind, zeitgleich mit dem Empfang der Daten zu dekodieren. Somit bemerkt der Benutzer keinen Nachteil, hat aber den Vorteil, dass die Übertragung schneller vonstatten geht, da die zu übertragende Datenmenge kleiner ist. Auch der Serverbetreiber kann Bandbreite und somit eventuell auch Geld sparen.

Wie gesagt verhalten sich Cache_Ouptput und Cache_OutputCompression weitgehend gleich, so dass ich primär die Unterschiede erläutern werde.

Die Cache-Session wird wiederum mit start() eingeleitet. Zum Beenden stehen die Methoden end() und endPrint() zur Verfügung. end() gibt in diesem Fall allerdings die komprimierten Daten zurück. Möchten Sie diese Daten zum Client schicken, empfiehlt es sich, die Methode printContent() zu nutzen. Diese sendet die korrekten Header, so dass es bei der Dekomprimierung nicht zu Problemen kommt. Die zu sendenden Daten werden ihr als Parameter übergeben.

Die Methode endGet() ist in dieser Klasse nicht definiert.

Über das verwendete Kompressionsverfahren müssen Sie sich normalerweise keine Gedanken machen, da die Klasse sich automatisch darum kümmert.

3.2.5 Cache_HTTP_Request 

Alle anderen Klassen haben sich immer auf die Ausgabe von Daten bezogen. Cache_HTTP_Request bezieht sich allerdings auf das Einlesen von Daten. Übernehmen Sie beispielsweise Daten von einem Server, so ist es häufig nicht nötig, die Daten bei jedem Aufruf des Scripts beim anderen Server anzufordern. Genau hier hilft Cache_HTTP_Request Ihnen. Sie können den Aufruf der entfernten Datei durch die Klasse »tunneln«. Ist die gecachte Information veraltet oder wurden die Daten noch nicht gespeichert, so werden sie beim Server angefordert.

Der Konstruktor bekommt in diesem Fall relativ umfangreiche Informationen übergeben. An erster Stelle wird die URL übergeben, von der die Daten bezogen werden sollen. Danach können Sie ein Array mit Parametern übergeben, das den Abruf der Daten steuert. Die Schlüssel, die Sie dabei nutzen können, finden Sie in Tabelle 3.2.

Der dritte Parameter ist der Name des Datencontainers, der genutzt werden soll. Standard ist auch in diesem Fall die Nutzung von file. Daran schließen sich die Optionen für den Container an, der Verwendung findet. Die letzten beiden Parameter sind die Sekundenzahl, wie lange der Cache-Eintrag gültig sein soll (Default-Einstellung sind 3600 Sekunden, was einer Stunde entspricht), und eine Konstante. Mit dieser können Sie definieren, wie der Cache sich verhalten soll, wenn der Server, von dem die Daten abgeholt werden sollen, nicht antwortet. Zulässig sind hier die Konstanten CACHE_HTTP_REQUEST_KEEP_LOCAL_COPY, CACHE_HTTP_REQUEST_RETURN_FALSE und E_HTTP_REQUEST_RETURN_PEAR_ERROR. Mit der ersten Konstante wird bei einem Serverausfall die lokale Kopie genutzt, selbst wenn die Daten schon überlagert sind. Das entspricht auch der Standardeinstellung. Mit der zweiten Einstellung gibt der Leseversuch false zurück, und die dritte Konstante besagt, dass ein Cache_Error-Objekt zurückgegeben werden soll.

Hierbei ist ein recht unwahrscheinlicher Sonderfall zu beachten. Sollten Sie die Einstellung CACHE_HTTP_REQUEST_KEEP_LOCAL_COPY nutzen, während der Server nicht erreichbar ist und auch keine lokale Kopie existiert, wird auch ein PEAR_Error-Objekt zurückgeliefert.

require_once('Cache/HTTP_Request.php'); 
 
// Optionen fuer das Request-Objekt 
$request_opts = array( 
                     'user' => 'pmeier', 
                     'pass' => 'geheim' 
                  ); 
 
// Optionen fuer den Container 
$cont_opts = array('cache_dir' => 'cache', 
               'filename_prefix' => 'cache_' 
          );_$ret_ 
// Neues Objekt ableiten und URL uebergeben 
$cache = new Cache_HTTP_Request( 
               'http://www.example.com/news/', 
               $request_opts,'file',$cont_opts,3600); 
// Daten aus dem Cache oder vom Server holen 
$res=$cache->sendRequest(); 
if (true === PEAR::isError($res)) 
{  // Ist ein Fehler aufgetreten? 
   die ($res->getMessage()); 
} 
 
$code = $cache->getResponseCode(); 
$header = $cache->getResponseHeader(); 
$body = $cache->getResponseBody();

Listing 3.8 Nutzung von Cache_HTTP_Request

Wie Sie in Listing 3.8 sehen können, werden die Daten nicht direkt zurückgegeben. Um die einzelnen Komponenten auszulesen, stehen die Methoden getResponseCode(), getResponseHeader() und getResponseBody() zur Verfügung. Die erste liefert Ihnen den Statuscode des Requests zurück. getResponseHeaders() liest die Header der Anfrage aus und gibt sie in Form eines Arrays zurück. Die Namen der Header fungieren hierbei als Schlüssel.

Der eigentliche Inhalt der Datei, die eingelesen wurde, gibt getResponseBody() in Form eines Strings zurück.