Design patterns
मध्यस्थ पैटर्न

मध्यस्थ पैटर्न जावा में उदाहरण है

मध्यस्थ पैटर्न एक वस्तु (मध्यस्थ) को परिभाषित करता है जो यह बताता है कि ऑब्जेक्ट्स का एक सेट कैसे इंटरैक्ट करता है। यह कई-कई-कई संचार को सक्षम करता है।

यूएमएल आरेख:

ज़रूरी भाग:

Mediator: सहकर्मियों के बीच संचार के लिए एक इंटरफ़ेस को परिभाषित करता है।

Colleague : एक अमूर्त वर्ग है, जो सहकर्मियों के बीच होने वाली घटनाओं को परिभाषित करता है

ConcreteMediator : Colleague वस्तुओं का समन्वय करके सहयोगी व्यवहार को लागू करता है और अपने सहयोगियों को बनाए रखता है

ConcreteColleague : इम्प्लीमेन्ट्स अधिसूचना संचालन के माध्यम से प्राप्त Mediator है, जो अन्य के द्वारा उत्पन्न की गई है Colleague

एक वास्तविक दुनिया उदाहरण:

आप Mesh टोपोलॉजी में कंप्यूटर का एक नेटवर्क बनाए हुए हैं।

एक जाल नेटवर्क एक नेटवर्क टोपोलॉजी है जिसमें प्रत्येक नोड नेटवर्क के लिए डेटा रिले करता है। सभी जाल नोड्स नेटवर्क में डेटा के वितरण में सहयोग करते हैं।

यदि एक नया कंप्यूटर जोड़ा जाता है या मौजूदा कंप्यूटर को हटा दिया जाता है, तो उस नेटवर्क के अन्य सभी कंप्यूटरों को इन दो घटनाओं के बारे में पता होना चाहिए।

आइए देखें कि कैसे मध्यस्थ पैटर्न इसमें फिट बैठता है।

सांकेतिक टुकड़ा:

import java.util.List;
import java.util.ArrayList;

/* Define the contract for communication between Colleagues. 
   Implementation is left to ConcreteMediator */
interface Mediator{
    void register(Colleague colleague);
    void unregister(Colleague colleague);
}
/* Define the contract for notification events from Mediator. 
   Implementation is left to ConcreteColleague
*/
abstract class Colleague{
    private Mediator mediator;
    private String name;
    
    public Colleague(Mediator mediator,String name){
        this.mediator = mediator;
        this.name = name;
    }
    public String toString(){
        return name;
    }
    public abstract void receiveRegisterNotification(Colleague colleague);
    public abstract void receiveUnRegisterNotification(Colleague colleague);    
}
/*  Process notification event raised by other Colleague through Mediator.   
*/
class ComputerColleague extends Colleague {
    private Mediator mediator;
    
    public ComputerColleague(Mediator mediator,String name){
        super(mediator,name);
    }
    public  void receiveRegisterNotification(Colleague colleague){
        System.out.println("New Computer register event with name:"+colleague+
        ": received @"+this);
        // Send further messages to this new Colleague from now onwards
    }
    public  void receiveUnRegisterNotification(Colleague colleague){
        System.out.println("Computer left unregister event with name:"+colleague+
        ":received @"+this);
        // Do not send further messages to this Colleague from now onwards
    }
}
/* Act as a central hub for communication between different Colleagues. 
   Notifies all Concrete Colleagues on occurrence of an event
*/
class NetworkMediator implements Mediator{
    List<Colleague> colleagues = new ArrayList<Colleague>();
    
    public NetworkMediator(){
    
    }
    
    public void register(Colleague colleague){
        colleagues.add(colleague);
        for (Colleague other : colleagues){
            if ( other != colleague){
                other.receiveRegisterNotification(colleague);
            }
        }
    }
    public void unregister(Colleague colleague){
        colleagues.remove(colleague);
        for (Colleague other : colleagues){
            other.receiveUnRegisterNotification(colleague);
        }
    }
}

public class MediatorPatternDemo{
    public static void main(String args[]){
        Mediator mediator = new NetworkMediator();
        ComputerColleague colleague1 = new ComputerColleague(mediator,"Eagle");
        ComputerColleague colleague2 = new ComputerColleague(mediator,"Ostrich");
        ComputerColleague colleague3 = new ComputerColleague(mediator,"Penguin");
        mediator.register(colleague1);
        mediator.register(colleague2);
        mediator.register(colleague3);
        mediator.unregister(colleague1);
    }
}

उत्पादन:

New Computer register event with name:Ostrich: received @Eagle
New Computer register event with name:Penguin: received @Eagle
New Computer register event with name:Penguin: received @Ostrich
Computer left unregister event with name:Eagle:received @Ostrich
Computer left unregister event with name:Eagle:received @Penguin

स्पष्टीकरण:

1. Eagle को रजिस्टर इवेंट के माध्यम से सबसे पहले नेटवर्क में जोड़ा जाता है। ईगल पहले के बाद से किसी भी अन्य सहयोगियों के लिए कोई सूचना नहीं है।
2. जब Ostrich को नेटवर्क में जोड़ा जाता है, तो Eagle को सूचित किया जाता है: आउटपुट की लाइन 1 अब प्रदान की गई है।
3. जब Penguin को नेटवर्क में जोड़ा जाता है, तो Eagle और Ostrich दोनों को सूचित किया गया है: आउटपुट का लाइन 2 और लाइन 3 अब प्रदान किया गया है।
4. जब Eagle ने अपंजीकृत घटना के माध्यम से नेटवर्क छोड़ा, तो Ostrich और Penguin दोनों को सूचित किया गया। आउटपुट की लाइन 4 और लाइन 5 अब प्रदान की गई है।