సింగిల్టన్

బహుశా మీరు సింగిల్టన్ సింగిల్ మాల్ట్ స్కాచ్ విస్కీ మంచిదని విన్నారా? సరే, ఆల్కహాల్ మీ ఆరోగ్యానికి హానికరం, కాబట్టి ఈరోజు మేము జావాలో సింగిల్టన్ డిజైన్ నమూనా గురించి మీకు చెప్తాము.

మేము మునుపు ఆబ్జెక్ట్‌ల సృష్టిని సమీక్షించాము, కాబట్టి జావాలో ఆబ్జెక్ట్‌ని సృష్టించడానికి, మీరు ఇలాంటివి వ్రాయవలసి ఉంటుందని మాకు తెలుసు:

Robot robot = new Robot(); 
    

అయితే తరగతికి సంబంధించిన ఒక ఉదాహరణ మాత్రమే సృష్టించబడిందని మనం నిర్ధారించుకోవాలనుకుంటే?

కొత్త రోబోట్() ప్రకటన అనేక వస్తువులను సృష్టించగలదు మరియు అలా చేయకుండా మనల్ని ఏదీ ఆపదు. ఇక్కడే సింగిల్టన్ నమూనా రెస్క్యూకి వస్తుంది.

మీరు ప్రింటర్‌కు కనెక్ట్ చేసే అప్లికేషన్‌ను వ్రాయవలసి ఉందని అనుకుందాం — కేవలం ఒక ప్రింటర్ — మరియు దానిని ప్రింట్ చేయమని చెప్పండి:

public class Printer { 
 
	public Printer() { 
	} 
     
	public void print() { 
    	… 
	} 
}
    

ఇది సాధారణ తరగతిలా కనిపిస్తోంది... కానీ! "కానీ" ఒకటి ఉంది: నేను నా ప్రింటర్ ఆబ్జెక్ట్‌కి సంబంధించిన అనేక పర్యాయాలను సృష్టించగలను మరియు వాటిపై వివిధ ప్రదేశాలలో కాల్ మెథడ్స్‌ను రూపొందించగలను. ఇది నా ప్రింటర్‌కు హాని కలిగించవచ్చు లేదా విచ్ఛిన్నం కావచ్చు. కాబట్టి మన ప్రింటర్‌లో ఒకే ఒక్క ఉదాహరణ మాత్రమే ఉందని మేము నిర్ధారించుకోవాలి మరియు అదే మన కోసం సింగిల్‌టన్ చేస్తుంది!

సింగిల్టన్ సృష్టించడానికి మార్గాలు

సింగిల్‌టన్‌ని సృష్టించడానికి రెండు మార్గాలు ఉన్నాయి:

• ఒక ప్రైవేట్ కన్స్ట్రక్టర్ ఉపయోగించండి;
• ఒకే ఉదాహరణకి ప్రాప్యతను అందించడానికి పబ్లిక్ స్టాటిక్ పద్ధతిని ఎగుమతి చేయండి.

ముందుగా ప్రైవేట్ కన్స్ట్రక్టర్‌ని ఉపయోగించడాన్ని పరిశీలిద్దాం. దీన్ని చేయడానికి, మన తరగతిలో ఒక ఫీల్డ్‌ను ఫైనల్‌గా ప్రకటించి , దాన్ని ప్రారంభించాలి. మేము దీనిని ఫైనల్‌గా గుర్తించాము కాబట్టి, ఇది మార్పులేనిదని మాకు తెలుసు , అంటే ఇకపై దానిని మార్చలేము.

తరగతి వెలుపల వస్తువులను సృష్టించడాన్ని నిరోధించడానికి మీరు కన్స్ట్రక్టర్‌ను ప్రైవేట్‌గా కూడా ప్రకటించాలి . ప్రోగ్రామ్‌లో మా ప్రింటర్ యొక్క ఇతర సందర్భాలు ఉండవని ఇది మాకు హామీ ఇస్తుంది. ప్రారంభ సమయంలో కన్స్ట్రక్టర్ ఒక్కసారి మాత్రమే పిలువబడుతుంది మరియు మా ప్రింటర్‌ను సృష్టిస్తుంది :

public class Printer { 
     
	public static final Printer PRINTER = new Printer(); 
     
	private Printer() { 
	} 
 
	public void print() { 
        // Printing... 
 
	} 
}
    

మేము PRINTER సింగిల్‌టన్‌ని సృష్టించడానికి ప్రైవేట్ కన్‌స్ట్రక్టర్‌ని ఉపయోగించాము - ఎప్పుడూ ఒక ఉదాహరణ మాత్రమే ఉంటుంది. దిప్రింటర్వేరియబుల్ స్టాటిక్ మాడిఫైయర్‌ను కలిగి ఉంది , ఎందుకంటే ఇది ఏ వస్తువుకు కాదు, ప్రింటర్ క్లాస్‌కు చెందినది.

ఇప్పుడు మన తరగతికి చెందిన ఒకే ఒక్క ఉదాహరణకి ప్రాప్యతను అందించడానికి స్టాటిక్ పద్ధతిని ఉపయోగించి సింగిల్‌టన్‌ని సృష్టించడాన్ని పరిశీలిద్దాం (మరియు ఫీల్డ్ ఇప్పుడు ప్రైవేట్‌గా ఉందని గమనించండి ):

public class Printer { 
 
	private static final Printer PRINTER = new Printer(); 
 
	private Printer() { 
	} 
 
	public static Printer getInstance() { 
    	return PRINTER; 
	} 
     
	public void print() { 
        // Printing... 
	} 
} 
    

మనం ఇక్కడ getInstance() పద్ధతిని ఎన్నిసార్లు పిలిచినా , మనకు ఎల్లప్పుడూ అదే వస్తుందిప్రింటర్వస్తువు.

ప్రైవేట్ కన్‌స్ట్రక్టర్‌ని ఉపయోగించి సింగిల్‌టన్‌ని సృష్టించడం సరళమైనది మరియు మరింత సంక్షిప్తమైనది. ఇంకా ఏమిటంటే, API స్పష్టంగా ఉంది, ఎందుకంటే పబ్లిక్ ఫీల్డ్ ఫైనల్‌గా ప్రకటించబడింది , ఇది ఎల్లప్పుడూ ఒకే వస్తువుకు సూచనను కలిగి ఉంటుందని హామీ ఇస్తుంది.

స్టాటిక్ మెథడ్ ఎంపిక దాని APIని మార్చకుండా సింగిల్‌టన్‌ని నాన్-సింగిల్టన్ క్లాస్‌కి మార్చడానికి మాకు సౌలభ్యాన్ని ఇస్తుంది. getInstance () పద్ధతి మన ఆబ్జెక్ట్‌కి ఒకే ఉదాహరణను ఇస్తుంది, కానీ మనం దానిని మార్చవచ్చు, తద్వారా అది కాల్ చేసిన ప్రతి వినియోగదారుకు ఒక ప్రత్యేక ఉదాహరణను అందిస్తుంది.

స్టాటిక్ ఐచ్ఛికం సాధారణ సింగిల్టన్ ఫ్యాక్టరీని వ్రాయడానికి కూడా అనుమతిస్తుంది.

స్టాటిక్ ఐచ్ఛికం యొక్క చివరి ప్రయోజనం ఏమిటంటే మీరు దానిని పద్ధతి సూచనతో ఉపయోగించవచ్చు.

మీకు పైన పేర్కొన్న ప్రయోజనాలు ఏవీ అవసరం లేకపోతే, పబ్లిక్ ఫీల్డ్‌ను కలిగి ఉన్న ఎంపికను ఉపయోగించమని మేము సిఫార్సు చేస్తున్నాము.

మనకు సీరియలైజేషన్ అవసరమైతే, సీరియలైజ్ చేయదగిన ఇంటర్‌ఫేస్‌ను అమలు చేయడం మాత్రమే సరిపోదు . మేము రీడ్‌రిసోల్వ్ పద్ధతిని కూడా జోడించాలి , లేకుంటే డీరియలైజేషన్ సమయంలో మనకు కొత్త సింగిల్‌టన్ ఉదాహరణ లభిస్తుంది.

ఇప్పుడు మన సింగిల్‌టన్‌ని తిరిగి వ్రాస్దాం:

public class Printer implements Serializable { 
 
	private static final Printer PRINTER = new Printer(); 
 
	private Printer() { 
	} 
 
	public static Printer getInstance() { 
    	return PRINTER; 
	} 
} 
    

ఇప్పుడు మనం దానిని సీరియలైజ్ చేసి డీరియలైజ్ చేస్తాము.

var printer = Printer.getInstance(); 
var fileOutputStream = new FileOutputStream("printer.txt"); 
var objectOutputStream = new ObjectOutputStream(fileOutputStream); 
objectOutputStream.writeObject(printer); 
objectOutputStream.close(); 
 
var fileInputStream = new FileInputStream("printer.txt"); 
var objectInputStream = new ObjectInputStream(fileInputStream); 
var deserializedPrinter =(Printer) objectInputStream.readObject(); 
objectInputStream.close(); 
 
System.out.println("Singleton 1 is: " + printer); 
System.out.println("Singleton 2 is: " + deserializedPrinter);
    

మరియు మేము ఈ ఫలితాన్ని పొందుతాము:

డీరియలైజేషన్ మా సింగిల్‌టన్‌కు భిన్నమైన ఉదాహరణను ఇచ్చిందని ఇక్కడ మనం చూస్తాము. దీన్ని పరిష్కరించడానికి, మన తరగతికి readResolve పద్ధతిని జోడిద్దాం :

public class Printer implements Serializable { 
 
	private static final Printer PRINTER = new Printer(); 
 
	private Printer() { 
	} 
 
	public static Printer getInstance() { 
    	return PRINTER; 
	} 
 
	public Object readResolve() { 
    	return PRINTER; 
	} 
}
    

ఇప్పుడు మేము మా సింగిల్‌టన్‌ని మళ్లీ సీరియలైజ్ చేస్తాము మరియు డీరియలైజ్ చేస్తాము:

var printer = Printer.getInstance(); 
var fileOutputStream = new FileOutputStream("printer.txt"); 
var objectOutputStream = new ObjectOutputStream(fileOutputStream); 
objectOutputStream.writeObject(printer); 
objectOutputStream.close(); 
 
var fileInputStream = new FileInputStream("printer.txt"); 
var objectInputStream = new ObjectInputStream(fileInputStream); 
var deserializedPrinter=(Printer) objectInputStream.readObject(); 
objectInputStream.close(); 
 
System.out.println("Singleton 1 is: " + printer); 
System.out.println("Singleton 2 is: " + deserializedPrinter); 
    

మరియు మేము పొందుతాము:

రీడ్‌రిసోల్వ్ () పద్ధతి మనం డీరియలైజ్ చేసిన అదే వస్తువును పొందేలా చేస్తుంది, తద్వారా రోగ్ సింగిల్‌టన్‌ల సృష్టిని నిరోధిస్తుంది.

సారాంశం

ఈ రోజు మనం సింగిల్‌టన్‌ల గురించి తెలుసుకున్నాము: వాటిని ఎలా సృష్టించాలి మరియు వాటిని ఎప్పుడు ఉపయోగించాలి, అవి దేని కోసం మరియు వాటిని సృష్టించడానికి జావా ఏ ఎంపికలను అందిస్తుంది. రెండు ఎంపికల యొక్క నిర్దిష్ట లక్షణాలు క్రింద ఇవ్వబడ్డాయి: