Mis à jour le mercredi 9 mars 2016
  • Facile
Connectez-vous ou inscrivez-vous gratuitement pour bénéficier de toutes les fonctionnalités de ce cours !

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.

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éparatifs

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.

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 fonctions

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()

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

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

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

?>

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

Exemple de certificat de réussite
Exemple de certificat de réussite