Sia per l'incremento di visite o per lúso di script sempre piú complessi, la esecuzione di consulte costanti al database MySQL puó provocare rallentamenti o addirittura un crash del server.

Una delle migliori alternative per la soluzione a questo problema è implementare un sistema di Cache con PHP. Con questo, invece di realizzare tutte le consulte al Database per generare una pagina, semplicemente si genererá un archivio html. Il risoltato è un enorme risparmio di risorse e una risposta molto piú rapida da parte del server.

In questo mini tutorial vedremo la creazione di una semplicissima classe PHP, peró sufficientemente flessibile per essere adattata ai nostri progetti e personalizzata secondo le nostre necessitá.

Le funzioni basiche

Peró prima di andare alla parte pratica e vedere il codice sorgente, diamo uno sguardo alle tre funzioni chiave che utilizzeremo nello script:

fileatime(): Con questa funzione otterremo il momento esatto (ora del server) in cui il file di cache `stato creato. Questo dato, ci servirá per verificare se la cache è scaduta(expired).

ob_start(): Questa funzione è la principale, e irrimpiazzabile, di tutte. Con essa indichiamo a PHP che immagazzini in un buffer interno tutta la informazione di uscita che incontra. Cioé, non si mostrerá niente nel browser, tutto il testo (html) finirá immagazzinato nel buffer.

ob_get_clean(): Questa funzione implementa ob_start() e permette di ridurre alcune linee di codice. In generale, per creare una cache si usano solitamente ob_get_contents() per recuperare e mostrare la informazione salvata nel buffer interno e, di seguito, ob_end_clean() per pulire il buffer. Bene, con ob_get_clean() otteniamo lo stesso risultato che utilizzando le due anteriori.

Conoscendo le funzioni chiave per creare il nostro script, ora vedremo il suo processo di creazione.

Gli attributi necessari

La nostra classe abbisogna di cinque attributi (variabili chiave). Ognuno di loro conterrá informazioni chiave per far funzionare la nostra classe correttamente.

$cache_dir, per indicare il path dove si immagazzina la cache
$cache_time, per indicare il tempo di durata della cache (in secondi)
$caching, se è true specifica che si salvi la cache. False per difetto.
$cleaning, se è true specifica che si pulisca la cache, per attualizzarla successivamente. False per difetto.
$file, per indicare il path dello script da cacheare

Conoscendo le funzioni básiche e gli attributi necessari, procedimao alla creazione della nostra classe.

La Classe PHP: Cache

La Nostra classe avrá solamente due metodi, con il primo indicheremo che si inizi la esecuzione della cache e con il secondo, che si finalizzi. I métodi sono:

function start_cache(): Questo metodo richiede 2 parámetri obbligatori e 1 opzionale. I due parámetri obbligatori sono:

$path, che trasmette il path della cache a $cache_dir; e
$time, que trasmette il tempo massimo di durata della cache a $cache_time.

Il parametro opzionale ($action), è molto utile per siti che si attualizzano costantemente. Per esempio, una pagina che mostra notizie, deve attualizzarsi ogni volta che si invia una notizia nuova, o la pagina di un articolo deve attualizzarsi ogni volta che si invia un commento nuovo. Voglio dire, ogni volta che si esegue una determinata azione, deve attualizzarsi la cache. Per ottenere questo possiamo utilizzare il seguente parametro:

$action, che trasmette se la cache deve attualizzarsi a $cleaning. Se si è eseguita una determinata azione, $action è true. Per difetto è false.

Una volta recuperati i parametri, il metodo start_cache() verificherá se si compie una condizione. Se la risposta é si, si legge la cache. Peró,se la risposta è no, immagazziniamo la informazione nel buffer e torniamo al parametro $caching come true (false per difetto).

Per ridurre far si che la classe sia ridotta di volume, e farla piú semplice, per la scrittura della cache utilizzeremo la funzione readfile(), al posto delle piú conosciute fopen(), fread() e fclose(), anche se, utilizzare queste funzioni, renderebbe la cosa piú flessibile (Nel codice appaiono commentate).

Il secondo metodo che utilizzeremo è:

function close_cache(): Questo metodo verifica se $caching é true. Se la risposta è affermativa, recupera la informazione salvata nel buffer, la mostra, e scrive (crea o attualizza) il file di cache.

  
/*
* Clase PHP - Cache
* www.baluart.net
*/

class cache 
{
var $cache_dir; // path dove si immagazzina la cache
var $cache_time; // tempo di expire della cache (in secondi)
var $caching = false; //true, per cacheare
var $cleaning = false; //true, per pulire e attualizzare
var $file = ''; // path dello script che si va cacheare

function start_cache($path='',$time,$action=NULL){

global $_SERVER;

$this->cache_dir = $path;
$this->cache_time = $time;
$this->cleaning = $action;
$this->file = $this->cache_dir."cache_".md5(urlencode($_SERVER['REQUEST_URI'])); //md5, criptato per sicurezza

//condizionale: Esistenza dell archivio, data di expire, azione
if (file_exists($this->file) && (fileatime($this->file)+$this->cache_time)>time() && $this->cleaning == false){

readfile($this->file);
/*
// apriamo il file
$handle = fopen( $this->file , "r");
do {
//leggiamo fino a 8192 bytes per difetto (possiamo incrementarlo)
$data = fread($handle, 8192);
if (strlen($data) == 0) {
break;
}
//mostriamo la cache
echo $data;
} while (true);
fclose($handle);
*/
exit();
} else {
$this->caching = true;
//grabamos buffer
ob_start();
}
}

function close_cache(){
if ($this->caching){
//Recuperiamo informaczione del buffer
$data = ob_get_clean();
// mostriamo informazione
echo $data;
//cancelliamo cache se esiste
if(file_exists($this->file)){
unlink($this->file);
}
//scriviamo informazione in cache
$fp = fopen( $this->file , 'w' );
fwrite ( $fp , $data );
fclose ( $fp );
}
}

} // Fine classe Cache

Cache con PHP: Messa in moto

Finalmente possiamo utilizzare il nostro script er cacheare qualsiasi pagina PHP. A mó di esempio, andiamo cacheare solo un pezzo di codice PHP e un'altro pezzo no, per osservare il suo funzionamento.

//Creiamo la istanza
$cache1 = new cache();
//Senza cache
echo "Sin cache: ". date("D M j G:i:s T Y") . "
";
//Con cache per sessanta secondi.
$cache1->start_cache('tmp/',60,false);
echo "Con cache: ". date("D M j G:i:s T Y");
$cache1->close_cache();
//Chiudiamo la cache

Tuttavia dobbiamo fare attenzione a che la cache immagazzini tutto il codice html cheandiamo a mostrare nella pagina. In caso contrario, quando si utilizza la cache, il testo posteriore alla cache non sará mostrato. Questo è dovuto al fatto che utilizziamo la funzione exit() per terminare la esecuzione dello script.

Conclusioni e esempio finale

Finalmente, possiamo vedere un esempio del funzionamento

include('clases/cache.class.php');

Dove cache.class.phpè il nome del file che contiene la classe.

Bene, per ora è tutto, spero che questo minitutorial vi sia di aiuto.