Patterns et Singleton - pour tous ceux qui les ont rencontrés pour la première fois

Cet article s'adresse à ceux qui ont découvert pour la première fois le concept de motifs, qui en ont entendu parler Singletonou qui l'ont créé d'une manière ou d'une autre, mais qui n'ont toujours rien compris. Accueillir! Les étudiants JavaRush rencontrent des modèles pour la première fois au niveau 15, lorsque, de manière inattendue, le plafond demande de « corriger » et d'implémenter un modèle Singletonavec une implémentation paresseuse. Les étudiants qui en entendent parler pour la première fois Singletonse posent immédiatement un tas de questions : qu'est-ce qu'un modèle, pourquoi est-il nécessaire, de quel type de modèle s'agit-il Singletonet, enfin, de quel type d'implémentation paresseuse s'agit-il. Commençons à répondre dans l'ordre :

Au fait, qu’est-ce qu’un modèle ?

Pour une meilleure compréhension, je pense qu’il vaut la peine de répondre à cette question historique. Parmi les programmeurs, il y a quatre auteurs célèbres : Erich Gamma, Richard Helm, Ralph Johnson et John Vlissides, qui ont eu une idée intéressante. Ils ont remarqué que lors de l'écriture de programmes, ils devaient souvent résoudre à peu près les mêmes problèmes et écrire du code de même type dans la structure. Par conséquent, ils ont décidé de décrire sous forme de modèles des modèles typiques souvent utilisés dans la programmation orientée objet. Le livre a été publié en 1995 sous le titre « Techniques de conception orientée objet. Modèles de conception" . Le titre du livre s'est avéré trop long et il est simplement devenu connu sous le nom de Le Livre de la Bande des Quatre . Dans la première édition, 23 modèles ont été publiés, après quoi des dizaines d'autres ont été découverts. Alors, répondant à la question de ce paragraphe, « Que sont les modèles ? » , résumons en quelques mots : Et Singletonce n’est qu’un de ces modèles.

Pourquoi avons-nous besoin de modèles (modèles de conception)

Vous pouvez programmer sans connaître les modèles ; vous pouvez le vérifier simplement en réalisant qu'au niveau 15 de JavaRush, vous aviez écrit des centaines de mini-programmes sans rien connaître de leur existence. Ceci suggère qu'un patron est une sorte d'outil dont la présence distingue un maître d'un amateur : Les modèles décrivent comment résoudre correctement l'un des problèmes typiques. En conséquence, connaître les modèles vous fait gagner du temps. Une analogie peut être faite avec les algorithmes. Par exemple, vous pouvez créer votre propre algorithme de tri avec le blackjack et les nombres et y consacrer beaucoup de temps, ou vous pouvez en utiliser un qui a déjà été décrit il y a longtemps et l'implémenter. C'est la même chose avec les modèles. De plus, avec l'utilisation de modèles, le code devient plus standardisé et, en utilisant les bons modèles, vous serez moins susceptible de commettre des erreurs, car elles étaient déjà prévues et éliminées dans ce modèle. Eh bien, en plus de tout, la connaissance des modèles permet aux programmeurs de mieux se comprendre. Il suffit de dire le nom du modèle, au lieu d'essayer d'expliquer à vos collègues programmeurs ce que vous voulez qu'ils fassent. Donc, pour résumer, les modèles de conception aident : En conclusion de cette section, nous notons que toute la variété des modèles peut être simplifiée en trois grands groupes :

Enfin un modèle Singleton

Singletonfait référence à des modèles génératifs . Sa traduction littérale est solitaire. Ce modèle garantit qu'une classe n'a qu'un seul objet (une instance de la classe) et qu'un point d'accès global est fourni à cet objet. Il ressort clairement de la description que ce modèle doit être utilisé dans deux cas :

1. lorsque pas plus d’un objet d’une classe ne doit être créé dans votre programme. Par exemple, dans un jeu informatique, vous avez une classe « Personnage », et cette classe ne doit avoir qu'un seul objet décrivant le personnage lui-même.


2. lorsque vous devez fournir un point d'accès global à un objet de classe. En d’autres termes, vous devez vous assurer que l’objet est appelé depuis n’importe où dans le programme. Et, hélas, pour cela, il ne suffit pas de créer simplement une variable globale, car elle n'est pas protégée en écriture et n'importe qui peut modifier la valeur de cette variable et le point d'accès global à l'objet sera perdu. Ces propriétés Singletonsont nécessaires, par exemple, lorsque vous disposez d'un objet d'une classe qui fonctionne avec une base de données et que vous avez besoin que la base de données soit accessible à partir de différentes parties du programme. Et Singletoncela garantira qu’aucun autre code n’a remplacé l’instance de classe précédemment créée.

Ces deux problèmes sont résolus par Singleton: il doit y avoir un seul objet dans le programme et il doit y avoir un accès global à celui-ci. Dans l'exemple au niveau 15, le cap demande d'implémenter ce pattern pour la tâche suivante (voici sa description) : Après avoir lu attentivement la condition, il devient clair pourquoi exactement Singleton(Single) est nécessaire ici. Après tout, le programme vous demande de créer un objet de chaque classe : Sun, Moon, Earth. Et il est logique de supposer que chaque classe du programme ne devrait pas créer plus d'un Soleil/Lune/Terre, sinon ce serait absurde, à moins bien sûr que vous n'écriviez votre propre version de Star Wars. Fonctionnalité d' implémentation SingletonJava en trois étapes Le comportement Singleton en Java ne peut pas être implémenté à l'aide d'un constructeur standard car le constructeur renvoie toujours un nouvel objet. Par conséquent, toutes les implémentations de Singleton'a se résument à cacher le constructeur et à créer une méthode statique publique qui contrôlera l'existence d'un seul objet et « détruira » tous les objets nouvellement apparaissant. Si Singleton'a est appelé, il doit soit créer un nouvel objet (s'il n'est pas déjà dans le programme), soit en renvoyer un qui a déjà été créé. Pour ce faire : #1. – Vous devez ajouter un champ statique privé à la classe contenant un seul objet :

public class LazyInitializedSingleton {
	private static LazyInitializedSingleton instance; //#1
}

#2. – Rendre le constructeur de classe (constructeur par défaut) privé (afin que l'accès à celui-ci soit fermé en dehors de la classe, il ne pourra alors pas renvoyer de nouveaux objets) :

public class LazyInitializedSingleton {
	private static LazyInitializedSingleton instance;
private LazyInitializedSingleton(){} // #2
}

#3 . – Déclarez une méthode de création statique qui servira à obtenir le singleton :

public class LazyInitializedSingleton {
    private static LazyInitializedSingleton instance;
        private LazyInitializedSingleton(){}
        public static LazyInitializedSingleton getInstance(){ // #3
        if(instance == null){		//if the object has not been created yet
            instance = new LazyInitializedSingleton();	//create a new object
        }
        return instance;		// return the previously created object
    }
}

L'exemple ci-dessus est quelque peu maladroit, car nous masquons simplement le constructeur et fournissons notre propre méthode au lieu du constructeur standard. Étant donné que cet article vise à permettre aux étudiants JavaRush d'entrer en contact pour la première fois avec ce modèle (et les modèles en général), les fonctionnalités d'implémentation de Singletons plus complexes ne seront pas données ici. Notons seulement qu'en fonction de la complexité du programme, un raffinement plus détaillé de ce modèle peut être nécessaire. Par exemple, dans un environnement multithread (voir la rubrique Threads), plusieurs threads différents peuvent appeler simultanément la méthode getter de Singleton, et le code décrit ci-dessus cessera de fonctionner, car chaque thread individuel pourra créer plusieurs instances de la classe. immediatement. Par conséquent, il existe encore plusieurs approches différentes pour créer des singletons Thread-safe corrects. Mais c'est une autre histoire =) Et enfin. Qu'est-ce que l'initialisation paresseuse demandée par le plafond ? L'initialisation paresseuse est également appelée initialisation paresseuse. Il s'agit d'une technique de programmation dans laquelle une opération gourmande en ressources (et la création d'un objet est une opération gourmande en ressources) est effectuée à la demande, plutôt qu'à l'avance. C'est essentiellement ce qui se passe dans notre code Singleton'a. En d’autres termes, notre objet est créé au moment où on y accède, et non à l’avance. Il ne faut pas supposer que le concept d'initialisation paresseuse est d'une manière ou d'une autre strictement lié à Singleton'om. L'initialisation paresseuse est également utilisée dans d'autres modèles de conception génératifs, par exemple dans Proxy et Factory Method, mais c'est une autre histoire =) Les sources suivantes ont été utilisées lors de la préparation de l'article :

1. Meilleures pratiques du modèle de conception Java Singleton avec exemples
2. Modèles de conception
3. Corriger Singleton en Java