Commence ici une petite serie de billets sur les "design patterns", les motifs de conception en français. Les motifs de conception ne sont rien d'autre que des solutions toutes prêtes à des problèmes couramment rencontrés, il s'agit de morceaux de code, des "squelettes" prêts à remplir leur fonction (variable) et à être adaptés a votre situation.
La quasi-totalité des design patterns ne dépendent pas d'un langage et peuvent être adaptés à n'importe quel langage moyennant l'adaptation de la syntaxe. Bien évidemment, un design pattern proposant une solution orientée objet ne sera valable que pour un language orienté objet, etc..Singleton: Utilité
Le motif de conception nommé "singleton" est sans conteste un des plus simples à mettre en oeuvre et à comprendre, c'est aussi un des plus utilisés et les exemples de singleton pullulent sur le web, d'ailleurs, j'y mets là mon grain de sel
Destiné a la programmation orientée objet, il permet de n'avoir toujours qu'une seule et unique instance d'un objet quel que soit le nombre de fois où l'on en a besoin.
Une situation typique et courante est la connection a une BDD (Base De Données): en général, vous ne voulez avoir pour toute l'exécution du script qu'une unique connection a la BDD même si vous faites appel à votre classe de gestion de BDD a maintes reprises et dans différents contextes.
Un autre cas pourrait être le suivant: Vous utilisez un ensemble de classes par le biais d'une autre classe, par exemple, votre classe de gestion de BDD ainsi que votre classe de gestion d'utilisateur sont accessibles toutes deux au travers de la classe "
moteur":
$moteur->bdd->query_sql()
$moteur->users->is_online();
Dans un tel contexte, vous voudriez sans doute là aussi n'avoir qu'une unique instance de la classe "
moteur".
resultat recherché
Afin d'utiliser toujours la même instance d'une classe "
BaseSql" par exemple, une solution pourrait être de l'instantiser une première fois lors de l'initialisation de votre script puis de faire passer la référence de l'objet de classe en classe de la sorte
class MaClasse_A
{
private $BaseSql;
__construct (&InstanceBDD) {
$this->BaseSql =& $InstanceBDD;
}
uneFonction () {
$requete = "SELECT * FROM `MaTable` WHERE 1";
$this->BaseSql->query_sql($requete);
}
}Mais cette solution n'est vraiment pas pratique ! car elle vous oblige à appeler votre classe en fournissant en argument l'instance de
$BaseSql:
$classA = new MaClasse_A ($BaseSql);
Mais surtout, cela devient vraiment vraiment pénible dès qu'il est question d'héritage et de collaboration entre les classes ! voyez l'exemple ci-dessous:
class MaClasse_A {
__construct (&instanceBDD) {
$this->BaseSql =& $InstanceBDD;
}
/*
... plein de methodes
*/
getUserInscriptionDate () {
$classeDate = new DATE ($this->BaseSql);
return $classeDate->userInstription();
}
}
class DATE {
__construct (&$instanceBDD) {
$this->bdd =& $instanceBDD;
}
userInscription() {
/* ... */
}
}Là c'était juste pour une classe qui se sert d'une autre classe, mais imaginez si cette même autre classe se sert elle-même d'une autre classe, puis que cette autre classe se serve de 4 autres classes, et ces 4 autres de 2 autres, etc.. Il faudra veiller à chaque fois que l'on a besoin de
BASESQL à prendre la référence de son instance, bien veiller à toujours passer l'instance à d'autres classes, etc.. en d'autres mots, croyez-moi: ca devient le bordel !
LA solution qui serait élégante serait, de tout simplement, et à chaque fois que l'on a besoin d'utiliser la classe
BASESQL, faire:
/* quelque part dans le code.. dans une classe ou n'importe ou */
$basesql = BASESQL::getInstance(); // et mainteant on fait ce qu'on veut
$basesql->methodeXYZ(); // et si on fait a nouveau
$Autre = BASESQL::getInstance();
/*
et ben on se retrouve avec toujours la même instance,
$basesql et $Autre contiendront la même instance de BASESQL
*/le motif Singleton le permet en 2 ou 3 lignes.
Mise en Oeuvre
La classe qui ne devra être instantisée qu'une seule fois devra être comme ceci:
class BASESQL {
private static $instance;
/* ...some code */
public static getInstance () {
if (is_null(self::instance)) {
self::instance = new BASESQL (/* ..some args */ ); }
return self::instance;
}
/* ...some code */
}Explication:
Lorsque vous faites un appel à la methode
getInstance() comme ceci:
$BaseSql = BASESQL::getInstance();
La méthode regarde si la propriété
$Instance est vide ( nulle ), si elle est vide, elle y affecte une nouvelle instance de
BASESQL ( donc d'elle-même ), sinon, si elle n'est pas nulle, c'est qu'elle contient déja une instance d'elle-même précédemment créée, donc rien à faire.
Elle finit par retourner
$Instance qui dans tous les cas contiendra donc une instance de
BASESQL.
Ainsi, si
BASESQL est déja instantisée on en transmet l'instance, sinon on instantise (et le prochain appel de la method
getInstance transmettra cette instance qui vient d'être faite ) et on transmet.
La méthode
getInstance() et la propriété
$Instance sont publiques et statiques dans le but d'être accessibles par tout le monde et ce sans avoir besoin que la classe ait été déjà instantisée (logique, c'est le but ! )
Des questions ? des suggestions ? des conseils ? n'hésitez pas a vous servir des commentaires, ils sont là pour ça, ou de la page contact (cf. menu a droite) pour un mail.
Le prochain billet traitera du motif Registry ou du motif Factory.