गोलैंग मेडिएटर पैटर्न

1. मीडिएटर पैटर्न क्या है

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

2. मीडिएटर पैटर्न की विशेषताएं और फायदे

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

• वस्तुओं के बीच सीधी जुड़ाव को कम करके सिस्टम की जटिलता को कम करता है।
• वस्तुओं के बीच संवाद को सरल बनाने के लिए उनके संवाद को एक मीडिएटर वस्तु के माध्यम से संभालता है।
• वस्तुओं के बीच बातचीत को नियंत्रित करके विस्तार और रखरखाव को सुविधापूर्वक करता है।

3. मीडिएटर पैटर्न के वास्तविक जीवन के उदाहरण

मीडिएटर पैटर्न का वास्तविक जीवन में कई अनुप्रयोग हैं। उदाहरण के लिए, एक हवाई अड्डे के अनुसूचना प्रणाली में, डिस्पैचर मीडिएटर के रूप में कार्य करता है, जबकि विभिन्न मॉड्यूल जैसे विमान और भूमि यातायात सहायक वर्ग डिस्पैचर के माध्यम से संवाद करते हैं और समन्वय करते हैं।

4. जीओलैंग में मीडिएटर पैटर्न का अमल

4.1 यूएमएल कक्षा आरेख का परिचय

नीचे जीओलैंग में मीडिएटर पैटर्न के लिए यूएमएल कक्षा आरेख है:

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

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

4.3 अमल कदम 1: मीडिएटर इंटरफेस और कारक मीडिएटर को परिभाषित करें

सबसे पहले, हम एक मीडिएटर इंटरफेस और एक कारक मीडिएटर क्लास परिभाषित करते हैं:

type Mediator interface {
    registerColleague(colleague Colleague)
    sendMessage(message string, colleague Colleague)
}

type ConcreteMediator struct {
    colleagues map[string]Colleague
}

func (m *ConcreteMediator) registerColleague(colleague Colleague) {
    m.colleagues[colleague.getName()] = colleague
}

func (m *ConcreteMediator) sendMessage(message string, colleague Colleague) {
    for _, c := range m.colleagues {
        if c != colleague {
            c.receiveMessage(message)
        }
    }
}

4.4 अमल कदम 2: सहकर्मी इंटरफेस और कारक सहकर्मी को परिभाषित करें

अगले, हम एक सहकर्मी इंटरफेस और कारक सहकर्मी क्लास परिभाषित करते हैं:

type Colleague interface {
    receiveMessage(message string)
    sendMessage(message string)
    getName() string
}

type ConcreteColleagueA struct {
    mediator Mediator
    name     string
}

func (c *ConcreteColleagueA) receiveMessage(message string) {
    fmt.Printf("%s received message: %s\n", c.name, message)
}

func (c *ConcreteColleagueA) sendMessage(message string) {
    c.mediator.sendMessage(message, c)
}

func (c *ConcreteColleagueA) getName() string {
    return c.name
}

type ConcreteColleagueB struct {
    mediator Mediator
    name     string
}

func (c *ConcreteColleagueB) receiveMessage(message string) {
    fmt.Printf("%s received message: %s\n", c.name, message)
}

func (c *ConcreteColleagueB) sendMessage(message string) {
    c.mediator.sendMessage(message, c)
}

func (c *ConcreteColleagueB) getName() string {
    return c.name
}

4.5 अमल कदम 3: मीडिएटर में सहकर्मियों का प्रबंधन

विशिष्ट मीडिएटर क्लास में, हमें सहकर्मी क्लास के बीच संवाद को प्रबंधित करने के लिए registerColleague विधि और sendMessage विधि का अमल करना होगा:

func main() {
    mediator := &ConcreteMediator{
        colleagues: make(map[string]Colleague),
    }

    colleagueA := &ConcreteColleagueA{
        mediator: mediator,
        name:     "Colleague A",
    }
    colleagueB := &ConcreteColleagueB{
        mediator: mediator,
        name:     "Colleague B",
    }

    mediator.registerColleague(colleagueA)
    mediator.registerColleague(colleagueB)

    colleagueA.sendMessage("Hello, World!")
    colleagueB.sendMessage("Hi, there!")
}

main फ़ंक्शन में, हम एक निर्दिष्ट मीडिएटर वस्तु और दो विशिष्ट सहकर्मी वस्तुओं को बनाते हैं, फिर मीडिएटर वस्तु के माध्यम से सहकर्मी वस्तुओं को पंजीकृत करते हैं और संवाद परीक्षण करते हैं।