Questo articolo fa parte di una serie dedicata alla programmazione di un framework MVC personalizzato in PHP. L'autore ha chiamato questo framework "Taste". Gli altri articoli della serie sono disponibili nella categoria Taste framework di php.html.it.
Con l'articolo di oggi ci prendiamo una piccola pausa per quanto riguarda
l'avanzamento dei lavori e ci soffermiamo su un'operazione di supporto che è
ormai fondamentale per tutte le applicazioni ed i siti web con alto traffico o
un basso numero di risorse: il caching.
Con caching si intendono fondamentalmente una serie di
operazioni che servono a salvare i risultati intermedi di un'elaborazione e
restituirli nel caso in cui venga richiamata la stessa operazione senza
effettuare nuovamente i calcoli. I browser internet per esempio immagazzinano su
disco, per un periodo di tempo controllato dagli header http e dalle
impostazioni di configurazione, i file recuperati dalla rete in modo da non
dover scaricare ogni volta lo stesso file nel caso di richieste successive.
Aggiungeremo quindi il supporto al caching sui due fronti che sono
solitamente quelli più sottoposti a stress: il routing e l'output dei
controller, implementando le classi necessarie e modificando leggermente il file
di bootstrap per riflettere i cambiamenti.
Come sempre potete trovare i sorgenti allegati a questo articolo, nella
sezione download.
Caching delle operazioni di routing
Come prima cosa iniziamo implementando il caching sulle operazioni di
routing. Ogni qualvolta viene richiesta una pagina il router
implementato deve effettuare un controllo su tutte le regole di routing
specificate, eseguendo delle espressioni regolari per verificare quale regola
risponde all'URL richiesto e recuperare il controller desiderato. Nel caso di un
grosso numero di pagine ed un alto numero di richieste le operazioni possono
essere molto gravose.
Per evitare questo implementeremo un router che salva i risultati delle
singole operazioni di routing all'interno di una cache su disco (che sarà
rappresentata da un array associativo) che verrà interrogata prima di
confrontare l'url recuperato con le regole specificate nel file di bootstrap. Le
chiavi di ogni record della cache saranno gli URL che provengono dalla
richiesta, comprensivi di eventuali parametri.
L'implementazione di questo router (che potete trovare all'interno del file
taste/mvc/routing/CachedRouter.php
Router
cui non venga trovato nella cache un record corrispondente alla richiesta.
class CachedRouter extends Router
{
private $cache_file;
private $cache;
private $base_router;
public function __construct(Router $base_router)
{
parent::__construct();
$this->base_router = $base_router;
$this-->cache = array();
$cache_dir = $this-->config-->get('cacheDir', 'static/cache/');
if($cache_dir{0} != '/')
$cache_dir = realpath(TASTE_DIR."/../".$cache_dir);
$this-->cache_file = $cache_file = $cache_dir."/cached_router_cache.php";
if(!file_exists($cache_file))
{
$fp = fopen($cache_file, "w+");
flock($fp, LOCK_EX);
fwrite($fp, "");
flock($fp, LOCK_UN);
fclose($fp);
}else
$this-->cache = require_once($cache_file);
}
public function route($url)
{
if(!array_key_exists($url, $this-->cache))
{
$cpath = $this-->base_router-->route($url);
if(is_null($cpath))
return null;
$this-->cache[$url] = $cpath;
$fp = fopen($this-->cache_file, "w+");
flock($fp, LOCK_EX);
fwrite($fp, "");
flock($fp, LOCK_UN);
fclose($fp);
}
return $this-->cache[$url];
}
}
La cache è salvata all'interno di un file PHP, e viene importata in fase di
inizializzazione ed aggiornata con il risultato del processo di routing nel caso
in cui non vi sia ancora alcun record corrispondente alla richiesta effettuata.
Effettuare il caching in questo modo per questo genere di operazione non è
forse la soluzioni migliore; sarebbe preferibile utilizzare qualche sistema che
mantenga l'array in memoria condivisa tra le varie richieste (come ad esempio
memcached).
La cache su disco
Prima di descrivere come implementare il caching delle risposte generate dai
controller ci occupiamo di vedere come si è deciso di rappresentare la cache su
disco. In questo caso ogni risposta verrà salvata all'interno di un file
differente, posizionato nella cartella di caching specificata nel file di
configurazione. La cache nel suo insieme è rappresentata da un'istanza della
classe Cache, mentre ogni singolo elemento salvato da un'istanza
della classe Slot. Entrambi queste classi sono definite all'interno
della cartella taste/cache.
La classe Cache espone dei metodi per recuperare, eliminare e
salvare degli Slot. Automaticamente si occupa di controllarne la
validità ed eventualmente di rimuovere da disco i file corrispondenti nel caso
in cui risultino scaduti. Il periodo di vita di uno slot è definito in modo
univoco in fase di costruzione della classe Cache, e può
eventualmente essere variato.
La classe Slot invece contiene i dati relativi ad un determinato
record della cache, che può essere salvato su disco dalla classe Cache
e recuperato quando richiesto.
$key = 'una-chiave-possibilmente-univoca';
$timeout = 10;
$cache = new Cache('/tmp/cache', $timeout);
$slot = $cache-->find($key);
if(is_null($slot))
{
$data = COMPUTE();
$slot = new Slot($key, $timeout);
$slot-->setData($data);
$cache-->store($slot);
}
echo $slot-->getData();
Quando vogliamo utilizzare la cache, le operazioni da eseguire sono molto
semplici:
- Inizializziamo la cache con la directory in cui salvare gli slot ed il tempo
di vita di ogni singolo slot; - richiedere alla cache lo slot necessario;
- se lo slot esiste utilizzare il metodo
getDataper recuperarne
il valore e gestirlo come necessario; - se lo slot non esiste, computarne il valore, crearne uno nuovo e salvarlo
all'interno della cache.
L'applicazione CacheApplication
Utilizzando la classe Cache e la classe Slot
precedentemente implementate, possiamo sviluppare l'applicazione che si occuperà
di effettuare in automatico il caching delle risposte generate in base alle
richieste. La classe in questione (che potete trovare in
taste/applications/CacheApplication.phpApplication
e viene utilizzata come middleware che opera in modo trasparente su un'altra
applicazione, che viene interrogata per recuperare i dati nel caso in cui la
cache per una determinata richiesta non esista oppure sia scaduta.
class CacheApplication extends Application
{
public function run(Request $request)
{
$key = md5($request-->getPathInfo());
$timeout = intval($this-->config-->get('timeout', 5));
$cache_dir = $this-->config-->get('cacheDir', 'static/cache');
if($cache_dir{0} != '/')
$cache_dir = realpath(TASTE_DIR."/../".$cache_dir);
$cache = new Cache($cache_dir, $timeout);
$slot = $cache-->find($key);
if(is_null($slot))
{
$response = $this-->runParent($request);
$slot = new Slot($key, $timeout);
$slot-->setData($response-->getContent());
$cache-->store($slot);
}else
$response = new Response($slot-->getData());
$response-->setHeaderIfUnset('ETag', $slot-->getId());
$response-->setHeaderIfUnset('Last-Modified', date("r"));
$response-->setHeaderIfUnset('Expires', date("r", $slot-->expireTime()));
$response-->setHeaderIfUnset('Cache-Control', "max_age=".$timeout);
return $response;
}
}
Sfruttando il sistema di middleware implementato quando abbiamo discusso
della classe Application, possiamo incapsulare un'applicazione
qualsiasi con una CacheApplication che salterà automaticamente il
processo di elaborazione della risposta nel caso in cui sia presente uno slot su
disco (non scaduto) corrispondente all'URL richiesto.
In aggiunta alla generazione automatica del response, ho inserito degli
header HTTP che informano il browser del fatto che la risposta che riceverà
potrà essere salvata in locale per un periodo di tempo pari al tempo di vita
dello slot recuperato. Gli header HTTP ed il processo di caching possono
sicuramente essere ottimizzati e migliorati in modo da comportarsi
differentemente in base alla tipologia di richiesta effettuata o al controller
che si prende in esame; per esempio potrebbe essere interessante sviluppare una
tipologia particolare di controller i cui risultati delle azioni richiamate non
verranno salvati in cache. Oppure si potrebbe utilizzare la query string come
discriminante per decidere se utilizzare o meno la cache.
Come ultima operazione per controllare definitivamente che i processi di
caching funzionino correttamente, dobbiamo modificare leggermente il file di
bootstrap in modo da aggiungere le chiamate alle classi CachedRouter
e CacheApplication.
require_once 'taste.php';
require_once 'taste/Server.php';
require_once 'taste/mvc/routing/ExplicitRouter.php';
require_once 'taste/mvc/routing/CachedRouter.php';
require_once 'taste/applications/MVCApplication.php';
require_once 'taste/applications/CacheApplication.php';
$router = new ExplicitRouter(array(
"^list/?$" => "test.TestController.show",
"^list/(d{4})/?$" => "test.TestController.show",
"^list/(d{4})/(d{2})/?$" => "test.TestController.show",
"^list/(d{4})/(d{2})/(d{2})/?$" => "test.TestController.show",
));
$router = new CachedRouter($router);
$server = new Server(
new CacheApplication(
new MVCApplication($router)));
$server-->run();
Conclusione
Abbiamo terminato questa piccola ma importate parentesi che ha anche
dimostrato come sia semplice estendere le applicazioni in modo da farle aderire
alle nostre esigenze. Nel prossimo articolo inizieremo a discutere del sistema
di template e di come strutturare un template engine basato su XML.
