终结者模式(Mediator Design Pattern)

中介者模式是用来降低多个对象和类之间的通信复杂性，该模式会限制对象之间的直接交互，能减少对象之间混乱无序的依赖关系。中介者模式提供了一个中介类，这个类用来处理不同类之间的通信，使各个类通过一个中介者对象进行合作，以实现松耦合，使代码更易于维护。不过，由于中介者对象封装了各个类之间的交互，会使中介者本身的变的复杂。

也有人一看到中介，可能会立马想到房产中介，这个中介者模式与房产中介确实相似。

在租房的场景中，没有中介之前，租房者要东奔西跑去找各个房东。有了中介后，房东会把出租房登记倒中介那里，租房者只需要去找中介就可以租到各种你想要的房子。也就是把多对多的复杂关系，变成了多对一的关系。

代码示例

那就以租房为例吧：

package mediator

import "fmt"

//房产中介
type HouseMediator struct {
    houses []HouseOwner
}

func (m *HouseMediator) Register(h HouseOwner) {
    m.houses = append(m.houses, h)
}

func (m *HouseMediator) Reply(name string) {
    fmt.Printf("我是中介，正在给您找%s\n", name)
    for _, a := range m.houses {
        if a.Name() == name {
            fmt.Print("找到了，")
            a.Rent()
        }
    }
}

//抽象同事 房主
type HouseOwner interface {
    Name() string
    Rent() //出租
}

//具体同事-小房子
type SmallHouseOwner struct {
    name string
}

func NewSmallHouseOwner() *SmallHouseOwner {
    return &SmallHouseOwner{name: "小房子"}
}
func (h SmallHouseOwner) Name() string {
    return h.name
}

func (h SmallHouseOwner) Rent() {
    fmt.Println("小房子屋主，出租小房子")
}

//具体同事-大房子出租人
type BigHouseOwner struct {
    name string
}

func NewBigHouseOwner() *BigHouseOwner {
    return &BigHouseOwner{name: "大房子"}
}
func (h BigHouseOwner) Name() string {
    return h.name
}

func (h BigHouseOwner) Rent() {
    fmt.Println("大房子屋主，出租大房子")
}

type Person struct {
    mediator *HouseMediator
}

func NewPerson(mediator *HouseMediator) *Person {
    return &Person{mediator: mediator}
}
func (p Person) FindHouse(name string) { //找房子租
    fmt.Printf("我想租%s\n", name)
    p.mediator.Reply(name)
}

调用：

mediator := &HouseMediator{}
mediator.Register(NewSmallHouseOwner())
mediator.Register(NewBigHouseOwner())

person := NewPerson(mediator)
person.FindHouse("大房子")
fmt.Println("")

person.FindHouse("大房子")

// Output:
// 我想租大房子
// 我是中介，正在给您找大房子
// 找到了，大房子屋主，出租大房子

// 我想租大房子
// 我是中介，正在给您找大房子
// 找到了，大房子屋主，出租大房子

中介者模式也有点类似于微服务里的网关，没有网关之前一个服务可能要和各个服务去通信，有了网关这个中介，服务调用方只需要和网关通信就行了，由网关替你去和不同的服务通信。