ஜாவாவில் serialVersionUID மற்றும் அதன் முக்கியத்துவத்தைப் புரிந்துகொள்வது

ஜாவாவில் serialVersionUID ஐ ஏன் பயன்படுத்த வேண்டும்?

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

SerialVersionUID என்பது வரிசைப்படுத்தக்கூடிய இடைமுகத்தை செயல்படுத்தும் ஒவ்வொரு வகுப்பிற்கும் ஒரு தனிப்பட்ட அடையாளங்காட்டியாகும். வரிசைப்படுத்தப்பட்ட பொருளின் அனுப்புநரும் பெறுநரும் வரிசைப்படுத்துதலுடன் இணக்கமான வகுப்புகளை ஏற்றியுள்ளார்களா என்பதைச் சரிபார்க்க இது உதவுகிறது. ஒரு சீரியல்VersionUID இல்லாதபோது எக்லிப்ஸ் அடிக்கடி எச்சரிக்கைகளை வெளியிடுகிறது, சீரான சீரியலைப் பராமரிப்பதில் அதன் முக்கியத்துவத்தை வலியுறுத்துகிறது.

கட்டளை	விளக்கம்
serialVersionUID	ஒவ்வொரு வரிசைப்படுத்தக்கூடிய வகுப்பிற்கும் ஒரு தனிப்பட்ட அடையாளங்காட்டி, வரிசைப்படுத்தப்பட்ட பொருளின் அனுப்புநர் மற்றும் பெறுநர் இணக்கமான வகுப்புகளைக் கொண்டுள்ளனர் என்பதைச் சரிபார்க்கப் பயன்படுகிறது.
ObjectOutputStream	ஒரு அவுட்புட் ஸ்ட்ரீமில் பொருட்களை எழுதுவதற்குப் பயன்படுத்தப்படும் ஒரு வகுப்பு, ஒரு கோப்பில் பொருள்களின் வரிசைப்படுத்தலை செயல்படுத்துகிறது.
ObjectInputStream	இன்புட்ஸ்ட்ரீமில் இருந்து பொருட்களைப் படிக்கப் பயன்படுத்தப்படும் ஒரு வகுப்பு, ஒரு கோப்பிலிருந்து பொருள்களை நீக்குவதைச் செயல்படுத்துகிறது.
writeObject	ObjectOutputStream இன் முறையானது ஒரு பொருளை வரிசைப்படுத்தவும், அதை OutputStream இல் எழுதவும் பயன்படுகிறது.
readObject	ஆப்ஜெக்ட்இன்புட்ஸ்ட்ரீமின் ஒரு முறை, ஒரு பொருளை இன்புட்ஸ்ட்ரீமில் இருந்து சீரழிக்கப் பயன்படுகிறது.
IOException	I/O செயல்பாடு தோல்வியடையும் போது அல்லது குறுக்கிடும்போது ஏற்படும் விதிவிலக்கு.
ClassNotFoundException	ஒரு பயன்பாடு அதன் சரம் பெயர் மூலம் ஒரு வகுப்பை ஏற்ற முயற்சிக்கும் போது ஏற்படும் விதிவிலக்கு, ஆனால் வகுப்பிற்கான வரையறை எதுவும் இல்லை.

எப்படி serialVersionUID மற்றும் Serialization வேலை செய்கிறது

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

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

import java.io.Serializable;

public class Foo implements Serializable {
    private static final long serialVersionUID = 1L;
    private String name;
    private int age;

    public Foo(String name, int age) {
        this.name = name;
        this.age = age;
    }

    @Override
    public String toString() {
        return "Foo{name='" + name + "', age=" + age + "}";
    }
}

import java.io.*;

public class SerializationExample {
    public static void main(String[] args) {
        Foo foo = new Foo("John Doe", 30);
        String filename = "foo.ser";

        try (ObjectOutputStream out = new ObjectOutputStream(new FileOutputStream(filename))) {
            out.writeObject(foo);
        } catch (IOException e) {
            e.printStackTrace();
        }

        try (ObjectInputStream in = new ObjectInputStream(new FileInputStream(filename))) {
            Foo deserializedFoo = (Foo) in.readObject();
            System.out.println("Deserialized Foo: " + deserializedFoo);
        } catch (IOException | ClassNotFoundException e) {
            e.printStackTrace();
        }
    }
}

import java.io.*;

public class Foo implements Serializable {
    private static final long serialVersionUID = 1L;
    private String name;
    private int age;
    private String address;  // New field added

    public Foo(String name, int age, String address) {
        this.name = name;
        this.age = age;
        this.address = address;
    }

    @Override
    public String toString() {
        return "Foo{name='" + name + "', age=" + age + ", address='" + address + "'}";
    }
}

import java.io.*;

public class DeserializationIssueExample {
    public static void main(String[] args) {
        String filename = "foo.ser";

        try (ObjectInputStream in = new ObjectInputStream(new FileInputStream(filename))) {
            Foo deserializedFoo = (Foo) in.readObject();
            System.out.println("Deserialized Foo: " + deserializedFoo);
        } catch (IOException | ClassNotFoundException e) {
            e.printStackTrace();
        }
    }
}

கிளாஸ் எவல்யூஷனில் சீரியல் வெர்ஷன் யுஐடியின் பங்கு

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

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

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