<sect1 id="zend.cache.introduction">
	<title>Introducción</title>
	<para>
		<code>Zend_Cache</code>
		provee una forma genérica para cualquier caché de datos.
	</para>
	<para>
		El almacenamiento en caché en Zend Framework se opera por
		interfaces, mientras que los registros de caché son almacenados
		a través de adapatadores del backend (
		<code>Archivo</code>
		,
		<code>Sqlite</code>
		,
		<code>Memcache</code>
		...) mediante un sistema flexible de documentos de identidad y
		etiquetas. Utilizando éstas, es fácil en el futuro eliminar
		determinados tipos de registro.(Ejemplo: "eliminar todos los
		registros caché de determinada etiqueta").
	</para>
	<para>
		El módulo principal (
		<code>Zend_Cache_Core</code>
		) es genérico, flexible y configurable. Aun para sus necesidades
		específicas existen frontends de caché que extienden
		<code>Zend_Cache_Core</code>
		a conveniencia:
		<code>Output</code>
		,
		<code>File</code>
		,
		<code>Function</code>
		y
		<code>Class</code>
		.

	</para>
	<example id="zend.cache.introduction.example-1">
		<title>
			Obtener un frontend con
			<code>Zend_Cache::factory()</code>
		</title>
		<para>
			<code>Zend_Cache::factory()</code>
			ejemplifica objetos correctos y los une. En este primer
			ejemplo, usaremos el frontend
			<code>Core</code>
			junto con el backend
			<code>File</code>
			.
		</para>

		<programlisting role="php"><![CDATA[
$frontendOptions = array(
   'lifetime' => 7200, // tiempo de vida de caché de 2 horas
   'automatic_serialization' => true
);

$backendOptions = array(
    'cache_dir' => './tmp/' // Carpeta donde alojar los archivos de caché
);

// getting a Zend_Cache_Core object
$cache = Zend_Cache::factory('Core',
                             'File',
                             $frontendOptions,
                             $backendOptions);
]]>
		</programlisting>
	</example>

	<note>
		<title>
			Frontends y Backends Compuestos de Múltiples Palabras
		</title>
		<para>
			Algunos frontends y backends se nombran usando varias
			palabras, tal como 'ZenPlatform'. Al fabricarlas las
			especificamos, las separamos usando un separador de
			palabras, como un espacio (' '), guión ('-'), o punto ('.').
		</para>
	</note>

	<example id="zend.cache.introduction.example-2">
		<title>Almacenando en caché un resultado de consulta a una base de datos</title>

		<para>
			Ahora que tenemos un frontend, podemos almacenar en caché
			cualquier tipo de dato (hemos activado la serialización). Por
			ejemplo, podemos almacenar en caché un resultado de una
			consulta de base de datos muy costosa. Después de ser
			almacenada en caché, no es necesario ni conectar la base
			de datos; los registros se obtienen del caché de forma no
			serializada.
		</para>

		<programlisting role="php"><![CDATA[
// $cache initializada en el ejemplo anterior

// Verificar si la cahce existe:
if(!$result = $cache->load('myresult')) {

    // no existe cache; conectar a la base de datos

    $db = Zend_Db::factory( [...] );

    $result = $db->fetchAll('SELECT * FROM huge_table');

    $cache->save($result, 'myresult');

} else {

    // cache existosa!, darlo a conocer
    echo "Éste es de caché!\n\n";

}

print_r($result);
]]>
		</programlisting>
	</example>

	<example id="zend.cache.introduction.example-3">
		<title>
			El almacenamiento en caché de salida con la interfaz de
			salida
			<code>Zend_Cache</code>
		</title>
		<para>
			‘Resaltamos’ las secciones en las que deseamos almacenar en
			caché la salida, mediante la adición de algunas condiciones lógicas,
			encapsulamos la sección dentro de los métodos
			<code>start()</code>
			y
			<code>end()</code>
			(esto se parece al primer ejemplo y es la estrategia
			fundamental para el almacenamiento en caché).
		</para>
		<para>
			Dentro, los datos de salida, como siempre – todas las salidas
			serán almacenadas en caché cuando se ordene la ejecución del
			método
			<code>end()</code>
			. En la siguiente ejecución, toda la sección se saltará a
			favor de la búsqueda de datos del caché (tanto tiempo como
			el registro del caché sea válido).
		</para>
		<programlisting role="php"><![CDATA[
$frontendOptions = array(
   'lifetime' => 30,                   // tiempo de vida de caché de 30 segundos
   'automatic_serialization' => false  // éste es el valor por defecto
);

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

$cache = Zend_Cache::factory('Output',
                             'File',
                             $frontendOptions,
                             $backendOptions);

// Pasamos un identificador único al método start() 
if(!$cache->start('mypage')) {
    // salida como de costumbre:

    echo 'Hola mundo! ';
    echo 'Esto está en caché ('.time().') ';

    $cache->end(); // la salida es guardada y enviada al navegador
}

echo 'Esto no estará en caché nunca ('.time().').';
]]>
		</programlisting>
		<para>
			Note que delineamos el resultado de
			<code>time()</code>
			dos veces; esto es algo dinámico para los propósitos de la
			demostración. Trate de ejecutarlo y entonces regenérelo
			muchas veces; notará que el primer número no cambia mientras
			que el segundo cambia a medida que pasa el tiempo. Esto
			es porque el primer número esta delineado en la sección
			caché y esta guardado en medio de otras salidas. Después de
			medio minuto (habremos establecido el tiempo de vida de 30
			segundos) los números deben acoplarse nuevamente porque el
			registro caché ha expirado -- sólo para ser almacenado en
			caché nuevamente. Deberá probarlo en su visualizador o
			consola.
		</para>
	</example>
	<note>
		<para>
			Cuando usamos Zend_Cache, ponemos atención a la importación
			del identificador caché (pasado a 
			<code>save()</code>
			y
			<code>start()</code>
			). Éste deberá ser único para cada recurso que se almacene
			en caché, de otra manera los registros almacenados en caché
			que no se vinculan podrían borrarse unos a otros, o peor
			aún, mostrarse uno en lugar del otro.
		</para>
	</note>
</sect1>
<!--
	vim:se ts=4 sw=4 et:
-->
