cs_eltyty87
Messages postés mercredi 31 janvier 2007Date d'inscription
22 novembre 2011
Dernière intervention
-
11 oct. 2009 à 22:49 - Dernière réponse : cs_eltyty87
Messages postés mercredi 31 janvier 2007Date d'inscription
22 novembre 2011
Dernière intervention
- 14 oct. 2009 à 10:01
J'ai réalisé un code pour réaliser une connexion "singleton" avec PDO or j'ai une erreur.
Voilà le code du singleton :
class Connexion_serveur {
/**
* Instance de la classe PDO
*/
private $PDOInstance = null;
/**
* Instance de la classe SPDO
*/
private static $instance = null;
private function __construct() {
try {
$this->PDOInstance = new PDO(DB_DSN, DB_USER, DB_PASSWORD);
$this->PDOInstance->query("SET NAMES utf8");//FOR USING UTF-8
$this->PDOInstance->query("SET CHARACTER SET 'utf8'");//FOR USING UTF-8
}
catch (PDOException $e){
echo 'Erreur : '.$e->getMessage().'
';
die();
}
}
/**
* Crée et retourne l'objet SPDO
*/
public static function getInstance()
{
if(is_null(self::$instance)OR !ISSET(self::$instance)) {
self::$instance = new Connexion_serveur();
}
return self::$instance;
}
/**
* Empeche la copie externe de l'instance
*/
private function __clone() {
throw new Exception('Le clonage de SPDO n\'est pas autorisé');
}
}
Et maintenant j'essaie de faire une requête en PDO :
Pour ce qui est de la patience, je n'en ai aucune quand il s'agit de boulets qui ne savent pas écrire ou manquent cruellement de politesse.
Par contre, quelqu'un qui s'intéresse à PDO, au design pattern du singleton (peut-être d'autres plus tard ?), je me sens obligé de prendre le temps, c'est ma manière de faire du prosélytisme :)
Tu aurais voulu utiliser mysql_query(), j'aurais pas insisté, vraiment. Mais là, je ne peux que t'aider à utiliser PDO en singleton, c'est pour le bien de l'humanité !
Tu ne t'y prends pas correctement, pour instancier ton singleton.
Le constructeur est la fonction qui est TOUJOURS exécutée lorsque la classe est instanciée, c'est à dire immédiatement après sa création, de manière automatique.
Le singleton, en terme de motif de conception, est une version bien particulière de la factory. La factory (ou usine) est censée instancier un objet adapté à certains paramètres. Là, l'usine construit l'instance et la retourne si elle existe déjà.
L'instanciation doit donc se faire dans la méthode getInstance() :
public static function getInstance() {
NULL self::$instance or self::$instance new self();
return self::$instance;
}
Plus parlant, le code suivant est synonyme :
public static function getInstance() {
if (NULL === self::$instance) {
self::$instance = new self();
}
return self::$instance;
}
Les méthodes de PDO doivent être appelées sur l'objet instancié, pas en tant que méthodes statiques (ce qu'elles ne sont pas, et qui ne fonctionnera donc pas).
Plusieurs possibilités dans ton code. Soit tu stockes l'instance dans une variable, soit tu l'utilises directement. Depuis PHP5, les objets sont TOUJOURS passés par référence, ce ne sera donc pas une copie, mais l'objet lui-même qui sera alors stocké (donc s'il est modifié, il sera modifié partout ailleurs où il est utilisé). De plus, il n'était pas possible en PHP4 de chainer les appels de méthodes : si une méthode retournait un objet, il n'était pas possible d'appeler directement une méthode de cet objet, il fallait le stocker dans une variable intermédiaire puis appeler la méthode sur cette variable... Du coup, en PHP5, on peut faire ça :
Connexion_serveur::getInstance() -> query('SELECT nom FROM table') -> fetchObj() -> nom;
Hum... Je viens de voir que tu instancies déjà ta classe dans getInstance() ^^
Côté perfs, is_null() est moins rapide que de tester une égalité stricte avec NULL
Sinon, dans ton constructeur, tu NE DOIS PAS instancier un nouvel objet PDO. Il est préférable d'étendre la classe PDO :
class Connexion_serveur extends PDO {
public function __construct() {
parent::__construct($dsn, $username, $password);
}
}
Euh bon, du coup, ma réponse est un peu désorganisée... :)
En fait, si, tu peux instancier un nouvel objet PDO dans ton constructeur et le stocker dans une propriété. Mais c'est inutile. Mais tu peux.
Si tu veux VRAIMENT faire ça, pour accéder aux propriétés et aux méthodes de l'objet PDO, il faut que ta classe fonctionne comme un proxy, grâce aux méthodes statiques __call(), __get() et __isset(), qui vont respectivement appeler une méthode de l'objet PDO, retourner une propriété, et vérifier si une propriété existe.
C'est pour cela que quand tu appelles une méthode de PDO sur ton objet Connexion_serveur ça ne fonctionne pas...
Mais vraiment, il est plus simple d'étendre la classe PDO, un proxy dans ce cas n'est absolument pas adapté ni en terme de conception ni en terme de performances.
syndrael2382
Messages postés lundi 4 février 2002Date d'inscription
29 décembre 2012
Dernière intervention -12 oct. 2009 à 08:45
0
Utile
Oups.. pas le temps de lire toute la réponse mais elle a le mérite de me rappelle la notion du OR qui peut être sympa. Merci de l'avoir fait remonter de mes souvenirs de 'mysql_query or die'
S.
cs_eltyty87
Messages postés mercredi 31 janvier 2007Date d'inscription
22 novembre 2011
Dernière intervention -12 oct. 2009 à 14:55
0
Utile
Alors je prends un peux de temps là, au taff mais bon. Mais en relisant le tout c'est un peu confus.
En gros :
-la modification sur public static function getInstance() ok sans pb
-erreur quant au constructeur pas sûr d'avoir compris l'erreur et ce qu'il faut faire en fait.
Donc je dois faire une classe étendue du style :
class connexion_serveur extends pdo {
public function __construct() {
parent::__construct($dsn, $username, $password);
try {
$this->PDOInstance = new PDO(DB_DSN, DB_USER, DB_PASSWORD);
$this->PDOInstance->query("SET NAMES utf8");//FOR USING UTF-8
$this->PDOInstance->query("SET CHARACTER SET 'utf8'");//FOR USING UTF-8
}
catch (PDOException $e){
echo 'Erreur : '.$e->getMessage().'
';
die();
}
}
}
Mais dans ce cas je laisse le constructeur de ma classe initiale vide ?
Du coup dans classe initiale j'obtiens :
class PDO {
/**
* Instance de la classe PDO
*/
private $PDOInstance = null;
/**
* Instance de la classe SPDO
*/
private static $instance = null;
private function __construct() {
}
/**
* Crée et retourne l'objet SPDO
*/
public static function getInstance()
{
if(null === self::$instance OR !ISSET(self::$instance)) {
self::$instance = new self();
}
return self::$instance;
}
/**
* Empeche la copie externe de l'instance
*/
private function __clone() {
throw new Exception('Le clonage de SPDO n\'est pas autorisé');
}
}
Et après je peux utiliser classiquement mon prepare pour les insert , select, etc. comme suit :
Non, dans ton constructeur tu NE DOIS PAS instancier d'objet PDO, puisque l'objet qui est en cours de construction est justement un objet PDO !
Il faut cependant appeler le constructeur de la classe parente (PDO) :
parent::__construct($dsn, $username, $password);
Du coup, dans ton constructeur, au lieu de faire $this -> pdoinstance -> method(); tu fais : $this -> method()
Ton objet hérite bien entendu des méthodes de la classe PDO (c'est ce à quoi sert d'étendre une classe)
cs_eltyty87
Messages postés mercredi 31 janvier 2007Date d'inscription
22 novembre 2011
Dernière intervention -12 oct. 2009 à 16:32
0
Utile
K,
je look vite fais mon boss est pas là. Je test ce soir en espérant que j'ai tout compris. Je m'attendais à ce que tu modifis le code s'il n'était pas bon mais je regarde ça ce soir.
Merci déjà
cs_eltyty87
Messages postés mercredi 31 janvier 2007Date d'inscription
22 novembre 2011
Dernière intervention -13 oct. 2009 à 13:46
0
Utile
Re,
alors j'ai tenté ceci mais il me manque qq chose :
class pdo {
public function __construct() {
try {
$this->PDOInstance = new PDO(DB_SESSIONS_DSN, DB_SESSIONS_USER, DB_SESSIONS_PASSWORD);
$this->PDOInstance->query("SET NAMES utf8");//FOR USING UTF-8
$this->PDOInstance->query("SET CHARACTER SET 'utf8'");//FOR USING UTF-8
}
catch (PDOException $e){
echo 'Erreur : '.$e->getMessage().'
';
die();
}
}
}
class Connexion_serveur extends pdo{
/** Instance de la classe SPDO */
private static $instance = null;
private function __construct() {
parent::__construct();
}
/** Crée et retourne l'objet SPDO */
public static function getInstance()
{
if(null === self::$instance OR !ISSET(self::$instance)) {
self::$instance = new self();
}
return self::$instance;
}
/**Empeche la copie externe de l'instance */
private function __clone() {
throw new Exception('Le clonage de SPDO n\'est pas autorisé');
}
}
Pourquoi est-ce que tu redéfinis la classe PDO ? PHP ne devrait pas aimer, parce qu'on ne peut pas définir une classe qui l'est déjà.
D'où l'extension de la classe PDO, ça, tu peux le faire.
Donc ce code :
try {$this->PDOInstance = new PDO(DB_SESSIONS_DSN, DB_SESSIONS_USER, DB_SESSIONS_PASSWORD);
$this->PDOInstance->query("SET NAMES utf8");//FOR USING UTF-8
$this->PDOInstance->query("SET CHARACTER SET 'utf8'");//FOR USING UTF-8
}
catch (PDOException $e){
echo 'Erreur : '.$e->getMessage().'
';
die();
}
tu dois le mettre dans le constructeur de ta classe. Et encore, sans le bloc try...catch, qui n'a rien à faire dans la classe : la classe génère une erreur si l'instanciation ne se déroule pas correctement (mauvais paramèrtes, connexion impossible, etc). La gestion des erreurs doit donc se faire à l'extérieur, ce n'est PAS le rôle de la classe de faire ça. A toi de déclarer, éventuellement, un gestionnaire d'exceptions personnalisées, ou de de mettre des blocs try...catch là où c'est nécessaire.
En gros, le constructeur de ta classe doit ressembler à ça :
public function __construct($dsn, $username, $password) {
parent::__construct($dsn, $username, $password);
$this -> query("SET NAMES utf8");
$this -> query("SET CHARACTER SET 'utf8'");
}
Et surtout, supprime la déclaration de ta classe PDO, elle existe déjà ;)
Etendre la classe PDO permet justement d'apporter à PDO des fonctionnalités qu'elle n'a pas et dont tu as besoin. Parmi ces fonctionnalités, on peut trouver l'automatisation de certaines tâches à l'instanciation, comme justement, la connexion en UTF8.
cs_eltyty87
Messages postés mercredi 31 janvier 2007Date d'inscription
22 novembre 2011
Dernière intervention -13 oct. 2009 à 18:39
0
Utile
Excuse moi mais là j'ai l'air vraiment bête...
Il est vrai que je suis autodidacte et j'ai pas appris l'anglais à l'école mais là...
Je pensais pas être trop mauvais mais... Je vois à peu près ce que tu me dis mais je t'avoue j'adapte le script en fonction de ce que tu me dis mais bug. En général je regarde le code et je compare par rapport au mien pour comprendre. Or là je tatonne.
Je m'y remets là mais en espérant que j'y arrive...
Merci déjà pour les infos.
cs_eltyty87
Messages postés mercredi 31 janvier 2007Date d'inscription
22 novembre 2011
Dernière intervention -13 oct. 2009 à 21:39
0
Utile
Voilà ce que j'obtiens d'après ce que tu me dis :
class SPDO {
private $PDOInstance = null;
private static $instance = null;
const DEFAULT_SQL_USER = 'xxx';
const DEFAULT_SQL_HOST = 'xxx';
const DEFAULT_SQL_PASS = 'xxxx';
const DEFAULT_SQL_DTB = 'xxxx';
private function __construct(){
$this->PDOInstance = new PDO('mysql:dbname='.self::DEFAULT_SQL_DTB.';host='.self::DEFAULT_SQL_HOST,self::DEFAULT_SQL_USER ,self::DEFAULT_SQL_PASS);
}
public static function getInstance() {
if(null === self::$instance OR !ISSET(self::$instance)) {
// self::$instance = new Connexion_serveur();
self::$instance = new self();
}
return self::$instance;
}
}
$db=SPDO::getInstance();
$insert = "INSERT INTO logs_erreurs (date_erreur, texte_erreur) VALUES (?, ?)";
$statement = $db->prepare($insert);
Donc là j'ai repris ce que tu m'as dit + la vision que j'utilisais pour ma version en php5 requête sql classique.
Mais j'obtiens : Call to undefined method SPDO::prepare()
...
Non, tu n'as pas repris ce que je t'ai dit... Tu as juste modifié ce que tu avais fait la première fois...
Tu persiste à instancier un objet PDO, alros qu'il ne FAUT PAS...
Il faut que ta classe SPDO ou peu importe son nom ETENDE PDO :
class SPDO extends PDO
Cela signifiera alors que l'objet instancié aura TOUTES LES PROPRIETES ainsi que TOUTES LES METHODES de la classe PDO, PLUS celles que tu lui rajouteras.
Pour cela, l'exemple que je t'ai donné est bon. Voici son fonctionnement :
- la méthode statique getInstance() vérifie que la variable statique $instance vaut null ou pas
- si elle vaut null, alors un objet de la classe (SPDO) est instancié et est stocké dans cette variable statique
- la variable statique (plus exactement son contenu) est alors retourné par getInstance() : il s'agit non pas d'une copie de l'objet, mais d'une référence, donc de l'objet lui-même.
Ce fonctionnement permet de n'instancier la classe qu'une seule fois.
Le constructeur __construct() ne DOIT pas instancier la classe PDO. Si tu fais ça, tu ne pourras pas facilement appeler les méthodes de PDO sur ton objet, il faudra utiliser la méthode magique __call() pour cela. Ce n'est pas utile : autant que ton objet étende PDO.
Je répète donc le code de ta classe SPDO (attention aux majuscules qui disparaissent dans la balise code)
class SPDO extends PDO {
CONST dsn = 'mysql:host=localhost;dbname=database;port=3306';
CONST username = 'username';
CONST password = 'password';
private static $instance;
public static function getInstance() {
null self::$instance or self::$instance new self();
return self::$instance;
}
# On est obligé de laisser le constructeur public parce qu'on étend PDO dont le constructeur est public
public function __construct() {
parent::__construct(self::dsn, self::username, self::password);
}
}
C'est tout ! Inutile de t'encombrer avec une instance de PDO, puisque ton objet est DEJA une instance de PDO ! :=)
Maintenant, la méthode query est bien une méthode de SPDO, puisque celui-ci est AUSSI une instance de PDO :)
J'espère que c'est plus clair, parce qu'après, je sais pas comment expliquer plus en détails...
cs_eltyty87
Messages postés mercredi 31 janvier 2007Date d'inscription
22 novembre 2011
Dernière intervention -13 oct. 2009 à 22:36
0
Utile
Alors, je suppose que je doit énerver
Car donc avec ton code + la prépare j'obtiens :
class SPDO extends PDO {
CONST dsn = DB_SESSIONS_DSN;
CONST username = DB_SESSIONS_USER;
CONST password = DB_SESSIONS_PASSWORD;
private static $instance;
public static function getInstance() {
null self::$instance or self::$instance new self();
return self::$instance;
}
# On est obligé de laisser le constructeur public parce qu'on étend PDO dont le constructeur est public
public function __construct() {
parent::__construct(self::dsn, self::username, self::password);
}
}
$req = SPDO::getInstance()->prepare("INSERT INTO logs_erreurs (date_erreur, texte_erreur) VALUES (?, ?)");
$author="jhj";
$title="hgjjh";
$req->bindParam(1, $author);
$req->bindParam(2, $title);
Et une erreur : Call to a member function prepare() on a non-object
Mais là normalement je pense avoir réussis même si la diff de code est subtile pour moi pourtant je lis pour être sur de bien assimiler ce que tu me dis.
class SPDO extends PDO {
private static $instance;
public function __construct() {
}
public static function getInstance() {
if(!isset(self::$instance)or null === self::$instance) {
self::$instance = new PDO(DB_SESSIONS_DSN, DB_SESSIONS_USER, DB_SESSIONS_PASSWORD);
self::$instance->setAttribute(PDO::ATTR_ERRMODE, PDO::ERRMODE_WARNING);
}
return self::$instance;
}
}
$req = SPDO::getInstance()->prepare("INSERT INTO logs_erreurs (date_erreur, texte_erreur) VALUES (?, ?)");
$date_erreur="jsddhj";
$texte_erreur="hgsdsdjjh";
$req->bindParam(1, $date_erreur, PDO::PARAM_STR);
$req->bindParam(2, $texte_erreur, PDO::PARAM_STR);
$req->execute();
Donc ça marche comme ça.
Moralité merci de ta suprême patience
Dernier truc :
-est-ce mieux ?
-pourquoi ça marche avec
Je comprendrais si tu veux plus répondre car là, tu m'as été du plus grand secours et d'une patience encore jamais rencontré pour ma part. Merci à toi.
Au temps pour moi, j'ai fait une petite erreur dans getInstance() : c'était null !== self::$instance or ....
Ah vouiiiiiiiiiiii :)) C'set mieux, puisque non seulement ça marche, mais en plus ça marche !
Oui, nickel comme ça... Maintenant, ta classe SPDO est une instance de PDO qui hérite de ses méthodes et propriétés.
Juste petit truc : tu utilises des constantes de classes, qui semblent inutiles si tu as déjà des constantes 'tout court' définies ailleurs : celles-ci restent accessibles dans ta classe, inutile donc de redéfinir des constantes de classe. Les constantes de classes permettent de définir des constantes qui sont... propres à la classe, c'est à dire qui sont liées au contexte de la classe. Par exemple, les constantes de classe de PDO sont des constantes qui ne sont pas censées servir dans un autre contexte que l'utilisation de PDO : elles ne sont donc pas supposées être utilisées avec SplFileObject ou autre classe, même si elles peuvent avoir la même valeur qu'une autre, ou quoi... Bref.
Sinon, bindParam permet de lier une variable à un marqueur dans la requête préparée.
Ca prend tout son sens si ta requête doit être exécutée plusieurs fois, par exemple dans une boucle foreach, ou while (une boucle quoi...)
Exemple, tu veux chercher plusieurs mots dans une colonne d'une table. Tu vas boucler sur la liste de mots et exécuter la requête autant de fois qu'il y a de mots. Dans ce cas, bindParam() est utile parce que tu ne l'exécutes qu'une seule fois... Démonstration :
$liste = array('mot1', 'mot2', 'mot3');
$mot = '';
$stmt = $db -> prepare("SELECT id, auteur FROM articles WHERE content LIKE '%:mot%'");
$stmt -> bindParam(':mot', $mot);
foreach ($liste as $mot) {
$stmt -> execute();
}
Ce qui se passe, c'est que la variable $mot étant liée par référence au marqueur :mot, quand sa valeur change (ce qui se produit à chaque itération de la boucle), la requête préparée tient compte de cette valeur.
Si tu n'as pas besoin de cette fonctionnalité, tu peux utiliser bindValue() qui fait exactement la même chose, mais sans lier par référence, uniquement par... valeur ;)
