Système de cache de Dr Night

Introduction du cours

Qu'est-ce qu'un système de cache ?

Un système de cache est un ensemble de fonctions qui permettent de stocker des données à un endroit auquel on peut accéder plus rapidement et plus efficacement que si on les stockait dans une base de données.

Les données sont bel et bien stockées dans une base, mais le système de cache permet de diminuer le nombre de demandes que ferait une requête SQL, par exemple, et donc de diminuer le temps de chargement de la page.

On dit qu'on met des données en cache.

Il existe déjà un tutoriel expliquant comment mettre en place un système de cache simple, mais je vais ici vous exposer une autre façon de faire.

Le tutoriel écrit par php5 : Un système de cache simple propose un système qui met à jour le cache si ce dernier a été créé il y a plus d'une minute, même si les données qu'il contient n'ont pas été modifiées entre-temps.

Les problèmes posés sont les suivants :

• les caches peuvent souvent être mis à jour inutilement ;

• le contenu du cache n'est pas mis à jour instantanément. Il peut être décalé au pire d'une minute.

Notez que mon objectif n'est pas du tout de critiquer ce tutoriel pour le plaisir, mais plutôt de vous expliquer une autre façon de faire. À vous de juger quelle est celle que vous préférez. ;)

Quelle différence ici ?

Le système de cache que je vous propose n'est pas basé sur une mise à jour périodique (toutes les 60 secondes) mais sur une mise à jour instantanée (mise à jour à chaque modification).

Il est en effet inutile de mettre à jour le cache quand il n'y a pas de modification : changer le cache à chaque modification permet d'avoir un affichage toujours à jour et ce, dans tous les cas. :)

PréparatifsCré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: ).

Pour autoriser l'accès en lecture et écriture au répertoire cache, il faut y effectuer un chmod 777.

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.

On a seulement besoin de ces trois actions ? o_O

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 !

Création des fonctionsDé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 fonctionsCréation d'un cache

create_cache()

OK, c'est cool, mais maintenant on l'enregistre comment, le cache ? Comment elle fonctionne, la fonction 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; }?>

Note : $nom_cache est le nom sous lequel le cache est stocké et $contenu, la variable contenant les données à mettre en cache.

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; } } ?>

Il est important de retourner false si le fichier de cache est inexistant. C'est en effet primordial pour le fonctionnement général du système. Cela permet de savoir si un cache existe ou non (vous comprendrez un peu plus bas, si ce n'est pas déjà fait ;) ).

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'); } ?>

Le @ permet de ne pas afficher de message d'erreur dans le cas où unlink() tenterait d'effacer un fichier qui n'existe pas.

Exemple d'utilisation

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 messagesSans 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. // } ?>

Que fait le second script ?

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à.

• #

Waouh !

Très heureux de voir que nos cours vous plaisent, déjà 3 pages lues aujourd'hui ! Vous pouvez continuer la lecture de nos cours en devenant un Roomie, un membre de la communauté d'OpenClassrooms. C'est gratuit !

Vous pourrez aussi suivre votre avancement dans le cours, faire les exercices et discuter avec les autres Roomies.

S'inscrire Se connecter

• Thématiques du cours : PHP Web

Chaque cours est créé par un professeur ou un expert dans le domaine. Il est composé d'une ou plusieurs parties et peut comporter du texte, des images (schéma, illustration) et des vidéos. Chaque partie d'un cours certifiant est ponctuée d'exercices de 2 types : Des quiz corrigés automatiquement Des devoirs libres (exemple : créer un site web avec des consignes précises). Ces devoirs sont évalués par les pairs. Chaque devoir est corrigé 3 fois par 3 autres élèves, dans un processus en double aveugle, selon un barème fixé par le professeur. La note finale est la moyenne des 3 notes reçues sur le devoir. 50% des devoirs corrigés par les pairs obtiennent quasiment les 3 mêmes notes, avec une variance inférieure à 1. La recherche académique montre d'ailleurs que l'évaluation par les pairs peut être aussi précise que celle des professeurs.