जावा में क्रमांकन। इतना सरल नहीं है

सीरियलाइज़ेशन एक ऐसी प्रक्रिया है जो किसी ऑब्जेक्ट को बाइट्स के अनुक्रम में अनुवादित करती है, जिससे यह तब पूरी तरह से बहाल किया जा सकता है। इसकी आवश्यकता क्यों है? तथ्य यह है कि सामान्य कार्यक्रम निष्पादन के दौरान, किसी भी वस्तु का अधिकतम जीवनकाल ज्ञात है - कार्यक्रम के लॉन्च से लेकर उसके अंत तक। सीरियलाइज़ेशन आपको इस रूपरेखा का विस्तार करने और प्रोग्राम लॉन्च के बीच उसी तरह से "जीवन देने" की अनुमति देता है।

सब कुछ के लिए एक अतिरिक्त बोनस क्रॉस-प्लेटफॉर्म का संरक्षण है। आपके पास कोई भी ऑपरेटिंग सिस्टम नहीं है, क्रमांकन ऑब्जेक्ट को बाइट्स की एक धारा में बदल देता है, जिसे किसी भी ओएस पर पुनर्स्थापित किया जा सकता है। यदि आपको नेटवर्क पर किसी ऑब्जेक्ट को स्थानांतरित करने की आवश्यकता है, तो आप ऑब्जेक्ट को अनुक्रमित कर सकते हैं, इसे एक फ़ाइल में सहेज सकते हैं और इसे प्राप्तकर्ता को नेटवर्क पर स्थानांतरित कर सकते हैं। वह प्राप्त वस्तु को पुनः प्राप्त करने में सक्षम होगा। सीरियलाइज़ेशन आपको दूरस्थ कॉल विधियों (जावा आरएमआई) की अनुमति देता है जो संभवतः, विभिन्न ऑपरेटिंग सिस्टमों के साथ विभिन्न मशीनों पर हैं, और उनके साथ काम करते हैं जैसे कि वे कॉलिंग जावा प्रक्रिया की मशीन पर थे।

एक क्रमांकन तंत्र को लागू करना काफी सरल है। आपकी कक्षा को Serializable इंटरफ़ेस लागू करने की आवश्यकता है। यह इंटरफ़ेस एक पहचानकर्ता है जिसकी कोई विधियाँ नहीं हैं, लेकिन यह jvm को बताता है कि इस वर्ग की वस्तुओं को क्रमबद्ध किया जा सकता है। चूंकि क्रमांकन तंत्र मूल इनपुट / आउटपुट सिस्टम से जुड़ा है और ऑब्जेक्ट को बाइट स्ट्रीम में अनुवाद करता है, इसे निष्पादित करने के लिए आपको आउटपुट स्ट्रीम क्रिएट करने की आवश्यकता है आउटपुटस्ट्रीम , इसे ObjectOutputStream में पैकेज करें और राइटऑबजेक्ट () विधि को कॉल करें । किसी ऑब्जेक्ट को पुनर्स्थापित करने के लिए, आपको एक इनपुटस्ट्रीम को एक ObjectInputStream में पैक करना होगा और रीडऑब्जेक्ट () विधि को कॉल करना होगा।

क्रमांकन प्रक्रिया के दौरान, क्रमिक ऑब्जेक्ट के साथ, इसका ऑब्जेक्ट ग्राफ़ सहेजा जाता है। यानी इससे संबंधित सभी वस्तुओं, अन्य वर्गों की वस्तुओं को भी इसके साथ क्रमबद्ध किया जाएगा।

वर्ग व्यक्ति की एक वस्तु को क्रमबद्ध करने के एक उदाहरण पर विचार करें।

import java.io.*; class Home implements Serializable { private String home; public Home(String home) { this.home = home; } public String getHome() { return home; } } public class Person implements Serializable { private String name; private int countOfNiva; private String fatherName; private Home home; public Person(String name, int countOfNiva, String fatherName, Home home) { this.name = name; this.countOfNiva = countOfNiva; this.fatherName = fatherName; this.home = home; } @Override public String toString() { return "Person{" + "name='" + name + '\'' + ", countOfNiva=" + countOfNiva + ", fatherName='" + fatherName + '\'' + ", home=" + home + '}'; } public static void main(String[] args) throws IOException, ClassNotFoundException { Home home = new Home("Vishnevaia 1"); Person igor = new Person("Igor", 2, "Raphael", home); Person renat = new Person("Renat", 2, "Raphael", home); //      ObjectOutputStream ObjectOutputStream objectOutputStream = new ObjectOutputStream( new FileOutputStream("person.out")); objectOutputStream.writeObject(igor); objectOutputStream.writeObject(renat); objectOutputStream.close(); //       ObjectInputStream ObjectInputStream objectInputStream = new ObjectInputStream( new FileInputStream("person.out")); Person igorRestored = (Person) objectInputStream.readObject(); Person renatRestored = (Person) objectInputStream.readObject(); objectInputStream.close(); //    ByteArrayOutputStream ByteArrayOutputStream byteArrayOutputStream = new ByteArrayOutputStream(); ObjectOutputStream objectOutputStream2 = new ObjectOutputStream(byteArrayOutputStream); objectOutputStream2.writeObject(igor); objectOutputStream2.writeObject(renat); objectOutputStream2.flush(); //    ByteArrayInputStream ObjectInputStream objectInputStream2 = new ObjectInputStream( new ByteArrayInputStream(byteArrayOutputStream.toByteArray())); Person igorRestoredFromByte = (Person) objectInputStream2.readObject(); Person renatRestoredFromByte = (Person) objectInputStream2.readObject(); objectInputStream2.close(); System.out.println("Before Serialize: " + "\n" + igor + "\n" + renat); System.out.println("After Restored From Byte: " + "\n" + igorRestoredFromByte + "\n" + renatRestoredFromByte); System.out.println("After Restored: " + "\n" + igorRestored + "\n" + renatRestored); } } 

निष्कर्ष:

 Before Serialize: Person{name='Igor', countOfNiva=2, fatherName='Raphael', home=Home@355da254} Person{name='Renat', countOfNiva=2, fatherName='Raphael', home=Home@355da254} After Restored From Byte: Person{name='Igor', countOfNiva=2, fatherName='Raphael', home=Home@27973e9b} Person{name='Renat', countOfNiva=2, fatherName='Raphael', home=Home@27973e9b} After Restored: Person{name='Igor', countOfNiva=2, fatherName='Raphael', home=Home@312b1dae} Person{name='Renat', countOfNiva=2, fatherName='Raphael', home=Home@312b1dae} 

इस उदाहरण में, होम क्लास यह प्रदर्शित करने के लिए बनाई गई है कि किसी व्यक्ति वस्तु को क्रमबद्ध करते समय, उसकी वस्तुओं का ग्राफ उसके साथ क्रमबद्ध होता है। होम क्लास को Serializable इंटरफ़ेस भी लागू करना होगा, अन्यथा java.io.NotSerializableException उत्पन्न होगी। उदाहरण बाइटएर्रेऑटपुटस्ट्रीम क्लास का उपयोग करके क्रमांकन का भी वर्णन करता है।

कार्यक्रम निष्पादन के परिणामों से एक दिलचस्प निष्कर्ष निकाला जा सकता है: जब वस्तुओं को पुनर्स्थापित किया जाता है जो क्रमांकन से पहले उसी वस्तु का संदर्भ था, तो यह ऑब्जेक्ट केवल एक बार बहाल किया जाएगा । यह पुनर्प्राप्ति के बाद वस्तुओं में समान लिंक पर देखा जा सकता है:

 After Restored From Byte: Person{name='Igor', countOfNiva=2, fatherName='Raphael', home=Home@27973e9b} Person{name='Renat', countOfNiva=2, fatherName='Raphael', home=Home@27973e9b} After Restored: Person{name='Igor', countOfNiva=2, fatherName='Raphael', home=Home@312b1dae} Person{name='Renat', countOfNiva=2, fatherName='Raphael', home=Home@312b1dae} 

हालांकि, यह भी देखा जाता है कि जब दो आउटपुट स्ट्रीम (हमारे पास ObjectInputStream और ByteArrayOutputStream है ) के साथ रिकॉर्डिंग होती है, तो होम ऑब्जेक्ट को फिर से बनाया जाएगा, इस तथ्य के बावजूद कि यह स्ट्रीम में से एक में पहले ही बनाया गया था। हम इसे दो धाराओं में प्राप्त घरेलू वस्तुओं के विभिन्न पतों पर देखते हैं। यह पता चला है कि यदि आप एक आउटपुट स्ट्रीम के साथ अनुक्रमित करते हैं, तो ऑब्जेक्ट को पुनर्स्थापित करें, तो हमारे पास अनावश्यक डुप्लिकेट के बिना ऑब्जेक्ट के पूर्ण नेटवर्क को पुनर्स्थापित करने की गारंटी है। बेशक, कार्यक्रम के निष्पादन के दौरान वस्तुओं की स्थिति बदल सकती है, लेकिन यह प्रोग्रामर के विवेक पर है।

समस्या

उदाहरण से यह भी पता चलता है कि किसी ऑब्जेक्ट को पुनर्स्थापित करते समय, एक ClassNotFoundException हो सकती है। इसका क्या कारण है? तथ्य यह है कि हम आसानी से किसी व्यक्ति की फ़ाइल में ऑब्जेक्ट क्लास को ऑब्जेक्ट कर सकते हैं, इसे अपने दोस्त को नेटवर्क पर स्थानांतरित कर सकते हैं, जो किसी अन्य एप्लिकेशन द्वारा ऑब्जेक्ट को पुनर्स्थापित कर सकता है जिसमें व्यक्ति वर्ग बस मौजूद नहीं है।

इसकी क्रमबद्धता। कैसे बनाये?

यदि आप खुद को क्रमबद्धता का प्रबंधन करना चाहते हैं तो क्या होगा? उदाहरण के लिए, आपकी वस्तु उपयोगकर्ता के उपयोगकर्ता नाम और पासवर्ड को संग्रहीत करती है। आपको नेटवर्क पर आगे संचरण के लिए इसे क्रमबद्ध करना होगा। इस मामले में पासवर्ड पास करना बेहद अविश्वसनीय है। इस समस्या को कैसे हल करें? इसके दो तरीके हैं। सबसे पहले, क्षणिक कीवर्ड का उपयोग करें। दूसरा, सीरियलाइज़ेबल इंट्रेस्ट को साकार करने के बजाय, इसके एक्सटेंशन का उपयोग करें - एक्सट्रूज़नेबल इंटरफ़ेस। उनकी तुलना करने के लिए पहले और दूसरे तरीकों के उदाहरणों पर विचार करें।

पहला तरीका - क्षणिक का उपयोग करते हुए सीरियलाइज़ेशन

 import java.io.*; public class Logon implements Serializable { private String login; private transient String password; public Logon(String login, String password) { this.login = login; this.password = password; } @Override public String toString() { return "Logon{" + "login='" + login + '\'' + ", password='" + password + '\'' + '}'; } public static void main(String[] args) throws IOException, ClassNotFoundException { Logon igor = new Logon("IgorIvanovich", "Khoziain"); Logon renat = new Logon("Renat", "2500RUB"); System.out.println("Before: \n" + igor); System.out.println(renat); ObjectOutputStream out = new ObjectOutputStream(new FileOutputStream("Externals.out")); out.writeObject(igor); out.writeObject(renat); out.close(); ObjectInputStream in = new ObjectInputStream(new FileInputStream("Externals.out")); igor = (Logon) in.readObject(); renat = (Logon) in.readObject(); System.out.println("After: \n" + igor); System.out.println(renat); } } 

निष्कर्ष:

 Before: Logon{login='IgorIvanovich', password='Khoziain'} Logon{login='Renat', password='2500RUB'} After: Logon{login='IgorIvanovich', password='null'} Logon{login='Renat', password='null'} 

दूसरा तरीका - बाहरी इंटरफ़ेस के कार्यान्वयन के साथ सीरियललाइज़ेशन

 import java.io.*; public class Logon implements Externalizable { private String login; private String password; public Logon() { } public Logon(String login, String password) { this.login = login; this.password = password; } @Override public void writeExternal(ObjectOutput out) throws IOException { out.writeObject(login); } @Override public String toString() { return "Logon{" + "login='" + login + '\'' + ", password='" + password + '\'' + '}'; } @Override public void readExternal(ObjectInput in) throws IOException, ClassNotFoundException { login = (String) in.readObject(); } public static void main(String[] args) throws IOException, ClassNotFoundException { Logon igor = new Logon("IgorIvanovich", "Khoziain"); Logon renat = new Logon("Renat", "2500RUB"); System.out.println("Before: \n" + igor); System.out.println(renat); ObjectOutputStream out = new ObjectOutputStream(new FileOutputStream("Externals.out")); out.writeObject(igor); out.writeObject(renat); out.close(); ObjectInputStream in = new ObjectInputStream(new FileInputStream("Externals.out")); igor = (Logon) in.readObject(); renat = (Logon) in.readObject(); System.out.println("After: \n" + igor); System.out.println(renat); } } 

निष्कर्ष:

 Before: Logon{login='IgorIvanovich', password='Khoziain'} Logon{login='Renat', password='2500RUB'} After: Logon{login='IgorIvanovich', password='null'} Logon{login='Renat', password='null'} 

आपकी आंख को पकड़ने वाले दो विकल्पों में पहला अंतर कोड का आकार है। बाहरी इंटरफ़ेस लागू करते समय, हमें दो विधियों को ओवरराइड करने की आवश्यकता होती है: writeExternal () और readExternal () । एक्सटर्नल ()) विधि में, हम इंगित करते हैं कि कौन से फ़ील्ड को क्रमबद्ध किया जाएगा और कैसे, readExternal () में उन्हें कैसे पढ़ा जाए। क्षणिक शब्द का उपयोग करते समय , हम स्पष्ट रूप से इंगित करते हैं कि किस क्षेत्र या क्षेत्र को क्रमबद्ध करने की आवश्यकता नहीं है। हम यह भी ध्यान देते हैं कि दूसरी विधि में, हमने स्पष्ट रूप से एक डिफ़ॉल्ट निर्माता, इसके अलावा, एक सार्वजनिक निर्माण किया है। ऐसा क्यों किया जाता है? आइए इस निर्माता के बिना कोड को चलाने का प्रयास करें। और आउटपुट को देखो:

 Before: Logon{login='IgorIvanovich', password='Khoziain'} Logon{login='Renat', password='2500RUB'} Exception in thread "main" java.io.InvalidClassException: Logon; no valid constructor at java.io.ObjectStreamClass$ExceptionInfo.newInvalidClassException(ObjectStreamClass.java:169) at java.io.ObjectStreamClass.checkDeserialize(ObjectStreamClass.java:874) at java.io.ObjectInputStream.readOrdinaryObject(ObjectInputStream.java:2043) at java.io.ObjectInputStream.readObject0(ObjectInputStream.java:1573) at java.io.ObjectInputStream.readObject(ObjectInputStream.java:431) at Logon.main(Logon.java:45) 

हमें java.io.InvalidClassException अपवाद मिला। इसका क्या कारण है? यदि आप स्टैक ट्रेस के साथ जाते हैं, तो आप पता लगा सकते हैं कि ObjectStreamClass क्लास के कंस्ट्रक्टर में लाइनें हैं:

  if (externalizable) { cons = getExternalizableConstructor(cl); } else { cons = getSerializableConstructor(cl); 

एक्सटर्नेसेबल इंटरफ़ेस के लिए, getExternalizableConstructor () कंस्ट्रक्टर विधि को बुलाया जाएगा , जिसके अंदर प्रतिबिंब के माध्यम से हम उस क्लास के डिफ़ॉल्ट कंस्ट्रक्टर को प्राप्त करने का प्रयास करेंगे जिसके लिए हम ऑब्जेक्ट को पुनर्स्थापित कर रहे हैं। यदि हम इसे नहीं ढूंढ सकते हैं, या यह सार्वजनिक नहीं है, तो हमें एक अपवाद मिलता है। आप निम्नानुसार इस स्थिति को प्राप्त कर सकते हैं: स्पष्ट रूप से कक्षा में कोई भी निर्माता न बनाएं और बसने वालों का उपयोग करके फ़ील्ड भरें और प्राप्तकर्ताओं के साथ मूल्य प्राप्त करें। फिर, कक्षा को संकलित करते समय, एक डिफ़ॉल्ट निर्माणकर्ता बनाया जाएगा, जो getExternalizableConstructor () के लिए उपलब्ध होगा। Serializable के लिए, getSerializableConstructor () विधि को ऑब्जेक्ट क्लास का कंस्ट्रक्टर मिलता है और इसमें से वांछित वर्ग की तलाश होती है, अगर यह नहीं मिलता है, तो हमें ClassNotFoundException मिलेगी । यह पता चला है कि सीरियलाइज़ेबल और एक्सटर्नेबल के बीच महत्वपूर्ण अंतर यह है कि ऑब्जेक्ट रिकवरी बनाने के लिए पूर्व को कंस्ट्रक्टर की आवश्यकता नहीं है। यह बस बाइट्स से पूरी तरह से ठीक हो जाएगा। दूसरे के लिए, पुनर्स्थापना के दौरान, एक ऑब्जेक्ट को पहले घोषणा बिंदु पर कंस्ट्रक्टर का उपयोग करके बनाया जाएगा, और फिर क्रमांकन के दौरान प्राप्त बाइट्स से इसके क्षेत्रों के मूल्यों को इसमें लिखा जाएगा। व्यक्तिगत रूप से, मैं पहली विधि पसंद करता हूं, यह बहुत सरल है। इसके अलावा, भले ही हमें धारावाहिक व्यवहार को निर्धारित करने की आवश्यकता है, हम बाहरी उपयोग नहीं कर सकते हैं, साथ ही इसे लिखने के बिना (ओवरराइड किए बिना ) लिखने और (पढ़ने के तरीके ) को लागू करने के द्वारा सीरियल को लागू करने के लिए उपयोग कर सकते हैं। लेकिन उनके लिए "काम" करने के लिए, उनके हस्ताक्षर को सख्ती से देखा जाना चाहिए।

 import java.io.*; public class Talda implements Serializable { private String name; private String description; public Talda(String name, String description) { this.name = name; this.description = description; } private void writeObject(ObjectOutputStream stream) throws IOException { stream.defaultWriteObject(); System.out.println("Our writeObject"); } private void readObject(ObjectInputStream stream) throws IOException, ClassNotFoundException { stream.defaultReadObject(); System.out.println("Our readObject"); } @Override public String toString() { return "Talda{" + "name='" + name + '\'' + ", description='" + description + '\'' + '}'; } public static void main(String[] args) throws IOException, ClassNotFoundException { Talda partizanka = new Talda("Partizanka", "Viiiski"); System.out.println("Before: \n" + partizanka); ObjectOutputStream out = new ObjectOutputStream(new FileOutputStream("Talda.out")); out.writeObject(partizanka); out.close(); ObjectInputStream in = new ObjectInputStream(new FileInputStream("Talda.out")); partizanka = (Talda) in.readObject(); System.out.println("After: \n" + partizanka); } } 

निष्कर्ष:

 Before: Talda{name='Partizanka', description='Viiiski'} Our writeObject Our readObject After: Talda{name='Partizanka', description='Viiiski'} 

हमारे जोड़े गए तरीकों के अंदर, DefaultWriteObject () और defaultReadObject () कहा जाता है। वे डिफ़ॉल्ट क्रमांकन के लिए जिम्मेदार हैं, जैसे कि यह हमारे द्वारा जोड़े गए तरीकों के बिना काम करता है।

वास्तव में, यह केवल हिमशैल का सिरा है, यदि आप क्रमबद्धता के तंत्र में तल्लीन करना जारी रखते हैं, तो उच्च स्तर की संभावना के साथ, आप अधिक बारीकियों को पा सकते हैं, जिसे हम कहते हैं: "सीरियलाइज़ेशन ... यह सरल नहीं है।"