Introduction à la classe Singleton en Java
La classe Singleton limite la création d'objets pour une classe à une seule dans la machine virtuelle java. Il aide également à fournir un point d'accès global à l'objet. Ce modèle de conception est couramment utilisé dans la mise en cache, Abstract Factory, la journalisation, le prototype, etc. Il est également utilisé dans les classes Java principales telles que java.awt.Desktop, java.lang.Runtime. Dans java.lang.Runtime, Java fournit une classe Runtime qui signifie l'environnement Runtime actuel où l'application s'exécute. Cela aide à interfacer l'application et l'environnement d'exécution. Il doit y avoir un objet car le JRE est unique. Dans java.awt.Desktop, la classe Desktop permet aux applications de lancer un URI ou un fichier avec le navigateur par défaut de l'utilisateur, du client de messagerie, etc. Ici aussi, il ne doit y avoir qu'une seule instance de la classe.
Fonctionnement de la classe Singleton en Java
La classe singleton peut être créée de deux manières.
- Définissez le constructeur comme privé afin de limiter la création d'un objet.
- Créez une méthode statique pour obtenir une instance de l'objet, afin de pouvoir gérer la création d'objet à l'intérieur de la classe uniquement.
Voyons maintenant le diagramme de classe UML (Unified Modeling Language) de la classe Singleton.
Dans le diagramme Class UML, la première partition représente le nom d'une classe, la deuxième partition représente les attributs et la troisième partition représente les méthodes. De plus, + indique des attributs ou méthodes publics et - indique des attributs ou méthodes privés. Dans notre diagramme UML de classe Singleton, le nom de classe est Singleton et il a une méthode principale. La méthode principale, la méthode getInstance et la méthode sampleMethod sont les seules méthodes qui sont publiques dans le diagramme ci-dessus. Le constructeur et l'attribut d'instance sont définis comme privés dans le cadre de notre implémentation. Cette méthode Main publique demande l'instance et getInstance la renvoie à la méthode main.
Basé sur l'instanciation, la seule différence entre la classe Java normale et la classe Singleton est que nous utiliserons un constructeur dans la classe Java alors que, dans Singleton, nous utiliserons la méthode getInstance ().
Le motif de conception singleton est de deux formes.
- Instanciation paresseuse: création d'instance si nécessaire
- Instanciation précoce: création d'instance au moment du chargement.
1. Instanciation paresseuse
Dans Lazy Instantiation, une instance de classe est créée lorsqu'elle est requise. Il est créé dans la méthode ou le bloc synchronisé afin d'éviter les conditions de concurrence qui peuvent se produire dans un environnement multi-thread.
2. Instanciation précoce
Dans Early Instantiation, une instance est créée au moment du chargement. Même s'il s'agit de l'approche la plus simple, elle présente l'inconvénient que la création d'instance se fait indépendamment de l'accès ou non.
Un exemple d'instanciation paresseuse et d'instanciation précoce est expliqué dans la section suivante.
Implémentation de la classe Singleton en Java
Comme indiqué ci-dessus, la classe Singleton peut être créée en instanciation précoce ou en instanciation paresseuse.
Instanciation paresseuse
Voici les étapes pour implémenter l'instanciation paresseuse
1. Définissez Constructor comme privé.
Par exemple, nous créons une classe LazyClass. Le constructeur sera comme indiqué ci-dessous.
private LazyClass ()
(
)
2. Créez une instance statique privée pour la classe créée.
private static LazyClass instance;
3. Créez une méthode synchronisée statique qui crée l'instance de classe.
public static synchronized LazyClass getInstance()
(
)
4. Dans la méthode getInstance (), vérifiez d'abord si une instance est présente ou non. S'il n'est pas trouvé, créez-en un. Sinon, renvoyez l'instance.
if(instance == null)
(
instance = new LazyClass ();
)
return instance;
Maintenant, examinons-le en utilisant un exemple de code.
//Java Program for Lazy Instantiation
public class LazyClass (
private static LazyClass instance;
//set the constructor as private
private LazyClass () ()
//Checks whether an instance is already in the getInstance method
public static synchronized LazyClass getInstance() (
//if instance is not present already, create a new one
if(instance == null) (
instance = new LazyClass ();
)
// if an instance is present, then return it
return instance;
)
//Sample method that is protected from more than one object creation
public void sampleMethod( ) (
System.out.println("sampleMethod for lazy singleton");
)
public static void main(String() args) (
LazyClass temp=LazyClass.getInstance();
temp.sampleMethod();
)
)
Production:
Ici, au lieu de créer une instance au moment du chargement, elle est créée à l'intérieur du bloc synchronisé. Pour une meilleure compréhension, un exemple de méthode est également donné qui est protégé contre plusieurs créations d'objets.
Instanciation précoce
Voyons maintenant les étapes de l'instanciation précoce. Elle est similaire à l'instanciation paresseuse, sauf qu'elle n'utilise aucune méthode ou bloc synchronisé.
1. Définissez Constructor comme privé.
Par exemple, nous créons une classe EarlyClass. Le constructeur sera comme indiqué ci-dessous.
private EarlyClass () ()
(
)
2. Créez une instance statique privée pour la classe créée.
private static EarlyClass ins = new EarlyClass();
3. Créez une méthode statique qui crée l'instance de classe.
public static EarlyClass getInstance()
(
)
Voici l'exemple de code pour l'instanciation précoce.
//Java Program for Early Instantiation
public class EarlyClass (
//Create an instance of the class at load time
private static EarlyClass ins = new EarlyClass();
//set the constructor as private
private EarlyClass () ()
//A static method to get the instance
public static EarlyClass getInstance() (
return ins ;
)
//A sample method that is protected from more than one object creation
public void sampleMethod() (
System. out .println("sampleMethod for Early singleton");
)
//Main method
public static void main(String() args) (
EarlyClass tmp = getInstance ();
tmp.sampleMethod();
)
)
Production:
Dans le programme ci-dessus, une instance est créée au moment du chargement et est renvoyée à l'aide de la méthode getInstance (). De plus, Constructor est défini comme privé dans le cadre de l'instanciation singleton.
L'économie de mémoire est le principal avantage de l'utiliser car un objet est réutilisé et non créé encore et encore.
Conclusion
Dans ce document, nous avons couvert le fonctionnement d'une classe Singleton à l'aide du diagramme, de l'algorithme et de l'exemple de code UML de classe. La classe Singleton est utilisée lorsque nous avons besoin d'un seul objet pour une classe et d'un point d'accès global à cet objet. Les deux formes telles que l'instanciation précoce et l'instanciation paresseuse peuvent être utilisées en fonction de l'exigence.
Articles recommandés
Ceci est un guide de la classe Singleton en Java. Nous discutons ici du fonctionnement de la classe singleton en java ainsi que de l'implémentation qui inclut l'instanciation paresseuse et l'instanciation précoce. Vous pouvez également consulter nos autres articles suggérés pour en savoir plus -
- Qu'est-ce que Design Pattern en Java?
- Classe abstraite en Java
- Annotations Java
- BorderLayout en Java
- JRE vs JVM | 8 principales différences avec (infographie)
- Comment travailler la méthode statique en JavaScript?