ฉันอ่านGang Of Fourเพื่อที่จะแก้ปัญหาบางอย่างของฉันและเจอรูปแบบคนกลาง

ก่อนหน้านี้ฉันใช้Observerในโครงการของฉันเพื่อสร้างแอปพลิเคชัน GUI ฉันสับสนเล็กน้อยเพราะฉันไม่พบความแตกต่างระหว่างสองอย่างนี้ ฉันเรียกดูเพื่อค้นหาความแตกต่าง แต่ไม่พบคำตอบที่เหมาะสมสำหรับคำถามของฉัน

มีใครช่วยฉันแยกความแตกต่างระหว่างสองอย่างด้วยตัวอย่างที่ดีที่แบ่งเขตทั้งสองอย่างชัดเจนได้ไหม

รูปแบบผู้สังเกตการณ์: กำหนดการอ้างอิงแบบหนึ่งต่อกลุ่มระหว่างอ็อบเจ็กต์ดังนั้นเมื่ออ็อบเจ็กต์หนึ่งเปลี่ยนสถานะผู้ติดตามทั้งหมดจะได้รับแจ้งและอัพเดตโดยอัตโนมัติ

รูปแบบสื่อกลาง: กำหนดวัตถุที่ห่อหุ้มวิธีที่ชุดของวัตถุโต้ตอบ คนกลางส่งเสริมการมีเพศสัมพันธ์แบบหลวม ๆ โดยป้องกันไม่ให้วัตถุอ้างอิงถึงกันอย่างชัดเจนและช่วยให้คุณสามารถเปลี่ยนแปลงการโต้ตอบของพวกมันได้อย่างอิสระ

ที่มา: dofactory

ตัวอย่าง:

รูปแบบผู้สังเกตการณ์: คลาส A สามารถมีผู้สังเกตการณ์ประเภท O เป็นศูนย์หรือมากกว่าที่ลงทะเบียนได้ เมื่อมีการเปลี่ยนแปลงบางอย่างใน A จะแจ้งเตือนผู้สังเกตการณ์ทั้งหมด

รูปแบบสื่อกลาง: คุณมีอินสแตนซ์ของคลาส X จำนวนหนึ่ง (หรืออาจจะเป็นหลายประเภท: X, Y & Z) และพวกเขาต้องการสื่อสารกัน (แต่คุณไม่ต้องการให้แต่ละอินสแตนซ์มีการอ้างอิงอย่างชัดเจนถึงแต่ละรายการ อื่น ๆ ) ดังนั้นคุณจึงสร้างคลาสคนกลาง M แต่ละอินสแตนซ์ของ X มีการอ้างอิงถึงอินสแตนซ์ที่ใช้ร่วมกันของ M ซึ่งสามารถสื่อสารกับอินสแตนซ์อื่นของ X (หรือ X, Y และ Z) ได้

ในหนังสือต้นฉบับที่บัญญัติศัพท์ Observer and Mediator, Design Patterns, Elements of Reusable Object-Oriented Softwareกล่าวว่ารูปแบบสื่อกลางสามารถนำไปใช้ได้โดยใช้รูปแบบผู้สังเกตการณ์ อย่างไรก็ตามยังสามารถใช้งานได้โดยการมีเพื่อนร่วมงาน (ซึ่งเทียบเท่ากับ Subjects of the Observer pattern) มีการอ้างอิงถึงคลาส Mediator หรืออินเทอร์เฟซ Mediator

มีหลายกรณีที่คุณต้องการใช้รูปแบบผู้สังเกตการณ์ที่สำคัญคือวัตถุไม่ควรรู้ว่าวัตถุอื่นกำลังสังเกตสถานะใด

คนกลางมีความเฉพาะเจาะจงมากขึ้นโดยหลีกเลี่ยงการให้ชั้นเรียนสื่อสารกันโดยตรง แต่ใช้คนกลางแทน สิ่งนี้ช่วยหลักการความรับผิดชอบเดียวโดยอนุญาตให้ถ่ายโอนการสื่อสารไปยังชั้นเรียนที่จัดการกับการสื่อสารได้

ตัวอย่างสื่อกลางแบบคลาสสิกอยู่ใน GUI ซึ่งวิธีการที่ไร้เดียงสาอาจนำไปสู่รหัสบนเหตุการณ์การคลิกปุ่มที่บอกว่า "ถ้าแผง Foo ถูกปิดใช้งานและแผง Bar มีป้ายกำกับว่า" โปรดป้อนวันที่ "จากนั้นอย่าเรียกเซิร์ฟเวอร์ ไปข้างหน้า "โดยที่รูปแบบสื่อกลางสามารถพูดได้ว่า" ฉันเป็นแค่ปุ่มและไม่มีธุรกิจทางโลกที่รู้เกี่ยวกับแผง Foo และป้ายกำกับบนแผง Bar ดังนั้นฉันจะถามคนกลางของฉันว่าโทรไปที่เซิร์ฟเวอร์ โอเคตอนนี้ "

หรือถ้าใช้ Mediator โดยใช้รูปแบบ Observer ปุ่มจะบอกว่า "เฮ้ผู้สังเกตการณ์ (ซึ่งรวมถึงคนกลางด้วย) สถานะของฉันก็เปลี่ยนไป (มีคนคลิกฉัน) ทำอะไรกับมันได้ถ้าคุณสนใจ" ในตัวอย่างของฉันที่อาจจะไม่ค่อยเข้าท่านักจากนั้นก็อ้างถึงสื่อกลางโดยตรง แต่ในหลาย ๆ กรณีการใช้รูปแบบผู้สังเกตการณ์ในการใช้สื่อกลางจะสมเหตุสมผลและความแตกต่างระหว่างผู้สังเกตการณ์และผู้ไกล่เกลี่ยจะเป็นเจตนามากกว่าความแตกต่างในรหัส

ผู้สังเกตการณ์

1. โดยไม่ต้อง

• Client1 : Hey Subjectคุณเปลี่ยนเมื่อไหร่?

• Client2 : คุณเปลี่ยนSubject เมื่อไหร่? ฉันไม่ได้สังเกต!

• Client3 : ฉันรู้ว่าSubjectมีการเปลี่ยนแปลง

2. ด้วย

• ลูกค้าเงียบ
• ในเวลาต่อมา ...
• Subject : เรียนลูกค้าฉันเปลี่ยนไปแล้ว!

คนกลาง

1. โดยไม่ต้อง

• ลูกค้า 1 : เฮ้แท็กซี่ 1 พาฉันไปที่ไหน
• ลูกค้า 2 : เฮ้แท็กซี่ 1 พาฉันไปที่ไหน
• Client1 : เฮ้Taxi2พาฉันไปที่ไหน
• Client2 : เฮ้Taxi2พาฉันไปที่ไหน

2. ด้วย

• Client1 : เฮ้TaxiCenterช่วยเรียกแท็กซี่ให้ฉันด้วย
• Client2 : Hey TaxiCenterโปรดฉันแท็กซี่

รูปแบบเหล่านี้ใช้ในสถานการณ์ต่างๆ:

รูปแบบสื่อกลางจะใช้เมื่อคุณมีระบบย่อยสองระบบที่มีการพึ่งพาบางระบบและหนึ่งในนั้นมีกำหนดจะมีการเปลี่ยนแปลงและเนื่องจากคุณอาจไม่ต้องการเปลี่ยนระบบที่ขึ้นอยู่กับระบบอื่นคุณอาจต้องการแนะนำผู้ไกล่เกลี่ยซึ่งจะ แยกการพึ่งพาระหว่างพวกเขา ด้วยวิธีนี้เมื่อระบบย่อยระบบใดระบบหนึ่งเปลี่ยนแปลงสิ่งที่คุณต้องทำก็คือการอัปเดตสื่อกลาง

รูปแบบผู้สังเกตการณ์ใช้เมื่อชั้นเรียนต้องการอนุญาตให้ชั้นเรียนอื่น ๆ ลงทะเบียนตนเองและรับการแจ้งเตือนเกี่ยวกับเหตุการณ์เช่น ButtonListener เป็นต้น

รูปแบบทั้งสองนี้อนุญาตให้มีการเชื่อมต่อน้อยลง แต่แตกต่างกันมาก

ลองดูตัวอย่าง: พิจารณาว่าคุณต้องการสร้างสองแอปพลิเคชัน:

1. โปรแกรมแชท
2. แอปพลิเคชันตัวดำเนินการรถพยาบาลฉุกเฉิน

คนกลาง

การสร้างแอปพลิเคชันแชทคุณจะต้องเลือก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);

ความแตกต่าง:

1. การแชทmediatorมีการสื่อสารสองทางระหว่างวัตถุบุคคล (ส่งและรับ) ในขณะที่ผู้ปฏิบัติงานobservableมีการสื่อสารทางเดียวเท่านั้น (มันบอกให้รถพยาบาลobserverขับรถและเสร็จสิ้น)
2. การแชทmediatorสามารถทำให้วัตถุของบุคคลโต้ตอบระหว่างพวกเขาได้ (แม้ว่าจะไม่ใช่การสื่อสารโดยตรงก็ตาม) รถพยาบาลobserversจะลงทะเบียนเฉพาะobservableเหตุการณ์ของเจ้าหน้าที่
3. วัตถุแต่ละคนมีการอ้างอิงถึงการแชทmediatorและการแชทmediatorจะอ้างอิงถึงบุคคลทุกคน Wheres รถพยาบาลobserverไม่ให้การอ้างอิงไปยังผู้ประกอบการobservableเพียงผู้ประกอบการอ้างอิงเก็บทุกพยาบาลobservableobserver

แม้ว่าทั้งสองอย่างจะใช้สำหรับวิธีการบอกเล่าเกี่ยวกับการเปลี่ยนแปลงสถานะอย่างเป็นระบบ แต่ IMO ที่มีโครงสร้างและความหมายต่างกันเล็กน้อย

Observer ใช้เพื่อถ่ายทอดการเปลี่ยนแปลงสถานะของวัตถุเฉพาะจากตัววัตถุเอง ดังนั้นการเปลี่ยนแปลงจึงเกิดขึ้นในวัตถุกลางซึ่งมีหน้าที่ในการส่งสัญญาณด้วย อย่างไรก็ตามใน Mediator การเปลี่ยนแปลงสถานะสามารถเกิดขึ้นได้ในทุกวัตถุ แต่จะถ่ายทอดจากคนกลาง ดังนั้นจึงมีความแตกต่างในการไหล แต่ฉันไม่คิดว่าสิ่งนี้จะส่งผลต่อพฤติกรรมโค้ดของเรา เราสามารถใช้อย่างใดอย่างหนึ่งเพื่อให้เกิดพฤติกรรมเดียวกัน ในทางกลับกันความแตกต่างนี้อาจมีผลต่อความเข้าใจแนวคิดเกี่ยวกับโค้ด

ดูจุดประสงค์หลักของการใช้รูปแบบคือการสร้างภาษากลางระหว่างนักพัฒนา ดังนั้นเมื่อฉันเห็นคนกลางฉันจึงเข้าใจองค์ประกอบหลายอย่างที่พยายามสื่อสารผ่านโบรกเกอร์ / ฮับเดียวเพื่อลดเสียงรบกวนในการสื่อสาร (หรือเพื่อส่งเสริม SRP) และวัตถุแต่ละชิ้นมีความสำคัญเท่าเทียมกันในแง่ของการมีความสามารถในการส่งสัญญาณการเปลี่ยนแปลงสถานะ ตัวอย่างเช่นลองนึกถึงเครื่องบินหลายลำที่เข้าใกล้สนามบิน แต่ละคนควรสื่อสารผ่านเสา (คนกลาง) มากกว่าที่จะสื่อสารกัน (ลองนึกถึงเครื่องบิน 1,000 ลำที่สื่อสารกันเมื่อลงจอดซึ่งจะเป็นเรื่องยุ่ง)

อย่างไรก็ตามเมื่อฉันเห็นผู้สังเกตการณ์นั่นหมายความว่ามีการเปลี่ยนแปลงสถานะบางอย่างที่ฉันอาจสนใจและควรลงทะเบียน / สมัครรับข้อมูลการเปลี่ยนแปลงสถานะโดยเฉพาะ มีวัตถุกลางที่รับผิดชอบในการส่งสัญญาณการเปลี่ยนแปลงสถานะ ตัวอย่างเช่นหากฉันสนใจเกี่ยวกับสนามบินที่เฉพาะเจาะจงระหว่างทางจาก A ไป B ฉันสามารถลงทะเบียนไปยังสนามบินนั้นเพื่อดูเหตุการณ์บางอย่างที่ออกอากาศเช่นว่ามีรันเวย์ว่างหรืออะไรทำนองนั้น

หวังว่าจะชัดเจน

@cdc อธิบายความแตกต่างของเจตนาอย่างยอดเยี่ยม

ฉันจะเพิ่มข้อมูลเพิ่มเติมด้านบน

ผู้สังเกตการณ์ : เปิดใช้งานการแจ้งเตือนเหตุการณ์ในวัตถุหนึ่งไปยังชุดของวัตถุที่แตกต่างกัน (อินสแตนซ์ของคลาสต่างๆ)

คนกลาง : รวมศูนย์การสื่อสารระหว่างชุดของวัตถุที่สร้างขึ้นจากคลาสเฉพาะ

โครงสร้างรูปแบบสื่อกลางจากโรงงาน dofactory :

คนกลาง : กำหนดอินเทอร์เฟซสำหรับการสื่อสารระหว่างเพื่อนร่วมงาน

เพื่อนร่วมงาน : เป็นคลาสนามธรรมซึ่งกำหนดเหตุการณ์ที่จะสื่อสารระหว่างเพื่อนร่วมงาน

ConcreteMediator : ดำเนินพฤติกรรมร่วมมือโดยประสานวัตถุเพื่อนร่วมงานและรักษาเพื่อนร่วมงาน

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

คำอธิบาย:

1. Eagleถูกเพิ่มในเครือข่ายในตอนแรกผ่านเหตุการณ์การลงทะเบียน ไม่มีการแจ้งเตือนไปยังเพื่อนร่วมงานคนอื่น ๆ เนื่องจาก Eagle เป็นคนแรก
2. เมื่อเพิ่มOstrichเข้าในเครือข่ายEagleจะได้รับแจ้ง: บรรทัดที่ 1 ของเอาต์พุตจะแสดงผลทันที
3. เมื่อเพนกวินถูกเพิ่มเข้าในเครือข่ายทั้งEagleและOstrich จะได้รับแจ้ง: บรรทัดที่ 2 และบรรทัดที่ 3 ของเอาต์พุตจะแสดงผลทันที
4. เมื่อEagleออกจากเครือข่ายผ่านเหตุการณ์ที่ไม่ได้ลงทะเบียนทั้งOstrichและPenguinได้รับการแจ้งเตือน บรรทัดที่ 4 และบรรทัดที่ 5 ของเอาต์พุตจะแสดงผลในขณะนี้

วิธีเกี่ยวกับคำอธิบายนี้ในทางเทคนิคทั้ง Observer และ Mediator นั้นเหมือนกันและใช้เพื่อระบุวิธีแยกสำหรับการสื่อสารคอมโพเนนต์ แต่การใช้งานแตกต่างกัน

ในขณะที่obeserver แจ้ง คอมโพเนนต์ที่สมัครเป็นสมาชิกเกี่ยวกับการเปลี่ยนแปลงสถานะ (เช่นการสร้าง db record ใหม่เป็นต้น) mediator คำสั่ง คอมโพเนนต์ที่ลงทะเบียนเพื่อทำบางสิ่งที่เกี่ยวข้องกับโฟลว์ตรรกะทางธุรกิจ (ส่งอีเมลไปยังผู้ใช้เพื่อรีเซ็ตรหัสผ่าน)

ผู้สังเกตการณ์

• การแจ้งเตือนผู้บริโภคมีหน้าที่สมัครสมาชิกเพื่อรับการแจ้งเตือน
• การประมวลผลการแจ้งเตือนไม่ได้เป็นส่วนหนึ่งของขั้นตอนทางธุรกิจ

คนกลาง

• ต้องมีการลงทะเบียนอย่างชัดเจนเพื่อเชื่อมต่อ "ผู้เผยแพร่" และ "ผู้บริโภค"
• การประมวลผลการแจ้งเตือนเป็นส่วนหนึ่งของขั้นตอนธุรกิจเฉพาะ