मोबाइल एप्लिकेशन डेटा प्रबंधन

Question

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

पहले प्रक्षेपण:
1. प्राप्त सर्वर डेटा के लिए निम्न चरणों मैं इस के लिए कर रहा हूँ कर रहे हैं।
2. स्क्लाइट डेटाबेस में सर्वर डेटा सहेजें।
3. स्क्लाइट डेटा दिखाएं।

अगला लॉन्च:
1. स्क्लाइट डेटा दिखाएं।
2. पृष्ठभूमि में सर्वर डेटा प्राप्त करें।
3. पिछले SQLite डेटा हटाएं।
4. स्क्लाइट डेटाबेस में नया सर्वर डेटा सहेजें।
5. स्क्लाइट डेटा दिखाएं।
1. यह सही दृष्टिकोण है:

मैंने ये चरण पर सवाल की जोड़ी है? अन्य तरीका सर्वर से हर बार डेटा दिखा रहा है लेकिन वह तुरंत स्क्रीन पर डेटा प्रदर्शित नहीं करेगा (इंटरनेट की गति के आधार पर)।
2. मैंने नए सर्वर डेटा के साथ Sqlite डेटा की तुलना करने का भी सोचा। लेकिन एक बड़ी चुनौती का सामना करना पड़ा। नए सर्वर डेटा में नए रिकॉर्ड या हटाए गए रिकॉर्ड हो सकते हैं। साथ ही, मुझे JSON डेटा के साथ प्रत्येक डेटाबेस फ़ील्ड की तुलना करने के लिए उचित दृष्टिकोण नहीं मिला।
तो नए सर्वर डेटा के साथ स्थानीय Sqlite डेटा की तुलना करने के लिए सबसे अच्छा तरीका क्या है?
3. प्रत्येक बार जब मैं Sqlite डेटा हटा देता हूं और नया डेटा डालता हूं और फिर स्क्रीन को रीफ्रेश करता हूं (जिसमें UITableView है), यह एक दूसरे के लिए स्पष्ट है जो स्पष्ट है। यदि चरण 3, 4, 5 का पालन किया जाता है तो इस समस्या से कैसे बचें?
4. यदि मैं प्रत्येक बार स्क्रीन पर वापस आ जाता हूं या जब एप्लिकेशन सक्रिय हो जाता है तो मैं डेटा अपडेट के साथ कैसे आगे बढ़ना चाहिए? मुझे इस मामले के लिए NSOperationQueues या GCD का बहुत उपयोग है। लेकिन क्या होगा यदि मैं पागल हूं और स्क्रीन पर बार-बार स्क्रीन पर जाता हूं। कतार में NSOperations की संख्या होगी।

Answer 1

सर्वर डेटा सिंक्रनाइज़ करना एक चुनौती है, मैंने पहले ऐसा किया है, और यदि आप उस पर समय बिता सकते हैं तो मैं कहूंगा कि यह सबसे अच्छा समाधान है।

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

यदि डेटा केवल सर्वर में बदला जाता है तो यह आसान होता है, जब ऐप डेटा भी बदल सकता है तो यह अधिक जटिल हो जाता है (लेकिन ऐसा लगता है कि यह आपका मामला नहीं है)। यह भी निर्भर करता है कि डेटाबेस कितना जटिल है।

यदि आप ऐसा करने में कुछ समय निवेश नहीं करना चाहते हैं, तो हर बार सभी डेटा लाने पर भी काम करता है, भले ही यह आदर्श न हो! पुराने डेटा को दिखाने और इसे झपकी देने के बजाए, जब आप नया डेटा प्राप्त करते हैं, तो आप प्रवेश करते समय उपयोगकर्ता को 2-3 सेकंड प्रतीक्षा कर सकते हैं।या इसके बजाय आप ऐप शुरू करते समय केवल डेटा ला सकते हैं, और इसलिए जब आप उस व्यू कंट्रोलर पर जाते हैं तो यह पहले से ही तैयार हो जाएगा।

यह एक जटिल समस्या यह है कि हर किसी को कुछ बिंदु पर का सामना कर रहा है, इसलिए मैं यह देखने के लिए कि क्या अन्य लोगों का सुझाव देगा उत्सुक हूँ है :)

Answer 2

कैसे इस बारे में:

1. डेटा SqlLite में मौजूद है, लोड में "में स्मृति" कॉपी और यह दिखाने के
2. पृष्ठभूमि लोड नया सर्वर डेटा
3. यदि वह मौजूद पुराने SQLite डेटा को हटाने (ध्यान दें कि इन-स्मृति प्रतिलिपि रहता है)
4. नए सर्वर Dat बचाने में एक sqlite
5. नए स्क्लाइट डेटा को "इन-मेमोरी" प्रतिलिपि में लोड करें और इसे दिखाएं।

कोई डेटा चरण 1 में मिला था, तो चरण 2.

मैं इस धारणा बना रही हूँ कि SqlLite से डेटा काफी छोटा एक प्रति रखना है के दौरान उपयोगकर्ता के लिए एक "लोड हो रहा" स्क्रीन प्रदर्शित आपके यूआईटीबल दृश्य में दिखाने के लिए स्मृति में (यूआईटीबल दृश्य हमेशा इन-मेमोरी से डेटा दिखाएगा)।

चरण 4 और 5 को गठबंधन करना संभव हो सकता है यदि डेटा एक ही समय में दो प्रतियों को स्मृति में रखने के लिए पर्याप्त छोटा है (आप एक नई इन-मेमोरी प्रतिलिपि बनायेंगे और पूर्ण होने पर दृश्य प्रतिलिपि के साथ स्वैप करेंगे)।

नोट: मैं यहां त्रुटि प्रबंधन के बारे में बात नहीं करता हूं, लेकिन मैं सुझाव दूंगा कि जब तक आपके पास इसे बदलने के लिए नया डेटा न हो तब तक आप स्क्लाइट डेटा को हटा नहीं देते।

यह दृष्टिकोण यह निर्धारित करने की आवश्यकता को भी समाप्त करता है कि यह पहला लॉन्च है या नहीं। तर्क हमेशा वही रहता है जो इसे लागू करने के लिए थोड़ा आसान बनाना चाहिए।

आशा है कि यह उपयोगी है।

Answer 3

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

स्रोत: MultiVersion Concurrency Control

Answer 4

यह एक अच्छा सवाल है।

मैं व्यक्तिगत रूप से डेटा डाउनलोड करना, स्थानीय रूप से स्टोर करना और बाद में सिंक करने का प्रयास करना एक खतरनाक परिदृश्य है।

1.:> गुलाम मुद्दों (क्या डेटा गुरु होना चाहिए, कई उपकरणों का इस्तेमाल किया आदि किया जाएगा अगर)

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

2. हर दृष्टि से सर्वर से डेटा को फिर से लोड करने की आवश्यकता से निपटना, बस स्मृति में वस्तुओं (SqlLite का उपयोग नहीं) के रूप में डाउनलोड की गई डेटा भंडारण के द्वारा किया जा सकता है।दृश्य आपके कैश मैनेजर को आवश्यक डेटा को लोड करने का प्रयास करेगा, और यदि उपलब्ध हो तो यह स्मृति से इसकी सेवा करेगा। यदि स्मृति में नहीं है तो बस अपने सर्वर से डेटा प्राप्त करें और इसे अपने मेमोरी कैश में जोड़ें। मेमोरी कैश कैश प्रबंधन/भंडारण और डेटा लोडिंग को लपेटने के लिए AppDelegate, या कुछ वैश्विक "सिंगेलटन" पर संग्रहीत Dictionary को लपेटने वाला घर बनाया गया डेटा मैनेजर हो सकता है।

3. आलसी लोड डेटा और मेमोरी कैश आप बनाने के लिए की आवश्यकता होगी के साथ यकीन है कि किसी भी अद्यतन (परिवर्तन, नए रिकॉर्ड, नष्ट कर दिया रिकॉर्ड) अपनी स्मृति डाटा मॉडल, साथ ही सर्वर के लिए इन परिवर्तनों को धक्का अद्यतन करता है जैसे ही मुमकिन। डेटा आकार इत्यादि के आधार पर आप उपयोगकर्ता को प्रतीक्षा करने के लिए मजबूर कर सकते हैं, या पृष्ठभूमि प्रक्रिया के रूप में इसे सीधे कर सकते हैं।

4. यह सुनिश्चित करने के लिए कि डेटा सिंक हो रहा है, आपको यह सुनिश्चित करना चाहिए कि आप समय-समय पर कैश में स्थानीय मेमोरी रिकॉर्ड्स को अमान्य (हटाएं) और सर्वर से डेटा अपडेट को मजबूर कर दें। सबसे अच्छा तरीका शायद स्मृति कैश में प्रत्येक रिकॉर्ड के लिए अंतिम अद्यतन टाइमस्टैम्प होगा। इसलिए आवधिक अमान्यता केवल स्मृति कैश से "पुराने रिकॉर्ड" को हटा देगी (एक बार फिर सर्वर से नहीं)।

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

5. डेटा आकार के आधार पर आपको "कैश अमान्यता" को देखने की आवश्यकता हो सकती है। जब एक्सएक्स रिकॉर्ड्स संग्रहीत किए जाते हैं, उतना आसान हो सकता है, पुरानी ऑब्जेक्ट्स को मेमोरी कैश से हटा देना शुरू करें (सर्वर नहीं, केवल स्थानीय डिवाइस पर)।

6. यदि डेटा सिंक बिल्कुल महत्वपूर्ण है तो आप रिकॉर्ड के लिए अपनी मेमोरी कैश को रीफ्रेश करना चाहते हैं, बस उपयोगकर्ता को डेटा बदलने की अनुमति देने से पहले। जैसे जब उपयोगकर्ता "संपादन" या इसी तरह के टैप करता है, तो आप उस रिकॉर्ड के लिए सर्वर से नवीनतम डेटा लेते हैं।

मेरे उस पर ले - यह सिर्फ यकीन है कि उपयोगकर्ता एक रिकार्ड पुराना डेटा और इस तरह गलती से रिमोट किए गए परिवर्तनों अधिभावी का उपयोग कर अद्यतन करने के लिए नहीं जा रहा है, या किसी अन्य उपकरण आदि

पर बनाने के लिए है। मुझे विश्वास नहीं है कि ऐसा करने के लिए एक "सही सही तरीका" है। लेकिन यह वही होगा जो मैं करने की कोशिश करता हूं।

आशा है कि यह कुछ विचारों और प्रेरणा के साथ मदद करेगा।

अपने दृष्टिकोण में