Zend_Cache_Core ist ein spezielles Frontend, da es der Kern dieses Moduls ist. Es ist ein generelles Cache Frontend und wurde von anderen Klassen erweitert.

Hinweis: Alle Frontends sind von Zend_Cache_Core abgeleitet, so dass deren Methoden und Optionen (wie folgt beschrieben) auch in anderen Frontends vorhanden sind. Deswegen werden sie dort nicht dokumentiert.

Diese Optionen werden der Factory Methode übergeben wie im nachfolgenden Beispiel demonstriert.

Ein Beispiel wird ganz am Anfang des Handbuches gegeben.

Wenn nur Strings in den Cache gespeichert werden (denn mit der "automatic_serialization" Option wäre es möglich Booleans zu speichern), kann ein kompakterer Weg wie folgt gewählt werden:

<?php
// Es wird angenommen das $cache existiert

$id = 'myBigLoop'; // Die Cache ID von dem "das gecached werden soll"

if (!($data = $cache->load($id))) {
    // Cache miss

    $data = '';
    for ($i = 0; $i < 10000; $i++) {
        $data = $data . $i;
    }

    $cache->save($data);

}

// [...] Irgendwas mit $data machen (ausgeben, verarbeiten, usw.)
            

Wenn mehrere Blöcke von Daten oder Daten Instanzen gecached werden sollen, ist die Idee dahinter die gleiche:

<?php
// Sicherstellen, dass eindeutige Identifizierer verwendet werden:
$id1 = 'foo';
$id2 = 'bar';

// Block 1
if (!($data = $cache->load($id1))) {
    // Cache miss

    $data = '';
    for ($i=0;$i<10000;$i++) {
        $data = $data . $i;
    }

    $cache->save($data);

}
echo($data);

// Hier wird NIE gecached
echo('NIE GECACHED! ');

// Block 2
if (!($data = $cache->load($id2))) {
    // Cache miss

    $data = '';
    for ($i=0;$i<10000;$i++) {
        $data = $data . '!';
    }

    $cache->save($data);

}
echo($data);
            

Zend_Cache_Frontend_Output ist ein Ausgabe-Empfangendes Frontend. Es verwendet den Ausgabe Puffer in PHP, um alles zwischen der start() und der end() Methode zu fangen.

Dieses Frontend hat keine bestimmten Optionen zusätzlich zu denen von Zend_Cache_Core.

Ein Beispiel wird ganz am Anfang des Handbuches gegeben. Hier ist es mit kleinen Änderungen:

<?php
// Wenn es ein Cache Miss ist, wird das puffern der Ausgabe ausgelöst
if( ! ($cache->start('mypage'))) {

    // Alle wie gewohnt ausgeben
    echo 'Hallo Welt! ';
    echo 'Das wird gecached ('.time().') ';

    $cache->end(); // Ausgabepufferung beenden

}

echo 'Hier wird nie gecached ('.time().').';
            

Die Verwendung dieser Form ist ziemlich einfach, um Ausgabe caching in einem bereits bestehenden Projekt, mit nur wenig oder gar keinen Codeänderungen, zu erhalten.

Zend_Cache_Frontend_Function cached das Ergebnis von Funktionsaufrufen. Es hat eine einzelne Hauptmethode genannt call(), welche den Funktionsnamen und Parameter für den Aufruf in einem Array entgegennimmt.

Die Verwendung der call() Funktion ist die gleiche, wie die von call_user_func_array() in PHP:

<?php
$cache->call('veryExpensiveFunc', $params);

# $params ist ein Array
# Zum Beispiel fürs Aufrufen (mit cachen) von veryExpensiveFunc(1, 'foo', 'bar'), wird
# $cache->call('veryExpensiveFunc', array(1, 'foo', 'bar')) benutzt
            

Zend_Cache_Frontend_Function ist elegant genug, um beides zu cachen, den Rückgabewert der Funktion und deren interne Ausgabe.

Hinweis: Man kann jede eingebaute oder benutzerdefinierte Funktion übergeben, mit ausnahme von array(), echo(), empty(), eval(), exit(), isset(), list(), print() und unset().

Zend_Cache_Frontend_Class ist unterschiedlich zu Zend_Cache_Frontend_Function, weil es das Cachen von Objekten und statischen Methodenaufrufen erlaubt.

zum Beispiel, um einen statischen Aufruf zu cachen:

<?php
class test {

    # Statische Methode
    public static function foobar($param1, $param2) {
        echo "foobar_output($param1, $param2)";
        return "foobar_return($param1, $param2)";
    }

}

// [...]
$frontendOptions = array(
    'cached_entity' => 'test' // Der Name der Klasse
);
// [...]

# Der gecachte Aufruf
$res = $cache->foobar('1', '2');
            

Um klassische Methodenaufrufe zu cachen :

<?php
class test {

    private $_string = 'Hallo !';

    public function foobar2($param1, $param2) {
        echo($this->_string);
        echo "foobar2_output($param1, $param2)";
        return "foobar2_return($param1, $param2)";
    }

}

// [...]
$frontendOptions = array(
    'cached_entity' => new test() // Eine Instanz der Klasse
);
// [...]

# Der gecachte Aufruf
$res = $cache->foobar2('1', '2');
            

Zend_Cache_Frontend_File ist ein Frontend angetrieben durch den Änderungszeitpunkt einer "Masterdatei". Es ist wirklich interessant für Beispiele in Konfigurations- oder Templateanwendungen.

Zum Beispiel eine XML Konfigurationsdatei, welche von einer Funktion geparsed wird und die ein "Config Objekt" zurückgibt (wie durch Zend_Config). Mit Zend_Cache_Frontend_File kann das "Config Objekt" im Cache gespeichert werden (um zu Verhindern, das die XML Konfiguration jedes mal geparsed wird), aber mit einer strengen Abhängigkeit zur "Masterdatei". Wenn also die XML Konfigurationsdatei geändert wird, wird der Cache sofort ungültig.

Die Verwendung dieses Frontends ist die gleiche wie die von Zend_Cache_Core. Es gibt kein eigenes Beispiel - was als einziges gemacht werden muß, ist das master_File zu definieren, wenn die Factory verwendet wird.

Zend_Cache_Frontend_Page ist wie Zend_Cache_Frontend_Output aber entwickelt für eine komplette Seite. Es ist unmöglich Zend_Cache_Frontend_Page nur für das Cachen eines einzelnen Blockes zu verwenden.

Andererseits wird die "Cache ID" automatisch berechnet mit $_SERVER['REQUEST_URI'] und (abhängig von den Optionen) mit $_GET, $_POST, $_SESSION, $_COOKIE, $_FILES. Trotzdem muß nur eine Methode aufgerufen werden (start()), weil der Aufruf von end() immer vollautomatisch ist, wenn die Seite endet.

Zur Zeit ist es nicht eingebaut, aber es ist ein HTTP abhängiges System geplant, um Bandbreiten zu sparen (das System wird ein "HTTP 304 nicht geändert" schicken, wenn der Cache gefunden wurde und wenn der Browser bereits eine gültige Version hat).

Die Verwendung von Zend_Cache_Frontend_Page ist wirklich trivial :

<?php
// [...] // Benötigt, Konfiguration und Factory

$cache->start();
// Wenn der Cache gefunden wurde, wird das Ergebnis zum Browser geschickt, und das Skript stoppt hier

// Rest der Seite ...
            

Ein etwas komplexeres Beispiel, welches einen Weg zeigt, um ein zentralisiertes Cache Management in einer Bootstrap Datei zu erhalten (um es z.B. mit Zend_Controller´ zu verwenden)

<?php
// [...] du solltest es vermeiden, zu viele Zeilen vor dem Cache Bereich zu setzen
// [...] zum Beispiel sollten für optimale Performanz "require_once" oder "Zend_Loader::loadClass"
// [...] nach dem Cache Bereich stehen

require_once 'Zend/Cache.php';

$frontendOptions = array(
   'lifetime' => 7200,
   'debug_header' => true, // für das Debuggen
   'regexps' => array(
       '^/$' => array('cache' => true),         // cache den gesamten IndexController
       '^/index/' => array('cache' => true),    // cache den gesamten IndexController
       '^/article/' => array('cache' => false), // wir cachen nicht den ArticleController...
       '^/article/view/' => array(              // ...aber wir cachen die "View" Aktion von
           'cache' => true,                     // diesem ArticleController
           'cache_with_post_variables' => true,    // und wir cachen sogar wenn es einige Variablen in $_POST gibt
           'make_id_with_post_variables' => true,   // (aber die Cache Id wird vom $_POST Array abhängig sein)
       )
   )
);
$backendOptions = array(
    'cache_dir' => '/tmp/'
);

// erhalte ein Zend_Cache_Frontend_Page Objekt
$cache = Zend_Cache::factory('Page', 'File', $frontendOptions, $backendOptions);

$cache->start();

// Wenn der Cache gefunden wurde, wird das Ergebnis zum Browser geschickt, und das Skript stoppt hier

// [...] das Ende der Bootstrap Datei (diese Zeilen werden nicht ausgeführt, wenn der Cache ausgegeben wurde)