Zend_Cache_Core es un frontend especial porque es el núcleo del módulo. Es un frontend de caché genérico y es extendido por otras clases.

	Nota
	Todos los frontends heredan de Zend_Cache_Core de modo que sus métodos y opciones (descritos abajo) también estarán disponibles en otros frontends, por lo que no se documentarán allí.

Estas opciones se pasan al método factory tal como se demostró en ejemplos anteriores.

Se da un ejemplo en el manual al principio.

Si solo se almacenan cadenas en caché (porque con la opción "automatic_serialization", es posible almacenar algunos booleanos), se puede usar una construcción más compacta como:

// we assume you already have $cache

$id = 'myBigLoop'; // cache id of "what we want to cache"

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

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

    $cache->save($data);

}

// [...] do something with $data (echo it, pass it on etc.)

Si desea cachear múltiples bloques o instancias de datos, la idea es la misma:

// make sure you use unique identifiers:
$id1 = 'foo';
$id2 = 'bar';

// block 1
if ( ($data = $cache->load($id1)) === false ) {
    // cache missed

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

    $cache->save($data);

}
echo($data);

// this isn't affected by caching
echo('NEVER CACHED! ');

// block 2
if ( ($data = $cache->load($id2)) === false ) {
    // cache missed

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

    $cache->save($data);

}
echo($data);

Si desea cachear valores especiales (booleanos con la opción "automatic_serialization") o cadenas vacías, no puede usar la construcción compacta anterior. Debe probar formalmente el registro de caché.

// the compact construction
// (not good if you cache empty strings and/or booleans)
if ( ($data = $cache->load($id)) === false ) {

    // cache missed

    // [...] we make $data

    $cache->save($data);

}

// we do something with $data

// [...]

// the complete construction (works in any case)
if (!($cache->test($id))) {

    // cache missed

    // [...] we make $data

    $cache->save($data);

} else {

    // cache hit

    $data = $cache->load($id);

}

// we do something with $data

Zend_Cache_Frontend_Output es un frontend de captura de salida. Utiliza el almacenamiento en búfer de salida en PHP para capturar todo lo que hay entre sus métodos start() y end().

Este frontend no tiene ninguna opción específica aparte de las de Zend_Cache_Core.

Se da un ejemplo en el manual al principio. Aquí está con cambios menores:

// if it is a cache miss, output buffering is triggered
if (!($cache->start('mypage'))) {

    // output everything as usual
    echo 'Hello world! ';
    echo 'This is cached ('.time().') ';

    $cache->end(); // output buffering ends

}

echo 'This is never cached ('.time().').';

Usando esta forma es bastante fácil establecer el caché de salida en un proyecto que ya está funcionando con poca o ninguna refactorización de código.

Zend_Cache_Frontend_Function cachea los resultados de las llamadas a funciones. Tiene un único método principal llamado call() que toma un nombre de función y los parámetros para la llamada en un array.

Usar la función call() es lo mismo que usar call_user_func_array() en PHP:

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

// $params is an array
// For example to call veryExpensiveFunc(1, 'foo', 'bar') with
// caching, you can use
// $cache->call('veryExpensiveFunc', array(1, 'foo', 'bar'))

Zend_Cache_Frontend_Function es lo bastante inteligente como para cachear tanto el valor de retorno de la función como su salida interna.

	Nota
	Se puede pasar cualquier función interna o definida por el usuario, con la excepción de array(), echo(), empty(), eval(), exit(), isset(), list(), print() y unset().

Zend_Cache_Frontend_Class es diferente de Zend_Cache_Frontend_Function porque permite cachear llamadas a métodos de objetos y métodos estáticos.

Por ejemplo, para cachear llamadas estáticas:

class Test {

    // Static method
    public static function foobar($param1, $param2) {
        echo "foobar_output($param1, $param2)";
        return "foobar_return($param1, $param2)";
    }

}

// [...]
$frontendOptions = array(
    'cached_entity' => 'Test' // The name of the class
);
// [...]

// The cached call
$result = $cache->foobar('1', '2');

Para cachear llamadas a métodos clásicos:

class Test {

    private $_string = 'hello !';

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

}

// [...]
$frontendOptions = array(
    'cached_entity' => new Test() // An instance of the class
);
// [...]

// The cached call
$result = $cache->foobar2('1', '2');

Zend_Cache_Frontend_File es un frontend gobernado por el tiempo de modificación de un "archivo maestro". Es realmente interesante para ejemplos en cuestiones de configuración o plantillas. También es posible usar múltiples archivos maestros.

Por ejemplo, tiene un archivo de configuración XML que es analizado por una función que devuelve un "objeto de configuración" (como con Zend_Config). Con Zend_Cache_Frontend_File, se puede almacenar el "objeto de configuración" en caché (para evitar el análisis del archivo de configuración XML cada vez) pero con una especie de dependencia fuerte del "archivo maestro". Así, si el archivo de configuración XML se modifica, la caché se invalida inmediatamente.

El uso de este frontend es el mismo que el de Zend_Cache_Core. No hay necesidad de un ejemplo específico: lo único que hay que hacer es definir el master_file al usar el factory.

Zend_Cache_Frontend_Page es como Zend_Cache_Frontend_Output pero está diseñado para una página completa. Es imposible usar Zend_Cache_Frontend_Page para cachear solo un bloque.

Por otro lado, el "id de caché" se calcula automáticamente con $_SERVER['REQUEST_URI'] y (dependiendo de las opciones) $_GET, $_POST, $_SESSION, $_COOKIE, $_FILES. Además, solo hay que llamar a un método (start()) porque la llamada a end() es completamente automática cuando termina la página.

Por el momento, no está implementado, pero planeamos añadir un sistema condicional HTTP para ahorrar ancho de banda (el sistema enviará un HTTP 304 Not Modified si la caché tiene un acierto y si el navegador ya tiene la versión correcta).

Nota

Este frontend opera registrando una función de retorno de llamada (callback) que se invoca cuando se limpia el búfer de salida que utiliza. Para que esto funcione correctamente, debe ser el último búfer de salida en la petición. Para garantizar esto, el almacenamiento en búfer de salida usado por el Dispatcher debe deshabilitarse llamando al método setParam() de Zend_Controller_Front, por ejemplo, $front->setParam('disableOutputBuffering', true); o añadiendo "resources.frontcontroller.params.disableOutputBuffering = true" a su archivo de configuración de arranque (se asume INI) si usa Zend_Application.

El uso de Zend_Cache_Frontend_Page es realmente trivial:

// [...] // require, configuration and factory

$cache->start();
// if the cache is hit, the result is sent to the browser
// and the script stop here

// rest of the page ...

un ejemplo más complejo que muestra una forma de obtener una gestión centralizada de la caché en un archivo de arranque (para usar con Zend_Controller, por ejemplo)

/*
 * You should avoid putting too many lines before the cache section.
 * For example, for optimal performances, "require_once" or
 * "Zend_Loader::loadClass" should be after the cache section.
 */

$frontendOptions = array(
   'lifetime' => 7200,
   'debug_header' => true, // for debugging
   'regexps' => array(
       // cache the whole IndexController
       '^/$' => array('cache' => true),

       // cache the whole IndexController
       '^/index/' => array('cache' => true),

       // we don't cache the ArticleController...
       '^/article/' => array('cache' => false),

       // ... but we cache the "view" action of this ArticleController
       '^/article/view/' => array(
           'cache' => true,

           // and we cache even there are some variables in $_POST
           'cache_with_post_variables' => true,

           // but the cache will be dependent on the $_POST array
           'make_id_with_post_variables' => true
       )
   )
);

$backendOptions = array(
    'cache_dir' => '/tmp/'
);

// getting a Zend_Cache_Frontend_Page object
$cache = Zend_Cache::factory('Page',
                             'File',
                             $frontendOptions,
                             $backendOptions);

$cache->start();
// if the cache is hit, the result is sent to the browser and the
// script stop here

// [...] the end of the bootstrap file
// these lines won't be executed if the cache is hit

Debido a cuestiones de diseño, en algunos casos (por ejemplo cuando se usan códigos de retorno HTTP distintos de 200), podría necesitar cancelar el proceso de caché actual. Por eso introducimos para este frontend en particular el método cancel().

// [...] // require, configuration and factory

$cache->start();

// [...]

if ($someTest) {
    $cache->cancel();
    // [...]
}

// [...]

Zend_Cache_Frontend_Capture es como Zend_Cache_Frontend_Output pero está diseñado para una página completa. Es imposible usar Zend_Cache_Frontend_Capture para cachear solo un bloque. Esta clase está diseñada específicamente para funcionar en conjunto solo con el backend Zend_Cache_Backend_Static para ayudar a cachear páginas completas de HTML / XML u otro contenido en un archivo físico estático del sistema de archivos local.

Consulte la documentación de Zend_Cache_Backend_Static para todos los casos de uso relativos a esta clase.

Nota

Este frontend opera registrando una función de retorno de llamada (callback) que se invoca cuando se limpia el búfer de salida que utiliza. Para que esto funcione correctamente, debe ser el último búfer de salida en la petición. Para garantizar esto, el almacenamiento en búfer de salida usado por el Dispatcher debe deshabilitarse llamando al método setParam() de Zend_Controller_Front, por ejemplo, $front->setParam('disableOutputBuffering', true); o añadiendo "resources.frontcontroller.params.disableOutputBuffering = true" a su archivo de configuración de arranque (se asume INI) si usa Zend_Application.