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
|
<?php
// Code permettant de se connecter à n'importe quel SGBDR dont on a définit la classe, avec 1 seul et même appel
// On instancie notre objet en lui passant en paramètre le nom de la base de données.
// N'autorise qu'une seule et unique instance de l'objet db
// Utilisation de la fonction magique __autoload()
// On crée une classe abstraite qui sera notre fabrique "factory" dont le but est d'être héritée par les classes filles
// Les classes filles seront les classes représentant un SGBDR quelconque
abstract class DBfactory {
private static $getInstance; // propriété statique qui va permettre de stocker l’unique instance de la classe.
protected $config = array(); // Paramètres de configuration pour une base de donnée.
public $default_cfg = array(); // Paramètres de configuration par défaut
// On initialise les variables de connections et on active la connection à la base de donnée.
// Nous mettons le constructeur en visibilité privée ce qui permet de n'avoir qu'une unique instance de la classe grâce à la méthode singleton
// Les paramètres de la future chaîne de connexion sont positionnés à null car ils sont modifiables
private function __construct($server = null, $username = null, $password = null, $dbname = null) {
// Les paramètres de configuration de chacune des bases de données seront stockées dans un tableau que nous appelons default_cfg
// On lance une exception si cette variable n'est pas un tableau
if (!is_array($this->default_cfg)) {
throw new Exception("Vous devez remplir les paramètres de la configuration par defaut de votre base de donnée");
}
// On parcours notre tableau pour récupérer la valeur de chacune des clés
foreach ($this->default_cfg as $key => $value) {
// on stocke la clé ainsi que sa valeur dans le tableau des paramètres de configuration de la base de données
$this->config[$key] = (isset($$key) ? $$key : $value);
}
unset($this->default_cfg); // On enlève les paramètres par defaut pour éviter toute confusion possible.
$this->connect(); // On invoque la méthode de connexion qui sera définie dans les classes filles
}
// usinage : permet d'instancier la classe correcte en fonction de la base de données choisie
// Le paramètre $type correspond à la classe (le nom de la base de données)
public static function factory($type, $server = null, $username = null, $password = null, $dbname = null, $charset = "utf8") {
if (class_exists($type)) { // On vérifie que la classe existe ...
$classname = $type;
echo 'connexion réussie avec ' . __CLASS__;
// on retourne une instance ayant pour arguments les paramètres de configuration
return new $classname($server, $username, $password, $dbname);
} else { // ... sinon on lance une exception
throw new Exception("Pas d'implémentation disponible pour " . $type);
}
}
// Rappel : Singleton garantit qu’une classe n’a qu’une seule instance et fournit un point d’accès global à cette instance.
// Voir http://design-patterns.fr/singleton
// getInstance() est un pseudo-constructeur l'avantage est qu'il nous permet de retourner l'unique instance
public static function getInstance() {
// on teste si l'instance est unique
if (!isset(self::$getInstance)) { // si l'instance est unique alors ...
$class = __CLASS__; // on récupère le nom de la classe via la constante magique __CLASS__
self::$getInstance = new $class; // on crée une instance de la classe et on stocke sa valeur dans cette propriété
}
return self::$getInstance; // on retourne la valeur de cette propriété
}
// on avertit le développeur qu'il n'a pas le droit de cloner l'objet instancié
// puisque l'objet instancié doit être unique
public function __clone() {
trigger_error("Le clônage n'est pas autorisé. ", E_USER_ERROR); // trigger_error() est utilisé pour déclencher une erreur utilisateur
}
// méthodes abstraites (car une classe abstraite doit avoir au moins une méthode abstraite)
abstract protected function connect(); // uniquement la signature de la méthode
abstract public function __destruct(); // uniquement la signature de la méthode
}
?> |
