Nous avons créé deux classes, Observable et Observer. La première sera héritée par les objets que nous souhaitons rendre observables et la seconde contient la définition de l’objet qui appellera le les méthodes déclenchées par les évènements.

Voici le code de ces deux classes, nous verrons après comment l’utilise.

Observer

final class Observer
{
    protected static $_instance;
    protected $_observed_events=array();
 
    public static function get_instance()
    {
        if(is_null(self::$_instance))
        {
            $c=__CLASS__;
            self::$_instance = new $c;
        }
        return self::$_instance;
    }
 
    public function observe($observed_class, $event, $called_class, $called_method, $arguments=array())
    {
        $this->_observed_events[]=array('observed_class' => $observed_class, 'event' => $event, 'called_class' => $called_class, 'called_method' => $called_method,'arguments' => $arguments);
    }   
 
    public function call_back($observed_class, $event)
    {
        $return_value=true;
        foreach ($this->_observed_events as $key => $value)
        {
            if($value['observed_class']==$observed_class && $value['event']==$event)
            {
                $return_value&=call_user_func_array(array($value['called_class'], $value['called_method']), $value['arguments']);
            }
        }
 
        return $return_value;
    }
}

Observable

interface iObservable
{
    public function __call($method_name, $arguments);
    public static function __callStatic($method_name, $arguments);
}
 
abstract class Observable implements iObservable
{
    public function __call($method_name, $arguments)
    {
        $ret = false;
        if(Observer::get_instance()->call_back(__CLASS__, 'before_'.$method_name))
        {
            $ret = call_user_func_array(array($this, '_'.$method_name), $arguments);
        }
        Observer::get_instance()->call_back(__CLASS__, 'on_'.$method_name, $ret);           
 
        return $ret;
    }
 
    public static function __callStatic($method_name, $arguments)
    {
        $ret = false;
        if(Observer::get_instance()->call_back(__CLASS__, 'before_'.$method_name))
        {
            $ret = call_user_func_array(array(__CLASS__, '_'.$method_name), $arguments);
        }
        Observer::get_instance()->call_back(__CLASS__, 'on_'.$method_name, $ret);       
 
        return $ret;
    }
    public function add_observer($event, $called_class, $called_method, $arguments=array())
    {
        Observer::get_instance()->observe(__CLASS__, $event, $called_class, $called_method, $arguments=array());
    }
}

Utilisation

Encore un peu de code pour illustrer tout ça, on commence par planter le décor avec nos deux classes.

class ClassA extends Observable
{
    public function _my_function_a()
    {
        return("Je suis dans ClassA");
    }
}
 
abstract class CalledClass
{
    public static $value;
 
    public static function callback_function_a()
    {
        self::$value = "je suis dans CalledClass";
        return true;
    }
}

Puis on place notre observer on on vérifie que tout c’est bien passé

ClassA::add_observer('on_my_function_a', 'CalledClass', 'callback_function_a');
 
$this->a = new ClassA();
echo $this->a->my_function_a();
echo CalledClass::$value;

Je vous laisse découvrir les petites subtilités du code que l’on n’a pas abordées ici, notamment dans les fonction magique.

Un indice : le callback est automatiquement appelé (s’il existe bien sûr) pour les méthodes qui commencent par un underscore, sinon vous pouvez placer des Observer::get_instance()->call_back(__CLASS__, $event); dans votre code aux endroits stratégiques de votre méthode observée.

Comment accéder aux données

Sur le principe du CRUD (Create Read Update Delete), cette classe contient des méthodes permettant d’effectuer les opérations de base.
Pour illustrer les exemples, nous utiliserons une table auteurs associée à l’objet Auteurs dont une instance est dans la variable $auteurs. Toujours pour l’exemple, la table est structurée ainsi :

• un entier qui sert d’index : id
• une chaîne pour le nom : nom

L’ajout de données

Pour ajouter un champ dans un table, il faut utiliser la méthode add. Elle prend en paramètre une table contenant toutes les données à ajouter. Les clés de la table doivent correspondrent aux noms des champs. Exemple :

/* On récupère les données issues du formulaire */
$auteur = $_POST['auteur'];if($auteurs->add($auteur))
{
    /* L'auteur à été ajouté */
}

associé au formulaire suivant :

<form action="ajoute-auteur.html" method="post">
<input name="auteur[nom]" type="text" />
<input name="auteur_ajout" value="Ajouter cet auteur" type="submit" />
</form>

Vous noterez que je n’ai rien mis pour le champ id, c’est parce que je le crée toujours en auto-incrément et c’est donc mySQL qui s’occupera d’y affecter une valeur lors de l’ajout. Cela s’applique aussi à tous les champs qui seraient définis avec une valeur par défaut : leur présence dans le tableau n’est pas obligatoire.

La lecture

Pour l’extraction de données j’ai créé trois fonctions :

• find_first()
• find_by_id()
• find_all()

find_first() et find_all() ont un seul paramètre : un tableau contenant la description de notre requête, la façon de construire ce tableau est assez simple : vous pouvez y mettre trois ordres : conditions, order et limit. Par exemple :

/* Trouver les 10 premiers auteurs classés suivant leur nom */
$ressource_mysql = $auteurs->find_all( array('order'=>'nom ASC', 'limit'=>10) );
 
/* Trouver le premier auteur classé suivant le nom */
$tableau_de_retour = $auteurs->find_first( array('order'=>'nom ASC') );
 
/* Trouver les 10 premiers auteurs classes dont le nom commence par 'bal' */
$ressource_mysql = $auteurs->find_all( array('conditions'=>"nom LIKE 'bal%'", 'limit'=>10) );
 
/* Trouver l'auteur qui a l'id 123 */
$tableau_de_retour = $auteurs->find_by_id(123);

La mise à jour

La façon de faire est exactement la même que pour l’ajout de données si ce n’est qu’il faut utiliser la fonction update_attributes($id, $donnees)

• $id est l’index du champ à mettre à jour.
• $données est le tableau contenant les données. Vous n’êtes pas obligé de mettre tous les champs présents dans la table, seul ceux qui sont dans le tableau sont mis à jour.

Il existe aussi une fonction permettant de mettre à jour un seul champ : update_attribute($id, $champ, $valeur)

La suppression de données

La aussi c’est très simple : la fonction destroy($id) permet de supprimer un enregistrement.

Extensions

Selon vos besoins et selon vos donnés, vous devrez ajouter des fonctionnalités à ces méthodes, par exemple : rechercher tous les auteurs selon leur nom. Ajoutez vos méthodes dans les fichiers correspondant à vos tables. Dans notre exemple vous pouvez créer une méthode find_all_by_name() dans le fichier auteurs.php

class Auteurs extends Database{
    function __construct($connexion, $table_name)
    {
        parent::__construct($connexion, $table_name);
    }
 
    public function find_all_by_name($name)
    {
        return $this->find_all(array("conditions"=>"name = 'hobb'");
    }
}

Ce qu’il reste à faire

Comme je l’ai déjà dit, le but de cette classe est juste de rendre service en gérant simplement des données, c’est pourquoi il n’y a pas d’abstraction au niveau de la gestion de la base de données même : On accède uniquement à une base mySQL. Il serait intéressant de sortir cette gestion de cette classe et de créer une autre couche permettant d’accéder à d’autres base de données comme PostgreSQL ou SQLite.

Si vous utilisez cette classe dans un de vos projets, vous pouvez m’envoyer l’adresse du site en question avec une petite description du projet afin d’être cité dans le billet des utilisateurs de cette classe.

De quelle configuration ai-je besoin ?

Utilisant la programmation objet et la version 4 de PHP n’étant pas assez complète à ce niveau, j’ai réalisé du code en PHP 5 pour cette bibliothèque. Il vous faut aussi une base de données, ici j’utilise mySQL en accès direct par les fonctions de PHP, je n’ai pas utilisé de couche d’abstraction d’accès à la base mais rien ne vous empêche de le réaliser en utilisant PDO par exemple et de me faire parvenir votre réalisation pour la diffuser ici : Cette bibliothèque est sous licence libre GPL.

Comment ça marche ? Un rapide aperçu.

Le principe est des plus simples : j’ai créé une classe Database servant de parent à tous mes futurs objets en sachant que chaque objet sera associé à une table.

Commencez donc par la création de vos tables en respectant ces quelques règles :

• Bien que ce ne soit pas obligatoire, j’aime bien nommer mes tables en utilisant des mots qui décrivent bien leur contenu, sans majuscule et en séparant les mots par des tirets ( _ )
• Les tables doivent avoir un champ « id » unique. Il peut être en autoincrement et il doit être un clé primaire.

Puis créez un fichier php déclarant un objet (dérivé de Database) pour chacune de vos tables, sur ce modèle :

class MaTable extends Database
 
{
 
  function __construct($connexion, $table_name)
 
  {
 
    parent::__construct($connexion, $table_name);
 
  }
 
}

Comment la mettre en place

Là encore rien n’est figé, il vous suffit d’inclure le fichier database.php à votre application et de créer autant d’objets que vous avez de tables :

include 'database.php';
 
include 'ma_table.php';$connexion = mysql_connect(DB_SERVER, DB_USER, DB_PASSWORD);
 
ma_table = new MaTable($connexion, 'ma_table');

Le constructeur de l’objet à besoin de deux paramètres : la connexion à la base de données et le nom de la table.

Pour simplifier tout ça, j’ai décidé de regrouper tous mes modèles (fichiers des objets correspondants aux tables, c’est le M de MVC) dans un seul répertoire et de créer une fonction d’initialisation (indépendante de la classe Database) qui s’occupe de créer les objets toute seule, cette fonction s’appelle models_initialize et elle prend en paramètre le chemin du répertoire où se trouvent les modèles. Cette fonction est disponible dans ce fichier : models.zip. Vous devrez modifier son fonctionnement pour le faire correspondre à vos besoinsmais l’essentiel y est (parcours du répertoire et création des objets)

Il vous suffit donc de créer un répertoire modeles par exemple, d’y mettre tous vos fichiers modèles (ma_table.php dans notre exemple) et la fonction « models_initialize » s’occupera de créer les variables globales suivantes :

• $DBCon et $DBBase : variables de connexion à la base mySQL.
• un objet pour chaque fichier nommé selon la convention que j’ai choisi : minuscules et tiret pour l’objet, majuscule de la première lettre de chaque mots sans espace pour le nom de la classe. Le nom de l’objet et de la table sont issus du nom du fichier alors faites attention de ne pas vous tromper en nommant vos fichiers.

N’hésitez pas à regarder le code source de cette fonction, il est dans le fichier database.php. C’est ici que vous devrez apporter vos modifications si vous n’utilisez pas la même convention de nommage que moi.

Téléchargement et fin de la première partie

Vous pouvez télécharger le fichier database : Sources Database. Je vous rappelle qu’il est sous licence libre GPL. Important : Maintenant, Database est intégrée au framework PHP Nano vous y trouverez une version bien plus récente mais aussi très différent du point de vue du fonctionnement.

La suite à la rentrée, je vous décrirai la façon d’utiliser les objets créés dans cette première partie. En attendant, passez de bonnes fêtes, et si vous le voulez, vous pouvez jeter un oeil aux méthodes de la classe Database j’ai essayé de les documenter au mieux…

La suite est disponible dans ce billet