मैं अपनी कुछ समस्याओं को हल करने के लिए गैंग ऑफ़ फोर को पढ़ रहा हूं और मध्यस्थ पैटर्न के पार आया हूं ।
मैंने पहले कुछ GUI एप्लिकेशन बनाने के लिए अपनी परियोजनाओं में ऑब्जर्वर का उपयोग किया था । मैं थोड़ा भ्रमित हूं क्योंकि मुझे दोनों के बीच बहुत अंतर नहीं लगता। मैं अंतर खोजने के लिए तैयार था, लेकिन मेरी क्वेरी के लिए कोई उपयुक्त उत्तर नहीं मिला।
क्या कोई मुझे कुछ अच्छे उदाहरण के साथ दोनों के बीच अंतर करने में मदद कर सकता है जो स्पष्ट रूप से दोनों का सीमांकन करता है?
ChangeManagerलिए उदाहरण देकर । देख; paginas.fe.up.pt/~aaguiar/as/gof/hires/pat5g.htm#samplecodeObserverMediator
जवाबों:
ऑब्जर्वर पैटर्न: वस्तुओं के बीच एक-से-कई निर्भरता को परिभाषित करता है ताकि जब कोई वस्तु राज्य बदलती है, तो उसके सभी आश्रित अधिसूचित और स्वचालित रूप से अपडेट हो जाएं।
मध्यस्थ पैटर्न: एक ऑब्जेक्ट को परिभाषित करता है जो यह बताता है कि ऑब्जेक्ट्स का एक सेट कैसे इंटरैक्ट करता है। मध्यस्थ ढीली युग्मन को बढ़ावा देता है वस्तुओं को स्पष्ट रूप से एक दूसरे से संदर्भित करते हुए, और यह आपको उनकी बातचीत को स्वतंत्र रूप से अलग करने देता है।
स्रोत: dofactory
उदाहरण:
ऑब्जर्वर पैटर्न: क्लास ए में इसके साथ पंजीकृत ओ के शून्य या अधिक पर्यवेक्षक हो सकते हैं। जब A में कुछ बदला जाता है तो यह सभी पर्यवेक्षकों को सूचित करता है।
मध्यस्थ पैटर्न: आपके पास दसवीं कक्षा के कुछ उदाहरण हैं (या शायद कई अलग-अलग प्रकार: X, Y & Z), और वे एक-दूसरे के साथ संवाद करना चाहते हैं (लेकिन आप नहीं चाहते कि प्रत्येक के पास स्पष्ट संदर्भ हों अन्य), इसलिए आप एक मध्यस्थ वर्ग बनाते हैं। एम। के प्रत्येक उदाहरण में एम के साझा उदाहरण का संदर्भ है, जिसके माध्यम से यह एक्स (या एक्स, वाई और जेड) के अन्य उदाहरणों के साथ संवाद कर सकता है।
मूल पुस्तक में जो ऑब्जर्वर और मध्यस्थ, डिजाइन पैटर्न, पुन: प्रयोज्य ऑब्जेक्ट-ओरिएंटेड सॉफ़्टवेयर के तत्वों को गढ़ा है , यह कहता है कि मध्यस्थ पैटर्न का उपयोग करके मध्यस्थ पैटर्न को लागू किया जा सकता है। हालाँकि यह सहकर्मियों (जो मोटे तौर पर ऑब्जर्वर पैटर्न के विषय के बराबर हैं) के द्वारा भी लागू किया जा सकता है, या तो एक मध्यस्थ वर्ग या एक मध्यस्थ इंटरफ़ेस का संदर्भ है।
ऐसे कई मामले हैं जब आप पर्यवेक्षक पैटर्न का उपयोग करना चाहते हैं, वे कुंजी यह है कि एक वस्तु को यह नहीं पता होना चाहिए कि अन्य वस्तुएं क्या देख रही हैं।
मध्यस्थ थोड़ा अधिक विशिष्ट है, यह कक्षाओं को सीधे संवाद करने से रोकता है लेकिन इसके बजाय मध्यस्थ के माध्यम से। यह एकल जवाबदेही सिद्धांत की मदद करता है जिससे संचार को एक वर्ग को लोड किया जा सकता है जो संचार को संभालता है।
एक क्लासिक मध्यस्थ उदाहरण जीयूआई में है, जहां भोले दृष्टिकोण बटन क्लिक घटना पर कोड के लिए नेतृत्व कर सकते हैं "अगर फू पैनल अक्षम है और बार पैनल में" कृपया तारीख दर्ज करें "कहते हुए एक लेबल है, तो सर्वर को कॉल न करें, अन्यथा आगे बढ़ें ", जहां मध्यस्थ पैटर्न के साथ यह कह सकता है" मैं सिर्फ एक बटन हूं और फू पैनल और बार पैनल पर लेबल के बारे में जानने वाला कोई सांसारिक व्यवसाय नहीं है, इसलिए मैं सर्वर को कॉल करने पर अपने मध्यस्थ से पूछूंगा अभी ठीक है। "
या, यदि ऑब्जर्वर पैटर्न का उपयोग करके मध्यस्थ को लागू किया जाता है, तो बटन कहता है "अरे, पर्यवेक्षकों (जिसमें मध्यस्थ भी शामिल होगा), मेरा राज्य बदल गया (किसी ने मुझे क्लिक किया)। यदि आप परवाह करते हैं तो इसके बारे में कुछ करें"। मेरे उदाहरण में, जो शायद कम समझ में आता है तो सीधे मध्यस्थ को संदर्भित करता है, लेकिन कई मामलों में मध्यस्थ को लागू करने के लिए ऑब्जर्वर पैटर्न का उपयोग करना समझ में आता है, और ऑब्जर्वर और मध्यस्थ के बीच का अंतर कोड में अंतर के बजाय इरादे से अधिक होगा।
Client1 : अरे विषय , आप कब बदलते हैं?
Client2 : आपने सब्जेक्ट कब बदला ? मैंने ग़ौर नहीं किया!
Client3 : मुझे पता है कि विषय बदल गया है।
ये पैटर्न विभिन्न स्थितियों में उपयोग किए जाते हैं:
मध्यस्थ पैटर्न का उपयोग तब किया जाता है जब आपके पास कुछ निर्भरता के साथ दो उप-प्रणालियां होती हैं और उनमें से एक परिवर्तन के कारण होता है, और चूंकि आप उस प्रणाली को बदलना नहीं चाहते हैं जो दूसरे पर निर्भर करता है, आप एक मध्यस्थ को पेश करना चाहते हैं जो करेगा उनके बीच निर्भरता को कम करना। इस तरह, जब उप-प्रणालियों में से एक बदल जाता है, तो आपको केवल मध्यस्थ को अपडेट करना होगा।
ऑब्जर्वर पैटर्न का उपयोग तब किया जाता है जब एक वर्ग अन्य वर्गों को खुद को पंजीकृत करने और घटनाओं पर सूचनाएं प्राप्त करने की अनुमति देना चाहता है, जैसे कि बटनलेनर आदि।
ये दोनों पैटर्न कम युग्मन की अनुमति देते हैं, लेकिन काफी अलग हैं।
एक उदाहरण से आइए: विचार करें कि आप दो एप्लिकेशन बनाना चाहते हैं:
चैट एप्लिकेशन का निर्माण करना आप mediatorडिज़ाइन पैटर्न का चयन करेंगे ।
हम क्यों पसंद करेंगे mediator? बस इसकी परिभाषा पर एक नज़र:
मध्यस्थ पैटर्न के साथ, वस्तुओं के बीच संचार एक मध्यस्थ वस्तु के भीतर समझाया जाता है। ऑब्जेक्ट अब एक दूसरे के साथ सीधे संवाद नहीं करते हैं, बल्कि मध्यस्थ के माध्यम से संवाद करते हैं। यह वस्तुओं को संप्रेषित करने के बीच निर्भरता को कम करता है, जिससे युग्मन कम होता है।
जादू कैसे काम करता है? सबसे पहले हम चैट मध्यस्थ का निर्माण करेंगे और व्यक्तियों की वस्तुओं को इसके लिए पंजीकृत करेंगे, इसलिए इसका हर एक व्यक्ति के साथ दो दिशात्मक संबंध होगा (चैट मध्यस्थ का उपयोग करके व्यक्ति संदेश भेज सकता है क्योंकि इससे इसकी पहुंच कम हो सकती है, और चैट मध्यस्थ तक पहुंच जाएगी) व्यक्ति वस्तु प्राप्त करने की विधि प्राप्त करता है क्योंकि उसके पास इसकी पहुंच भी है)
function Person(name) {
let self = this;
this._name = name;
this._chat = null;
this._receive(from, message) {
console.log("{0}: '{1}'".format(from.name(), message));
}
this._send(to, message) {
this._chat.message(this, to, message);
}
return {
receive: (from, message) => { self._receive(from, message) },
send: (to, message) => { self._send(to, message) },
initChat: (chat) => { this._chat = chat; },
name: () => { return this._name; }
}
}
function ChatMediator() {
let self = this;
this._persons = [];
return {
message: function (from, to, message) {
if (self._persons.indexOf(to) > -1) {
self._persons[to].receive(from, message);
}
},
register: function (person) {
person.initChat(self);
self._persons.push(person);
}
unRegister: function (person) {
person.initChat(null);
delete self._persons[person.name()];
}
}
};
//Usage:
let chat = new ChatMediator();
let colton = new Person('Colton');
let ronan = new Person('Ronan');
chat.register(colton);
chat.register(ronan);
colton.send(colton, 'Hello there, nice to meet you');
ronan.send(ronan, 'Nice to meet you to');
colton.send(colton, 'Goodbye!');
chat.unRegister(colton);
911 कॉल एप्लिकेशन का निर्माण करना आप observerडिज़ाइन पैटर्न का चयन करेंगे ।
observerआपातकालीन स्थिति होने पर प्रत्येक एम्बुलेंस वस्तु को सूचित किया जाना चाहिए, इसलिए वह पता चला सकता है और मदद दे सकता है।observableएम्बुलेंस पर प्रत्येक के लिए संदर्भ रखता है observersऔर मदद (या जनरेटिंग इवेंट) की आवश्यकता होने पर उन्हें सूचित करता है।हम क्यों पसंद करेंगे observer? बस इसकी परिभाषा पर एक नज़र:
एक वस्तु, जिसे विषय कहा जाता है, अपने आश्रितों की एक सूची रखता है, जिसे पर्यवेक्षक कहा जाता है, और उन्हें किसी भी राज्य परिवर्तनों के लिए स्वचालित रूप से सूचित करता है, आमतौर पर उनके तरीकों में से एक को कॉल करके।
function AmbulanceObserver(name) {
let self = this;
this._name = name;
this._send(address) {
console.log(this._name + ' has been sent to the address: ' + address);
}
return {
send: (address) => { self._send(address) },
name: () => { return this._name; }
}
}
function OperatorObservable() {
let self = this;
this._ambulances = [];
return {
send: function (ambulance, address) {
if (self._ambulances.indexOf(ambulance) > -1) {
self._ambulances[ambulance].send(address);
}
},
register: function (ambulance) {
self._ambulances.push(ambulance);
}
unRegister: function (ambulance) {
delete self._ambulances[ambulance.name()];
}
}
};
//Usage:
let operator = new OperatorObservable();
let amb111 = new AmbulanceObserver('111');
let amb112 = new AmbulanceObserver('112');
operator.register(amb111);
operator.register(amb112);
operator.send(amb111, '27010 La Sierra Lane Austin, MN 000');
operator.unRegister(amb111);
operator.send(amb112, '97011 La Sierra Lane Austin, BN 111');
operator.unRegister(amb112);
mediatorमें व्यक्तियों की वस्तुओं के बीच दो तरह से संचार होता है (भेजना और प्राप्त करना), जहां ऑपरेटर के observableपास केवल एक ही तरीका है संचार (यह observerड्राइव और खत्म करने के लिए एम्बुलेंस को बताता है )।mediatorव्यक्तियों को उनके बीच की बातचीत (भले ही यह एक सीधा संचार न हो) बना सकती है, एम्बुलेंस observersकेवल ऑपरेटर observableघटनाओं को पंजीकृत करता है ।mediator, और चैट भी प्रत्येक व्यक्ति के mediatorलिए संदर्भ रखता है। एंबुलेंस observerको ऑपरेटर के संदर्भ में नहीं रखा जाता है observable, केवल ऑपरेटर ही observableहर एम्बुलेंस का संदर्भ रखता है observer।यद्यपि दोनों का उपयोग राज्य परिवर्तनों के बारे में बताने के संगठित तरीके के लिए किया जाता है, वे थोड़े अलग संरचनात्मक और शब्दार्थ IMO हैं।
ऑब्ज़र्वर का उपयोग ऑब्जेक्ट से ही किसी विशेष वस्तु के राज्य परिवर्तन को प्रसारित करने के लिए किया जाता है। तो परिवर्तन केंद्रीय वस्तु में होता है जो इसे संकेत देने के लिए भी जिम्मेदार है। हालाँकि, मध्यस्थ में, राज्य परिवर्तन किसी भी वस्तु में हो सकता है लेकिन यह एक मध्यस्थ से प्रसारित होता है। इसलिए प्रवाह में अंतर है। लेकिन, मुझे नहीं लगता कि यह हमारे कोड व्यवहार को प्रभावित करता है। समान व्यवहार को प्राप्त करने के लिए हम एक या दूसरे का उपयोग कर सकते हैं। दूसरी ओर, इस अंतर से कोड की वैचारिक समझ पर कुछ प्रभाव पड़ सकता है।
देखें, पैटर्न का उपयोग करने का प्राथमिक उद्देश्य डेवलपर्स के बीच एक आम भाषा बनाना है। इसलिए, जब मैं एक मध्यस्थ देखता हूं, तो मैं व्यक्तिगत रूप से संचार शोर को कम करने के लिए (या SRP को बढ़ावा देने के लिए) किसी एक ब्रोकर / हब से संपर्क करने की कोशिश करने वाले कई तत्वों को समझता हूं और राज्य परिवर्तन को संकेत देने की क्षमता के मामले में प्रत्येक वस्तु समान रूप से महत्वपूर्ण है। उदाहरण के लिए, एक हवाई अड्डे के पास आने वाले कई विमानों के बारे में सोचें। प्रत्येक को एक-दूसरे के साथ संवाद करने के बजाय तोरण (मध्यस्थ) पर संवाद करना चाहिए। (लैंडिंग के समय एक दूसरे के साथ संचार करने वाले 1000 विमानों के बारे में सोचो - यह एक गड़बड़ होगा)
हालाँकि, जब मैं एक पर्यवेक्षक देखता हूं, तो इसका मतलब है कि कुछ राज्य परिवर्तन हैं जिनकी मैं परवाह कर सकता हूं और विशेष राज्य परिवर्तनों को सुनने के लिए पंजीकरण / सदस्यता लेनी चाहिए। राज्य परिवर्तन के संकेत के लिए एक केंद्रीय वस्तु जिम्मेदार है। उदाहरण के लिए, यदि मुझे A से B तक के रास्ते में किसी विशिष्ट हवाई अड्डे की परवाह है, तो मैं उस हवाई अड्डे पर प्रसारित होने वाली कुछ घटनाओं को पकड़ने के लिए पंजीकरण कर सकता हूं जैसे कि कोई खाली रनवे या ऐसा कुछ।
आशा है कि यह स्पष्ट है।
@ LCDc ने इरादे में अंतर को बहुत अच्छे से समझाया।
मैं इसके ऊपर कुछ और जानकारी जोड़ूंगा।
ऑब्जर्वर : ऑब्जेक्ट के अलग-अलग सेट (विभिन्न वर्गों के उदाहरण) में एक वस्तु में एक घटना की सूचना को सक्षम करता है
मध्यस्थ : किसी विशेष वर्ग से निर्मित वस्तुओं के सेट के बीच संचार को केंद्रीकृत करना।
Dofactory से मध्यस्थ पैटर्न की संरचना :
मध्यस्थ : सहकर्मियों के बीच संचार के लिए एक इंटरफ़ेस को परिभाषित करता है।
सहकर्मी : एक अमूर्त वर्ग है, जो सहकर्मियों के बीच संवाद होने वाली घटनाओं को परिभाषित करता है
कंकरीटमेडिएटर : सहकर्मी वस्तुओं का समन्वय करके सहयोगी व्यवहार को लागू करता है और अपने सहयोगियों को बनाए रखता है
ConcreteColleague : इम्प्लीमेन्ट्स अधिसूचना संचालन के माध्यम से प्राप्त मध्यस्थ है, जो अन्य के द्वारा उत्पन्न की गई है सहकर्मी
एक वास्तविक दुनिया उदाहरण:
आप मेष टोपोलॉजी में कंप्यूटर का एक नेटवर्क बनाए हुए हैं । यदि एक नया कंप्यूटर जोड़ा जाता है या मौजूदा कंप्यूटर को हटा दिया जाता है, तो उस नेटवर्क के अन्य सभी कंप्यूटरों को इन दो घटनाओं के बारे में पता होना चाहिए।
आइए देखें कि कैसे मध्यस्थ पैटर्न इसमें फिट बैठता है।
सांकेतिक टुकड़ा:
import java.util.List;
import java.util.ArrayList;
/* Define the contract for communication between Colleagues.
Implementation is left to ConcreteMediator */
interface Mediator{
public void register(Colleague colleague);
public 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
स्पष्टीकरण:
इस विवरण के बारे में तकनीकी रूप से ऑब्जर्वर और मध्यस्थ दोनों समान हैं और घटक संचार के लिए decoupled रास्ता प्रदान करने के लिए उपयोग किया जाता है, लेकिन उपयोग अलग है।
जबकि obeserver अधिसूचित सदस्यता ली राज्य परिवर्तन (नया डाटाबेस रिकॉर्ड के निर्माण, उदाहरण के लिए) के बारे में घटक, mediator आदेशों पंजीकृत व्यापार तर्क प्रवाह से संबंधित कुछ (पासवर्ड रीसेट के लिए उपयोगकर्ता को ईमेल भेजने) करने के लिए घटकों।
Programmers.StackExchangeअस्वीकार कर दिया गया था, लेकिन मैंने वहां एक समान पद बनाया क्योंकि मुझे उत्तर में रुचि थी। आपको कुछ जवाब दिलचस्प लग सकते हैं। :)