Dynamic-Mess.com


"The world is a dynamic mess of jiggling things..."

Gérer la transition BDD -> Objet avec la fonction PHP Hydrate

Article posté le 26-11-2013 dans la catégorie PHP

Le principe de l'hydratation consiste à remplir un objet, donc l'instance d'une classe, avec les variables lui permettant d'être "remplie". Cela permet par exemple d'éviter d'avoir à remplir manuellement chaque champ de chaque objet lorsque l'on lit les données dans la base.

1- Principe de départ

Un joueur est représenté dans la base de données par trois champs: ID, Pseudo et Score.

Si je veux rechercher un joueur, pas son ID (unique), et afficher son pseudo, voici comment je m'y prends :

$mesDonnees = verifJoueur(1);
if($mesDonnees!=null)
{
    $Eric = new joueur();
    $Eric->hydrate($mesDonnees);
    $Eric->getPseudo();
}

Explications :

La fonction verifJoueur() prend en paramètre l'ID du joueur à vérifier. Si elle retourne quelque chose, c'est que le joueur existe, donc je peux créer un objet, l'hydrater, et afficher le Pseudo en appelant son "getter".

2- Lire la base

Voici le code pour lire la base, rien de sorcier, cela utilise l'API PDO.

function infoBdd()
{
    $infos['serverName'] = "127.0.0.1";
    $infos['dbName'] = "test";
    $infos['userName'] = "root";
    $infos['userPassword'] = "";
    return ($infos);
}
function verifJoueur($ID)
{
    $infos = infoBdd();
    $resultat = null;
    try
    {
        $conn = new PDO("mysql:host=$infos[serverName];dbname=$infos[dbName]", $infos['userName'], $infos['userPassword']); // connexion à la BDD
        $conn->setAttribute( PDO::ATTR_ERRMODE, PDO::ERRMODE_EXCEPTION );
        $sql = "SELECT * FROM joueurs WHERE ID = '$ID'";
        $req = $conn->query($sql);   
        //$resultat = $req->fetch();
        $resultat = $req->fetch(PDO::FETCH_ASSOC);
        $req->closeCursor();
        if($resultat==null)
        {
            echo "Aucun enregistrement ne correspond!
";
        }
        else
        {
            echo "Un enregistrement a ete trouve
";
        }
        return($resultat);
    }
    catch(Exception $e)
    {
        die(print_r($e));
    }
    return($resultat);
}

Voici à présent le contenu de ma classe :

class joueur
{
    private $_ID;
    private $_Pseudo;
    private $_Score;
    public function hydrate(array $infos)
    {
        foreach ($infos as $clef => $donnee)
        {
            // On récupère le nom du setter correspondant à l'attribut.
            $methode = 'set'.$clef;
            //echo $clef.$donnee."
";
            // Si le setter correspondant existe.
            if (method_exists($this, $methode))
            {
                // On appelle le setter.
                $this->$methode($donnee);
            }
        }
    }
    public function setID($sonID)
    {
        $this->_ID = $sonID;
    }
    public function setPseudo($sonPseudo)
    {
        $this->_Pseudo = $sonPseudo;
    }
    public function setScore($sonScore)
    {
        $this->_Score = $sonScore;
    }
    public function getPseudo()
    {
        echo "Le pseudo est : ".$this->_Pseudo;
    }
}

3- Explications du code

Comme expliqué plus haut, si un enregistrement correspondant existe, $mesDonnees ne sera pas null. On pourra donc l'envoyer en paramètre dans la fonction hydrate de l'objet. Cette fonction va se charger de remplir automatiquement les champs. Voici comment elle fonctionne (code commenté ) :

public function hydrate(array $infos) // On lui envoie le tableau lu dans la base
    {
        foreach ($infos as $clef => $donnee) // Chaque champ est lu
        {
            // On récupère le nom du setter correspondant à l'attribut de la classe.
            $methode = 'set'.$clef;
            // Si le setter correspondant existe.
            if (method_exists($this, $methode))
            {
                // On appelle le setter.
                $this->$methode($donnee);
            }
        }
    }

Rien de sorcier... mais bien utile pour gagner du temps et en simplicité.

4- Gagner encore plus de temps

Si la fonction hydrate vous permet de gagner du temps, un bon respect des noms de vos attributs de classe par rapport à leur correspondance dans la base SQL permet d'être encore plus rapide, car PDO peut gérer l'hydration lui-même :

$req->fetchAll(PDO::FETCH_CLASS, $Object) //$Object = le type d'objet que vous voulez lire...

Cet article vous a plu? Découvrez d'autres articles


Tweet
comments powered by Disqus