சிங்கிள்டன்

சிங்கிள்டன் சிங்கிள் மால்ட் ஸ்காட்ச் விஸ்கி நல்லது என்று கேள்விப்பட்டிருக்கிறீர்களா? ஆல்கஹால் உங்கள் ஆரோக்கியத்திற்கு மோசமானது, எனவே ஜாவாவில் உள்ள சிங்கிள்டன் வடிவமைப்பு முறையைப் பற்றி இன்று உங்களுக்குச் சொல்வோம்.

பொருட்களின் உருவாக்கத்தை நாங்கள் முன்பு மதிப்பாய்வு செய்தோம், எனவே ஜாவாவில் ஒரு பொருளை உருவாக்க, நீங்கள் இதைப் போன்ற ஒன்றை எழுத வேண்டும் என்பதை நாங்கள் அறிவோம்:

Robot robot = new Robot(); 
    

ஆனால் வகுப்பின் ஒரே ஒரு நிகழ்வு மட்டுமே உருவாக்கப்படுவதை உறுதி செய்ய விரும்பினால் என்ன செய்வது?

புதிய 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... 
 
	} 
}
    

பிரிண்டர் சிங்கிள்டனை உருவாக்க, நாங்கள் ஒரு தனிப்பட்ட கட்டமைப்பாளரைப் பயன்படுத்தினோம் - ஒரே ஒரு நிகழ்வு மட்டுமே இருக்கும். திபிரிண்டர்மாறி நிலையான மாற்றியைக் கொண்டுள்ளது , ஏனெனில் இது எந்த பொருளுக்கும் சொந்தமானது அல்ல, ஆனால் பிரிண்டர் வகுப்பிற்கு சொந்தமானது.

இப்போது எங்கள் வகுப்பின் ஒரு நிகழ்விற்கான அணுகலை வழங்க நிலையான முறையைப் பயன்படுத்தி ஒரு சிங்கிள்டனை உருவாக்குவதைக் கருத்தில் கொள்வோம் (மேலும் புலம் இப்போது தனிப்பட்டது என்பதை நினைவில் கொள்ளவும் ):

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

இங்கே getInstance() முறையை எத்தனை முறை அழைத்தாலும் , நமக்கு எப்போதும் ஒரே மாதிரிதான் கிடைக்கும்பிரிண்டர்பொருள்.

ஒரு தனிப்பட்ட கட்டமைப்பாளரைப் பயன்படுத்தி ஒரு சிங்கிள்டனை உருவாக்குவது எளிமையானது மற்றும் மிகவும் சுருக்கமானது. மேலும் என்னவென்றால், பொதுப் புலம் இறுதியானது என அறிவிக்கப்பட்டதால் , ஏபிஐ வெளிப்படையானது , இது எப்போதும் ஒரே பொருளின் குறிப்பைக் கொண்டிருக்கும் என்று உத்தரவாதம் அளிக்கிறது.

நிலையான முறை விருப்பம், அதன் API ஐ மாற்றாமல், சிங்கிள்டனை ஒற்றை அல்லாத வகுப்பிற்கு மாற்றுவதற்கான நெகிழ்வுத்தன்மையை வழங்குகிறது. getInstance () முறையானது நமது பொருளின் ஒரு நிகழ்வை நமக்குத் தருகிறது, ஆனால் நாம் அதை மாற்றலாம், அதனால் அதை அழைக்கும் ஒவ்வொரு பயனருக்கும் தனித்தனி நிகழ்வை வழங்கும்.

நிலையான விருப்பம் ஒரு பொதுவான சிங்கிள்டன் தொழிற்சாலையை எழுத அனுமதிக்கிறது.

நிலையான விருப்பத்தின் இறுதி நன்மை என்னவென்றால், நீங்கள் அதை ஒரு முறை குறிப்புடன் பயன்படுத்தலாம்.

மேலே உள்ள நன்மைகள் எதுவும் உங்களுக்குத் தேவையில்லை என்றால், பொதுத் துறையை உள்ளடக்கிய விருப்பத்தைப் பயன்படுத்த பரிந்துரைக்கிறோம் .

நமக்கு வரிசையாக்கம் தேவைப்பட்டால், சீரியலைசபிள் இடைமுகத்தை செயல்படுத்தினால் மட்டும் போதாது . நாம் readResolve முறையையும் சேர்க்க வேண்டும் , இல்லையெனில் டீரியலைசேஷன் போது புதிய சிங்கிள்டன் நிகழ்வைப் பெறுவோம்.

இப்போது நமது தனிப்பாடலை மீண்டும் எழுதுவோம்:

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); 
    

மற்றும் நாம் பெறுகிறோம்:

readResolve () முறையானது, நாம் டீரியலைஸ் செய்த அதே பொருளைப் பெற அனுமதிக்கிறது, இதன் மூலம் முரட்டு சிங்கிள்டன்களை உருவாக்குவதைத் தடுக்கிறது.

சுருக்கம்

இன்று நாம் சிங்கிள்டன்களைப் பற்றி கற்றுக்கொண்டோம்: அவற்றை எவ்வாறு உருவாக்குவது மற்றும் எப்போது பயன்படுத்த வேண்டும், அவை எதற்காக, அவற்றை உருவாக்க ஜாவா என்ன விருப்பங்களை வழங்குகிறது. இரண்டு விருப்பங்களின் குறிப்பிட்ட அம்சங்கள் கீழே கொடுக்கப்பட்டுள்ளன: