中介者模式：促进群体之间的有效沟通

在设计模式中，中介者模式是一种常用于解决多个对象之间复杂通信问题的设计模式。该模式通过引入一个中介者对象，将一系列的交互集中管理，从而使得对象之间的通信变得更加简单和可维护。本文将详细介绍中介者模式的相关概念、优点、实际应用场景以及实现方式。

中介者模式的定义和背景

中介者模式是一种结构型设计模式，它定义了一个中介者类，该类将一组对象之间的交互封装起来，使得这些对象可以通过中介者进行通信，从而降低了对象之间的耦合性。

中介者模式的优点

1. 降低耦合性：通过引入中介者，对象之间的通信不再直接进行，而是通过中介者进行。这样，对象之间的耦合性得到了极大的降低，各个对象可以独立地进行修改和扩展。
2. 提高可维护性：中介者将一组对象的交互集中管理，使得交互的逻辑更加清晰，也方便进行维护。此外，中介者还可以对通信进行记录或监控，有利于故障排查和性能分析。
3. 提供灵活性：中介者可以灵活地添加新的交互逻辑，而不需要修改现有的对象。这使得系统的扩展变得更加容易。

中介者模式的应用场景

1. 多个对象之间的通信逻辑较复杂，需要加以管理的情况。
2. 需要对对象之间的通信进行监控或记录的情况。
3. 需要在对象之间共享数据或状态的情况。

模式UML

中介者模式包含如下角色：

• Mediator: 抽象中介者
• ConcreteMediator: 具体中介者
• Colleague: 抽象同事类
• ConcreteColleague: 具体同事类

javascript代码实现

let Colleague = function () {}
    Colleague.prototype.sendmsg = function (key, msg) {
        this.mediator.operation(key, msg)
    }

    Colleague.prototype.setMediator = function (mediator) {
        this.mediator = mediator
    }

    let ConcreteColleagueA = function () {}
    ConcreteColleagueA.prototype = Object.create(Colleague.prototype)
    ConcreteColleagueA.prototype.constructor = ConcreteColleagueA
    ConcreteColleagueA.prototype.receivemsg = function (str) {
        console.log("ConcreteColleagueA 收到信息：" + str);
    }

    let ConcreteColleagueB = function () {}
    ConcreteColleagueB.prototype = Object.create(Colleague.prototype)
    ConcreteColleagueB.prototype.constructor = ConcreteColleagueB
    ConcreteColleagueB.prototype.receivemsg = function (str) {
        console.log("ConcreteColleagueB 收到信息：" + str);
    }

    let Mediator = function () {
        this.colleagueMap = {}
    }

    Mediator.prototype.operation = function (key, aColleague) {
        throw (new Error("需要子类实现"))
    }

    Mediator.prototype.register = function (colleague) {
        throw (new Error("需要子类实现"))
    }

    let ConcreteMediator = function () {
        Mediator.apply(this, arguments)
    }

    ConcreteMediator.prototype = Object.create(Mediator.prototype)
    ConcreteMediator.prototype.constructor = ConcreteMediator

    ConcreteMediator.prototype.operation = function (key, msg) {
        let colleague = this.colleagueMap[key]

        if (colleague) {
            colleague.receivemsg(msg)
        }
    }

    Mediator.prototype.register = function (key, aColleague) {
        let colleague = this.colleagueMap[key]

        if (!colleague) {
            this.colleagueMap[key] = aColleague
            aColleague.setMediator(this)
        }
    }

    let _ConcreteMediator = new ConcreteMediator()
    let _ConcreteColleagueA = new ConcreteColleagueA()
    let _ConcreteColleagueB = new ConcreteColleagueB()


    _ConcreteMediator.register("1", _ConcreteColleagueA)
    _ConcreteColleagueA.setMediator(_ConcreteMediator)

    _ConcreteMediator.register("2", _ConcreteColleagueB)
    _ConcreteColleagueB.setMediator(_ConcreteMediator)

    _ConcreteColleagueA.sendmsg("2", "i am a"); // ConcreteColleagueB 收到信息：i am a
    _ConcreteColleagueB.sendmsg("1", "i am b"); //ConcreteColleagueA 收到信息：i am b

中介者Mediator主要通过colleagueMap记录 ConcreteMediator 的键值对信息.同事之间相互传递信息，通过key来查找消息的接收者，以达到信息之间共享.