Zend_Cache_Core is een speciale frontend omdat het de kern van de module is. Het is een generieke cache frontend en wordt uitgebreid door andere classes.

	Opmerking
	Alle frontends erven van Zend_Cache_Core zodat zijn methodes en opties (zoals hieronder beschreven) ook beschikbaar zijn in andere frontends, dus ze zullen hier niet worden gedocumenteerd.

Deze opties worden doorgegeven aan de factory methode zoals hierboven gedemonstreerd.

Een voorbeeld wordt gegeven aan het begin van de handleiding.

Wanneer je alleen strings in de cache wil opslaan (want met "automaticSerialization" is het mogelijk ook sommige booleans op te slaan), kan je een compactere constructie gebruiken:

<?php  
             
// we gaan er vanuit dat je $cache al hebt

$id = 'mijnGroteLoop'; // cache id van "wat we willen cachen"

if (!($data = $cache->get($id))) {
    // cache miss
    
    $data = '';
    for ($i = 0; $i < 10000; $i++) {
        $data = $data . $i;
    }
    
    $cache->save($data);
    
} 

// [...] doe iets met $data (echo het, stuur het door enz.)
             
?>       

Als je meerdere blokken of data instanties wilt cachen, is het idee hetzelfde:

<?php  
             
// Zorg ervoor dat je unieke identifiers hebt:
$id1 = 'foo';
$id2 = 'bar';

// blok 1
if (!($data = $cache->get($id1))) {
    // cache miss
    
    $data = '';
    for ($i=0;$i<10000;$i++) {
        $data = $data . $i;
    }
    
    $cache->save($data);
    
} 
echo($data);

// Dit wordt niet door de cache beïnvloed
echo('NOOIT GECACHED! ');

// blok 2
if (!($data = $cache->get($id2))) {
    // cache miss
    
    $data = '';
    for ($i=0;$i<10000;$i++) {
        $data = $data . '!';
    }
    
    $cache->save($data);
    
} 
echo($data);

?>       

Zend_Cache_Frontend_Output is een output-vangend frontend. Het gebruikt output buffering in PHP om alles tussen zijn start() en end() methodes te vangen.

Dit frontend heeft geen specifieke opties andere dan deze van Zend_Cache_Core.

Een voorbeeld is in het begin van de handleiding gegeven. Hier is het met enkele kleine veranderingen:

<?php

// indien het een cache miss is, output buffering inroepen
if(!$cache->start('mijnpagina')):

// alles weergeven zoals gewoonlijk
echo 'Dag wereld! ';
echo 'Dit is gecached ('.time().') ';

$cache->end(); // einde van output buffering
endif;

echo 'Dit is nooit gecached ('.time().').';

?>       

Deze vorm gebruiken maakt het eenvoudig om output caching op te zetten in je reeds werkende projekt met geen of weinig herschrijven van de code.

Zend_Cache_Frontend_Function cached het resultaat van functie oproepen. Het heeft één enkele hoofdmethode genaam call() die de functienaam en parameters voor de oproep in een array aanvaard.

De call() functie gebruiken is hetzelfde als call_user_func_array() in PHP:

<?php

$cache->call('heelZwareFunctie', $params);

# $params is een array
# bijvoorbeeld om heelZwareFunctie(1, 'foo', 'bar') op te roepen (met caching), zal je
# $cache->call('heelZwareFunctie', array(1, 'foo', 'bar')) gebruiken

?>       

Zend_Cache_Frontend_Function is slim genoeg om zowel de return waarde van de functie als zijn interne output te cachen.

	Opmerking
	Je kan eender welke ingebouwde of gebruikerfunctie doorgeven, behalve array(), echo(), empty(), eval(), exit(), isset(), list(), print() and unset().

Zend_Cache_Frontend_Class verschilt van Zend_Cache_Frontend_Function omdat het toelaat een object en statische methode oproepen te cachen.

Bijvoorbeeld, om statische oproepen te cachen :

<?php

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

}

// [...]
$frontendOptions = array(
    'cachedEntity' => 'test' // De naam van de klasse
);
// [...]

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

?>       

Om klassieke methode oproepen te cachen :

<?php

class test {
   
    private $_string = 'hoi !';
      
    public function foobar2($param1, $param2) {
        echo($this->_string);
        echo "foobar2_output($param1, $param2)";
        return "foobar2_return($param1, $param2)";   
    }

}

// [...]
$frontendOptions = array(
    'cachedEntity' => new test() // Een instantie van de klasse
);
// [...]

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

?>       

Zend_Cache_Frontend_File is een frontend dat bestuurd word door de wijzigingstijd van een "meesterbestand". Het is zeer interessant voor voorbeelden in configuratie of template problemen.

Bijvoorbeeld, je hebt een XML configuratiebestand dat door een functie wordt ingelezen die een "config object" teruggeeft (zoals met Zend_Config). Met Zend_Cache_Frontend_File kan je "config object" in de cache opslaan (om te vermijden dat je het XML bestand elke keer inleest) maar met een soort van sterke afhankelijkheid met het "meesterbestand". Dus, indien het XML configuratiebestand wordt gewijzigd wordt de cache onmiddellijk invalide.

Het gebruik van dit frontend is hetzelfde als dat van Zend_Cache_Core. Er is geen nood aan een specifiek voorbeeld - het enige dat er te doen is, is het definiëren van masterFile bij het gebruik van de factory.

Zend_Cache_Frontend_Page is net als Zend_Cache_Frontend_Output maar werd ontworpen voor een volledige pagina. Het is onmogelijk om Zend_Cache_Frontend_Page te gebruiken om een enkel blok te cachen.

Anderzijds word "cache id" automatisch berekend met $_SERVER['REQUEST_URI'] en (afhankelijk van de opties) $_GET, $_POST, $_SESSION, $_COOKIE, $_FILES. Bovendien hoef je slechts één methode op te roepen (start()) want de end() oproep is volledig automatisch bij het einde van de pagina.

Het is niet geïmplementeerd voor het ogenblik, maar we hebben plannen om een HTTP conditioneel systeem bij te voegen om bandbreedte te sparen (het systeem zal een HTTP 304 Not Modified header zenden indien de browser cache word aangesproken en indien de browser reeds de goede versie heeft).

	Opmerking
	) Zend_Cache_Frontend_Page is echt "alpha stuff" en moet later verder worden verbeterd.

Het gebruik van Zend_Cache_Frontend_Page is echt eenvoudig :

<?php
	           
// [...] // require, configuratie en factory
	
$cache->start();
# indien de cache wordt aangesproken wordt het resultaat naar de browser gestuurd en stopt het script hier
	
// rest van de pagina ...
	
?>