ऑब्जर्वर पैटर्न

1. अवलोकक का पैटर्न क्या है

अवलोकक पैटर्न (Observer Pattern) एक व्यावहारिक डिज़ाइन पैटर्न है जो वस्तुओं के बीच एक-से-बहुत संवेगनपन की स्थापना के लिए उपयोग किया जाता है। विशेष रूप से, जब एक वस्तु (जिसे subject या observable कहा जाता है) में परिवर्तन होता है, तो उसके सभी संवेगनपन (जिन्हें observers या अवलोकक कहा जाता है) को सूचित किया जाता है और स्वतः अपडेट किया जाता है। यह पैटर्न subject और observers के बीच कस्पलम में छूट की अनुमति देता है, जिससे वस्तुओं के बीच कस्पलम और लचीलापन हासिल होता है।

2. अवलोकक पैटर्न की विशेषताएँ और फायदे

अवलोकक पैटर्न की निम्नलिखित विशेषताएँ और फायदे हैं:

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

3. अवलोकक पैटर्न के व्यावसायिक अनुप्रयोग के उदाहरण

अवलोकक पैटर्न का कई व्यावसायिक अनुप्रयोग हैं, जैसे:

• GUI इंटरफ़ेस में घटना संचालन योजना, जैसे किसी बटन पर क्लिक करते समय कार्रवाई का संचालन करना।
• वास्तविक समय में शेयर बाजार के लिए कोट दर पुश।
• ई-वाणिज्य प्लेटफ़ॉर्म पर प्रचारकीय गतिविधियों की सूचना।

4. गोलैंग में अवलोकक पैटर्न का अंतर्वास

4.1 UML वर्ग डायाग्राम

4.2 उदाहरण परिचय

इस उदाहरण में, हमारे पास एक विषय (विषय) और दो अवलोकक (अवलोककA और अवलोककB) हैं। विषय अवलोककों को पंजीकृत, पंजीकरण हटाएं, और सूचित कर सकता है।

4.3 अंतर्वास कदम

4.3.1 विषय इंटरफ़ेस और स्थापित विषय वर्ग

type Subject interface {
    RegisterObserver(observer Observer)
    RemoveObserver(observer Observer)
    NotifyObservers()
}

type ConcreteSubject struct {
    observers []Observer
}

// पंजीकरण श्रोता वस्तु
func (subject *ConcreteSubject) RegisterObserver(observer Observer) {
    subject.observers = append(subject.observers, observer)
}

// हटाएं श्रोता वस्तु
func (subject *ConcreteSubject) RemoveObserver(observer Observer) {
    for i, obs := range subject.observers {
        if obs == observer {
            subject.observers = append(subject.observers[:i], subject.observers[i+1:]...)
            break
        }
    }
}

// घटना सूचना करें
func (subject *ConcreteSubject) NotifyObservers() {
    for _, observer := range subject.observers {
        observer.Update()
    }
}

4.3.2 अवलोकक इंटरफ़ेस और स्थापित अवलोकक वर्ग

type Observer interface {
    Update()
}

type ConcreteObserverA struct {}

func (observer *ConcreteObserverA) Update() {
    fmt.Println("अवलोकक A को सूचित किया गया है।")
}

type ConcreteObserverB struct {}

func (observer *ConcreteObserverB) Update() {
    fmt.Println("अवलोकक B को सूचित किया गया है।")
}

4.4 उदाहरण कोड डेमो

func main() {
    subject := &ConcreteSubject{}
    observerA := &ConcreteObserverA{}
    observerB := &ConcreteObserverB{}

    subject.RegisterObserver(observerA)
    subject.RegisterObserver(observerB)

    subject.NotifyObservers()

    subject.RemoveObserver(observerA)

    subject.NotifyObservers()
}

Output:

अवलोकक A को सूचित किया गया है।
अवलोकक B को सूचित किया गया है।
अवलोकक B को सूचित किया गया है।

उपरोक्त उदाहरण कोड में स्पष्ट रूप से अवलोकक पैटर्न की विशेष अंतर्निर्देश को प्रस्तुत किया गया है। विषय (ConcreteSubject) ने दो अवलोककों (अवलोककA और अवलोककB) को पंजीकृत किया, और उसके बाद इन दो अवलोककों को सूचित किया। उसके बाद, अवलोकक A को विषय से अपंगता कर दी गई और अब केवल बचे हुए अवलोकक B को फिर सूचित किया गया।