POO et DB

[NicoMSEvent]

Je me mets (enfin) à la POO, je retravaille mon projet pour le transformer en full POO (qui a dit :impossible? ^^)
C'est un certain boulot, mais les lignes de codes se multipliant, et arrivant tout doucement aux limites humaines du procédural, et aussi, voulant enfin me mettre a la POO (premier par vers ruby? p-e pas, il me manquerait un hébergeur ), j'ai décidé de faire le grand pas. Je connais déjà relativement bien la POO, et j'avais quelques question sur vos habitudes.

Pour enregistrer des objets en DB, vous passez un objet DB a travers toutes vos classes, et chaque objet est responsable de sa propre sauvegarde en DB, ou vous avez un autre truc (variable globale que je trouve crade) ?
(mon but serait, si c'est pas propre, d'éviter d'avoir dans chaque objet un paramètre "db")

Edit : j'ai trouvé une excellente petite doc/tuto/cours sur le net en PDF. Si quelqu'un veut bien se donner la peine de regarder, ça parle de PDO (p-e une solution pour mon problème? ^^)

[Anthor]

En général, on utilise le pattern Singleton, et Adapter.

De cette manière on récupère toujours la connexion courante. Et on peux changer facilement de type de base de données.

EDIT: J'ai pas eu la motive de me plonger dans les 209 pages ^^

[NicoMSEvent]

ok, j'ai vu brievement le pattern Singleton et Adapter (qui permet de ne lancer qu'une seule fois la connection, et qui permet d'utiliser a peu près n'importe que lSGBD), mais ça ne me dit pas si je dois faire mes appels SQL dans les objets (en passant l'objet DB en parametre ou en global?), ou autrement?

Comme je n'ai pas vraiment d'expérience en PHP objet (orienté web), je ne vois pas trop comment mettre ça en place... un petit coup de pouce? histoire de me mettre sur la bonne voie...

[Sephi-Chan]

Tes instances de modèles (qui utilisent la BdD comme source de données) peuvent étendre une classe dont le constructeur se charge de récupérer l'Adapter (l'instance de la connexion).
Et effectivement, tu fais ensuite tes appels à la base de données dans les méthodes de ton modèle.


Sephi-Chan

[Anthor]

Effectivement, j'avais zappé cette partie là ^^

[christouphe]

J'utilise la POO comme ceci, dite moi si j'ai faux:

BDD <= userDao (description et stockage des informations) <= userFactory (fabrique mes objets User en lui passant les paramètres et la connexion) <= userManager (gère mes objets Users création/modification/suppression en passant la connexion ET les paramètres)

Et en parlant de singleton, j'ai réussi à faire un singleton manager, par contre pour ma classe accédant à la BDD, comme elle hérite de PDO, j'ai une erreur si je mets le constructeur en "private", des solutions ?

[pascal]

J'utilise la POO comme ceci, dite moi si j'ai faux:

BDD <= userDao (description et stockage des informations) <= userFactory (fabrique mes objets User en lui passant les paramètres et la connexion) <= userManager (gère mes objets Users création/modification/suppression en passant la connexion ET les paramètres)

Et en parlant de singleton, j'ai réussi à faire un singleton manager, par contre pour ma classe accédant à la BDD, comme elle hérite de PDO, j'ai une erreur si je mets le constructeur en "private", des solutions ?

ça ressemble aux architectures du boulot tout ça !

Pour la connection, tu peux aussi regarder du coté de symfony, les DAO + formulaires liés fonctionnent bien en pratique.

A+

Pascal

[christouphe]

je m'inspire du boulot pour mes projets personnels , d'ailleurs je viens de finir l'admin d'une table équipement pour mon futur jeu..

[Anthor]

Et en parlant de singleton, j'ai réussi à faire un singleton manager, par contre pour ma classe accédant à la BDD, comme elle hérite de PDO, j'ai une erreur si je mets le constructeur en "private", des solutions ?

Code PHP :

<?php 

class Singleton_PDO

{

    /**

     * Singleton

     */

    private static $_instance = null;

    

    public static function getInstance()

    {

        if( is_null(self::$_instance) )

            self::$_instance = new PDO('mysql:host=localhost;dbname=test', 'root', '');

         

        return self::$_instance;

    }

    

    private function __construct() {}

    private function __clone() {}

} 

[christouphe]

il faut redéfinir toutes les méthodes PDO, car pour m'éviter cela, j'avais fait un héritage, ça me semblait logique.

Code PHP :

<?php



class database extends PDO {

    

    private $_connexion;                //La connexion à la base de données

    private $_result;                    //La ressource issue de la requête SQL

    private $_resultats;                // la liste du/des résultat(s) de requête(s)

    

    private $_dbDns = "DNS";

    private $_dbUser = "USER";

    private $_dbPassword = "PASS";

    

    /*

     * Constructeur de l'objet "vide" afin de pouvoir le paramétrer

     */

    public function __construct() {

    }



    

    /*

     * Méthode de destruction d'objet

     */

    public function __destruct() {

    }



    public function __get($name) {

        if (isset($this -> $name)) {

            return $this -> $name;

        } else {

            throw new Exception(get_class($this).": L'attribut ".$name." n'existe pas.");

        }

    }

    

    public function __set($name,$value) {

        if (isset($this -> $name)) {

            $this -> $name = $value;

        } else {

            throw new Exception(get_class($this).": L'attribut ".$name." n'existe pas.");

        }

    }

    

    /*

     * Méthode ouvrant la connexion ou une exception PDO si une erreur survient

     */

    public function getConnexion() {

        $this -> _connexion = new PDO($this -> _dbDns,$this -> _dbUser,$this -> _dbPassword);

        $this -> _connexion -> setAttribute(PDO::ATTR_ERRMODE, PDO::ERRMODE_EXCEPTION);



    }

    

    public function closeConnexion() {

        //

    }



    /*

     * Méthode de traitement des requêtes formulées par l'application.

     * @param $_req - array/string - la/les requête(s) à traiter

     * @param $_select - boolean - une sélection ou non 

     */

    public function envoieRequete($_req,$_select=true,$prepare=false,array $data=array()) {

        if (!is_array($_req)) {

            $temp = $_req;

            $_req = array($temp);

        }    

        if ($_select) {

            foreach ($_req AS $requete) {

                if (!($this -> _result = $this -> _connexion -> prepare($requete))) {

                    //ERREUR

                    throw new PDOException(get_class($this).": ERREUR preparation requete: ".$requete);

                } else {

                    if ($this -> _result -> execute()) {

                        $this -> _resultats = $this -> _result -> fetchAll();

                    }

                }

            }              

        } else {

            //UPDATE/INSERT/DELETE

            try {

                $this -> _connexion -> beginTransaction();

                if ($prepare) {

                    //requete préparée

                    foreach ($_req AS $requete) {

                        $stmt = $this -> _connexion -> prepare($requete);            

                        $stmt -> execute($data);

                    }

                } else {

                    foreach ($_req AS $requete) {

                        $this -> _connexion -> exec($requete);

                    }                    

                }

                $this -> _connexion -> commit();

            } catch (PDOException $pdoE) {

                $this -> _connexion -> rollback();

                debug($pdoE -> getMessage());debug($pdoE->getCode());

                throw new PDOException($pdoE -> getMessage(),$pdoE->getCode());

            }

        }

    }

?>