Cacheando contenido con PHP

Cacheando contenido con PHP: "Hace unas semanas tuve que implementar una Class para cachear elementos de mi PHP en ficheros estáticos. Inicialmente usé un sistema similar al que había usado siempre basado en la función filemtime() que me devolvía la fecha de modificación del archivo estático y la contrastaba con la actual, si el resultado era mayor a un número de segundos especificado volvía a generar el fichero estático.

Código filemtime()

class Cache {
function fileName($key){
return 'cache/'.md5($key);
}

function put($key, $datos){
$f = fopen($this->fileName($key), 'w');
if (!$f) die('No se puede leer el fichero de caché');

$data = serialize($data);

if (fwrite($f,$data)===false) {
die('No se puede escribir el fichero de caché');
}
fclose($f);
}

function get($key){
$filename = $this->fileName($key);
if (!file_exists($filename) || !is_readable($filename)) return false;
if ((filemtime($filename) + 3600) < time()) {
return file_get_contents($filename);
}
return false;
}
}

Esta versión, me permite cachear en fichero cualquier contenido que yo le indique mediante put(). Veamos un ejemplo.

$cache = new Cache();
if (!$data = $cache->get('misdatos')) {
....
$cache->put('misdatos', $misdatos);
}

Problemas

Tras unas horas usándolo me encontré con un problema, la poca flexibilidad de este sistema. Necesitaba que ciertos datos, se cachearan una hora y otros lo hicieran 24. De esta forma me era dificil montar un sistema basado en filemtime() que me permitiera indicar una caché para tiempos diferentes.

Las soluciones pasaba por comprobar el tipo de contenido y dependiendo de que fuera tomar un tiempo u otro, o crear métodos específicos para cachear por tiempos (put60(), put24(),...). Ninguna solución me parecía elegante.

Serialize()

Entonce recordé un artículo de hace ya unos años en los que mediante el uso de serialize() permitía hacer lo que estaba buscando.

serialize() es una función de PHP que permite convertir un objeto que puede ser fácilmente almacenable. Algo que me venía ideal para hacer que mi caché de ficheros estática fuera más flexible.

Código serialize()

>class Cache {
var $cacheDir;

function __construct($cacheDir = './'){
$this->cacheDir = $cacheDir;
}

// Indicamos el directorio donde queremos alojar los ficheros de caché
function put( $key , $data ,$time = 600) {

$h = fopen( $this->getFileName( $key ) , 'w' );
if (!$h) throw new Error('No se puede leer el fichero de caché');

$data = serialize( array( time() + $time , $data ) );

if ( fwrite( $h , $data ) === false ) {
throw new Error('No se puede escribir el fichero de caché');
}
fclose($h);

}

// Obtenemos el nombre del fichero codificado
private function getFileName($key) {
return  $this->cacheDir.md5($key);
}

// Recuperamos de caché
function get($key) {

$filename = $this->getFileName($key);
if (!file_exists($filename) || !is_readable($filename)) return false;

$data = file_get_contents($filename);

$data = @unserialize($data);
if (!$data) {
unlink($filename);
return false;
}
if (time() > $data[0]) {
unlink($filename);
return false;
}
return $data[1];
}
}

Esta clase ya me permite especificiar de una forma cómoda el tiempo que quiero que se cachee un contenido determinado.

$cache = new Cache('cache/');
if (!$data = $cache->get('misdatos')) {
....
$cache->put('misdatos', $misdatos, 60); // 60 seg
}

Rendimiento

Este sistema es muy cómodo, pero hay que ser conscientes de los problemas de rendimiento que presenta. Hemos de pensar que cada comprobación pasa por leer el contenido del fichero, convertir el objeto serializado y comprobar la fecha de este último.

Esto, frente a la simple consulta de la última fecha de modificación hace que este método sea considerablemente más lento. Pero por contra es bastante más flexible.

Mejoras

Bueno, despues de todo el rollo os propongo un juego. ¿Como lo podemos mejorar?

Mi opción

La opción que estaba barajando era la de generar un fichero con la fecha de caducidad del fichero y el nombre del fichero. De esta forma, únicamente tendría que hacer una lectura de fichero para cargar la fecha de caducidad asociada al fichero y despues mediante filemtime() comprobar si esta es superior a la especificada.

Ejemplo

<?php
...

// Leer
$content = file_get_content($file);
$times = unserialize($content);

if (filemtime($cache_file) > $times[$cache_file]) {
....
 // Generamos de nuevo la caché
 $times[$cache_file] = time() + 60; // 60 seg.
}

// Grabar
serialize(array(
md5("tmp".time()).".cache" => '123456789'
....
));

...
?>

¿Alguna idea más?

Noticies XGavalda

Cercar en aquest blog