Tutoriel : Système de cache de Dr Night

Création du dossier cache

Pour fonctionner, le système de cache a besoin d'un dossier autorisé en lecture et en écriture pour stocker les données temporaires.

Ici, le dossier sera placé en racine du site et son nom sera cache (ouais, on va pas spécialement chercher quelque chose d'original :lol: ).

Fonctionnement

Le système de cache a besoin d'effectuer trois actions :

• créer un fichier de cache contenant des informations,

• lire les informations contenues dans un fichier de cache,

• détruire un fichier de cache.

Oui, le système est basé sur la création et la suppression de fichiers, et pas vraiment sur la modification.

Explications

Imaginons que nous voulons mettre en cache les messages d'un sujet de forum.

Au premier affichage, le script constate qu'il n'existe pas de fichier de cache contenant les messages voulus, il va alors récupérer dans la base de données les messages, puis créera un nouveau fichier de cache contenant ces messages.

Aux prochains affichages, le script verra que le fichier de cache existe et lira donc son contenu, sans passer par la base de données.

Lors d'une modification, c'est-à-dire quand un message sera posté, le fichier de cache sera effacé, et la base de données mise à jour pour qu'au prochain affichage, un nouveau fichier de cache soit créé !

Regardez bien, il n'y a que trois actions différentes à effectuer. ;) On peut maintenant commencer le concret !

Définition des fonctions

Comme je l'ai dit plus haut, le système de cache a besoin d'effectuer trois actions principales. Ces trois grandes actions vont être effectuées par trois fonctions PHP (que nous allons créer) :

• create_cache(nom_cache,contenu)

• get_cache(nom_cache)

• destroy_cache(nom_cache)

Vous l'aurez peut-être compris, create_cache() permet d'enregistrer contenu dans le fichier de cache nommé nom_cache, get_cache() permet de récupérer contenu et destroy_cache() permet de détruire le cache nom_cache.

Écriture des fonctions

Création d'un cache

create_cache()

L'idée est d'obtenir une fonction PHP qui, quand on l'appelle, restitue les données qu'on lui a fournies lors de sa création.

Pour stocker tout type de données, on va utiliser la fonction serialize(), qui transforme n'importe quelle variable (ou presque) en une chaîne de caractères.

Le fichier créé contiendra le code permettant de récupérer la variable initiale en utilisant la fonction unserialize().

Voilà la fonction que j'ai faite :

<?php
// met en cache une variable
function create_cache($nom_cache, $contenu)
{
        // Utilisation de serialize() pour transformer $content en chaîne de caractères.
        $contenu = serialize($contenu);

        // Échappement les caractères spéciaux pour pouvoir mettre le tout entre quotes dans le futur fichier.
        $contenu = str_replace(array('', '\'', "0"), array('\\', '\'', '0'), $contenu);

        // Création du code PHP à stocker dans le fichier.
        $contenu = '<?php' . "nn" . '$cache = unserialize('' .  $contenu . '');' . "nn" . '?>';
        
        // Écriture du code dans le fichier.
        $fichier = fopen('./cache/donnees_' . $nom_cache . '.php', 'w');
        $resultat = fwrite($fichier, $contenu);
        fclose($fichier);

        // Renvoie true si l'écriture du fichier a réussi.
        return $resultat;
}?>

Lecture d'un cache

get_cache()

Vous pouvez tester la fonction create_cache(), par exemple en faisant
create_cache('test', 'Bonjour !').

Vous verrez ensuite qu'un fichier nommé donnees_test.php aura été créé dans le dossier cache/.

Si l'on regarde le contenu du fichier donnees_test.php, on voit ceci :

<?php

$cache = unserialize('s:9:"Bonjour !";');

?>

Le fichier contient les données sérialisées. Lorsqu'il est exécuté, il recrée les données telles qu'elles étaient au moment de la création du cache avec unserialize() et les enregistre dans la variable $cache.

La fonction get_cache() a donc juste servi à appeler le fichier créé en utilisant include(), puis à retourner le contenu de $cache.

Voici le code que je vous propose :

<?php
// Récupère une variable mise en cache.
function get_cache($nom_cache)
{
        // Vérifie que le fichier de cache existe.
        if ( is_file('./cache/donnees_' . $nom_cache . '.php') )
        {
                // Le fichier existe, on l'exécute puis on retourne le contenu de $cache.
                include('./cache/donnees_' . $nom_cache . '.php');
                return $cache;
        }
        else
        {
                // Le fichier de cache n'existe pas, on retourne false.
                return false;
        }
}
?>

Destruction d'un cache

destroy_cache()

Cette fonction est simple. Elle permet juste de supprimer un fichier de cache en utilisant la fonction unlink() :

<?php
// Détruit un cache.
function destroy_cache($nom_cache)
{
        return @unlink('./cache/donnees_' . $nom_cache . '.php');
}
?>

Voilà ! On a créé nos 3 fonctions. Il ne reste plus qu'à les utiliser ! :)

Je vais donc, en reprenant l'exemple des messages d'un sujet de forum, vous montrer comment les fonctions s'emploient. Vous allez voir, ce n'est pas compliqué ! ;)

Lecture des messages

Sans le système de cache

Voici un script d'exemple simplifié récupérant les messages du sujet :

<?php

// Récupération des messages.
$resultat = mysql_query('SELECT * FROM messages WHERE sujet = 42');

while ( $ligne = mysql_fetch_array($resultat) )
{
        //
        // On affiche les messages.
        //
}

?>

Avec le système de cache

Voici maintenant le même script, avec le système de cache.

<?php

// On essaye de récupérer les données dans le cache.
if ( !$donnees = get_cache('messages_sujet_42') )
{
        // Le cache n'existe pas, récupération des messages dans la base de données.
        $resultat = mysql_query('SELECT * FROM messages WHERE sujet = 42');

        // Stockage du résultat dans la variable $donnees.
        $donnees = array();
        while ( $donnees[] = mysql_fetch_array($resultat) );

        // Mise en cache de $donnees.
        create_cache('messages_sujet_42', $donnees);
}

// Lecture des messages.
foreach ( $donnees as $ligne )
{
        //
        // On affiche les messages.
        //
}

?>

Le second script, contrairement au premier, utilise un intermédiaire : la variable $donnees. Si le cache existe, on met le contenu du cache dans $donnees, sinon on y met le contenu lu depuis la base de données, et on recrée le cache.

Ensuite, on lit les messages ligne par ligne à partir de $donnees comme si on lisait les lignes obtenues à partir d'une requête SQL.

Ainsi, vous n'avez pas à modifier le code qui consiste à afficher les messages.

Mise à jour du cache lors d'une modification

Voici un code simplifié d'exemple lorsqu'un message est posté :

<?php

// Ajout d'un message.
mysql_query('INSERT INTO messages(texte, sujet) VALUES ('blablablablabla', 42)');

?>

Ici, il n'y a qu'une chose à faire : supprimer le fichier de cache pour qu'à la prochaine lecture des messages, il soit remis à jour :) :

<?php

// Ajout d'un message.
mysql_query('INSERT INTO messages(texte, sujet) VALUES (\'blablablablabla\', 42)');

// Suppression du cache.
destroy_cache('messages_sujet_42');

?>

Voilà ! Ici, le système de cache a été mis en place assez facilement sans grande modification. Avec un système de ce type, on peut facilement ajouter le cache à ses anciens scripts, par exemple ! ;)

Ce tutoriel s'achève ici, je vous souhaite une bonne optimisation de vos scripts ! :lol:

Et si vous avez des questions, les commentaires sont là.