前言

中介者模式属于行为型模式，这个类型的设计模式总结出了 类、对象之间的经典交互方式，将类、对象的行为和使用解耦了，花式的去使用对象的行为来完成特定场景下的功能。

中介者模式

使用场景：当遇到多对多关系时，可以考虑使用中介者模式，它可以将多对多的关系梳理成一对一的关系，避免了对象于对象之间的直接关联，中介者模式很好用，通过一个中间层就能实现对象与对象之间的直接通信。

理解：这是一种类、对象之间的经典交互方式，将类、对象的行为和使用解耦了。也许你会觉得中介者模式和观察者模式、代理模式有相似的地方，但是中介者模式注重的是将对象与对象之间进行解耦，让对象与对象之间的通信能够通过中间层来处理，这样多对多的关系就能变成1:1:1的关系了。观察者用于处理 1:n这样的关系，也可以优化成n:n这样的关系，它更注重通信的分发处理。代理模式用于将目标隐藏，然后所有操作都通过代理来实现，它注重的是操作的统一和隔离，只有代理类的对象才能真正操作目标。这样一比较 中介者和代理模式很像嘞，但是它们的含义不同噢，从语义上分析，中介者的对象们都是对外开放的，而代理模式的目标对象是不对外开放的，中介者简化关系，代理模式简化操作。

namespace action_mode_11 {

    interface IMediator {

        buy(user1: Tenant, user2: HouseOwner): void
        sell(user1: HouseOwner, user2: Tenant): void
    }

    class Tenant {

        name: string
        typeName: string = '租客'
        mediator: IMediator

        constructor(name: string, mediator: IMediator) {
            this.name = name
            this.mediator = mediator
        }

        buy(user: HouseOwner) {
            this.mediator.buy(this, user)
        }

    }

    class HouseOwner {

        name: string
        typeName: string = '房东'
        mediator: IMediator

        constructor(name: string, mediator: IMediator) {
            this.name = name
            this.mediator = mediator
        }

        sell(user: Tenant) {
            this.mediator.sell(this, user)
        }
    }

    class Mediator implements IMediator {

        buy(user1: Tenant, user2: HouseOwner): void {
            console.log(`${user1.name}(${user1.typeName}):我要租房子`)
            console.log(`${user2.name}(${user2.typeName}):我要出租房子`)
        }
        sell(user1: HouseOwner, user2: Tenant): void {
            console.log(`${user1.name}(${user1.typeName}):我要出租房子`)
            console.log(`${user2.name}(${user2.typeName}):我要租房子`)
        }
    }

    const mediator = new Mediator()

    const tenant1 = new Tenant('小明', mediator)
    const houseOwner = new HouseOwner('老王', mediator)

    tenant1.buy(houseOwner)
    houseOwner.sell(tenant1)

}

像观察者模式的中介者模式

理解：这样的中介者模式是否像是观察者，但是并不是哟，它是个中介者，房东通过中介者告诉所有租客，租客通过中介者告诉所有房东。而观察者模式是目标发生变化，所有观察者才会发生相应的变化，这是两种不同的含义。

namespace action_mode_11_2 {

    interface IMediator {
        tenantList: Array<Tenant>
        houseOwnerList: Array<HouseOwner>

        buy(user1: Tenant): void
        sell(user1: HouseOwner): void
    }

    class Tenant {

        name: string
        typeName: string = '租客'
        mediator: IMediator

        constructor(name: string, mediator: IMediator) {
            this.name = name
            this.mediator = mediator
            this.mediator.tenantList.push(this)
        }

        buy() {
            this.mediator.buy(this)
        }

    }

    class HouseOwner {

        name: string
        typeName: string = '房东'
        mediator: IMediator

        constructor(name: string, mediator: IMediator) {
            this.name = name
            this.mediator = mediator
            this.mediator.houseOwnerList.push(this)
        }

        sell() {
            this.mediator.sell(this)
        }
    }

    class Mediator implements IMediator {

        tenantList: Array<Tenant> = new Array()
        houseOwnerList: Array<HouseOwner> = new Array()

        buy(user1: Tenant): void {

            console.log(`${user1.name}(${user1.typeName}):我要租房子`)
            this.houseOwnerList.forEach(houseOwner => {
                console.log(`${houseOwner.name}(${houseOwner.typeName}):我要出租房子`)
            })

        }
        sell(user1: HouseOwner): void {

            console.log(`${user1.name}(${user1.typeName}):我要出租房子`)
            this.tenantList.forEach(tenant => {
                console.log(`${tenant.name}(${tenant.typeName}):我要租房子`)
            })
        }
    }

    const mediator = new Mediator()

    const tenant1 = new Tenant('小明', mediator)
    const tenant2 = new Tenant('小黄', mediator)
    const tenant3 = new Tenant('大正', mediator)
    const houseOwner1 = new HouseOwner('老王头', mediator)
    const houseOwner2 = new HouseOwner('老李头', mediator)
    const houseOwner3 = new HouseOwner('老张头', mediator)

    tenant1.buy()
    houseOwner1.sell()

}