🚡 🔡 👦🏾 रेडिस बेस्ट प्रैक्टिस, भाग 2 🦔 👨🏿‍⚕️ 🚵🏽

रेडिस लैब्स से रेडिस बेस्ट प्रैक्टिस ट्रांसलेशन चक्र का दूसरा हिस्सा है, और यह इंटरेक्शन पैटर्न और डेटा स्टोरेज पैटर्न पर चर्चा करता है।

पहला भाग यहाँ है ।

सहभागिता पैटर्न

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

घटनाओं की कतार;
रेडलॉक के साथ अवरुद्ध;
पब / उप;
वितरित कार्यक्रम।

घटना कतार

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

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

#	ग्राहक 1	ग्राहक २
1		`> BRPOP my-q 0` [मूल्य की उम्मीद]
2	`> LPUSH my-q hello (integer) 1`	`1) "my-q" 2) "hello"` [ग्राहक खुला, आज्ञा मानने के लिए तैयार]
3		`> BRPOP my-q 0` [मूल्य की उम्मीद]

इस उदाहरण में, चरण 1 में, हम देखते हैं कि अवरुद्ध क्लाइंट तुरंत कुछ भी वापस नहीं करता है, क्योंकि इसमें कुछ भी शामिल नहीं है। अंतिम तर्क प्रतीक्षा समय है। यहाँ 0 का अर्थ है अनन्त अपेक्षा। दूसरी पंक्ति में , एक मान my-q में दर्ज किया गया है , और पहला क्लाइंट तुरंत अवरुद्ध स्थिति से बाहर निकलता है। तीसरी पंक्ति पर, बीआरपीओपी को फिर से कहा जाता है (आप आवेदन में लूप में ऐसा कर सकते हैं), और ग्राहक भी अगले मूल्य की प्रतीक्षा करता है। "Ctrl + C" दबाकर आप लॉक को तोड़ सकते हैं और क्लाइंट से बाहर निकल सकते हैं।

चलो उदाहरण को उलटते हैं और देखते हैं कि BRPOP एक गैर-रिक्त सूची के साथ कैसे काम करता है:


> LPUSH my-q hello
(integer) 1
> LPUSH my-q hej
(integer) 2
> LPUSH my-q bonjour
(integer) 3
> BRPOP my-q 0
1) "my-q"
2) "hello"
> BRPOP my-q 0
1) "my-q"
2) "hej"
> BRPOP my-q 0
1) "my-q"
2) "bonjour"
> BRPOP my-q 0

#	ग्राहक 1	ग्राहक २
1	`> LPUSH my-q hello (integer) 1`
2	`> LPUSH my-q hej (integer) 2`
3	`> LPUSH my-q bonjour (integer) 3`
4		`> BRPOP my-q 0 1) "my-q" 2) "hello"`
5		`> BRPOP my-q 0 1) "my-q" 2) "hej"`
6		`> BRPOP my-q 0 1) "my-q" 2) "bonjour"`
7		`> BRPOP my-q 0` [मूल्य की उम्मीद]

चरण 1-3 में, हम सूची में 3 मान जोड़ते हैं और देखते हैं कि उत्तर बढ़ता है, सूची में तत्वों की संख्या को दर्शाता है। चरण 4, BRPOP को कॉल करने के बावजूद, तुरंत मूल्य लौटाता है। ऐसा इसलिए है क्योंकि अवरुद्ध व्यवहार केवल तब होता है जब कतार में कोई मान नहीं होते हैं। हम 5-6 चरणों में एक ही त्वरित प्रतिक्रिया देख सकते हैं क्योंकि यह कतार में प्रत्येक आइटम के लिए किया जाता है। चरण 7 में, BRPOP कतार में कुछ भी नहीं ढूंढता है और क्लाइंट को तब तक ब्लॉक करता है जब तक कुछ जोड़ा नहीं जाता है।

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

#	ग्राहक 1	ग्राहक २
1		`> LINDEX worker-q 0 (nil)`
2		[यदि परिणाम शून्य नहीं है, तो किसी तरह इसे संसाधित करें और चरण 4 पर जाएं]
3		`> LREM worker-q -1 [ 1] (integer) 1` [चरण 1 पर लौटें]
4		`> BRPOPLPUSH my-q worker-q 0` [मूल्य की उम्मीद]
5	`> LPUSH my-q hello`	`"hello"` [ग्राहक खुला, आज्ञा मानने के लिए तैयार]
6		[संभालो]
7		`> LREM worker-q -1 hello (integer) 1`
8		[चरण 1 पर लौटें]

1-2 चरणों में, हम कुछ भी नहीं करते हैं, क्योंकि कार्यकर्ता-क्यू खाली है। यदि कुछ वापस आ गया है, तो हम इसे संसाधित करते हैं और इसे हटाते हैं, और फिर से चरण 1 पर वापस लौटते हैं कि क्या कुछ कतार में मिला है। इस प्रकार, हम पहले कार्यकर्ता की कतार को साफ़ करते हैं और मौजूदा कार्य करते हैं। चरण 4 में, हम प्रतीक्षा करते हैं जब तक कि मूल्य मेरी-क्यू में प्रकट नहीं होता है , और जब यह होता है, तो इसे कार्यकर्ता-क्यू में स्थानांतरित कर दिया जाता है । फिर हम किसी तरह "हैलो" की प्रक्रिया करते हैं , उसके बाद हम इसे कार्यकर्ता-क्यू से हटाते हैं और चरण 1 पर लौटते हैं। यदि प्रक्रिया चरण 6 में मर जाती है, तो मूल्य अभी भी कार्यकर्ता-क्यू में रहता है । प्रक्रिया को पुनरारंभ करने के बाद, हम चरण 7 में हटाए गए सभी चीजों को तुरंत हटा देंगे।

यह पैटर्न नौकरी के नुकसान की संभावना को काफी कम कर देता है, लेकिन केवल अगर कार्यकर्ता चरण 2 और 3 या 5 और 6 के बीच मर जाता है, जो कि संभावना नहीं है, लेकिन सबसे अच्छा अभ्यास कार्यकर्ता के तर्क में इसे ध्यान में रखेगा।

रेडलॉक के साथ लॉक करें

कभी-कभी सिस्टम में कुछ संसाधन को ब्लॉक करना आवश्यक होता है। प्रतिस्पर्धी वातावरण में हल नहीं किए जा सकने वाले महत्वपूर्ण परिवर्तनों को लागू करने के लिए यह आवश्यक हो सकता है। अवरोधक उद्देश्य:

संसाधन पर कब्जा करने के लिए एक और केवल एक कार्यकर्ता को अनुमति दें;
लॉक ऑब्जेक्ट को मज़बूती से रिलीज़ करने में सक्षम होना;
संसाधन को कसकर लॉक न करें (निश्चित अवधि के बाद अनलॉक होना चाहिए)।

रेडिस ब्लॉकिंग को लागू करने के लिए एक अच्छा विकल्प है, क्योंकि इसमें एक सरल कुंजी-आधारित डेटा मॉडल है, और प्रत्येक शार्क एकल-थ्रेडेड और काफी तेज है। Redlock नामक Redis का उपयोग करते हुए एक उत्कृष्ट लॉक कार्यान्वयन है।
Redlock क्लाइंट लगभग हर भाषा के लिए उपलब्ध हैं, हालाँकि, यह जानना महत्वपूर्ण है कि Redlock सुरक्षित और प्रभावी रूप से उपयोग करने के लिए कैसे काम करता है।

सबसे पहले, आपको यह समझने की आवश्यकता है कि Redlock को कम से कम 3 मशीनों पर चलने के लिए डिज़ाइन किया गया है जिसमें स्वतंत्र Redis इंस्टेंसेस हैं। यह आपके लॉकिंग तंत्र में विफलता के एकल बिंदु को समाप्त करता है, जिससे सभी संसाधनों का गतिरोध हो सकता है। समझने के लिए एक और बिंदु यह है कि यद्यपि मशीनों पर घड़ियों को 100% सिंक्रनाइज़ नहीं किया जाना चाहिए, उन्हें उसी तरह कार्य करना चाहिए - समय समान गति से चलता है: मशीन पर एक सेकंड और मशीन बी पर एक सेकंड।

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

लॉक ऑब्जेक्ट को मुक्त करने के लिए, एक लुआ स्क्रिप्ट का उपयोग करना बेहतर होता है जो यह जांच करेगा कि क्या कुंजी के सेट में अपेक्षित यादृच्छिक मूल्य है या नहीं। अगर वहाँ है, तो आप इसे हटा सकते हैं, अन्यथा चाबियों को छोड़ना बेहतर है, क्योंकि ये नए लॉक ऑब्जेक्ट हो सकते हैं।

if redis.call("get",KEYS[1]) == ARGV[1] then
    return redis.call("del",KEYS[1])
else
    return 0
end

रेडलॉक प्रक्रिया अच्छी गारंटी प्रदान करती है और विफलता का एक भी बिंदु नहीं है, इसलिए आप पूरी तरह से सुनिश्चित हो सकते हैं कि एकल लॉक ऑब्जेक्ट वितरित किए जाएंगे और कोई भी पारस्परिक लॉक नहीं होगा।

पब / उप

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

आप एक से अधिक चैनलों की सदस्यता ले सकते हैं। हम SUBSCRIBE कमांड का उपयोग करके दो मौसम और खेल चैनलों की सदस्यता से शुरू करते हैं:

> SUBSCRIBE weather sports
Reading messages... (press Ctrl-C to quit)
1) "subscribe"
2) "weather"
3) (integer) 1
1) "subscribe"
2) "sports"
3) (integer) 2

एक अलग क्लाइंट (उदाहरण के लिए एक और टर्मिनल विंडो) में, हम इनमें से किसी भी चैनल में सार्वजनिक कमांड का उपयोग करके संदेश प्रकाशित कर सकते हैं:

> PUBLISH sports oilers/7:leafs/1
(integer) 1

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

1) "message"
2) "sports"
3) "oilers/7:leafs/1"

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

प्रकाशक के पास लौटकर, हम एक और संदेश पोस्ट कर सकते हैं:

> PUBLISH weather snow/-4c
(integer) 1

ग्राहक में हम एक ही प्रारूप देखेंगे, लेकिन संदेश के साथ एक अलग चैनल के साथ:

1) "message"
2) "weather"
3) "snow/-4c"

आइए एक चैनल पर एक संदेश पोस्ट करें जहां ग्राहक नहीं हैं:

> PUBLISH currency CADUSD/0.787
(integer) 0

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

एकल चैनल की सदस्यता लेने के अलावा, Redis मास्क द्वारा चैनलों की सदस्यता लेने की अनुमति देता है। ग्लोब-स्टाइल मास्क को PSUBSCRIBE कमांड में दिया गया है:

> PSUBSCRIBE sports:*

क्लाइंट को सभी चैनलों से संदेश प्राप्त होंगे, जो खेल से शुरू होते हैं :। किसी अन्य क्लाइंट में, निम्न आदेशों को कॉल करें:

> PUBLISH sports:hockey oilers/7:leafs/1
(integer) 1
> PUBLISH sports:basketball raptors/33:pacers/7
(integer) 1
> PUBLISH weather:edmonton snow/-4c
(integer) 0

कृपया ध्यान दें कि पहली दो टीमें 1 पर लौटती हैं, जबकि अंतिम 0. पर लौटती है और यद्यपि हम सीधे खेल के लिए सब्सक्राइब नहीं किए जाते हैं : हॉकी या खेल: बास्केटबॉल , ग्राहक मास्क द्वारा सदस्यता के माध्यम से संदेश प्राप्त करता है। क्लाइंट-सब्सक्राइबर विंडो में, हम देख सकते हैं कि केवल मास्क मिलान करने वाले चैनलों के लिए परिणाम हैं।

1) "pmessage"
2) "sports:*"
3) "sports:hockey"
4) "oilers/7:leafs/1"
1) "pmessage"
2) "sports:*"
3) "sports:basketball"
4) "raptors/33:pacers/7"

यह आउटपुट SUBSCRIBE कमांड के आउटपुट से थोड़ा अलग है क्योंकि इसमें मास्क ही होता है, साथ ही चैनल का असली नाम भी होता है।

वितरित कार्यक्रम

दिलचस्प वितरित घटनाओं को बनाने के लिए रेडिस की पब / उप संदेश योजना का विस्तार किया जा सकता है। मान लीजिए कि हमारे पास एक संरचना है जिसे हैश तालिका में संग्रहीत किया गया है, लेकिन हम ग्राहकों को केवल तभी अपडेट करना चाहते हैं जब एक एकल क्षेत्र ग्राहक द्वारा निर्धारित संख्यात्मक मान से अधिक हो। हम मुखौटा द्वारा चैनलों को सुनेंगे और हैश को स्थिति में निकालेंगे । इस उदाहरण में, हम 5-9 मानों के साथ update_status में रुचि रखते हैं ।

> PSUBSCRIBE update_status:[5-9]
1) "psubscribe"
2) "update_status:[5-9]"
3) (integer) 1
...

स्थिति / error_level मान को बदलने के लिए , हमें दो आदेशों की आवश्यकता होती है जिन्हें क्रमिक रूप से या MULTI / MEC ब्लॉक में निष्पादित किया जा सकता है। पहला कमांड स्तर सेट करता है, और दूसरा एक अधिसूचना प्रकाशित करता है, जिसके साथ ही चैनल में इनकोड किया गया मान होता है।

> HSET status error_level 5
(integer) 1
> PUBLISH update_status:5 0
(integer) 1

पहली विंडो में, हम देखते हैं कि संदेश प्राप्त हो गया है, और उसके बाद आप किसी अन्य क्लाइंट पर स्विच कर सकते हैं और HGETALL कमांड को कॉल कर सकते हैं:

...
1) "pmessage"
2) "update_status:[5-9]"
3) "update_status:5"
4) "0"

> HGETALL status
1) "error_level"
2) "5"

हम कुछ लंबी प्रक्रिया के स्थानीय चर को अपडेट करने के लिए भी इस विधि का उपयोग कर सकते हैं। यह वास्तविक समय में डेटा का आदान-प्रदान करने के लिए एक ही प्रक्रिया के कई उदाहरणों की अनुमति दे सकता है।

पब / सब का उपयोग करने से यह पैटर्न बेहतर क्यों है? जब प्रक्रिया फिर से शुरू होती है, तो यह पूरे राज्य को प्राप्त कर सकता है और सुनना शुरू कर सकता है। किसी भी संख्या में प्रक्रियाओं के बीच परिवर्तन को सिंक्रनाइज़ किया जाएगा।

डेटा भंडारण पैटर्न

रेडिस में संरचित डेटा संग्रहीत करने के लिए कई पैटर्न हैं। इस अध्याय में हम निम्नलिखित पर विचार करेंगे:

JSON में डेटा स्टोरेज;
भंडारण - सुविधाएँ।

JSON डेटा संग्रहण

Redis में JSON डेटा संग्रहीत करने के लिए कई विकल्प हैं। सबसे सामान्य रूप वस्तु को पहले से क्रमबद्ध करना और एक विशेष कुंजी के तहत सहेजना है:

> SET car "{\"colour\":\"blue\",\"make\":\"saab\",\"model\":93,\"features\":[\"powerlocks\",\"moonroof\"]}"
OK
> GET car
"{\"colour\":\"blue\",\"make\":\"saab\",\"model\":93,\"features\":[\"powerlocks\",\"moonroof\"]}"

यह सरल प्रतीत होता है, लेकिन इसमें कुछ बहुत ही गंभीर कमियां हैं:

क्रमांकन पढ़ने और लिखने के लिए क्लाइंट कंप्यूटिंग संसाधनों को लेता है;
JSON प्रारूप डेटा का आकार बढ़ाता है;
रेडिस के पास JSON में डेटा को संभालने का केवल एक अप्रत्यक्ष तरीका है।

डेटा की छोटी मात्रा पर अंकों की पहली जोड़ी नगण्य हो सकती है, लेकिन जैसे-जैसे डेटा बढ़ता है, लागत बढ़ेगी। हालांकि, तीसरा बिंदु सबसे महत्वपूर्ण है।

Redis 4.0 से पहले, Redis के अंदर JSON के साथ काम करने का एकमात्र तरीका cjson मॉड्यूल में एक Lua स्क्रिप्ट का उपयोग करना था। इसने आंशिक रूप से समस्या को हल किया, हालांकि यह अभी भी एक अड़चन बना रहा और लुआ को सीखने के साथ अतिरिक्त परेशानी पैदा की। इसके अलावा, कई अनुप्रयोगों को संपूर्ण JSON स्ट्रिंग प्राप्त हुई, इसे deserialized किया, डेटा के साथ काम किया, वापस serialized किया, और इसे फिर से सहेजा। यह एक एंटीपैटर्न है। इस तरह से डेटा खोने का एक बड़ा जोखिम है।


> GET my-car
> GET my-car
> SET my-car
> SET my-car
> GET my-car

#	आवेदन उदाहरण # 1	आवेदन उदाहरण # 2
1	`> GET my-car`
2	[deserialize, मशीन रंग बदलें और फिर से क्रमबद्ध करें]	`> GET my-car`
3	`> SET my-car` [उदाहरण # 1 से नया मूल्य]	[deserialize, मशीन मॉडल बदलें और फिर से क्रमबद्ध करें]
4		`> SET my-car` [उदाहरण # 2 से नया मूल्य]
5		`> GET my-car`

लाइन 5 पर परिणाम केवल उदाहरण 2 में परिवर्तन दिखाएगा, और उदाहरण 1 से रंग परिवर्तन खो जाएगा।

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

ReJSON का उपयोग करने के लिए, आपको इसे Redis सर्वर पर स्थापित करना होगा या इसे Redis Enterprise में सक्षम करना होगा।

रेजसन का उपयोग करने वाला पिछला उदाहरण इस तरह दिखेगा:

# आवेदन उदाहरण # 1 आवेदन उदाहरण # 2

#	आवेदन उदाहरण # 1	आवेदन उदाहरण # 2
1	`> JSON.SET car2 . '{"colour": "blue", "make":"saab", "model":93, "features": ["powerlocks", "moonroof"]}‘ OK`
2	`> JSON.SET car2 colour '"red"' OK`
3		`> JSON.SET car2 model '95' OK > JSON.GET car2 . "{\"colour\":\"red",\"make\":\"saab\",\"model\":95,\"features\":[\"powerlocks\",\"moonroof\"]}"`

> JSON.SET car2 . '{"colour": "blue",  "make":"saab", "model":93,  "features": ["powerlocks",  "moonroof"]}‘
OK

> JSON.SET car2 colour '"red"'
OK

> JSON.SET car2 model '95'
OK
> JSON.GET car2 .
"{\"colour\":\"red",\"make\":\"saab\",\"model\":95,\"features\":[\"powerlocks\",\"moonroof\"]}"

ReJSON रेडिस में JSON डेटा के साथ काम करने के लिए एक सुरक्षित, तेज और अधिक सहज तरीका प्रदान करता है, खासकर उन मामलों में जहां नेस्टेड तत्वों के लिए परमाणु परिवर्तन आवश्यक हैं।

वस्तु संग्रहण

पहली नज़र में, मानक Redis "हैश टेबल" डेटा प्रकार बहुत JSON ऑब्जेक्ट या अन्य प्रकार के समान लग सकता है। खेतों को या तो एक स्ट्रिंग या एक संख्या बनाना और नेस्टेड संरचनाओं को रोकना बहुत आसान है। हालांकि, प्रत्येक क्षेत्र के लिए "पथ" की गणना करने के बाद, आप ऑब्जेक्ट को "समतल" कर सकते हैं और इसे रेडिस हैश तालिका में सहेज सकते हैं।

{
    "colour": "blue",
    "make": "saab",
    "model": {
        "trim": "aero",
        "name": 93
    },
    "features": ["powerlocks", "moonroof"]
}

JSONPath (JSON के लिए XPath) का उपयोग करते हुए , हम हैश तालिका के समान स्तर पर प्रत्येक तत्व का प्रतिनिधित्व कर सकते हैं:

> HSET car3 colour blue
> HSET car3 make saab
> HSET car3 model.trim aero
> HSET car3 model.name 93
> HSET car3 features[0] powerlocks
> HSET car3 features[1] moonroof

स्पष्टता के लिए, आदेशों को अलग से सूचीबद्ध किया गया है, लेकिन एचएसईटी के लिए कई मापदंडों को पारित किया जा सकता है।

अब आप संपूर्ण वस्तु या उसके व्यक्तिगत क्षेत्र का अनुरोध कर सकते हैं:

> HGETALL car3
 1) "colour"
 2) "blue"
 3) "make"
 4) "saab"
 5) "model.trim"
 6) "aero"
 7) "model.name"
 8) "93"
 9) "features[0]"
10) "powerlocks"
11) "features[1]"
12) "moonroof"

> HGET car3 model.trim
"aero"

हालांकि यह रेडिस में संग्रहीत वस्तु को पुनः प्राप्त करने का एक त्वरित और उपयोगी तरीका प्रदान करता है, इसकी कमियां हैं:

विभिन्न भाषाओं और पुस्तकालयों में, JSONPath का कार्यान्वयन अलग हो सकता है, जिससे असंगति हो सकती है। इस मामले में, यह एक उपकरण के साथ डेटा को क्रमबद्ध और deserializing के लायक है;
सरणी समर्थन:
- विरल सरणियों की समस्या हो सकती है;
- कई ऑपरेशन करना असंभव है, जैसे कि एक सरणी के बीच में एक तत्व सम्मिलित करना।
JSONPath कुंजियों में अनावश्यक संसाधन की खपत।

यह पैटर्न बहुत हद तक ReJSON जैसा है। यदि ReJSON उपलब्ध है, तो ज्यादातर मामलों में इसका उपयोग करना बेहतर है। हालांकि, उपरोक्त तरीके से वस्तुओं को संग्रहीत करने से रेजसन पर एक फायदा होता है: रेडिस SORT टीम के साथ एकीकरण। हालांकि, यह कमांड कम्प्यूटेशनल रूप से जटिल है और इस पैटर्न के दायरे से परे एक अलग जटिल विषय है।

अगला समापन खंड समय श्रृंखला पैटर्न, गति सीमा पैटर्न, ब्लूम फ़िल्टर पैटर्न, काउंटर और रेडिस में लुआ के उपयोग को कवर करेगा।

PS मैंने इन लेखों के पाठ को "बर्बर" अंग्रेजी में यथासंभव रूसी में रूपांतरित करने का प्रयास किया, लेकिन अगर आपको लगता है कि कहीं न कहीं यह विचार असंगत या गलत है, तो मुझे टिप्पणियों में सही करें।

रेडिस बेस्ट प्रैक्टिस, भाग 2