《golang设计模式》第三部分·行为型模式-05-仲裁者/中介模式(Mediator)

文章目录

  • 1. 概述
    • 1.1 作用
    • 1.2 角色
    • 1.3 类图
  • 2. 代码示例
    • 2.1 设计
    • 2.2 代码
    • 2.3 类图

1. 概述

仲裁者(Mediator)可以封装和协调多个对象之间的耦合交互行为,以减弱这些对象之间的耦合关联。

1.1 作用

将多个对象相互耦合的设计转变为所有对象通过中介协作,从而降低其耦合性

多个对象相互耦合:
《golang设计模式》第三部分·行为型模式-05-仲裁者/中介模式(Mediator)_第1张图片

所有对象通过中介(E)相互协作
《golang设计模式》第三部分·行为型模式-05-仲裁者/中介模式(Mediator)_第2张图片

1.2 角色

抽象仲裁者(Mediator)角色:封装和实现其子类的协作行为。
具体仲裁者(ConcreteMediator)角色:实现仲裁者行为。
抽象协作者类(Colleague)角色:持有指向仲裁者Mediator对象的引用
具体协作者(ConcreteColleague):

1.3 类图

Mediator
ConcreteMediator
-ConcreteColleagueA:concreteColleagueA
-ConcreteColleagueB:concreteColleagueB
«interface»
Colleague
+mediator:Mediator
ConcreteColleagueA
+Mediator mediator
ConcreteColleagueB
+Mediator mediator

2. 代码示例

2.1 设计

  • 定义抽象仲裁者Mediator
  • 定义具体仲裁者ConcreteMediator
    • 它依赖了需要的具体协作者ConcreteColleagueAConcreteColleagueBConcreteColleagueC
    • 它的Process()方法选择了如何执行何种实际协作者
  • 定义了抽象协作者Colleague
  • 定义了各个实际协作者ConcreteColleagueAConcreteColleagueBConcreteColleagueC
    • 它们实现了抽象协作者Colleague
    • 它们都依赖了抽象仲裁者Mediator
    • 它们的Action()方法,通过所依赖的仲裁者,执行对应的实际协作者的Option()方法
    • 它们的Option()方法,是实际协作中的操作
  • 调用
    • 实例化一个具体仲裁者
    • 实例化三个具体协作者
    • 每个具体协作者关联仲裁者实例
    • 分别执行三个仲裁者的Action()方法完成每一次协作

2.2 代码

  • 代码
package main

import "fmt"

// 抽象中介
type Mediator interface {
	Process(colleague Colleague)
}

// 实际中介,它持有所有具体协作者
type ConcreteMediator struct {
	concreteColleagueA *ConcreteColleagueA
	concreteColleagueB *ConcreteColleagueB
	concreteColleagueC *ConcreteColleagueC
}

// 该方法实现了各协作者之间通过实际中介的相互协作(该例中实际中介同时维护了实际协作者的协作关系)
func (cm *ConcreteMediator) Process(colleague Colleague) {
	switch {
	case colleague == cm.concreteColleagueA:
		cm.concreteColleagueA.Option()
		cm.concreteColleagueC.Option()
	case colleague == cm.concreteColleagueB:
		cm.concreteColleagueB.Option()
		cm.concreteColleagueC.Option()
	case colleague == cm.concreteColleagueC:
		cm.concreteColleagueC.Option()
	}
}

// 抽象协作者
type Colleague interface {
	Action()
}

// 定义实际协作者A,它关联了中介
type ConcreteColleagueA struct {
	mediator Mediator
}

// 该方法调用中介,已达到调用其他协作者的目的(调用顺序由中介维护)
func (a *ConcreteColleagueA) Action() {
	a.mediator.Process(a)
}

// 该方法是协作者A自身的操作
func (e *ConcreteColleagueA) Option() {
	fmt.Println("ConcreteColleagueA")
}

// 实际协作者B(说明同协作者A)
type ConcreteColleagueB struct {
	mediator Mediator
}

func (e *ConcreteColleagueB) Action() {
	e.mediator.Process(e)
}

func (e *ConcreteColleagueB) Option() {
	fmt.Println("ConcreteColleagueB")
}

// 实际协作者C(说明同协作者A)
type ConcreteColleagueC struct {
	mediator Mediator
}

func (t *ConcreteColleagueC) Action() {
	t.mediator.Process(t)
}

func (t *ConcreteColleagueC) Option() {
	fmt.Println("ConcreteColleagueC")
}

func main() {
	//实例化一个具体中介
	concreteMediator := &ConcreteMediator{}
	//实例化三个实际协作者
	concreteColleagueA := &ConcreteColleagueA{
		mediator: concreteMediator,
	}
	concreteColleagueB := &ConcreteColleagueB{
		mediator: concreteMediator,
	}
	concreteColleagueC := &ConcreteColleagueC{
		mediator: concreteMediator,
	}
	//具体中介应持有所有协作者
	concreteMediator.concreteColleagueA = concreteColleagueA
	concreteMediator.concreteColleagueB = concreteColleagueB
	concreteMediator.concreteColleagueC = concreteColleagueC

	//协作者A的Action()方法向它的实际中介请求,并由中介按它维护的顺序依次调用协作者
	concreteColleagueA.Action()
	//协作者A的Action()方法向它的实际中介请求,并由中介按它维护的顺序依次调用协作者
	concreteColleagueB.Action()
	//协作者A的Action()方法向它的实际中介请求,并由中介按它维护的顺序依次调用协作者
	concreteColleagueC.Action()
}
  • 输出

2.3 类图

«interface»
Mediator
+Process(colleague Colleague)
ConcreteMediator
+ConcreteColleagueA:concreteColleagueA
+ConcreteColleagueB:concreteColleagueB
+ConcreteColleagueC:concreteColleagueC
+Process(colleague Colleague)
«interface»
Colleague
Action()
ConcreteColleagueA
+Mediator mediator
+Action()
+Option()
ConcreteColleagueB
+Mediator mediator
+Action()
+Option()
ConcreteColleagueC
+Mediator mediator
+Action()
+Option()

你可能感兴趣的:(架构设计,设计模式,中介者模式,服务器,Mediator,仲裁者模式,行为模式,架构师)