【Golang设计模式】模版、空对象、策略、备忘录、责任链、中介模式

最新推荐文章于 2024-04-13 19:25:53 发布
最新推荐文章于 2024-04-13 19:25:53 发布
阅读量159 收藏
点赞数
分类专栏： golang 设计模式 文章标签： 设计模式
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_46537958/article/details/118061132
版权

golang设计模式

一、模版模式

定义一个操作中的算法的骨架，而将实现逻辑步骤延迟到子类中。模板方法使得子类可以不改变一个算法的结构即可重定义该算法的某些特定步骤。
可以参考sort.quickSort的Interface接口，将Len() int长度、Less(i, j int) bool比较、Swap(i, j int)交换，这些排序的具体实现逻辑交给用户实现。

  1. 定义模版接口
    type Template interface {
	initialize()
	startPlay()
	endPlay()
}
  2. 定义游戏父类
    type Game struct {
	temp Template
}
// 实现模版方法
func (this *Game) play()  {
	this.temp.initialize()
	this.temp.startPlay()
	this.temp.endPlay()
}
  3. 定义子类
    type PlayBasketball struct {
	Game //继承父类
}
func (this *PlayBasketball) initialize() {
	fmt.Println("初始化")
}
func (this *PlayBasketball) startPlay() {
	fmt.Println("开始游戏")
}
func (this *PlayBasketball) endPlay() {
	fmt.Println("结束游戏")
}

func NewPlayBasketball() *PlayBasketball {
	ball := new(PlayBasketball)
	ball.Game = Game{temp: ball}
	return ball
}
  4. 测试
    func main() {
	ball := NewPlayBasketball()
	ball.play()
}

二、空对象模式

一个空对象取代 NULL 对象实例的检查。Null 对象不是检查空值，而是反应一个不做任何动作的关系。这样的 Null 对象也可以在数据不可用的时候提供默认的行为。

  1. 行为接口

    type AbstractInterface interface {
	isNil() bool
	getName() string
}

  2. 空对象模式

    type AbstractObject struct {
	name string
}
// ==== 真实对象 ====
type RealObject struct {
	*AbstractObject
}
func (this *RealObject) getName() string {
	return this.name
}
func (this *RealObject) isNil() bool {
	return false
}

// ==== 空对象 ====
type NilObject struct {
	AbstractObject
}
func (this *NilObject) getName() string {
	return "nil"
}
func (this *NilObject) isNil() bool {
	return true
}

  3. 工厂

    var names = []string{"bob", "tom"}
func Factory(name string) AbstractInterface {
	for i := 0; i < len(names); i++ {
		if name == names[i] {
			return &RealObject{
				&AbstractObject{ name: name },
			}
		}
	}
	// 不存在就返回模拟的空对象
	return &NilObject{}
}

  4. 测试

    func Try() {
	fact01 := Factory("bob")
	fact02 := Factory("tom")
	fact03 := Factory("wang")
	fmt.Println(fact01.getName())
	fmt.Println(fact02.getName())
	fmt.Println(fact03.getName())
	fmt.Println(fact01.isNil())
	fmt.Println(fact02.isNil())
	fmt.Println(fact03.isNil())
}

三、策略模式

一个系统里面有许多类，它们之间的区别仅在于它们的行为，那么使用策略模式可以动态地让一个对象在许多行为中选择一种行为。

  1. 定义三个锦囊
    type Strategy interface {
	doOperation(operation string)
}

type Operation01 struct {}
func (this *Operation01) doOperation(operation string) {
	fmt.Println("策略01:", operation)
}
type Operation02 struct {}
func (this *Operation02) doOperation(operation string) {
	fmt.Println("策略02:", operation)
}
type Operation03 struct {}
func (this *Operation03) doOperation(operation string) {
	fmt.Println("策略01:", operation)
}
  2. 执行锦囊
    type Context struct {
	strategy Strategy
}
func (this *Context) Execute(operation string) {
	this.strategy.doOperation(operation)
}

func NewContext(strategy Strategy) *Context {
	return &Context{
		strategy: strategy,
	}
}
  3. 测试
    策略组合工厂模式
    // 打开一个锦囊
func Open(option int) Strategy {
	switch option {
		case 1:
			return &Operation01{}
		case 2:
			return &Operation02{}
		case 3:
			return &Operation03{}
	}
}
func main(){
	c1 := NewContext(Open(1))
	c1.Execute()
}

四、备忘录模式

单独创建一个对象，作为副本，将副本存在版本中保存修改历史记录。可以想象成git的版本控制，会比较好理解。

  1. 备份对象和历史版本对象
    // Note 备份
type Memento struct {
	state string
}
func (this *Memento) getState() string {
	return this.state
}

// 备份历史版本
type MementoVersion struct {
	mementos []*Memento
}
func (this *MementoVersion) add(memento *Memento) {
	this.mementos = append(this.mementos, memento)
}
func (this *MementoVersion) get(index int) *Memento {
	return this.mementos[index]
}
  2. 正文和备份
    // 正文
type Note struct {
	state string
}
func (this *Note) setState(state string) {
	this.state = state
}
func (this *Note) getState() {
	fmt.Println(this.state)
}
// 创建正文副本
func (this *Note) saveStateToMemento() *Memento {
	return &Memento{
		state: this.state,
	}
}
// 获取正文副本，并将状态保存给当前状态
func (this *Note) getStateFromMemento(memento *Memento)  {
	this.state = memento.getState()
}
  3. 测试
    func Try() {
	ori := &Note{}
	car := &MementoVersion{}

	ori.setState("修改第1次")
	ori.setState("修改第2次")
	car.add(ori.saveStateToMemento())
	ori.setState("修改第3次")
	car.add(ori.saveStateToMemento())
	ori.setState("修改第4次")

	ori.getState()
	ori.getStateFromMemento(car.get(0)) // 将最初修改的历史版本 拿出来
	ori.getState()
	ori.getStateFromMemento(car.get(1))
	ori.getState()
}

五、责任链模式

可以想象成JS中的冒泡事件。由首层触发后，会一直向下执行，直到所有节点遍历完毕。

  1. 上代码，用心感受
    var (
	INFO = 1
	DEBUG = 2
	ERROR = 3
)

// 接口
type BaseLogger interface {
	write(message string)
	LogMessage(level int, message string)
}

// 父类实现
type AbstractLogger struct {
	Level int
	nextLogger BaseLogger
}
// 设置下一个logger对象
func (this *AbstractLogger) setNextLogger(nextLogger BaseLogger)  {
	this.nextLogger = nextLogger
}
  2. 定义三种类型的logger
    // ==== error logger ===== 
type ErrorLogger struct {
	*AbstractLogger
}
func (this *ErrorLogger) write(message string) {
	fmt.Println("error:", message)
}
// log输出
func (this *ErrorLogger) LogMessage(level int, message string) {
	// 判断传入的level是否相等，相等执行当前对象的write方法
	if this.Level == level {
		this.write(message)
	}
	// 判断是否存在下一个节点，下一个存在则调用下一个节点的LogMessage
	if this.nextLogger != nil {
		this.nextLogger.LogMessage(level, message)
	}
}
func NewErrorLogger() *ErrorLogger {
	return &ErrorLogger{
		&AbstractLogger{
			Level: ERROR,
			nextLogger: nil,
		},
	}
}
// ==== console logger ===== 
type ConsoleLogger struct {
	*AbstractLogger
}
func (this *ConsoleLogger) write(message string) {
	fmt.Println("info:", message)
}
func (this *ConsoleLogger) LogMessage(level int, message string) {
	if this.Level == level {
		this.write(message)
	}
	if this.nextLogger != nil {
		this.nextLogger.LogMessage(level, message)
	}
}
func NewConsoleLogger() *ConsoleLogger {
	return &ConsoleLogger{
		&AbstractLogger{
			Level: INFO,
			nextLogger: nil,
		},
	}
}
// ==== debug logger ===== 
type DebeugLogger struct {
	*AbstractLogger
}
func (this *DebeugLogger) write(message string) {
	fmt.Println("debug:", message)
}
func (this *DebeugLogger) LogMessage(level int, message string) {
	if this.Level == level {
		this.write(message)
	}
	if this.nextLogger != nil {
		this.nextLogger.LogMessage(level, message)
	}
}
func NewDebeugLogger() *DebeugLogger {
	return &DebeugLogger{
		&AbstractLogger{
			Level: DEBUG,
			nextLogger: nil,
		},
	}
}
  3. 组合节点顺序
    func GetChainOfLoggers() BaseLogger {
	consoleLogger := NewConsoleLogger()
	errorLogger := NewErrorLogger()
	debugLogger := NewDebeugLogger()
	
	// 设置console下一个节点是errlogger
	consoleLogger.setNextLogger(errorLogger)
	// 设置errorlogger节点下一个是debuglogger节点
	errorLogger.setNextLogger(debugLogger)

	// 返回栈定的节点
	return consoleLogger
}
  4. 测试
    func Try() {
	loggerChain := GetChainOfLoggers()
	// 会将整个链表遍历，找到与参数一箱等的level输出
	loggerChain.LogMessage(INFO, "info")
	loggerChain.LogMessage(ERROR, "error")
	loggerChain.LogMessage(DEBUG, "debug")
}

六、中介模式

将一对多转化成了一对一。 2、各个类之间的解耦.
想通过一个中间类来封装多个类中的行为，而又不想生成太多的子类

var chatRoom = &ChatRoom{}
// 中介
type ChatRoom struct {}
func (this *ChatRoom) ShowMessage(user *User, message string)  {
	fmt.Println(time.Now(), user.getName(), ":", message)
}

type User struct {
	name string
}
func (this *User) setName(name string) {
	this.name = name
}
func (this *User) getName() string {
	return this.name
}
func (this *User) SendMessage(msg string) {
	chatRoom.ShowMessage(this, msg)
}

func main() {
	user := &User{
		name: "张三",
	}
	user.SendMessage("这是一个测试，看看效果")
}
小鱼小鱼啊
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 1
    评论
专栏目录
Golang设计22种模式
刘贤松的博客
10-19 410
一个Builder类会一步一步构造最终的对象，该Builder类是独立于其他对象的。
golang设计模式介绍（内含各个模式的java对比）代码解读
啊阿啊啊啊杨的博客
04-27 1035
golang设计模式详解（配有java对比）
golang设计模式——行为模式
qq_39280718的博客
09-03 590
行为模式主要关注对象之间的通信
golang设计模式——简介
qq_39280718的博客
09-03 517
设计模式是面向对象软件的设计经验，是解决特定问题的一系列套路。
Golang设计模式——10备忘录模式
清风
09-25 276
package Memento type Memento struct { state int } func NewMemento(value int) *Memento { return &Memento{value} } type Number struct { value int } func NewNumber(value int) *Number { return &Number{value} } func (n *Number) Double() { n.va
Golang设计模式专栏汇总
清风
09-26 324
01工厂模式 02抽象工厂模式 03外观模式 04建造者模式 05桥接模式 06命令模式 07迭代器模式 08模板模式 09访问者模式 10备忘录模式 11责任链模式 12中介模式 13原型模式 14状态模式 15策略模式 16享元模式 17组合模式 18解释器模式介绍 19单例模式 20适配器模式 21代理模式 22装饰器模式 23观察者模式 ...
Golang设计模式——15策略模式
清风
09-25 535
package Strategy import "fmt" type Strategy interface { Execute() } type strategyA struct { } func NewStrategyA() Strategy { return &strategyA{} } func (s *strategyA) Execute() { fmt.Println("A plan executed.") } type strategyB struct { } fun
设计模式（Golang）
qq_22321199的专栏
04-13 1155
软件设计原则是一组指导软件开发人员进行系统设计、模块划分、类和接口定义、代码组织等方面的准则，旨在提高软件的可维护性、可扩展性、灵活性和重用性。（Open）：对扩展开放，即允许在不修改现有代码的基础上扩展系统的行为或功能。这意味着应通过扩展而非修改已有类或模块来应对需求变化。（Closed）：对修改封闭，即已有的代码（尤其是稳定的部分）应尽量避免改动。这通常通过抽象和依赖注入来实现，使系统能够在不改动现有代码的情况下添加新功能或适应新情况。一个类、模块或函数应有且仅有一个引起它变化的原因。
Golang设计模式——11责任链模式
清风
09-25 852
package ResponsibilityChain import ( "strconv" ) type Handler interface { Handler(handlerID int) string } type handler struct { name string next Handler handlerID int } func NewHandler(name string, next Handler, handlerID int) *handler {
shumintao#conf#Golang设计模式1
07-25
设计模式1. 单利模式// 创建全局对象// 同步Once,保证每次调用时，只有第一次生效// 定义一个包级别的Public实例变量//初始化单利对象2. 观察
Golang设计模式-代理模式
01-08
在面向对象系统中，有些对象由于某些原因（比如对象创建开销很大，或者某些操作需要安全控制，或者需要进程外的访问），直接访问会给使用者或者系统结构带来很多麻烦，我们可以在访问此对象时加上一个对此对象的访问...
Golang语言基础超详细教程&备忘录
最新发布
06-18
本文是基础内容，适合初学者，也适合老手用来当备忘录。和网上其他文档不同的是，我陆陆续续将很多小的知识点也补进来了，后续也会继续补充。 文章内容包括Golang简介、开发环境安装、语言基础（命名规则、关键字、...
go-patterns:Golang 设计模式
08-04
Golang设计模式思想 前言 一切设计模式都是灵活应用struct的组合模式，以及go隐形继承接口的特性 go中的interface就是一些方法装饰, 而struct并不依赖于接口 设计模式类型 创建模式 将一个复杂对象的构建与它的表示...
C 语言中文网 Java、Swing、设计模式、Python、Golang 等十三本
03-07
'Java 设计模式：23 种设计模式全面解析（C 语言中文网）.epub' 'JSP 教程：1 天玩转 JSP 网站开发技术（C 语言中文网）.epub' 'Linux vi 命令 30 分钟入门教程（C 语言中文网）.epub' 'Python 基础教程（C 语言中文...
【Golang】六、基础篇 -- map和结构体
m0_46537958的博客
04-06 3677
golang的map、结构体，为什么把这两个放在一起呢，因为这两个都可以理解为，键值对类型，所以可以理解为同属性的
【Golang】一、基础篇 -- 基本数据类型
m0_46537958的博客
03-13 2997
golang安装 MAC环境下安装go，下面所有操作都是针对MAC OS环境构建，本篇文章只有基础教程，无框架介绍！ 安装
【oauth2.0】golang简单实现oauth2.0授权逻辑
m0_46537958的博客
09-02 2687
oauth2.0授权分类、授权流程代码实现
【Golang】十一、重点篇 --- 协程和管道！
m0_46537958的博客
04-26 2027
goroutine、channel是golang设计最最最优美的地方，go对并发的操作都是源自于这两点
golang 设计模式
01-05
以下是几种常见的Golang设计模式： 1. 工厂模式（Factory Pattern）：用于创建对象的模式，通过定义一个创建对象的接口来实现对象的实例化。 ```go type Shape interface { Draw() } type Circle struct{} func...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

小鱼小鱼啊

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值