सरल फ्रेमवर्क के साथ XML को पार्स करना

हेलो रीडर्स हबरहाब!

यह पोस्ट एक अन्य पोस्ट से प्रेरित है और वहाँ से सम्मानित अनातोलीबी हब्रायुज़र की टिप्पणी है।

मुझे लगता है कि कई लोग इस पुस्तकालय से परिचित हैं, लेकिन, फिर भी, यह पता चला है कि यह अभी तक हाबरा के पन्नों पर प्रतिबिंबित नहीं हुआ था। हम आज इस गलतफहमी से निपटेंगे।

और, निश्चित रूप से, मैं उन लोगों के लिए सलाह देता हूं जो इस खूबसूरत पुस्तकालय से जल्द से जल्द परिचित नहीं हैं, मैं इसके साथ आपकी मदद करने की कोशिश करूंगा।

पहचान

सरल फ्रेमवर्क एक एंड्रॉइड वर्चुअल मशीन है जो एक्सएमएल में जावा ऑब्जेक्ट्स को क्रमांकित / डिसेरलाइज़ करने के लिए संगत लाइब्रेरी है और इसके विपरीत।

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

आधिकारिक साइट में वह सब कुछ है जो आपको पुस्तकालय के साथ काम करना शुरू करने की आवश्यकता है, साथ ही साथ मेरे पसंदीदा प्रकार के प्रलेखन: बहुमुखी उदाहरणों के एक बड़े सेट के साथ प्रलेखन।

सबसे पहले, यहां से लाइब्रेरी डाउनलोड करें । हम जार फ़ाइल को ढूंढते हैं और इसे हमारी परियोजना के अंदर के lib फ़ोल्डर में कॉपी करते हैं। इसके बाद, हमारे जार को "ऐड जार ..." के माध्यम से बिल्ड पाथ में जोड़ें, और कुछ इस तरह से समाप्त करें:

उपयोग के उदाहरण

अब हम अपने प्रोजेक्ट में सिंपल का उपयोग कर सकते हैं। और पहली चीज जो हम करने की कोशिश करते हैं वह सरल XML को एक जावा वर्ग में बदल देता है।

मान लें कि हमारे पास निम्नलिखित XML है:

<Pet> <Name>Bobby</Name> <Age>8</Age> <NickName>Lucky</NickName> </Pet> 

यह "पालतू" के सार का प्रतिनिधित्व करता है, जिसमें आवश्यक फ़ील्ड हैं: नाम और उम्र, साथ ही एक वैकल्पिक: उपनाम।

इस XML को किसी वर्ग के साथ जोड़ने के लिए, हमें एक वर्ग बनाने और उसमें विशेष गुण जोड़ने की आवश्यकता है ताकि सरल समझ सके कि हम क्या और कैसे करना चाहते हैं। हमारे उदाहरण के लिए, वर्ग इस तरह दिखेगा:

 @Root(name="Pet") public class MyPet { @Element(name="Name") public String name; @Element(name="Age") public int age; @Element(required=false, name="NickName") public String nickName; } 

जहां:

• रूट - रूट XML तत्व को इंगित करता है।
• तत्व - पालतू आंतरिक क्षेत्र।
• आवश्यक - इस क्षेत्र को वैकल्पिक कहा जा सकता है।
• name - इनपुट XML में तत्व के नाम को इंगित करता है, यदि यह नाम और वर्ग मैच का क्षेत्र है, तो इस विशेषता को छोड़ा जा सकता है।

यदि पालतू फ़ील्ड तत्वों के बजाय विशेषताओं द्वारा निर्धारित किए गए थे, तो इनपुट XML इस तरह दिखाई देगा:

 <Pet Name="Bobby" Age="8" NickName="Lucky"/> 

और हमारी कक्षा इस तरह दिखेगी:

 @Root(name="Pet") public class MyPet { @Attribute(name="Name") public String name; @Attribute(name="Age") public int age; @Attribute(required=false, name="NickName") public String nickName; } 

डीसेरिएलाइज़ेशन कोड स्वयं इस तरह दिखता है:

 Reader reader = new StringReader(xml); Persister serializer = new Persister(); try { MyPet pet = serializer.read(MyPet.class, reader, false); Log.v("SimpleTest", "Pet Name" + pet.name); } catch (Exception e) { Log.e("SimpleTest", e.getMessage()); } 

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

उलटा परिवर्तन के लिए कोड भी काफी सरल है:

 Writer writer = new StringWriter(); Serializer serializer = new Persister(); try { MyPet pet = new MyPet(); pet.name = "Bobby"; pet.age = 8; pet.nickName = "Lucky"; serializer.write(pet, writer); String xml = writer.toString(); } catch (Exception e) { Log.e("SimpleTest", e.getMessage()); } 

इनकैप्सुलेशन सिद्धांत का पालन करने के लिए, वर्ग के क्षेत्रों को गेटर्स और सेट'र्स में लपेटा जा सकता है और सरल इनसे काम करेगा:

 @Root(name="Pet") public class MyPet { private String name; private int age; private String nickName; @Attribute(name="Name") public void setName(String name) { this.name = name; } @Attribute(name="Name") public String getName() { return name; } @Attribute(name="Age") public void setAge(int age) { this.age = age; } @Attribute(name="Age") public int getAge() { return age; } @Attribute(required=false, name="NickName") public void setNickName(String nickName) { this.nickName = nickName; } @Attribute(required=false, name="NickName") public String getNickName() { return nickName; } } 

यदि किसी XML तत्व की अपनी विशेषताएँ या नेस्टेड तत्व हैं, तो उसे एक अलग वर्ग या उनमें से एक सूची घोषित किया जा सकता है। हम अपने उदाहरण को संशोधित करते हैं, इकाई "नर्सरी" को जोड़ते हैं, जिसमें वस्तुओं की एक मनमानी संख्या "पालतू" (पालतू) हो सकती है। एक उदाहरण:

 <Nursery> <Pet Name="Bobby" Age="8" NickName="Lucky"/> <Pet Name="Rex" Age="3"/> <Pet Name="Pumba" Age="1"/> </Nursery> 

इस उदाहरण के लिए, हमें "नर्सरी" के लिए एक वर्ग जोड़ने की जरूरत है:

 @Root(name="Nursery") public class MyNursery { @ElementList(inline=true, name="Pet") public List<MyPet> pets; } 

जैसा कि आप देख सकते हैं, सब कुछ उतना ही सरल है। इनलाइन कीवर्ड इंगित करता है कि "पालतू" तत्वों को एक मध्यवर्ती मूल तत्व का उपयोग किए बिना, तुरंत MyNursery के अंदर समाहित किया जाता है।

नर्सरी को डाउनलोड करने के लिए कोड, हमने पेट के लिए क्या किया है:

 Reader reader = new StringReader(xml); Persister serializer = new Persister(); try { MyNursery nursery = serializer.read(MyNursery.class, reader, false); Log.v("SimpleTest", "Pets in nursery: " + nursery.pets.size()); } catch (Exception e) { Log.e("SimpleTest", e.getMessage()); } 

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

निष्कर्ष

सरल प्रस्ताव समाधान, शायद सभी निर्माणों के लिए जो केवल XML में संभव हैं। जावा की विशेषताएं जैसे कि विरासत और इंटरफेस भी समर्थित हैं।

सरल का उपयोग करते समय, निम्नलिखित सकारात्मक और नकारात्मक पहलुओं पर ध्यान दिया जा सकता है।

सकारात्मक:

1. उपयोग करने और समझने में आसान।
2. इस दृष्टिकोण के साथ कोड की मात्रा न्यूनतम है।
3. Android प्लेटफ़ॉर्म समर्थन।
4. विभिन्न XML निर्माणों के लिए समृद्ध समर्थन।
5. गैर-एंड्रॉइड अनुप्रयोगों में आवेदन करने की क्षमता, उदाहरण के लिए, यूनिट परीक्षणों में जो उपकरणों से अप्रकाशित हैं।
6. अपाचे लाइसेंस यानी। वाणिज्यिक सॉफ्टवेयर में स्वतंत्र रूप से इस्तेमाल किया जा सकता है।

नकारात्मक:

1. सरल गुण वाक्यविन्यास वर्ग प्रतिनिधित्व को अधिभारित करता है।
2. सरल के संचालन के लिए, परावर्तन तंत्र का उपयोग किया जाता है, और ये महंगे ऑपरेशन हैं। इसलिए, यदि आप प्रदर्शन पर मांग वाले उत्पाद में इस फ्रेमवर्क का उपयोग करने का इरादा रखते हैं, तो यह इस तरह के समाधान की व्यवहार्यता पर विचार करने योग्य है।

उपयोगी लिंक

1. आधिकारिक साइट।
2. प्रलेखन के लिए सीधा लिंक।
3. विषय पर एक और लेख।