gof23行为类模式(golang版)

综合技术 2018-12-08 阅读原文

命令模式



命令模式是一个高内聚的模式,其定义:将一个请求封装成一个对象,从而让你使用 不同的请求
客户端参数化
,对请求排除或者记录请求日志,可以提供命令的撤销和恢复功能。

命令模式包含如下角色:

  • Command: 抽象命令类
    需要执行的所有命令得出在这里声明。
  • ConcreteCommand: 具体命令类
    负责实现在Command角色中定义的接口
  • Invoker: 调用者
    开始执行命令的角色,它会调用在Command角色中定义的接口。
  • Receiver: 接收者
    该角色就是干活的角色,命令传递到这里是应该被执行的

命令模式的优点

  • 类间解耦
    调用者角色与接收者角色之间没有任何依赖关系,调用者实现功能时只须调用Command抽象类的execute方法就可以,不需要了解到底是哪个接收者执行
  • 可扩展性
    Command的子类可以非常容易地扩展,而调用者Invoker和高层次的模块Client不产生严重的代码耦合

命令模式的缺点

偏偏模式的缺点就是膨胀,如果有N个命令,问题就出来了,Command的子类会有N个。

package main

import (
    "fmt"
)

/**
Command: 抽象命令类
ConcreteCommand: 具体命令类
Invoker: 调用者
Receiver: 接收者
 */

// receiver
type TV struct {
}

func (p TV) Open() {
    fmt.Println("play...")
}

func (p TV) Close() {
    fmt.Println("stop...")
}

//command
type Command interface {
    Press()
}

//ConcreteCommand
type OpenCommand struct {
    tv TV
}

func (p OpenCommand) Press() {
    p.tv.Open()
}

//ConcreteCommand
type CloseCommand struct {
    tv TV
}


func (p CloseCommand) Press() {
    p.tv.Close()
}

//invoker
type Invoke struct {
    cmd Command

}

func (p *Invoke) SetCommand(cmd Command) {
    p.cmd = cmd
}

func (p *Invoke) Do() {
    p.cmd.Press()
}

type OpenCloseCommand struct {
    index int
    cmds []Command
}


func NewOpenCLoseCommand() *OpenCloseCommand {
    openCLose := &OpenCloseCommand{}
    openCLose.cmds = make([]Command, 2)
    return openCLose
}

func (p *OpenCloseCommand) AddCommand(cmd Command) {
    p.cmds[p.index] = cmd
    p.index++
}

func (p *OpenCloseCommand) Press() {
    for _, item := range p.cmds {
        item.Press()
    }
}

func main() {
    //单一命令
    tv := TV{}
    openCommand := OpenCommand{tv}
    invoker := Invoke{openCommand}
    invoker.Do()

    closeCommand := CloseCommand{tv}
    invoker.SetCommand(closeCommand)
    invoker.Do()

    //复合命令
    fmt.Println("############复合命令###############")
    openClose := NewOpenCLoseCommand()
    openClose.AddCommand(openCommand)
    openClose.AddCommand(closeCommand)

    invoker.SetCommand(openClose)
    invoker.Do()
}

中介者模式

中介者模式的定义为:用一个中介对象封装一系列的对象交互,中介者使各对象不需要显示地相互作用,从而使其耦合松散,而且可以独立地改变它们之间的交互。

中介者模式化多对多依赖为一对多依赖。

中介者模式由以下部分组成

  • Mediator: 抽象中介者
    抽象中介者角色定义统一的接口,用于各同事角色之间的通信
  • ConcreteMediator: 具体中介者
    具体中介者角色通过协调各同事角色实现协作行为,因此它必须依赖于各个同事角色
  • Colleague: 抽象同事类
    每一个同事角色都知道中介者角色,而且与其他的同事角色通信的时候,一定要通过中介者角色协作。
  • ConcreteColleague: 具体同事类
    每个同事类的行为分为两种:一种是再带本身的行为,比如改变对象本身的状态,处理自己的行为等,这种行为叫做自发行为,与其他的同事类或中介者没有任何的依赖;第二种是必须依赖中介者才能完成的行为,叫做依赖方法。
package behavior

import "fmt"

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

//mediator 及 ConcreteMediator
type UnitedNations interface {
    ForwardMessage(message string, country Country)
}

type UnitedNationsSecurityCouncil struct {
    USA
    Iraq
}

func (unsc UnitedNationsSecurityCouncil) ForwardMessage(message string, country Country) {
    switch country.(type) {
    case USA:
        unsc.Iraq.GetMessage(message)
    case Iraq:
        unsc.USA.GetMessage(message)
    default:
        fmt.Printf("The country is not a member of UNSC")
    }
}

type Country interface {
    SendMessage(message string)
    GetMessage(message string)
}

//Colleague以及ConcreteColleague类
type USA struct {
    UnitedNations
}

func (usa USA) SendMessage(message string) {
    usa.UnitedNations.ForwardMessage(message, usa)
}

func (usa USA) GetMessage(message string) {
    fmt.Printf("美国收到对方消息: %sn", message)
}

type Iraq struct {
    UnitedNations
}

func (iraq Iraq) SendMessage(message string) {
    iraq.UnitedNations.ForwardMessage(message, iraq)
}

func (iraq Iraq) GetMessage(message string) {
    fmt.Printf("伊拉克收到对方消息: %sn", message)
}

client

package main

import "gof23/behavior"

func main() {
    tMediator := behavior.UnitedNationsSecurityCouncil{}
    usa := behavior.USA{tMediator}

    iraq := behavior.Iraq{tMediator}

    tMediator.USA = usa
    tMediator.Iraq = iraq

    usa.SendMessage("停止大规模杀伤性武器的研发,否则发动战争")
    iraq.SendMessage("我们没有研发大规模杀伤性武器,也不怕战争")
}
Go语言中文网

责编内容by:Go语言中文网阅读原文】。感谢您的支持!

您可能感兴趣的

深入解析 Go 中 Slice 底层实现 切片是 Go 中的一种基本的数据结构,使用这种结构可以用来管理数据集合。切片的设计想法是由动态数组概念而来,为了开发者可以更加方便的使一个数据结构可以自动增加和减少。但是切片本身并不是动态数据或者数组指针。切片常见的操作有 res...
Show: (Almost) range over multiple go channels sim... In my experiments ( flowbase , scipipe ) in using Flow-based programming (FBP) principles in pure Go, there is...
concurrentcache–golang内存缓存 concurrentcache是golang版的内存缓存库,采用多Segment设计,支持不同Segment间并发写入,提高读写性能。 设想场景 内存缓存的实现,防止并发写冲突,都需要先获取写锁,再写入。如果只有一个存储空间,那么并...
go环境以及kubernetes的go-client介绍 1、go语言介绍: (1)Go语言是谷歌2009发布的第二款开源编程语言。 (2)Go语言专门针对多处理器系统应用程序的编程进行了优化,使用Go编译的程序可以媲美C或C++代码的速度,而且更加安全、支持并行进程。 2、go语言特...
golang 如何将多路复异步io转变成阻塞io的... 对于我们都会写上面的代码,很简单,的确golang的网络部分对于我们隐藏了太多东西,我们不用像c++一样去调用底层的socket函数,也不用去使用epoll等复杂的io多路复用相关的逻辑,但是上面的代码真的就像我们看起来的那样在调用acce...