Modèles de conception Java – Modèle Singleton

Les modèles de conception sont une solution bien décrite aux problèmes courants tels que ceux rencontrés lors du développement de logiciels. Ces solutions ont été obtenues grâce à l'expérience de nombreux professionnels du logiciel sur une période assez longue. Par conséquent, ces modèles sont «évolués» plutôt que «découverts». L'apprentissage de ces modèles aide les développeurs à venir à apprendre la conception de logiciels de manière simple et plus rapide

En 1994, quatre auteurs Erich Gamma, Richard Helm, Ralph Johnson et John Vlissides ont publié un livre intitulé Design Patterns – Elements of Reusable Object-Oriented Software qui a initié le concept de Design Pattern dans le développement de logiciels. Ces auteurs sont collectivement connus sous le nom de Gang of Four (GOF). Le modèle de conception a reçu son nom court en tant que modèles de conception GOF. Selon ces auteurs, les modèles de conception sont principalement basés sur les principes suivants de conception orientée objet.

• Programmer vers une interface et non une implémentation
• Privilégier la composition des objets à l'héritage

Types de modèles de conception: [19659005] Il existe 23 modèles de conception qui peuvent être classés en trois catégories: modèles de création, structurels et comportementaux.
Ici, nous discuterons également d'un autre type de modèle de conception appelé Divers / J2EE / Patterns de présentation. Ces modèles sont identifiés par Sun Java Center.

1. Motif de conception créative
Motifs de conception qui traitent de la création d'un objet tout en masquant la logique de création, plutôt que d'instancier des objets directement à l'aide d'un nouvel opérateur. Cela donne au programme plus de flexibilité pour décider quels objets doivent être créés pour un cas d'utilisation donné.

1.1 Modèle singleton
Le modèle singleton est l'un des modèles de conception les plus simples de Java.

Pouvons-nous nous rappeler ce qu'est une classe singleton?

«Dans la programmation orientée objet, une classe singleton est une classe qui ne peut avoir qu'un seul objet (une instance de la classe) à la fois . »
Le motif Singleton a pour but de contrôler la création d'objets, en limitant le nombre d'objets à un seul.
Vous savez maintenant ce qu'est le motif Singleton Design. La prochaine étape serait de l'implémenter.

Pour implémenter le modèle de conception Singleton dans le langage de programmation Java, les développeurs doivent disposer des éléments suivants:
• Membre statique: Il créera une seule instance dans la mémoire JVM en tant que statique sont des variables au niveau de la classe.
• Constructeur privé: Cela limitera l'instanciation de la classe Singleton à partir du monde extérieur (c'est-à-dire que l'initialisation de cette classe à l'aide du nouveau mot clé est empêchée)
• Méthode d'usine statique: Ceci fournit le point d'accès global à l'objet Singleton et renvoie l'instance à l'appelant

Le diagramme ci-dessous vous donne une image claire du modèle de conception Singleton [19659002]

Types d'initialisation de Singleton:

La classe Singleton peut être instanciée par deux méthodes :

1. Initialisation précoce: Dans cette méthode, la classe est initialisée, qu'elle soit utilisée ou non. Le principal avantage de cette méthode est sa simplicité. Vous lancez la classe au moment du chargement de la classe. L'inconvénient est que la classe est toujours initialisée, qu'elle soit utilisée ou non.
2. Initialisation paresseuse: Dans cette méthode, la classe in n'est initialisée que lorsqu'elle est requise. Cela peut vous éviter d'instancier la classe lorsque vous n'en avez pas besoin. Généralement, l'initialisation paresseuse est utilisée lorsque nous créons une classe singleton.

Initialisation précoce:

package com.creationaldesign.singleton;
classe publique SingletonClass {
/ * * Initialisation précoce * /
// créer un objet de SingletonClass
// Attribut statique
privé statique SingletonClass instance = new SingletonClass ();
// rendre le constructeur privé afin que cette classe ne puisse pas être
// instancié
// Remarque: le modèle Singleton limite l'instanciation d'une classe et garantit
// qu'il n'existe qu'une seule instance de la classe dans la machine virtuelle Java
// Constructeur privé
private SingletonClass () {
}
// Récupère le seul objet disponible
// Fonction statique
public statique SingletonClass getInstance () {
retourne l'instance;
}
public void showMessage () {
System.out.println ("Voici le message fr om the Singleton Class ");
}
}

Ici, nous avons créé une instance de singleton dans l'initialiseur statique. JVM exécute un initialiseur statique lorsque la classe est chargée. Utilisez cette méthode uniquement lorsque votre classe singleton est légère et est utilisée tout au long de l'exécution de votre programme.

Vous pouvez également opter pour une meilleure approche " Verrouillage à double vérification "
"Verrouillage à double vérification" :
Si vous remarquez attentivement une fois qu'un objet est créé, la synchronisation n'est plus utile car maintenant obj ne sera pas nul et toute séquence d'opérations conduira à des résultats cohérents.

Nous n'acquérirons donc que le verrou sur getInstance () une fois, lorsque l'obj est nul. De cette façon, nous synchronisons uniquement le premier chemin, exactement ce que nous voulons et, par conséquent, cela est garanti comme thread-safe

Initialisation paresseuse:

package com.creationaldesign.singleton ;
/ **
* Implémentation Java basée sur le verrouillage à double vérification du modèle de conception singleton
* Ceci est clairement mentionné dans https://en.wikipedia.org/wiki/Singleton_pattern[19459005indirect*sousInitialisationparesseuse
* /
public class SingletonClass {
// Attribut Static and Volatile
private volatile static SingletonClass obj;
// Constructeur privé
private SingletonClass () {
} [
}
// Fonction statique
public statique SingletonClass getInstance () {
if (obj == null) {
// Pour fournir une implémentation thread-safe
synchronisée (SingletonClass.class) {
// vérifier à nouveau car plusieurs threads peuvent atteindre l'étape
if (obj == null)
obj = new SingletonClass ();
}
}
return obj;
}
}

Nous avons déclaré l'obj volatile qui garantit que plusieurs threads proposent correctement la variable obj lorsque il est en cours d'initialisation sur l'instance Singleton. Cette méthode réduit considérablement les frais généraux liés à l'appel de la méthode synchronisée à chaque fois.

Dans l'une des deux méthodes ( Initialisation précoce / paresseuse ), créez une classe. Créez ensuite une méthode principale pour tester la classe singleton comme ci-dessous,

Méthode principale:

package com.creationaldesign.singleton;
/ **
* Singleton Pattern Main Class!
*
* /
public class SingletonPatternApp {
public static void main (String [] args) {
// construction illégale de la classe singleton
// Erreur de compilation: le constructeur SingleObject () n'est pas visible
// SingletonClass newObjInstance = new SingletonClass ();
// Récupère le seul objet disponible
SingletonClass getOldInstance = SingletonClass.getInstance ();
// affiche le message
getOldInstance.showMessage ();
}
}

Sortie console:
Voici le message de la classe Singleton [19659002] Diagramme de classe:

Voyons quelques-uns des Exemples de classe Singleton:

1) java.lang.Runtime: Java fournit une classe Runtime dans son paquetage lang qui est de nature singleton.
2) java. awt.Desktop: La classe Desktop permet à une application Java de lancer des applications associées enregistrées sur le bureau natif pour gérer un URI ou un fichier. Cette classe ne peut pas non plus être instanciée à partir de l'application. C'est donc aussi une classe singleton.
3) mémoire cache
4) connexion à la base de données
5) pilotes
6) journalisation
7) Accès matériel
8) Fichiers de configuration [19659002] Consultez également mes blogs sur d'autres modèles de conception Java ?