Le pattern Singleton en Java

J’avais envie de prendre un peu de temps pour parler de cette petite méthode à connaitre en programmation objet, qu’est le pattern Singleton. Comme son nom le laisse à penser, cette technique va nous permettre de n’instancier qu’une seule fois notre classe dans tout le programme. En gros, cela est très, très pratique pour les énormes classes (comme des DataManager …) ou tout simplement pour « bloquer » la création d’autres instances (en effet, si on créé une fenêtre graphique, il serait inutile de pouvoir l’instancier plus d’une fois dans le cas ou elle est notre fenêtre mère).

Le singleton basique :

Ici nous utiliserons la méthode du « lazy-loading », c’est à dire que notre appel à la création de l’objet sera faite au démarrage du programme. Ceci va pouvoir se faire ainsi :

Prenons la classe PresidentRepubliqueFrancaise , ça c’est de l’exemple qui respire l’originalité ! :)  :

public class PresidentRepubliqueFrancaise {
     private String nom;
     private PartiPolitique parti;
     private int niveauDeMensonge;

     public PresidentRepubliqueFrancaise() {

     }

     public void mentir() {
     }
}

En apparence, rien d’anormal jusque la, j’ai bien évidemment omis ce qui n’était pas important pour un président ;) C’est une blague, hein, j’ai tout simplement pas le temps d’écrire les attributs et méthodes que pourraient posséder un président. Une chose est sûre, il ne peut y avoir qu’un seul président de la république.

Maintenant si on veut y ajouter le fait qu’une unique instance puisse être créée, il faut ajouter un attribut :

protected static PresidentRepubliqueFrancaise current = null;

Cet attribut va servir de « verrou » vous allez comprendre plus loin. Maintenant, définissons une méthode qui permet de « verrouiller » notre attribut current :

 public static PresidentRepubliqueFrancaise getPresidentRepubliqueFrancaise() {
	if (current == null)
	    current = new PresidentRepubliqueFrancaise();
	return current;
 }

Cette méthode édicte le fait que la première instance sera créée sans problème, et stockée dans la classe même, dans l’attribut « current« . Ainsi, la classe créée se maintient en vie, en quelque sorte. Imaginons à l’instant que l’on essaye d’instancier à nouveau la classe : current, n’est pas égal à null, la méthode va donc directement retourner son instance, sans créer quoi que ce soit.

Ainsi, nous avons deux utilisations différentes pour utiliser notre instance ailleurs :

  • Soit la déclarer une bonne fois pour toutes :
    PresidentRepubliqueFrancaise lambda = new PresidentRepubliqueFrancaise();

  Note : Si vous utilisez cette technique, il faudra enlever le mot clé « static » dans la classe, afin de pouvoir l’instancier en dehors d’elle même.

  • Soit utiliser une instanciation dynamique, qui détruira l’objet immédiatement lorsqu’on en a plus besoin (ce que je conseille de faire, si vous êtes amené a utiliser votre objet dans différentes classes, et pour éviter tout problème de portée et de visibilité) :
    traitement(PresidentRepubliqueFrancaise.getPresidentRepubliqueFrancaise());

 

Voila donc pour l’utilisation d’un singleton, attention toutefois ! Ce pattern n’est pas adapté pour une utilisation multi-threading. Il existe une petite modification à apporter si l’on veut pouvoir définir un Singleton dans une application qui utilise les threads, il suffit d’ajouter le mot clé « synchronized » pour rendre la méthode thread-safe.

public static synchronized PresidentRepubliqueFrancaise getPresidentRepubliqueFrancaise() { 
     ....
}

Compliqué hein ?

Laisser un commentaire