GoLang设计模式11 - 中介者模式(行为型)

中介者模式是一种行为型设计模式。在中介者模式中创建了一个中介对象来负责不同类间的通信。因为这些类不需要直接交互，所以也就能避免它们之间的直接依赖，实现解耦的效果。

中介者模式的一个典型案例是老式小火车站。为保证铁路系统稳定运行，两列火车一般不会直接通信，而是听从车站管理员的调度。这里车站管理员就是一个中介者。他维护着一个火车进站的调度表，让火车站一次只允许一列火车停靠。当一列火车离开车站时，他才会通知调度表中的下一趟火车进站。

下面的代码模拟了小火车站管理员调度火车的工作。

火车接口 train ，火车行为：1.请求进站. 2.出站. 3.接收进站信号

客车类(passengerTrain)和货车类(goodsTrain)分别实现了train接口

中介者接口 mediator  行为：1.查询是否可以进站. 2.广播站台空闲,让在等候的列车进站

车站管理员(stationManager)实现了mediator接口，属性：1.站台是否空闲. 2.候车队列

type train interface {

    requestArrival()//列车请求进站

    departure()//列车出站

    permitArrival()//接收进站信号
}

type passengerTrain struct {
    mediator mediator
}

func (g *passengerTrain) requestArrival() {
    if g.mediator.canLand(g) {
        fmt.Println("PassengerTrain: Landing")
    } else {
        fmt.Println("PassengerTrain: Waiting")
    }
}

func (g *passengerTrain) departure() {
    fmt.Println("PassengerTrain: Leaving")
    g.mediator.notifyFree()
}

func (g *passengerTrain) permitArrival() {
    fmt.Println("PassengerTrain: Arrival Permitted. Landing")
}

type goodsTrain struct {
    mediator mediator
}

func (g *goodsTrain) requestArrival() {
    if g.mediator.canLand(g) {
        fmt.Println("GoodsTrain: Landing")
    } else {
        fmt.Println("GoodsTrain: Waiting")
    }
}

func (g *goodsTrain) departure() {
    g.mediator.notifyFree()
    fmt.Println("GoodsTrain: Leaving")
}

func (g *goodsTrain) permitArrival() {
    fmt.Println("GoodsTrain: Arrival Permitted. Landing")
}

type mediator interface {

    canLand(train) bool //查询是否可以进站

    notifyFree() //广播站台空闲,让在等候的列车进站
}

type stationManager struct {
    isPlatformFree bool //站台是否空闲
    lock           *sync.Mutex
    trainQueue     []train //候车队列
}

func newStationManger() *stationManager {
    return &stationManager{
        isPlatformFree: true,
        lock:           &sync.Mutex{},
    }
}

func (s *stationManager) canLand(t train) bool {
    s.lock.Lock()
    defer s.lock.Unlock()
    if s.isPlatformFree {
        s.isPlatformFree = false
        return true
    }
    s.trainQueue = append(s.trainQueue, t)
    return false
}

func (s *stationManager) notifyFree() {
    s.lock.Lock()
    defer s.lock.Unlock()
    if !s.isPlatformFree {
        s.isPlatformFree = true
    }
    if len(s.trainQueue) > 0 {
        firstTrainInQueue := s.trainQueue[0]
        s.trainQueue = s.trainQueue[1:]
        firstTrainInQueue.permitArrival()
    }
}

func main() {
    stationManager := newStationManger()
    passengerTrain := &passengerTrain{
        mediator: stationManager,
    }
    goodsTrain := &goodsTrain{
        mediator: stationManager,
    }
    passengerTrain.requestArrival()
    goodsTrain.requestArrival()
    passengerTrain.departure()
}

 

执行结果：

PassengerTrain: Landing
GoodsTrain: Waiting
PassengerTrain: Leaving
GoodsTrain: Arrival Permitted. Landing