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

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

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

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

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

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

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

ஜாவா சீரியலைசேஷனில் 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 + "}";
    }
}

விடுபட்ட serialVersionUID மற்றும் அதன் விளைவுகளின் எடுத்துக்காட்டு

ஜாவா சீரியலைசேஷன் பிழை

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 + "'}";
    }
}

சீரியல்VersionUID இல்லாமல் சீரியலைசேஷன் சிக்கல்

ஜாவா இணக்கமற்ற சீரியலைசேஷன்

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

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

serialVersionUID பற்றி அடிக்கடி கேட்கப்படும் கேள்விகள்

1. என்ன serialVersionUID?
2. இது ஒவ்வொன்றிற்கும் ஒரு தனிப்பட்ட அடையாளங்காட்டியாகும் Serializable வரிசைப்படுத்தப்பட்ட பொருளின் அனுப்புநரும் பெறுநரும் இணக்கமான வகுப்புகளைக் கொண்டிருப்பதை உறுதிசெய்யப் பயன்படும் வகுப்பு.
3. ஏன் serialVersionUID முக்கியமான?
4. வரிசைப்படுத்தப்பட்ட பொருளை சரியாக சீரமைக்க முடியுமா என்பதை உறுதி செய்வதன் மூலம் ஒரு வகுப்பின் வெவ்வேறு பதிப்புகளுக்கு இடையே பொருந்தக்கூடிய தன்மையை பராமரிக்க இது உதவுகிறது.
5. என்றால் என்ன நடக்கும் serialVersionUID அறிவிக்கப்படவில்லையா?
6. இயக்க நேரத்தில் ஜாவா ஒன்றை உருவாக்குகிறது, இது வழிவகுக்கும் InvalidClassException வர்க்க அமைப்பு மாறினால்.
7. முடியும் serialVersionUID தடுக்க InvalidClassException?
8. ஆம், ஒரு நிலையானது serialVersionUID டீரியலைசேஷன் போது வர்க்க இணக்கத்தன்மையை உறுதி செய்வதன் மூலம் இந்த விதிவிலக்கை தடுக்கிறது.
9. நான் எப்படி அறிவிப்பது serialVersionUID ஒரு வகுப்பில்?
10. நீங்கள் அதை ஒரு என அறிவிக்கிறீர்கள் static final long வகுப்பிற்குள் புலம்.
11. இருக்கிறது serialVersionUID கட்டாயமாகும்?
12. கட்டாயம் இல்லை என்றாலும், நம்பகமான சீரியலைசேஷன் மற்றும் டீரியலைசேஷன் ஆகியவற்றை உறுதிப்படுத்துவது மிகவும் பரிந்துரைக்கப்படுகிறது.
13. நான் மாற்றலாமா serialVersionUID?
14. ஆம், ஆனால் அதை மாற்றுவது முன்பு வரிசைப்படுத்தப்பட்ட பொருட்களுடன் பொருந்தக்கூடிய தன்மையை உடைத்து, வழிவகுக்கும் InvalidClassException.
15. இயல்புநிலை மதிப்பு என்ன serialVersionUID அறிவிக்கவில்லை என்றால்?
16. ஜாவா அதை வகுப்பின் புலங்கள் மற்றும் முறைகளின் அடிப்படையில் கணக்கிடுகிறது, ஆனால் இந்த மதிப்பு வெவ்வேறு பதிப்புகள் அல்லது சூழல்களில் சீராக இல்லை.

வரிசைப்படுத்தல் இணக்கத்தன்மையை உறுதி செய்தல்

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