[PHP 5.3] Problème de Singleton

[adc15]

Bonsoir,

J'essaye desespérement depuis quelques temps de mettre en place le design pattern Singleton pour pouvoir me connecter à ma base de donnée

Voici d'abord mon code de Singleton :

Code :

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
<?php
 
 
//Classe de connexion à la BDD - Design Pattern Singleton
class Connection{
 
	private static $instance;
	private $host = 'localhost';
	private $user = 'root';
	private $password = '';
	private $dbName = 'db354423753';
 
	private function __construct() 
	{	
		try
		{
			self::$instance = new PDO('mysql:host=' . $this->$host . ';dbname=' . $this->$db, $this->$user, $this->$password);
 
			self::$instance->setAttribute(PDO::ATTR_ERRMODE, PDO::ERRMODE_EXCEPTION);
		}
		catch (Exception $e)
		{
			die('Erreur de connexion: ' . $e->getMessage());
		}
	}
 
	private function __clone() {}
 
	static public function getInstance() 
	{
		if (! (self::$instance instanceof self) ) 
		  self::$instance = new self();
 
		return self::$instance;
	}
 
}

Et je fais ensuite :

Code :

$bdd = Connection::getInstance()->getBdd();

Et paf un beau message d'erreur :

Fatal error: Cannot access empty property in C:\wamp\www\Site\model\Connection.class.php on line 16

Pourtant j'ai regardé pas mal d'autres code de Singleton et je vois vraiment pas ce qui ne vas pas dans le mien !

Merci de votre aide, et bonne soirée !

[stealth35]

$this->val pas $this->$val

[Shikiryu]

En plus de ce que dit stealth (syntaxe des attributs de l'objet), le pattern n'est pas très bon ici.

Code :

1
2
3
4
5
6
 
static public function getInstance() {
	if (! (self::$instance instanceof self) ) 
		self::$instance = new self();
	return self::$instance;
}

Ici, à chaque fois que vous demandez "l'instance", vous regardez si la variable static "$instance" de l'objet Connection est une instance de l'objet Connection sinon vous le construisez.
Or, dans le constructeur de Connection, vous mettez dans $instance un objet PDO...

Donc à chaque fois que vous appelerez getInstance(), il instanciera un nouveau Connection.

Ce serait plus un truc comme ça :

Code :

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
class Connection{
 
	private static $instance;
	protected $db; // sera un objet PDO
	private $host = 'localhost';
	private $user = 'root';
	private $password = '';
	private $dbName = 'db354423753';
 
	private function __construct(){	
		try{
			$this->db = new PDO('mysql:host=' . $this->host . ';dbname=' . $this->db, $this->user, $this->password);
			$this->db->setAttribute(PDO::ATTR_ERRMODE, PDO::ERRMODE_EXCEPTION);
		}catch(PDOException $e){
			die('error : '.$e->getMessage());
		}
	}
 
	private function __clone() {}
 
	static public function getInstance() 
	{
		if (! (self::$instance instanceof self) ) 
		  self::$instance = new self();
 
		return self::$instance;
	}
 
}

[stealth35]

autant faire juste un instanceof PDO

[Shikiryu]

Moui, mais tu perds la possibilité de surcharger avec tes propres méthodes.

Code :

Connection::getInstance()->getAllArticles();

te donnera une erreur car getAllArticles() n'existe pas pour la classe PDO.

Or, rien ne t'empêche avec ma classe de faire :

Code :

1
2
3
4
5
6
7
8
...
public function getAllArticles(){
    $sql = "SELECT * FROM ARTICLES WHERE ETAT = 1";
    $stmt = $this->db->prepare($sql);
    $stmt->execute();
    return $stmt->fetchAll();
}
...

Enfin, là, c'est un exemple un peu simple. Bref, ça créé des raccourcis pas trop mal et permet de surcharger un peu tout ça

[stealth35]

t'utilises SingletonFactory et c'est réglé
https://github.com/stealth35/SingletonFactory

[Benjamin Delespierre]

@stealth - je savais en ouvrant le post que tu lui fourguerait ta classe.

+1 à Stealth, son singleton factory est exactement ce qu'il te faut.
Au passage, faire en sorte que les classes modèles utilisent un singleton revient exactement à mettre l'instance PDO dans les variables globales, c'est sale. Exemple:

Code :

1
2
3
4
5
6
7
8
9
10
11
12
13
 
class TEST1 {
 
  // ...
 
  public function getSomething () {
     // ne pas faire
     $results = Database::query('UNE QUERY');
 
     // faire
     $results = $this->_database->query('UNE QUERY');
  } 
}

Au niveau design, les objets qui ont besoin de communiquer avec la base doivent porter dans leurs attributs le handle de connection de la base avec la quelle ils communiquent. C'est plus propre et surtout plus souple. A cet effet, tu peux par exemple munir ton constructeur du paramètre adéquat, comme par exemple:

Code :

1
2
3
4
5
6
7
8
9
10
11
 
class TEST2 {
 
  protected $_pdo = null;
 
  public function __construct (PDO $pdo, $id = false) {
     $this->_pdo = $pdo;
     if ($id !== false)
       $this->read($id);
  }
}

Tu n'as pas à te soucier de la mémoire dans ce cas car l'objet PDO est passé par référence, il n'y a donc pas de copie quand tu l'utilise comme dans cet exemple.

[Shikiryu]

Envoyé par stealth35

t'utilises SingletonFactory et c'est réglé
https://github.com/stealth35/SingletonFactory

Intéressant. Je ne m'étais pas intéressé à __callStatic() et votre classe est plutôt sympa.
Mais au final, son titre est plutôt bon : c'est une usine à Singleton et ça ne résout en rien son interrogation (à moins que je ne l'ai pas compris.)

Code :

Singleton::PDO('...');

créera bien une instance unique de singleton (ou la récupèrera) mais aucune méthode ne pourra y être ajoutée.

Code :

Singleton::Connection();

créera une instance de sa classe mais il ne saura pas la gérer (je pense).

C'est gentil de me montrer, ce serait mieux de lui expliquer.

@Benjamin : Au final ton dernier exemple est une évolution de mon exemple. L'avantage étant la possibilité d'avoir des connections à plusieurs bases en même temps.

Quoi qu'il en soit, pour moi, un Singleton pour gérer la base de donnée est quasiment une hérésie. En cas d'évolution, on est bien embêté. C'est pour cela que je préfère soit la dernière proposition, soit la mienne

[Benjamin Delespierre]

Intéressant. Je ne m'étais pas intéressé à __callStatic() et votre classe est plutôt sympa.

Attention: __callStatic est une nouveauté introduite par PHP 5.3 (pas sur tous les hebergeurs).

Mais au final, son titre est plutôt bon

C'est le nom du pattern.

@Benjamin : Au final ton dernier exemple est une évolution de mon exemple. L'avantage étant la possibilité d'avoir des connections à plusieurs bases en même temps.

Yep et surtout de découpler l'architecture (on pourrait aller beaucoup plus loin avec des adapters et un DAO mais bon, il faut rester simple).
On peut voir la classe de Stealth en quelque sorte comme une Data Identity Map: son rôle est de servir des instances et de s'assurer qu'elles sont uniques. Mais ça reste une évolution de la notion de "variable globale" au fond...

[stealth35]

si on veux rajouter des méthode il fait étendre PDO donc creer ca classe Connection comme une classe normale et le SingletonFactory la rendra en Singleton comme ça plus besoin de s’embêter

[Shikiryu]

Envoyé par Benjamin Delespierre

Attention: __callStatic est une nouveauté introduite par PHP 5.3 (pas sur tous les hebergeurs).

Oui, oui, j'ai vu ça dans la doc. C'est néanmoins bien cool. (J'ai du mal à suivre les nouveautés de PHP à chaque version, ça me les fait découvrir petit à petit et j'adore)

Envoyé par Benjamin Delespierre

C'est le nom du pattern.

J'ai déjà utilisé le pattern Factory Et il porte toujours bien son nom !
Le mélange des 2 patterns est néanmoins ingénieux.

Envoyé par Benjamin Delespierre

Mais ça reste une évolution de la notion de "variable globale" au fond...

C'est ce qu'est un Singleton in-fine... C'est pour cela que je n'en suis pas un grand fan. (Même si parfois, pour aller vite, j'avoue, je suis tombé dedans )

Envoyé par stealth35

si on veux rajouter des méthode il fait étendre PDO donc creer ca classe Connection comme une classe normale et le SingletonFactory la rendra en Singleton comme ça plus besoin de s’embêter

Je reste sur mon "moui". Perso, au final, j'aurais fait soit ma méthode ou celle de Benjamin, soit un simple extension de PDO sans Singleton. Mais bon, c'est le choix de adc15.

Au final, on s'est bien éloigné de sa question d'ailleurs
(et aucun retour de sa part )

[adc15]

Shikiryu, effectivement je vois le problème de instanceof, je vais changer ça.

stealth, j'ai regardé ton Singleton Factory, mais ça m'a paru bien compliqué

Benjamin, si je fais ta méthode qui consiste, si j'ai bien compris, à mettre une variable dans chaque classe qui contiendra l'instance de PDO, je n'ai plus besoin du singleton, c'est ça ?

Mais bon, c'est le choix de adc15.

Moi j'ai choisi ça parce que j'ai vu que c'était une bonne solution quand on se connectait à un serveur/bdd, après si y'en a d'autres plus adaptées je suis preneur...

(et aucun retour de sa part )

J'essayais de faire marcher mon bazar mais je vous avais pas oublié :p

[Benjamin Delespierre]

Selon moi, le plus propre serait d'avoir:

Code :

1
2
 
$obj = new MaClass(Singleton::PDO(), $id);

Et puis si tu veux te simplifier la vie avec Singleton classique, en voici un:

Code :

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
 
/**
 * Database Class
 *
 * This class manages an instance of PDO registered
 * as a singleton by the Singleton class
 *
 * @see cobalt\util\Singleton
 * @author Delespierre
 * @version 1.0.0
 * @package cobalt\data\source\database
 */
abstract class Database extends Object {
 
    /**
     * Typo helper for PDO constructor
     * @param string $phptype
     * @param string $host
     * @param string $database
     * @param string $username = ""
     * @param string $password = ""
     * @return void
     * @throws PDOException
     */
    public static function open ($phptype, $host, $database, $username = "", $password = "", array $driver_options = array()) {
        $dsn = "$phptype:dbname=$database;host=$host";
        Singleton::PDO($dsn, $username, $password, $driver_options);
    }
 
    /**
     * Allow the use of the PDO Singleton directly
     * as Database static methods
     * @param string $name
     * @param array $args
     * @throws BadMethodCallException
     * @return mixed
     */
    public static function __callStatic ($name, $args) {
        $pdo = Singleton::PDO();
        if (is_callable(array($pdo, $name))) {
            switch (count($arguments)) {
                case 0: return $pdo->$name(); break;
                case 1: return $pdo->$name($args[0]); break;
                case 2: return $pdo->$name($args[0], $args[1]); break;
                case 3: return $pdo->$name($args[0], $args[1], $args[2]); break;
                case 4: return $pdo->$name($args[0], $args[1], $args[2], $args[3]); break;
                case 5: return $pdo->$name($args[0], $args[1], $args[2], $args[3], $args[4]); break;
                default: return call_user_func_array(array($pdo, $name), $param_arr); break;
            }
        }
        else
            throw new BadMethodCallException("No such method: $name");
    }
 
    /**
     * Typo helper for PDO::prepare
     * @param string $statement
     * @param array $driver_options
     * @return PDOStatement
     */
    public static function prepare ($statement, array $driver_options = array()) {
        return Singleton::PDO()->prepare($statement, $driver_options);
    }
 
    /**
     * Typo helper for PDO::query.
     * @param string $statement
     * @return PDOStatement
     */
    public static function simpleQuery ($statement) {
        return Singleton::PDO()->query($statement);
    }
}

Edit - ah bah j'avais oublié que j'utilisai déjà la solution de Stealth là dedans
Voilà donc ma version de Singleton:

Code :

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
 
/**
 * Singleton
 *
 * @author Stealth35, Delespierre
 * @version 1.0.0
 * @package cobalt\util
 */
final class Singleton extends Object
{
    /**
     * Singleton's instances
     * @var object
     */
    private static $_instances;
 
    /**
     * Let the singleton use any namespaced
     * class.
     * @var string
     */
    private static $_current_namespace = '';
 
    /**
     * __callStatic overloading.
     *
     * Allow the use of the factory.
     * E.G.
     * > Singleton::PDO($dsn, $user, $pwd);
     *
     * @param string $name
     * @param array $arguments
     * @return object
     */
    public static function __callStatic($name, array $args) {
        $name = static::$_current_namespace . '\\' . $name;
        if(empty(static::$_instances[$name]) || !empty($args)) {
            $class = new ReflectionClass($name);
            static::$_instances[$name] = !empty($args) ? $class->newInstanceArgs($args) : $class->newInstance();
        }
        return static::$_instances[$name];
    }
 
    /**
     * Sets the namespace to be used
     * @param string $ns = ''
     * @return void
     */
    public static function setNamespace ($ns = '') {
        if (strpos($ns, '\\') === 0) $ns = substr($ns, 1);
        static::$_current_namespace = $ns;
    }
}

[adc15]

OK OK, par contre je comprends pas trop comment marche le deuxième code.

Quand tu fais Singleton:: PDO(), qu'est ce qui est appelé, __callStatic() ?

[stealth35]

Envoyé par adc15

OK OK, par contre je comprends pas trop comment marche le deuxième code.

Quand tu fais Singleton:: PDO(), qu'est ce qui est appelé, __callStatic() ?

oui, puisque ma méthode PDO n'existe pas

[adc15]

D'accord, je viens de comprendre comment marche __callStatic, mais c'est quoi l'intérêt de faire ça par rapport à créer une méthode classique tout simplement ?

[Benjamin Delespierre]

C'est plus pratique et plus esthétique de faire:

Code :

Singleton::PDO($dsn, $user, $pwd);

Que

Code :

Singleton::factory("PDO", array($dsn, $user, $pwd));

Mais le résultat est le même.

[adc15]

Bon alors là je suis perdu, je vois plus du tout comment faire pour récupérer mon instance de PDO.

A quelle endroit je dois créer mon objet PDO ?
L'héritage d'Object n'est pas reconnu par wamp, et quand je l'enlève, et que je fais Singleton:DO(...), ça me dit qu'il ne trouve pas la méthode PDO()

[Benjamin Delespierre]

A quelle endroit je dois créer mon objet PDO ?

Durant le bootstrap, l'init si tu préfère, de l'application serait le mieux.

L'héritage d'Object n'est pas reconnu par wamp

ça ne veut rien dire, les classes héritent d’entre-elles, pas les objets...
Si ta version de PHP est inférieure à 5.3.0, tu ne peux pas utiliser la méthode magique __callStatic.

[adc15]

Mais l'objet PDO je suis censé le créer dans le singleton non ? Sinon il sert à rien...