În programarea orientată pe obiecte, o clasă java singleton este o clasă care poate avea un singur obiect (o instanță a clasei) la un moment dat. După prima dată, dacă încercăm să instanțiem clasele Java Singleton, noua variabilă indică și prima instanță creată. Deci, orice modificări pe care le facem oricărei variabile din interiorul clasei prin orice instanță, afectează variabila instanței unice create și este vizibilă dacă accesăm acea variabilă prin orice variabilă a acelui tip de clasă definită.
Amintiți-vă punctele cheie atunci când definiți o clasă ca o clasă singleton care este în timp ce proiectați o clasă singleton:
- Faceți un constructor privat.
- Scrieți o metodă statică care are obiectul de tip return al acestei clase singleton. Aici, conceptul de inițializare Lenesă este folosit pentru a scrie această metodă statică.
Scopul clasei Singleton
Scopul principal al unei clase Java Singleton este de a restricționa limita numărului de creații de obiecte la doar una. Acest lucru asigură adesea că există controlul accesului la resurse, de exemplu, socket sau conexiune la baza de date.
Risipirea spațiului de memorie nu are loc cu utilizarea clasei singleton, deoarece restricționează crearea instanțelor. Deoarece crearea obiectului va avea loc o singură dată, în loc să fie creată de fiecare dată când se face o nouă solicitare.
Putem folosi acest singur obiect în mod repetat, conform cerințelor. Acesta este motivul pentru care aplicațiile multi-threaded și de baze de date folosesc în mare parte modelul Singleton în Java pentru stocarea în cache, înregistrare în jurnal, pooling de fire, setări de configurare și multe altele.
De exemplu, există o licență la noi și avem o singură conexiune la baza de date sau presupunem că driverul nostru JDBC nu ne permite să facem multithreading, atunci clasa Singleton intră în imagine și se asigură că la un moment dat, doar o singură conexiune sau un singur thread poate accesa conexiunea.
Cum să proiectați/creați o clasă Singleton în Java?
Pentru a crea o clasă singleton, trebuie să urmam pașii, dați mai jos:
1. Asigurați-vă că există o singură instanță a clasei.
șirul de înlocuire java
2. Oferiți acces global la acea instanță prin
- Declararea tuturor constructorilor clasei ca fiind private.
- Furnizarea unei metode statice care returnează o referință la instanță. Conceptul de inițializare leneșă este folosit pentru a scrie metodele statice.
- Instanța este stocată ca o variabilă statică privată.
Un exemplu de clase singleton este Clasa de rulare, Servlet de acțiune și Localizator de servicii . Constructorii privați și metodele din fabrică sunt, de asemenea, un exemplu de clasă singleton.
Diferența dintre Clasa Normală și Clasa Singleton
Putem distinge o clasă Singleton de clasele obișnuite în ceea ce privește procesul de instanțiere a obiectului clasei. Pentru a instanția o clasă normală, folosim un constructor java. Pe de altă parte, pentru a instanția o clasă singleton, folosim metoda getInstance().
Cealaltă diferență este că o clasă normală dispare la sfârșitul ciclului de viață al aplicației, în timp ce clasa singleton nu se distruge odată cu finalizarea unei aplicații.
Forme ale modelului de clasă Singleton
Există două forme de modele de design singleton, care sunt:
- Instanciare timpurie: Crearea obiectului are loc la momentul încărcării.
- Instanțierea leneșă: Crearea obiectului se face conform cerinței.
Implementare: Să vedem pe scurt cum variază clasa singleton față de clasa normală din java. Aici diferența este în termeni de instanțiere, deoarece pentru clasa normală folosim un constructor, în timp ce pentru clasa singleton folosim metoda getInstance(). pe care îl vom arunca cu ochiul în exemplul 1, așa cum este prezentat mai jos. În general, pentru a evita confuzia, putem folosi și numele clasei ca nume de metodă în timp ce definim această metodă, care va fi descrisă în exemplul 2 de mai jos, după cum urmează.
Exemplul 1:
Java
// Java program implementing Singleton class> // with using getInstance() method> // Class 1> // Helper class> class> Singleton {> >// Static variable reference of single_instance> >// of type Singleton> >private> static> Singleton single_instance =>null>;> >// Declaring a variable of type String> >public> String s;> >// Constructor> >// Here we will be creating private constructor> >// restricted to this class itself> >private> Singleton()> >{> >s =>'Hello I am a string part of Singleton class'>;> >}> >// Static method> >// Static method to create instance of Singleton class> >public> static> synchronized> Singleton getInstance()> >{> >if> (single_instance ==>null>)> >single_instance =>new> Singleton();> >return> single_instance;> >}> }> // Class 2> // Main class> class> GFG {> >// Main driver method> >public> static> void> main(String args[])> >{> >// Instantiating Singleton class with variable x> >Singleton x = Singleton.getInstance();> >// Instantiating Singleton class with variable y> >Singleton y = Singleton.getInstance();> >// Instantiating Singleton class with variable z> >Singleton z = Singleton.getInstance();> >// Printing the hash code for above variable as> >// declared> >System.out.println(>'Hashcode of x is '> >+ x.hashCode());> >System.out.println(>'Hashcode of y is '> >+ y.hashCode());> >System.out.println(>'Hashcode of z is '> >+ z.hashCode());> >// Condition check> >if> (x == y && y == z) {> >// Print statement> >System.out.println(> >'Three objects point to the same memory location on the heap i.e, to the same object'>);> >}> >else> {> >// Print statement> >System.out.println(> >'Three objects DO NOT point to the same memory location on the heap'>);> >}> >}> }> |
>
>Ieșire
Hashcode of x is 558638686 Hashcode of y is 558638686 Hashcode of z is 558638686 Three objects point to the same memory location on the heap i.e, to the same object>
Ieșire Explicație:
spring initializr
Într-o clasă singleton, când numim pentru prima dată metoda getInstance(). , creează un obiect al clasei cu numele single_instance și îl returnează variabilei. Deoarece single_instance este static, este schimbat de la null la un obiect. Data viitoare, dacă încercăm să apelăm metoda getInstance() deoarece single_instance nu este nulă, aceasta este returnată la variabilă, în loc să instanțiem din nou clasa Singleton. Această parte este realizată de condiția if.
În clasa principală, instanțiăm clasa singleton cu 3 obiecte x, y și z apelând la static metoda getInstance() . Dar, de fapt, după crearea obiectului x, variabilele y și z sunt îndreptate către obiectul x așa cum se arată în diagramă. Prin urmare, dacă schimbăm variabilele obiectului x, aceasta se reflectă atunci când accesăm variabilele obiectelor y și z. De asemenea, dacă schimbăm variabilele obiectului z, aceasta se reflectă atunci când accesăm variabilele obiectelor x și y.
Acum am terminat cu acoperirea tuturor aspectelor din exemplul 1 și am implementat același lucru, acum vom implementa clasa Singleton cu numele metodei ca și numele clasei.
Exemplul 2:
Java
// Java program implementing Singleton class> // with method name as that of class> // Class 1> // Helper class> class> Singleton {> >// Static variable single_instance of type Singleton> >private> static> Singleton single_instance =>null>;> >// Declaring a variable of type String> >public> String s;> >// Constructor of this class> >// Here private constructor is used to> >// restricted to this class itself> >private> Singleton()> >{> >s =>'Hello I am a string part of Singleton class'>;> >}> >// Method> >// Static method to create instance of Singleton class> >public> static> Singleton Singleton()> >{> >// To ensure only one instance is created> >if> (single_instance ==>null>) {> >single_instance =>new> Singleton();> >}> >return> single_instance;> >}> }> // Class 2> // Main class> class> GFG {> >// Main driver method> >public> static> void> main(String args[])> >{> >// Instantiating Singleton class with variable x> >Singleton x = Singleton.Singleton();> >// Instantiating Singleton class with variable y> >Singleton y = Singleton.Singleton();> >// instantiating Singleton class with variable z> >Singleton z = Singleton.Singleton();> >// Now changing variable of instance x> >// via toUpperCase() method> >x.s = (x.s).toUpperCase();> >// Print and display commands> >System.out.println(>'String from x is '> + x.s);> >System.out.println(>'String from y is '> + y.s);> >System.out.println(>'String from z is '> + z.s);> >System.out.println(>'
'>);> >// Now again changing variable of instance z> >z.s = (z.s).toLowerCase();> >System.out.println(>'String from x is '> + x.s);> >System.out.println(>'String from y is '> + y.s);> >System.out.println(>'String from z is '> + z.s);> >}> }> |
>
în care an a fost inventat computerul
>Ieșire
String from x is HELLO I AM A STRING PART OF SINGLETON CLASS String from y is HELLO I AM A STRING PART OF SINGLETON CLASS String from z is HELLO I AM A STRING PART OF SINGLETON CLASS String from x is hello i am a string part of singleton class String from y is hello i am a string part of singleton class String from z is hello i am a string part of singleton class>
Explicaţie: În clasa singleton, când apelăm pentru prima dată metoda Singleton(), aceasta creează un obiect din clasa Singleton cu numele single_instance și îl returnează variabilei. Deoarece single_instance este static, este schimbat de la null la un obiect. Data viitoare, dacă încercăm să apelăm metoda Singleton(), deoarece single_instance nu este nulă, aceasta este returnată la variabilă, în loc să instanțieze din nou clasa Singleton.
Citiți în continuare: Tutorial Java Design Patterns