खट्टेपन स्वचालित रूप से दायरे वस्तु संरचनाओं में बदलने के लिए

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

समस्याओं

कोड अनुकूलन

जाहिर है, हर बार एक दायरे वस्तु के लिए आरंभीकरण कोड लिखना और वस्तुओं को पढ़ने और लिखने के लिए एक ही फ़ंक्शन को कॉल करना असुविधाजनक है। आप इसे अमूर्तन में लपेट सकते हैं।

उदाहरण डेटा एक्सेस ऑब्जेक्ट:

struct DAO<O: Object> { func persist(with object: O) { guard let realm = try? Realm() else { return } try? realm.write { realm.add(object, update: .all) } } func read(by key: String) -> O? { guard let realm = try? Realm() else { return [] } return realm.object(ofType: O.self, forPrimaryKey: key) } } 

का उपयोग करें:

 let yourObjectDAO = DAO<YourObject>() let object = YourObject(key) yourObjectDAO.persist(with: object) let allPersisted = yourObjectDAO.read(by: key) 

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

गलत धागे से पहुँचा

क्षेत्र एक थ्रेड सुरक्षित डेटाबेस है। इससे जो मुख्य असुविधा उत्पन्न होती है, वह Realm.Object के ऑब्जेक्ट को एक थ्रेड से दूसरे में ट्रांसफर करने में असमर्थता है।

कोड:

 DispatchQueue.global(qos: .background).async { let objects = yourObjectDAO.read(by: key) DispatchQueue.main.sync { print(objects) } } 

यह एक त्रुटि देगा:

 Terminating app due to uncaught exception 'RLMException', reason: 'Realm accessed from incorrect thread.' 

बेशक, आप हर समय एक थ्रेड में ऑब्जेक्ट के साथ काम कर सकते हैं, लेकिन वास्तव में यह कुछ मुश्किलें पैदा करता है जो बेहतर है कि इसे दरकिनार किया जाए।

समाधान के लिए, यह Realm.Object को उन संरचनाओं में परिवर्तित करने के लिए "सुविधाजनक" है जो चुपचाप विभिन्न थ्रेड्स के बीच स्थानांतरित हो जाएंगे।

क्षेत्र वस्तु:

 final class BirdObj: Object { @objc dynamic var id: String = "" @objc dynamic var name: String = "" override static func primaryKey() -> String? { return "id" } } 

संरचना:

 struct Bird { var id: String var name: String } 

वस्तुओं को संरचनाओं में बदलने के लिए, हम प्रोटोकॉल कार्यान्वयन का उपयोग करेंगे
अनुवादक:

 protocol Translator { func toObject(with any: Any) -> Object func toAny(with object: Object) -> Any } 

बर्ड के लिए, यह इस तरह दिखेगा:

 final class BirdTranslator: Translator { func toObject(with any: Any) -> Object { let any = any as! Bird let object = BirdObj() object.id = any.id object.name = any.name return object } func toAny(with object: Object) -> Any { let object = object as! BirdObj return Bird(id: object.id, name: object.name) } } 

अब यह डीएओ को थोड़ा बदलने के लिए बना हुआ है ताकि यह संरचनाओं को स्वीकार करे और वापस लौटे, न कि दायरे की वस्तुओं को।

 struct DAO<O: Object> { private let translator: Translator init(translator: Translator) { self.translator = translator } func persist(with any: Any) { guard let realm = try? Realm() else { return } let object = translator.toObject(with: any) try? realm.write { realm.add(object, update: .all) } } func read(by key: String) -> Any? { guard let realm = try? Realm() else { return nil } if let object = realm.object(ofType: O.self, forPrimaryKey: key) { return translator.toAny(with: object) } else { return nil } } } 

समस्या हल होती दिख रही है। अब DAO एक बर्ड संरचना लौटाएगा जो कि धागों के बीच स्वतंत्र रूप से स्थानांतरित की जा सकती है।

 let birdDAO = DAO<BirdObj>(translator: BirdTranslator()) DispatchQueue.global(qos: .background).async { let bird = birdDAO.read(by: key) DispatchQueue.main.sync { print(bird) } } 

एक ही प्रकार के कोड की एक बड़ी राशि।

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

प्रत्येक इकाई के लिए कोड हमेशा, सार में, समान होता है। इसमें अंतर केवल संरचनाओं के क्षेत्रों पर निर्भर करता है।

आप ऑटो-जनरेशन लिख सकते हैं, जो प्रत्येक के लिए Realm.Object और Translator जारी करके हमारी संरचनाओं को पार्स कर देगा। खट्टा इसमें मदद कर सकता है। इसकी मदद से मॉकिंग के बारे में पहले से ही हैबर पर एक लेख था।

इस उपकरण को पर्याप्त स्तर पर महारत हासिल करने के लिए, मेरे पास खाके का टेम्प्लेट टैग और फिल्टर स्टैंसिल (जिसके आधार पर सूर्चरी बनाई गई थी) और डॉक्यूमेंटेशन का पर्याप्त विवरण था।

हमारे विशिष्ट उदाहरण में, Realm.Object की पीढ़ी इस तरह दिख सकती है:

 import Foundation import RealmSwift #1 {% for type in types.structs %} #2 final class {{ type.name }}Obj: Object { #3 {% for variable in type.storedVariables %} {% if variable.typeName.name == "String" %} @objc dynamic var {{variable.name}}: String = "" {% endif %} {% endfor %} override static func primaryKey() -> String? { return "id" } } {% endfor %} 

# 1 - हम सभी संरचनाओं से गुजरते हैं।
# 2 - प्रत्येक के लिए, हम अपने स्वयं के इनहेरीटर क्लास ऑब्जेक्ट बनाते हैं।
# 3 - टाइप नाम वाले प्रत्येक क्षेत्र के लिए == स्ट्रिंग, एक ही नाम और प्रकार के साथ एक चर बनाएं। यहां आप आदिमों के लिए कोड जोड़ सकते हैं जैसे Int, Date, और अधिक जटिल। मुझे लगता है कि सार स्पष्ट है।

Translator जनरेट करने का कोड समान दिखता है।

 {% for type in types.structs %} final class {{ type.name }}Translator: Translator { func toObject(with entity: Any) -> Object { let entity = entity as! {{ type.name }} let object = {{ type.name }}Obj() {% for variable in type.storedVariables %} object.{{variable.name}} = entity.{{variable.name}} {% endfor %} return object } func toAny(with object: Object) -> Any { let object = object as! {{ type.name }}Obj return Bird( {% for variable in type.storedVariables %} {{variable.name}}: object.{{variable.name}}{%if not forloop.last%},{%endif%} {% endfor %} ) } } {% endfor %} 

निर्भरता प्रबंधक के माध्यम से सॉरीरी को स्थापित करना सबसे अच्छा है, संस्करण को इंगित करता है ताकि आप जो लिखते हैं वह सभी के लिए उसी तरह काम करता है और टूटता नहीं है।

स्थापना के बाद, बिल्डपेज़ प्रोजेक्ट में इसे चलाने के लिए हमारे पास बैश कोड की एक पंक्ति लिखना शेष है। आपके प्रोजेक्ट की फ़ाइलें संकलित करने से पहले इसे जेनरेट किया जाना चाहिए।

निष्कर्ष

मैंने जो उदाहरण दिया वह बहुत सरल था। यह स्पष्ट है कि बड़ी परियोजनाओं में,। पेंसिल जैसी फाइलें बहुत बड़ी होंगी। मेरी परियोजना में, वे 200 से कम लाइनों पर कब्जा कर लेते हैं, जबकि 4000 उत्पन्न करते हैं और अन्य बातों के अलावा, दायरे में बहुरूपता की संभावना।
सामान्य तौर पर, मैंने कुछ वस्तुओं को दूसरों को बदलने के कारण देरी का सामना नहीं किया।
मुझे किसी भी प्रतिक्रिया और आलोचना पर खुशी होगी।

संदर्भ

दायरे का तेज
खट्टी गीठब
खट्टे दस्तावेज
स्टैंसिल अंतर्निर्मित टेम्प्लेट टैग और फ़िल्टर
सॉकरी के साथ स्विफ्ट में मॉकिंग
दायरे और स्विफ्ट का उपयोग करके एक टूडू एप्लिकेशन बनाना