"वस्तु क्रमांकन" से क्या अभिप्राय है? क्या आप इसे कुछ उदाहरणों के साथ समझा सकते हैं?
जवाबों:
सीरियलाइज़ेशन किसी ऑब्जेक्ट का बाइट्स की श्रृंखला में रूपांतरण है, जिससे ऑब्जेक्ट को लगातार स्टोरेज में सहेजा जा सकता है या संचार लिंक पर प्रवाहित किया जा सकता है। बाइट स्ट्रीम को तब deserialized किया जा सकता है - मूल वस्तु की प्रतिकृति में परिवर्तित।
आप क्रमांकन को एक वस्तु उदाहरण को बाइट्स के अनुक्रम में बदलने की प्रक्रिया के रूप में सोच सकते हैं (जो कि द्विआधारी हो सकता है या कार्यान्वयन के आधार पर नहीं हो सकता है)।
यह तब बहुत उपयोगी होता है जब आप एक वस्तु डेटा को पूरे नेटवर्क में प्रसारित करना चाहते हैं, उदाहरण के लिए एक जेवीएम से दूसरे में।
जावा में, क्रमांकन तंत्र को प्लेटफ़ॉर्म में बनाया गया है, लेकिन आपको ऑब्जेक्ट को सीरियल करने योग्य बनाने के लिए सीरियल इंटरफ़ेस लागू करने की आवश्यकता है ।
आप विशेषता के रूप में क्षणिक के रूप में क्रमबद्ध होने से अपनी वस्तु में कुछ डेटा को रोक सकते हैं ।
अंत में आप डिफ़ॉल्ट तंत्र को ओवरराइड कर सकते हैं, और अपना खुद का प्रदान कर सकते हैं; यह कुछ विशेष मामलों में उपयुक्त हो सकता है। ऐसा करने के लिए, आप जावा में छिपी सुविधाओं में से एक का उपयोग करते हैं ।
यह ध्यान रखना महत्वपूर्ण है कि जो चीज क्रमबद्ध हो जाती है वह वस्तु, या सामग्री का "मूल्य" है, न कि वर्ग परिभाषा। इस प्रकार तरीके क्रमबद्ध नहीं हैं।
इसकी पढ़ने की सुविधा के लिए टिप्पणियों के साथ यहां एक बहुत ही बुनियादी नमूना है:
import java.io.*;
import java.util.*;
// This class implements "Serializable" to let the system know
// it's ok to do it. You as programmer are aware of that.
public class SerializationSample implements Serializable {
// These attributes conform the "value" of the object.
// These two will be serialized;
private String aString = "The value of that string";
private int someInteger = 0;
// But this won't since it is marked as transient.
private transient List<File> unInterestingLongLongList;
// Main method to test.
public static void main( String [] args ) throws IOException {
// Create a sample object, that contains the default values.
SerializationSample instance = new SerializationSample();
// The "ObjectOutputStream" class has the default
// definition to serialize an object.
ObjectOutputStream oos = new ObjectOutputStream(
// By using "FileOutputStream" we will
// Write it to a File in the file system
// It could have been a Socket to another
// machine, a database, an in memory array, etc.
new FileOutputStream(new File("o.ser")));
// do the magic
oos.writeObject( instance );
// close the writing.
oos.close();
}
}जब हम इस प्रोग्राम को चलाते हैं, तो फ़ाइल "o.ser" बनाई जाती है और हम देख सकते हैं कि पीछे क्या हुआ था।
यदि हम के मान को बदलते हैं: someInteger to, उदाहरण के लिए Integer.MAX_VALUE , हम आउटपुट की तुलना यह देखने के लिए कर सकते हैं कि अंतर क्या है।
यहां एक स्क्रीनशॉट दिखाया गया है जो ठीक यही अंतर दिखा रहा है:
क्या आप मतभेदों को देख सकते हैं? ;)
जावा सीरियलाइज़ेशन में एक अतिरिक्त प्रासंगिक क्षेत्र है: सीरियलवर्सन यूआईडी लेकिन मुझे लगता है कि इसे कवर करने के लिए यह पहले से ही बहुत लंबा है।
SerializationSample
SerializationSample instance = new SerializationSample();तब आउटपुट बनाया जाता है और उस आउटपुट पर लिखी गई वस्तु।
6 साल पुराने सवाल का जवाब देने की हिम्मत, जावा के लिए नए लोगों के लिए सिर्फ एक बहुत ही उच्च-स्तरीय समझ को जोड़ना
Serialization क्या है?
किसी वस्तु को बाइट में बदलना
Deserialization क्या है?
बाइट्स को वापस किसी ऑब्जेक्ट में बदलना (Deserialization)।
क्रमांकन का उपयोग कब किया जाता है?
जब हम वस्तु को जारी रखना चाहते हैं। जब हम चाहते हैं कि वस्तु जेवीएम के जीवनकाल से परे मौजूद है।
वास्तविक विश्व उदाहरण:
एटीएम: जब खाताधारक एटीएम के माध्यम से सर्वर से पैसे निकालने की कोशिश करता है, तो खाता धारक की जानकारी जैसे निकासी विवरणों को क्रमबद्ध किया जाएगा और सर्वर को भेजा जाएगा जहां विवरणों को डीरजाइलाइज किया गया है और संचालन करने के लिए उपयोग किया जाता है।
जावा में क्रमबद्धता कैसे निभाई जाती है।
java.io.Serializableइंटरफ़ेस लागू करें (मार्कर इंटरफ़ेस लागू करने के लिए कोई विधि नहीं)।
ऑब्जेक्ट को जारी रखें: उपयोग करें java.io.ObjectOutputStream क्लास का , एक फिल्टर स्ट्रीम जो निचले स्तर की बाइट स्ट्रीम के चारों ओर एक आवरण है (सिस्टम फाइल करने के लिए ऑब्जेक्ट लिखने या नेटवर्क वायर पर एक चपटा ऑब्जेक्ट ट्रांसफर करने और दूसरी तरफ पुनर्निर्माण करने के लिए)।
writeObject(<<instance>>) - किसी वस्तु को लिखने के लिए readObject() - क्रमबद्ध ऑब्जेक्ट पढ़ने के लिएयाद है:
जब आप किसी ऑब्जेक्ट को क्रमबद्ध करते हैं, तो केवल ऑब्जेक्ट की स्थिति को बचाया जाएगा, न कि ऑब्जेक्ट की क्लास फ़ाइल या विधियों को।
जब आप 2-बाइट ऑब्जेक्ट को क्रमांकित करते हैं, तो आप 51 बाइट्स क्रमबद्ध फ़ाइल देखते हैं।
कदम कैसे वस्तु क्रमबद्ध और de- क्रमबद्ध है।
के लिए उत्तर: यह 51 बाइट्स फ़ाइल में कैसे परिवर्तित हुआ?
java.lang.Object ।यदि आप जावा सीरियलाइज़ेशन के बारे में अधिक जानकारी में रुचि रखते हैं, तो कृपया इस लिंक की जाँच करें ।
संपादित करें : एक और अच्छी कड़ी पढ़ने के लिए ।
यह कुछ लगातार सवालों के जवाब देगा:
कक्षा में किसी भी क्षेत्र को क्रमबद्ध कैसे न करें।
उत्तर: क्षणिक कीवर्ड का उपयोग करें
जब चाइल्ड क्लास को सीरियल किया जाता है तो पेरेंट क्लास को सीरियल किया जाता है?
उत्तर: नहीं, यदि कोई माता-पिता सीरियल इंटरफ़ेस उपलब्ध नहीं करा रहा है, तो माता-पिता फ़ील्ड को क्रमबद्ध नहीं बनाते हैं।
जब एक माता-पिता को सीरियल किया जाता है तो क्या बच्चे की क्लास को सीरियल किया जाता है?
उत्तर: हां, डिफ़ॉल्ट रूप से बाल वर्ग भी क्रमबद्ध हो जाता है।
बाल वर्ग को धारावाहिक बनाने से कैसे बचें?
उत्तर: ए। ओवरराइड राइटऑबजेक्ट और रीडऑब्जेक्ट विधि और फेंक NotSerializableException।
ख। इसके अलावा, आप बच्चे के वर्ग में सभी क्षेत्रों को चिह्नित कर सकते हैं।
सीरियलाइज़ेशन मेमोरी में एक "लाइव" ऑब्जेक्ट ले रहा है और इसे एक प्रारूप में परिवर्तित कर रहा है जिसे कहीं भी संग्रहीत किया जा सकता है (उदाहरण के लिए, मेमोरी में, डिस्क पर) और बाद में लाइव ऑब्जेक्ट में "डिसेरिएलाइज्ड" वापस।
मुझे @OscarRyz प्रस्तुत करने का तरीका पसंद आया। हालाँकि यहाँ मैं क्रमबद्धता की कहानी जारी रख रहा हूँ जो मूल रूप से @amitgupta द्वारा लिखी गई थी।
भले ही रोबोट वर्ग संरचना के बारे में जानते हुए और क्रमबद्ध डेटा होने के कारण पृथ्वी के वैज्ञानिक डेटा को निष्क्रिय करने में सक्षम नहीं थे, जो रोबोट को काम कर सकते हैं।
Exception in thread "main" java.io.InvalidClassException:
SerializeMe; local class incompatible: stream classdesc
:मंगल के वैज्ञानिक पूर्ण भुगतान की प्रतीक्षा कर रहे थे। भुगतान हो जाने के बाद मंगल के वैज्ञानिकों ने पृथ्वी के वैज्ञानिकों के साथ serialversionUID को साझा किया । पृथ्वी के वैज्ञानिक ने इसे रोबोट क्लास में सेट किया और सब कुछ ठीक हो गया।
सीरियलाइजेशन का अर्थ है जावा में वस्तुओं का बने रहना। यदि आप वस्तु की स्थिति को बचाना चाहते हैं और बाद में राज्य का पुनर्निर्माण करना चाहते हैं (दूसरे JVM में हो सकता है) क्रमांकन का उपयोग किया जा सकता है।
ध्यान दें कि किसी वस्तु के गुण केवल सहेजे जाने वाले हैं। यदि आप ऑब्जेक्ट को फिर से जीवित करना चाहते हैं, तो आपके पास कक्षा फ़ाइल होनी चाहिए, क्योंकि सदस्य चर केवल संग्रहीत होंगे और सदस्य फ़ंक्शन नहीं।
उदाहरण के लिए:
ObjectInputStream oos = new ObjectInputStream(
new FileInputStream( new File("o.ser")) ) ;
SerializationSample SS = (SearializationSample) oos.readObject();Searializable एक मार्कर इंटरफ़ेस है जो बताता है कि आपकी कक्षा क्रमबद्ध है। मार्कर इंटरफ़ेस का मतलब है कि यह सिर्फ एक खाली इंटरफ़ेस है और उस इंटरफ़ेस का उपयोग करने से जेवीएम को सूचित किया जाएगा कि इस वर्ग को क्रमबद्ध बनाया जा सकता है।
मेरे अपने ब्लॉग से मेरे दो सेंट:
यहाँ सीरियल का विस्तृत विवरण दिया गया है : (मेरा अपना ब्लॉग)
क्रमबद्धता:
सीरियलाइजेशन एक वस्तु की स्थिति को बनाए रखने की प्रक्रिया है। इसे बाइट्स के अनुक्रम के रूप में दर्शाया और संग्रहीत किया जाता है। इसे एक फाइल में स्टोर किया जा सकता है। फ़ाइल से ऑब्जेक्ट की स्थिति को पढ़ने और इसे पुनर्स्थापित करने की प्रक्रिया को डीराइजेशन कहा जाता है।
Serialization की क्या आवश्यकता है?
आधुनिक वास्तुकला में, हमेशा वस्तु स्थिति को संग्रहीत करने और फिर उसे पुनः प्राप्त करने की आवश्यकता होती है। हाइबरनेट में उदाहरण के लिए, एक वस्तु को स्टोर करने के लिए हमें वर्ग को सीरियल बनाने योग्य बनाना चाहिए। यह क्या करता है, यह है कि एक बार ऑब्जेक्ट राज्य बाइट्स के रूप में सहेजे जाने के बाद इसे किसी अन्य सिस्टम में स्थानांतरित किया जा सकता है जो तब राज्य से पढ़ सकता है और कक्षा को पुनः प्राप्त कर सकता है। ऑब्जेक्ट स्थिति एक डेटाबेस या एक अलग jvm या एक अलग घटक से आ सकती है। Serialization की मदद से हम ऑब्जेक्ट स्टेट को पुनः प्राप्त कर सकते हैं।
कोड उदाहरण और स्पष्टीकरण:
पहले आइए एक नजर डालते हैं आइटम क्लास पर:
public class Item implements Serializable{
/**
* This is the Serializable class
*/
private static final long serialVersionUID = 475918891428093041L;
private Long itemId;
private String itemName;
private transient Double itemCostPrice;
public Item(Long itemId, String itemName, Double itemCostPrice) {
super();
this.itemId = itemId;
this.itemName = itemName;
this.itemCostPrice = itemCostPrice;
}
public Long getItemId() {
return itemId;
}
@Override
public String toString() {
return "Item [itemId=" + itemId + ", itemName=" + itemName + ", itemCostPrice=" + itemCostPrice + "]";
}
public void setItemId(Long itemId) {
this.itemId = itemId;
}
public String getItemName() {
return itemName;
}
public void setItemName(String itemName) {
this.itemName = itemName;
}
public Double getItemCostPrice() {
return itemCostPrice;
}
public void setItemCostPrice(Double itemCostPrice) {
this.itemCostPrice = itemCostPrice;
}
}उपरोक्त कोड में यह देखा जा सकता है कि आइटम वर्ग सीरियल को लागू करता है ।
यह वह इंटरफ़ेस है जो किसी वर्ग को क्रमबद्ध होने में सक्षम बनाता है।
अब हम serialVersionUID नामक एक चर देख सकते हैं को लॉन्ग वैरिएबल के लिए इनिशियलाइज़ किया गया है। इस संख्या की गणना कम्पाइलर द्वारा क्लास की स्थिति और क्लास की विशेषताओं के आधार पर की जाती है। यह वह संख्या है जो jvm को किसी ऑब्जेक्ट की स्थिति की पहचान करने में मदद करेगी जब वह फ़ाइल से ऑब्जेक्ट की स्थिति पढ़ती है।
उसके लिए हम आधिकारिक Oracle दस्तावेज पर एक नज़र डाल सकते हैं:
क्रमांकन रनटाइम प्रत्येक क्रमिक श्रेणी के साथ संबद्ध होता है एक संस्करण संख्या, जिसे serialVersionUID कहा जाता है, जिसका उपयोग यह प्रमाणित करने के लिए किया जाता है कि क्रमबद्ध ऑब्जेक्ट के प्रेषक और रिसीवर ने उस ऑब्जेक्ट के लिए लोड की गई कक्षाएं हैं जो क्रमांकन के संबंध में संगत हैं। यदि रिसीवर ने ऑब्जेक्ट के लिए एक वर्ग लोड किया है जिसमें संबंधित प्रेषक वर्ग की तुलना में एक अलग serialVersionUID है, तो deserialization एक InvalidClassException में परिणाम देगा। एक क्रमबद्ध वर्ग अपने स्वयं के क्रमबद्ध सीरियल "UID" को स्पष्ट रूप से "serialVersionUID" नाम के एक क्षेत्र की घोषणा करके घोषित कर सकता है जो स्थिर, अंतिम और प्रकार का लंबा होना चाहिए: कोई भी ACCESS-MODIFIER स्थिर अंतिम लंबा धारावाहिक VersionUID = 42L; यदि कोई श्रेणीबद्ध श्रेणी स्पष्ट रूप से एक सीरियलवर्जन घोषित नहीं करती है, तब क्रमांकन रनटाइम उस वर्ग के लिए एक डिफ़ॉल्ट serialVersionUID मान की गणना करेगा, जो कक्षा के विभिन्न पहलुओं पर आधारित है, जैसा कि जावा (टीएम) ऑब्जेक्ट सीरियलाइज़ेशन विशिष्टता में वर्णित है। हालांकि, यह दृढ़ता से अनुशंसा की जाती है कि सभी क्रमबद्ध कक्षाएं स्पष्ट रूप से क्रमबद्धता प्रदान करती हैं, क्योंकि डिफ़ॉल्ट serialVersionUID अभिकलन वर्ग के विवरण के प्रति अत्यधिक संवेदनशील है, जो संकलक कार्यान्वयन के आधार पर भिन्न हो सकते हैं, और इस प्रकार डिसेरिएलाइज़ेशन के दौरान अप्रत्याशित इनवॉयसक्लास अपवाद हो सकते हैं। इसलिए, विभिन्न जावा कंपाइलर कार्यान्वयन के अनुरूप सुसंगत सीरियलवर्जन मूल्य की गारंटी देने के लिए, एक श्रेणीबद्ध श्रेणी को एक स्पष्ट क्रमबद्ध धारावाहिक मूल्य घोषित करना चाहिए। यह भी दृढ़ता से सलाह दी जाती है कि स्पष्ट serialVersionUID घोषणाएं निजी संशोधक का उपयोग करें जहां संभव हो,
यदि आपने देखा है कि एक और खोजशब्द है जिसका हमने उपयोग किया है जो क्षणिक है ।
यदि कोई क्षेत्र क्रमिक नहीं है, तो इसे क्षणिक चिह्नित किया जाना चाहिए। यहां हमने आइटमकॉस्टप्राइस चिह्नित किया है को क्षणिक के रूप में और यह नहीं चाहते हैं कि यह एक फ़ाइल में लिखा जाए
अब आइए नजर डालते हैं कि फाइल में किसी ऑब्जेक्ट की स्थिति कैसे लिखी जाए और फिर उसे वहां से पढ़ें।
public class SerializationExample {
public static void main(String[] args){
serialize();
deserialize();
}
public static void serialize(){
Item item = new Item(1L,"Pen", 12.55);
System.out.println("Before Serialization" + item);
FileOutputStream fileOut;
try {
fileOut = new FileOutputStream("/tmp/item.ser");
ObjectOutputStream out = new ObjectOutputStream(fileOut);
out.writeObject(item);
out.close();
fileOut.close();
System.out.println("Serialized data is saved in /tmp/item.ser");
} catch (FileNotFoundException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
}
}
public static void deserialize(){
Item item;
try {
FileInputStream fileIn = new FileInputStream("/tmp/item.ser");
ObjectInputStream in = new ObjectInputStream(fileIn);
item = (Item) in.readObject();
System.out.println("Serialized data is read from /tmp/item.ser");
System.out.println("After Deserialization" + item);
} catch (FileNotFoundException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
} catch (ClassNotFoundException e) {
e.printStackTrace();
}
}
}उपर्युक्त में हम किसी वस्तु के क्रमांकन और विलयन का उदाहरण देख सकते हैं।
उसके लिए हमने दो वर्गों का उपयोग किया। ऑब्जेक्ट को क्रमबद्ध करने के लिए हमने ObjectOutputStream का उपयोग किया है। हमने फाइल में ऑब्जेक्ट लिखने के लिए मेथड राइट ऑबजेक्ट का इस्तेमाल किया है।
Deserializing के लिए हमने ObjectInputStream का उपयोग किया है जो फ़ाइल से ऑब्जेक्ट से पढ़ता है। यह फ़ाइल से ऑब्जेक्ट डेटा को पढ़ने के लिए readObject का उपयोग करता है।
उपरोक्त कोड का उत्पादन निम्नानुसार होगा:
Before SerializationItem [itemId=1, itemName=Pen, itemCostPrice=12.55]
Serialized data is saved in /tmp/item.ser
After DeserializationItem [itemId=1, itemName=Pen, itemCostPrice=null]ध्यान दें कि deserialized ऑब्जेक्ट से itemCostPrice शून्य है क्योंकि यह नहीं लिखा गया था।
हमने पहले ही इस लेख के भाग I में जावा सीरियललाइज़ेशन की मूल बातें पर चर्चा की है।
अब हम इस पर गहन चर्चा करते हैं कि यह कैसे काम करता है।
पहले चलो के साथ शुरू करते हैं serialversionuid के ।
serialVersionUID एक Serializable कक्षा में एक संस्करण नियंत्रण के रूप में प्रयोग किया जाता है।
यदि आप स्पष्ट रूप से एक सीरियलवर्जन यूआईडी की घोषणा नहीं करते हैं, तो जेवीएम आपके लिए यह सीरियल के विभिन्न गुणों के आधार पर स्वचालित रूप से करेगा।
अनुक्रमिक गणना की जावा की एल्गोरिथ्म (यहाँ और अधिक विवरण पढ़ें)
- वर्ग का नाम।
- क्लास मॉडिफायर को 32-बिट पूर्णांक के रूप में लिखा गया है।
- नाम से छांटे गए प्रत्येक इंटरफ़ेस का नाम।
- फ़ील्ड नाम के आधार पर छाँटे गए वर्ग के प्रत्येक क्षेत्र के लिए (निजी स्थैतिक और निजी क्षणिक क्षेत्रों को छोड़कर: फ़ील्ड का नाम। फ़ील्ड के संशोधक को 32-बिट पूर्णांक के रूप में लिखा जाता है। फ़ील्ड का वर्णनकर्ता।
- यदि कोई क्लास इनिशियलाइज़र मौजूद है, तो निम्न लिखिए: विधि का नाम,।
- विधि का संशोधन, java.lang.reflect.Modifier.STATIC, जिसे 32-बिट पूर्णांक के रूप में लिखा गया है।
- विधि का वर्णन करने वाला, () वी।
- विधि नाम और हस्ताक्षर द्वारा छांटे गए प्रत्येक गैर-निजी निर्माणकर्ता के लिए: विधि का नाम,। 32-बिट पूर्णांक के रूप में लिखी गई विधि के संशोधक। विधि का वर्णन करनेवाला।
- विधि नाम और हस्ताक्षर द्वारा छांटे गए प्रत्येक गैर-निजी विधि के लिए: विधि का नाम। 32-बिट पूर्णांक के रूप में लिखी गई विधि के संशोधक। विधि का वर्णन करनेवाला।
- SHA-1 एल्गोरिथ्म DataOutputStream द्वारा निर्मित बाइट्स की धारा पर निष्पादित किया जाता है और पांच 32-बिट मान शेक [0..4] का उत्पादन करता है। हैश मान SHA-1 संदेश डाइजेस्ट के पहले और दूसरे 32-बिट मान से इकट्ठा किया जाता है। यदि संदेश पचता है, तो पाँच 32-बिट शब्द H0 H1 H2 H3 H4, पाँच समान मानों के एक समूह में है जिसका नाम sha है, हैश मान की गणना निम्नानुसार की जाएगी:
long hash = ((sha[0] >>> 24) & 0xFF) |
> ((sha[0] >>> 16) & 0xFF) << 8 |
> ((sha[0] >>> 8) & 0xFF) << 16 |
> ((sha[0] >>> 0) & 0xFF) << 24 |
> ((sha[1] >>> 24) & 0xFF) << 32 |
> ((sha[1] >>> 16) & 0xFF) << 40 |
> ((sha[1] >>> 8) & 0xFF) << 48 |
> ((sha[1] >>> 0) & 0xFF) << 56;जावा के क्रमांकन एल्गोरिथ्म
किसी वस्तु को क्रमबद्ध करने के लिए एल्गोरिथ्म नीचे वर्णित है:
1. यह एक उदाहरण के साथ जुड़े वर्ग के मेटाडेटा को लिखता है।
2. जब तक यह java.lang.object नहीं मिलता है तब तक यह सुपरक्लास के वर्णन को पुन: लिखता है ।
3. एक बार जब यह मेटाडेटा जानकारी लिखना समाप्त कर देता है, तो यह उदाहरण के साथ जुड़े वास्तविक डेटा से शुरू होता है। लेकिन इस बार, यह सबसे ऊपरी सुपरक्लास से शुरू होता है।
4. यह कम से कम सुपरक्लास से सबसे अधिक व्युत्पन्न वर्ग से शुरू होने वाले उदाहरणों से संबंधित डेटा को पुन: लिखता है।
ध्यान रखने योग्य बातें:
किसी कक्षा में स्थैतिक क्षेत्रों को क्रमबद्ध नहीं किया जा सकता है।
public class A implements Serializable{
String s;
static String staticString = "I won't be serializable";
}यदि सीरियलवर्सन रीड क्लास में अलग है, तो यह एक InvalidClassExceptionअपवाद फेंक देगा ।
यदि कोई वर्ग क्रमबद्धता को लागू करता है तो उसके सभी उप वर्गों को भी क्रमबद्ध किया जाएगा।
public class A implements Serializable {....};
public class B extends A{...} //also Serializableयदि किसी वर्ग में किसी अन्य वर्ग का संदर्भ है, तो सभी संदर्भों को सीरियल करने योग्य होना चाहिए अन्यथा क्रमबद्धता प्रक्रिया नहीं होगी। ऐसे मामले में, NotSerializableException को रनटाइम पर फेंक दिया जाता है।
उदाहरण के लिए:
public class B{
String s,
A a; // class A needs to be serializable i.e. it must implement Serializable
}serialVersionUIDयह अलग है InvalidClassException, तो यह एक फेंक देगा , नहीं ClassCastException। यह आवश्यक नहीं है कि serialVersionUIDगणना करने वाले सभी स्थान को बेकार कर दिया जाए । दस्तावेज़ीकरण अत्यधिक लंबाई में उद्धृत किया गया है, लेकिन लिंक नहीं किया गया है या ठीक से उद्धृत नहीं किया गया है। यहाँ बहुत अधिक फुलाना और बहुत सारी त्रुटियां हैं।
सीरियलाइज़ेशन एक वस्तु की अवस्था को बिट्स में बदलने की प्रक्रिया है ताकि इसे हार्ड ड्राइव पर संग्रहीत किया जा सके। जब आप एक ही वस्तु को डिसेर्बलाइज करते हैं, तो यह बाद में अपनी स्थिति को बनाए रखेगा। यह आपको वस्तुओं के गुणों को हाथ से सहेजे बिना वस्तुओं को फिर से बनाने की सुविधा देता है।
जावा ऑब्जेक्ट सीरियल
Serializationस्टोरेज ( to disk file) या ट्रांसमिशन ( across a network) के लिए जावा ऑब्जेक्ट्स के ग्राफ को बाइट्स के एक सरणी में बदलने के लिए एक तंत्र है , फिर डिसेरिएलाइज़ेशन का उपयोग करके हम ऑब्जेक्ट्स के ग्राफ को पुनर्स्थापित कर सकते हैं। संदर्भ साझाकरण तंत्र का उपयोग करके वस्तुओं के ग्राफ़ को सही ढंग से बहाल किया जाता है। लेकिन स्टोर करने से पहले, जांचें कि क्या इनपुट-फाइल / नेटवर्क और सीरियल फ़ाइल से सीरियलवर्सन यूआईडी एक ही हैं। यदि नहीं, एक फेंक java.io.InvalidClassException।
प्रत्येक संस्करण वर्ग को मूल वर्ग संस्करण की पहचान करनी चाहिए, जिसके लिए वह धाराएँ लिखने में सक्षम है और जहाँ से वह पढ़ सकता है। उदाहरण के लिए, एक संस्करण वर्ग को घोषित करना चाहिए:
सीरियलवर्सन यूआईडी सिंटेक्स
// ANY-ACCESS-MODIFIER static final long serialVersionUID = (64-bit has)L; private static final long serialVersionUID = 3487495895819393L;
serialVersionUID क्रमांकन प्रक्रिया के लिए आवश्यक है। लेकिन डेवलपर के लिए इसे जावा स्रोत फ़ाइल में जोड़ना वैकल्पिक है। यदि कोई सीरियलवर्जन यूआईडी शामिल नहीं है, तो क्रमिक रनटाइम एक सीरियलव्यूडयूआईडी उत्पन्न करेगा और इसे कक्षा के साथ संबद्ध करेगा। क्रमबद्ध ऑब्जेक्ट में अन्य डेटा के साथ इस serialVersionUID शामिल होगा।
नोट - यह दृढ़ता से अनुशंसा की जाती है कि सभी अनुक्रमिक वर्ग स्पष्ट रूप से एक सीरियलव्यूडयूआईडी की घोषणा करते हैं since the default serialVersionUID computation is highly sensitive to class details that may vary depending on compiler implementations, और इस प्रकार deserialization के दौरान अप्रत्याशित serialVersionUID संघर्ष का परिणाम हो सकता है, जिससे deserialization विफल हो सकता है।
एक जावा ऑब्जेक्ट केवल सीरियल करने योग्य है। यदि कोई वर्ग या उसका कोई भी सुपरक्लास java.io.Serializable इंटरफ़ेस या उसके उप-संस्करण, java.io.Externalizable को लागू करता है ।
एक वर्ग को लागू करना चाहिए java.io.Serializable इंटरफ़ेस ताकि वह अपनी वस्तु को सफलतापूर्वक प्रसारित कर सके। Serializable एक मार्कर इंटरफ़ेस है और इसे संकलक को सूचित करने के लिए उपयोग किया जाता है कि इसे लागू करने वाले वर्ग को क्रमबद्ध व्यवहार को जोड़ना होगा। यहां जावा वर्चुअल मशीन (JVM) अपने स्वचालित क्रमांकन के लिए जिम्मेदार है।
क्षणिक कीवर्ड:
java.io.Serializable interfaceकिसी ऑब्जेक्ट को क्रमबद्ध करते समय, यदि हम नहीं चाहते हैं कि ऑब्जेक्ट के कुछ डेटा सीरियल किए जाएं तो हम क्षणिक संशोधक का उपयोग कर सकते हैं। क्षणिक कीवर्ड उस डेटा सदस्य को क्रमबद्ध होने से रोकेगा।
- क्षणिक या स्थिर के रूप में घोषित फ़ील्ड्स को क्रमबद्धता प्रक्रिया द्वारा अनदेखा किया जाता है।
+--------------+--------+-------------------------------------+ | Flag Name | Value | Interpretation | +--------------+--------+-------------------------------------+ | ACC_VOLATILE | 0x0040 | Declared volatile; cannot be cached.| +--------------+--------+-------------------------------------+ |ACC_TRANSIENT | 0x0080 | Declared transient; not written or | | | | read by a persistent object manager.| +--------------+--------+-------------------------------------+
class Employee implements Serializable {
private static final long serialVersionUID = 2L;
static int id;
int eno;
String name;
transient String password; // Using transient keyword means its not going to be Serialized.
}बाहरी इंटरफ़ेस को लागू करने से ऑब्जेक्ट को ऑब्जेक्ट के क्रमबद्ध रूप की सामग्री और प्रारूप पर पूर्ण नियंत्रण ग्रहण करने की अनुमति मिलती है। एक्सरसाइज़ करने योग्य इंटरफ़ेस के तरीके, writeExternal और readExternal, को ऑब्जेक्ट्स स्टेट को बचाने और पुनर्स्थापित करने के लिए कहा जाता है। जब एक वर्ग द्वारा कार्यान्वित किया जाता है तो वे ObjectOutput और ObjectInput के सभी तरीकों का उपयोग करके अपने स्वयं के राज्य को लिख और पढ़ सकते हैं। यह किसी भी संस्करण को संभालने के लिए वस्तुओं की जिम्मेदारी है।
class Emp implements Externalizable {
int eno;
String name;
transient String password; // No use of transient, we need to take care of write and read.
@Override
public void writeExternal(ObjectOutput out) throws IOException {
out.writeInt(eno);
out.writeUTF(name);
//out.writeUTF(password);
}
@Override
public void readExternal(ObjectInput in) throws IOException, ClassNotFoundException {
this.eno = in.readInt();
this.name = in.readUTF();
//this.password = in.readUTF(); // java.io.EOFException
}
}केवल ऑब्जेक्ट जो java.io.Serializable या java.io.Externalizable इंटरफ़ेस का समर्थन करते हैं written to/read from स्ट्रीम हो सकते हैं। प्रत्येक अनुक्रमिक वस्तु का वर्ग वर्ग के नाम और हस्ताक्षर सहित, ऑब्जेक्ट के क्षेत्र और सरणियों के मूल्यों और प्रारंभिक वस्तुओं से संदर्भित किसी भी अन्य ऑब्जेक्ट के बंद होने सहित एन्कोडेड है।
फ़ाइलों के लिए सीरियल योग्य उदाहरण
public class SerializationDemo {
static String fileName = "D:/serializable_file.ser";
public static void main(String[] args) throws IOException, ClassNotFoundException, InstantiationException, IllegalAccessException {
Employee emp = new Employee( );
Employee.id = 1; // Can not Serialize Class data.
emp.eno = 77;
emp.name = "Yash";
emp.password = "confidential";
objects_WriteRead(emp, fileName);
Emp e = new Emp( );
e.eno = 77;
e.name = "Yash";
e.password = "confidential";
objects_WriteRead_External(e, fileName);
/*String stubHost = "127.0.0.1";
Integer anyFreePort = 7777;
socketRead(anyFreePort); //Thread1
socketWrite(emp, stubHost, anyFreePort); //Thread2*/
}
public static void objects_WriteRead( Employee obj, String serFilename ) throws IOException{
FileOutputStream fos = new FileOutputStream( new File( serFilename ) );
ObjectOutputStream objectOut = new ObjectOutputStream( fos );
objectOut.writeObject( obj );
objectOut.close();
fos.close();
System.out.println("Data Stored in to a file");
try {
FileInputStream fis = new FileInputStream( new File( serFilename ) );
ObjectInputStream ois = new ObjectInputStream( fis );
Object readObject;
readObject = ois.readObject();
String calssName = readObject.getClass().getName();
System.out.println("Restoring Class Name : "+ calssName); // InvalidClassException
Employee emp = (Employee) readObject;
System.out.format("Obj[No:%s, Name:%s, Pass:%s]", emp.eno, emp.name, emp.password);
ois.close();
} catch (ClassNotFoundException e) {
e.printStackTrace();
}
}
public static void objects_WriteRead_External( Emp obj, String serFilename ) throws IOException {
FileOutputStream fos = new FileOutputStream(new File( serFilename ));
ObjectOutputStream objectOut = new ObjectOutputStream( fos );
obj.writeExternal( objectOut );
objectOut.flush();
fos.close();
System.out.println("Data Stored in to a file");
try {
// create a new instance and read the assign the contents from stream.
Emp emp = new Emp();
FileInputStream fis = new FileInputStream(new File( serFilename ));
ObjectInputStream ois = new ObjectInputStream( fis );
emp.readExternal(ois);
System.out.format("Obj[No:%s, Name:%s, Pass:%s]", emp.eno, emp.name, emp.password);
ois.close();
} catch (ClassNotFoundException e) {
e.printStackTrace();
}
}
}नेटवर्क पर सीरियल करने योग्य उदाहरण
बांटने वाली वस्तुअलग-अलग एड्रेस स्पेस में की स्थिति को , या तो एक ही कंप्यूटर पर अलग-अलग प्रक्रियाओं में, या यहां तक कि एक नेटवर्क के माध्यम से जुड़े कई कंप्यूटरों में, लेकिन जो डेटा साझा करने और विधियों को साझा करके एक साथ काम करते हैं।
/**
* Creates a stream socket and connects it to the specified port number on the named host.
*/
public static void socketWrite(Employee objectToSend, String stubHost, Integer anyFreePort) {
try { // CLIENT - Stub[marshalling]
Socket client = new Socket(stubHost, anyFreePort);
ObjectOutputStream out = new ObjectOutputStream(client.getOutputStream());
out.writeObject(objectToSend);
out.flush();
client.close();
} catch (IOException e) {
e.printStackTrace();
}
}
// Creates a server socket, bound to the specified port.
public static void socketRead( Integer anyFreePort ) {
try { // SERVER - Stub[unmarshalling ]
ServerSocket serverSocket = new ServerSocket( anyFreePort );
System.out.println("Server serves on port and waiting for a client to communicate");
/*System.in.read();
System.in.read();*/
Socket socket = serverSocket.accept();
System.out.println("Client request to communicate on port server accepts it.");
ObjectInputStream in = new ObjectInputStream(socket.getInputStream());
Employee objectReceived = (Employee) in.readObject();
System.out.println("Server Obj : "+ objectReceived.name );
socket.close();
serverSocket.close();
} catch (IOException | ClassNotFoundException e) {
e.printStackTrace();
}
}@देख
JVM to JVM
सीरियलाइज़ेशन एक स्टोरेज माध्यम (जैसे कि फ़ाइल, या मेमोरी बफर) में किसी ऑब्जेक्ट को सहेजने या बाइनरी फॉर्म में नेटवर्क कनेक्शन पर प्रसारित करने की प्रक्रिया है। क्रमबद्ध वस्तुएँ JVM स्वतंत्र होती हैं और इन्हें किसी भी JVM द्वारा पुन: क्रमबद्ध किया जा सकता है। इस स्थिति में "मेमोरी" जावा ऑब्जेक्ट्स स्टेट बाइट स्ट्रीम में परिवर्तित हो जाते हैं। इस प्रकार की फ़ाइल को उपयोगकर्ता द्वारा नहीं समझा जा सकता है। यह एक विशेष प्रकार की वस्तु है जिसका उपयोग जेवीएम (जावा वर्चुअल मशीन) द्वारा किया जाता है। किसी वस्तु को क्रमबद्ध करने की इस प्रक्रिया को किसी वस्तु को अपवित्र या मार्शलाइज करना भी कहा जाता है।
सीरियलाइज्ड होने वाली वस्तु को java.io.Serializableइंटरफ़ेस लागू करना होगा । किसी वस्तु के लिए डिफ़ॉल्ट क्रमांकन तंत्र, वस्तु के वर्ग, वर्ग हस्ताक्षर और सभी गैर-क्षणिक और गैर-स्थिर क्षेत्रों के मूल्यों को लिखता है।
class ObjectOutputStream extends java.io.OutputStream implements ObjectOutput,ObjectOutputइंटरफ़ेस इंटरफ़ेस का विस्तार करता DataOutputहै और वस्तुओं को क्रमबद्ध करने और फ़ाइल को बाइट्स लिखने के लिए तरीके जोड़ता है। ObjectOutputStreamफैली हुई है java.io.OutputStreamऔर औजार ObjectOutput इंटरफेस। यह एक धारा में वस्तुओं, सरणियों और अन्य मूल्यों को क्रमबद्ध करता है। इस प्रकार के निर्माता के ObjectOutputStreamरूप में लिखा है:
ObjectOutput ObjOut = new ObjectOutputStream(new FileOutputStream(f));निर्माणकर्ता के ObjectOutputसाथ वर्ग का उदाहरण बनाने के लिए उपरोक्त कोड का उपयोग किया गया ObjectOutputStream( )है, जो इसका उदाहरण लेता हैFileOuputStream एक पैरामीटर रूप ।
ObjectOutputइंटरफ़ेस को लागू करने से प्रयोग किया जाता है ObjectOutputStreamवर्ग। ObjectOutputStreamवस्तु को क्रमानुसार करने का निर्माण किया है।
जावा में किसी वस्तु का वर्णन करना
सीरियलाइज़ेशन के विपरीत ऑपरेशन को डिसेरिएलाइज़ेशन कहा जाता है यानी बाइट्स की एक श्रृंखला से डेटा निकालने के लिए डीरिएरलाइज़ेशन के रूप में जाना जाता है जिसे फुलाया या अनमरसॉलिंग भी कहा जाता है।
ObjectInputStreamविस्तार java.io.InputStreamऔर ObjectInput इंटरफ़ेस लागू करता है। यह एक इनपुट स्ट्रीम से ऑब्जेक्ट्स, एरेज़ और अन्य वैल्यूज़ को डिसेरियलाइज़ करता है। इस प्रकार के निर्माता के ObjectInputStreamरूप में लिखा है:
ObjectInputStream obj = new ObjectInputStream(new FileInputStream(f));प्रोग्राम के ऊपर कोड ObjectInputStreamउस फ़ाइल को डिसेर्बलाइज करने के लिए कक्षा का उदाहरण बनाता है जिसे ObjectInputStreamकक्षा द्वारा क्रमबद्ध किया गया था । उपरोक्त कोड उस FileInputStreamश्रेणी के उदाहरण का उपयोग करके उदाहरण बनाता है जो निर्दिष्ट फ़ाइल ऑब्जेक्ट को रखता है जिसे deserialized करना पड़ता है क्योंकि ObjectInputStream()निर्माता को इनपुट स्ट्रीम की आवश्यकता होती है।
सीरियलाइज़ेशन एक जावा ऑब्जेक्ट को बाइट सरणी में बदलने की प्रक्रिया है और फिर अपने संरक्षित राज्य के साथ फिर से ऑब्जेक्ट में वापस आ जाता है। विभिन्न चीजों के लिए उपयोगी है जैसे नेटवर्क पर वस्तुओं को भेजना या डिस्क पर चीजों को कैशिंग करना।
इस लघु लेख से अधिक पढ़ें जो प्रक्रिया के प्रोग्रामिंग भाग को काफी अच्छी तरह से समझाता है और फिर Serializable javadoc पर जाता है । इस संबंधित प्रश्न को पढ़ने में भी आपकी रुचि हो सकती है ।
ऑब्जेक्ट के रूप में फ़ाइल लौटाएँ: http://www.tutorialspoint.com/java/java_serialization.htm
import java.io.*;
public class SerializeDemo
{
public static void main(String [] args)
{
Employee e = new Employee();
e.name = "Reyan Ali";
e.address = "Phokka Kuan, Ambehta Peer";
e.SSN = 11122333;
e.number = 101;
try
{
FileOutputStream fileOut =
new FileOutputStream("/tmp/employee.ser");
ObjectOutputStream out = new ObjectOutputStream(fileOut);
out.writeObject(e);
out.close();
fileOut.close();
System.out.printf("Serialized data is saved in /tmp/employee.ser");
}catch(IOException i)
{
i.printStackTrace();
}
}
}
import java.io.*;
public class DeserializeDemo
{
public static void main(String [] args)
{
Employee e = null;
try
{
FileInputStream fileIn = new FileInputStream("/tmp/employee.ser");
ObjectInputStream in = new ObjectInputStream(fileIn);
e = (Employee) in.readObject();
in.close();
fileIn.close();
}catch(IOException i)
{
i.printStackTrace();
return;
}catch(ClassNotFoundException c)
{
System.out.println("Employee class not found");
c.printStackTrace();
return;
}
System.out.println("Deserialized Employee...");
System.out.println("Name: " + e.name);
System.out.println("Address: " + e.address);
System.out.println("SSN: " + e.SSN);
System.out.println("Number: " + e.number);
}
}| * | किसी वर्ग को क्रमबद्ध करना: किसी वस्तु को बाइट्स और बाइट्स पर वापस वस्तु में बदलना (देशीकरण)।
class NamCls implements Serializable
{
int NumVar;
String NamVar;
}| => वस्तु-क्रमीकरण किसी वस्तु की स्थिति को बाइट्स के भाप में परिवर्तित करने की प्रक्रिया है।
| => वस्तु-देशीकरण एक वस्तु की स्थिति प्राप्त करने और उसे एक वस्तु (java.lang.Object) में संग्रहीत करने की प्रक्रिया है।
| => एक जावा वस्तु केवल क्रमिक है, यदि उसका वर्ग या उसका कोई सुपरक्लास
| => एक कक्षा में स्थैतिक क्षेत्रों को क्रमबद्ध नहीं किया जा सकता है।
class NamCls implements Serializable
{
int NumVar;
static String NamVar = "I won't be serializable";;
}| => यदि आप वर्ग उपयोग क्षणिक कीवर्ड के एक चर को क्रमबद्ध नहीं करना चाहते हैं
class NamCls implements Serializable
{
int NumVar;
transient String NamVar;
}| => यदि कोई वर्ग क्रमबद्धता को लागू करता है तो उसके सभी उप वर्ग भी धारावाहिक होंगे।
| => यदि किसी वर्ग में किसी अन्य वर्ग का संदर्भ है, तो सभी संदर्भों को सीरियल करने योग्य होना चाहिए अन्यथा क्रमबद्धता प्रक्रिया नहीं होगी। ऐसे मामले में,
NotSerializableException को रनटाइम पर फेंक दिया जाता है।
मैं वैचारिक उद्देश्य / व्यावहारिकता को वस्तु क्रमबद्धता / डीरियलाइज़ेशन को ठोस बनाने में सहायता करने के लिए एक सादृश्य प्रदान करता हूँ ।
मैं एक तूफान नाली के माध्यम से एक वस्तु को स्थानांतरित करने के प्रयास के संदर्भ में वस्तु क्रमांकन / deserialization की कल्पना करता हूं । वस्तु अनिवार्य रूप से "विघटित" है या स्वयं के अधिक मॉड्यूलर संस्करणों में क्रमबद्ध है - इस मामले में, बाइट्स की एक श्रृंखला है - प्रभावी रूप से एक माध्यम से पारित होने के लिए दी जाती है। एक कम्प्यूटेशनल अर्थ में, हम एक नेटवर्क के माध्यम से यात्रा बाइट्स के समान होने के रूप में तूफान नाली के माध्यम से बाइट्स द्वारा यात्रा पथ देख सकते हैं। हम परिवहन के एक अधिक वांछनीय मोड, या प्रारूप के अनुरूप हमारी वस्तु को स्थानांतरित कर रहे हैं। क्रमबद्ध ऑब्जेक्ट को आमतौर पर एक बाइनरी फ़ाइल में संग्रहीत किया जाएगा जिसे बाद में पढ़ा, लिखा या दोनों से पढ़ा जा सकता है।
शायद एक बार जब हमारी वस्तु बाइट्स के विघटित श्रृंखला के रूप में नाली के माध्यम से फिसलने में सक्षम हो जाती है, तो हम उस डेटाबेस या हार्ड डिस्क ड्राइव के भीतर बाइनरी डेटा के रूप में ऑब्जेक्ट के प्रतिनिधित्व को संग्रहीत करना चाह सकते हैं। हालांकि मुख्य रूप से, यह कहा जाता है कि क्रमांकन / deserialization के साथ, हमारे पास विकल्प है कि हम क्रमबद्ध होने के बाद अपनी वस्तु को बाइनरी रूप में रहने दें, या deserialization करके ऑब्जेक्ट के मूल रूप को "पुनः प्राप्त" करें।