工厂模式与策略模式(golang示例)

Hello.Reader2024-09-12 5:03
一、工厂模式简介

工厂模式是一种创建型设计模式，主要用于封装对象的创建过程。通过使用工厂模式，客户端代码无需直接实例化对象，而是通过工厂类来创建对象。这样可以将对象的创建与使用分离，从而提高代码的灵活性。

1.1 工厂模式的实现

示例场景：假设我们需要创建不同类型的日志记录器（如文件日志记录器、控制台日志记录器）。

go 复制代码 
package main

import (
	"fmt"
)

// 产品接口
type Logger interface {
	Log(message string)
}

// 具体产品类：文件日志记录器
type FileLogger struct{}

func (f *FileLogger) Log(message string) {
	fmt.Printf("FileLogger: %s\n", message)
}

// 具体产品类：控制台日志记录器
type ConsoleLogger struct{}

func (c *ConsoleLogger) Log(message string) {
	fmt.Printf("ConsoleLogger: %s\n", message)
}

// 工厂类
type LoggerFactory struct{}

func (lf *LoggerFactory) CreateLogger(loggerType string) Logger {
	if loggerType == "file" {
		return &FileLogger{}
	} else if loggerType == "console" {
		return &ConsoleLogger{}
	}
	return nil
}

func main() {
	factory := &LoggerFactory{}

	logger1 := factory.CreateLogger("file")
	logger1.Log("This is a file log message.")

	logger2 := factory.CreateLogger("console")
	logger2.Log("This is a console log message.")
}

输出：

FileLogger: This is a file log message.
ConsoleLogger: This is a console log message.
1.2 适用场景
  • 系统需要独立于产品类的创建和使用。
  • 系统需要通过统一的接口创建一系列相关或依赖的对象。
  • 需要在运行时根据某些条件决定创建哪个类的实例。
1.3 工厂模式的优缺点

  • 优点：

    • 提供对象创建的封装，使代码更加灵活，便于维护和扩展。
    • 通过工厂类可以很容易地扩展和修改对象的创建过程。

  • 缺点：

    • 随着产品类的增加，工厂类可能变得复杂，难以管理。
二、策略模式简介

策略模式是一种行为型设计模式，旨在定义一系列可互换的算法或行为，使得它们可以在运行时互相替换。通过使用策略模式，算法的实现被封装起来，客户端可以根据不同的需求选择不同的算法，而无需修改客户端代码。

2.1 策略模式的实现

示例场景：假设我们有一个支付系统，支持多种支付方式（如信用卡支付、微信支付、支付宝支付）。

go 复制代码 
package main

import (
	"fmt"
)

// 策略接口
type PaymentStrategy interface {
	Pay(amount float64)
}

// 具体策略类：信用卡支付
type CreditCardPayment struct {
	CardNumber string
}

func (c *CreditCardPayment) Pay(amount float64) {
	fmt.Printf("Paid %.2f using Credit Card: %s\n", amount, c.CardNumber)
}

// 具体策略类：微信支付
type WeChatPayment struct {
	WeChatID string
}

func (w *WeChatPayment) Pay(amount float64) {
	fmt.Printf("Paid %.2f using WeChat ID: %s\n", amount, w.WeChatID)
}

// 具体策略类：支付宝支付
type AlipayPayment struct {
	AlipayID string
}

func (a *AlipayPayment) Pay(amount float64) {
	fmt.Printf("Paid %.2f using Alipay ID: %s\n", amount, a.AlipayID)
}

// 上下文类
type PaymentContext struct {
	strategy PaymentStrategy
}

func (p *PaymentContext) SetStrategy(strategy PaymentStrategy) {
	p.strategy = strategy
}

func (p *PaymentContext) ExecutePay(amount float64) {
	if p.strategy == nil {
		fmt.Println("Payment strategy not set.")
		return
	}
	p.strategy.Pay(amount)
}

func main() {
	context := &PaymentContext{}

	creditCard := &CreditCardPayment{CardNumber: "1234-5678-9012-3456"}
	context.SetStrategy(creditCard)
	context.ExecutePay(100.0)

	weChat := &WeChatPayment{WeChatID: "weixin_abc123"}
	context.SetStrategy(weChat)
	context.ExecutePay(200.0)

	alipay := &AlipayPayment{AlipayID: "alipay_xyz789"}
	context.SetStrategy(alipay)
	context.ExecutePay(300.0)
}

输出：

Paid 100.00 using Credit Card: 1234-5678-9012-3456
Paid 200.00 using WeChat ID: weixin_abc123
Paid 300.00 using Alipay ID: alipay_xyz789
2.2 适用场景
  • 系统需要在不同的算法或行为之间进行切换，并且这些算法或行为可以互相替换。
  • 需要在运行时根据客户端的需求选择不同的策略或算法。
  • 避免使用大量的条件语句来选择不同的算法。
2.3 策略模式的优缺点

  • 优点：

    • 策略的分离使得算法可以独立于客户端的变化，并且可以轻松添加或更改策略。
    • 避免了大量的条件语句，使代码更加清晰、易于维护。

  • 缺点：

    • 客户端必须知道所有可用的策略，并且需要选择合适的策略，这可能增加代码的复杂性。
三、工厂模式与策略模式的区别

尽管工厂模式和策略模式在设计思想上有相似之处，但它们的应用场景和解决的问题却完全不同。

  1. 意图和用途：

    • 工厂模式 ：关注的是对象的创建。它通过封装对象的创建过程，避免客户端直接实例化对象，并允许系统在不修改客户端代码的情况下扩展新的产品类型。
    • 策略模式 ：关注的是行为的选择。它通过将不同的算法或行为封装在不同的策略类中，使得客户端可以在运行时自由选择和切换行为。

  2. 参与者：

    • 工厂模式：包含工厂类、产品接口/抽象类以及具体产品类，工厂类负责创建产品对象。
    • 策略模式：包含策略接口、具体策略类和上下文类，上下文类负责在运行时选择和执行具体的策略。

  3. 使用场景：

    • 工厂模式：适用于系统需要独立于产品类的创建和使用，并且需要通过统一的方式创建一系列相关或依赖的对象时。
    • 策略模式：适用于系统需要在不同算法或行为之间进行切换，并且这些算法或行为可以互相替换的场景。

  4. 代码结构：

    • 工厂模式：通常涉及到多个工厂类和产品类，工厂类的复杂度可能会随着产品类型的增加而增加。
    • 策略模式：通常包含一个策略接口及其多个具体实现类，策略类的增加不会影响上下文类的实现。
四、综合对比与选择

在实际开发中，工厂模式和策略模式可以独立使用，也可以结合使用，视具体需求而定。例如，可以使用工厂模式来创建策略对象，从而实现策略模式的灵活扩展。

示例：结合工厂模式创建策略对象

go 复制代码 
package main

import (
	"fmt"
)

// 策略接口
type PaymentStrategy interface {
	Pay(amount float64)
}

// 具体策略类：信用卡支付
type CreditCardPayment struct {
	CardNumber string
}

func (c *CreditCardPayment) Pay(amount float64) {
	fmt.Printf("Paid %.2f using Credit Card: %s\n", amount, c.CardNumber)
}

// 具体策略类：微信支付
type WeChatPayment struct {
	WeChatID string
}

func (w *WeChatPayment) Pay(amount float64) {
	fmt.Printf("Paid %.2f using WeChat ID: %s\n", amount, w.WeChatID)
}

// 具体策略类：支付宝支付
type AlipayPayment struct {
	AlipayID string
}

func (a *AlipayPayment) Pay(amount float64) {
	fmt.Printf("Paid %.2f using Alipay ID: %s\n", amount, a.AlipayID)
}

// 策略工厂
type PaymentFactory struct{}

func (pf *PaymentFactory) CreatePayment(strategyType string) PaymentStrategy {
	if strategyType == "creditcard" {
		return &CreditCardPayment{CardNumber: "1234-5678-9012-3456"}
	} else if strategyType == "wechat" {
		return &WeChatPayment{WeChatID: "weixin_abc123"}
	} else if strategyType == "alipay" {
		return &AlipayPayment{AlipayID: "alipay_xyz789"}
	}
	return nil
}

// 上下文类
type PaymentContext struct {
	strategy PaymentStrategy
}

func (p *PaymentContext) SetStrategy(strategy PaymentStrategy) {
	p.strategy = strategy
}

func (p *PaymentContext) ExecutePay(amount float64) {
	if p.strategy == nil {
		fmt.Println("Payment strategy not set.")
		return
	}
	p.strategy.Pay(amount)
}

func main() {
	factory := &PaymentFactory{}
	context := &PaymentContext{}

	// 使用工厂创建策略
	creditCard := factory.CreatePayment("creditcard")
	context.SetStrategy(creditCard)
	context.ExecutePay(150.0)

	weChat := factory.CreatePayment("wechat")
	context.SetStrategy(weChat)
	context.ExecutePay(250.0)

	alipay := factory.CreatePayment("alipay")
	context.SetStrategy(alipay)
	context.ExecutePay(350.0)
}

输出：

Paid 150.00 using Credit Card: 1234-5678-9012-3456
Paid 250.00 using WeChat ID: weixin_abc123
Paid 350.00 using Alipay ID: alipay_xyz789

在这个示例中，PaymentFactory 结合了工厂模式和策略模式，通过工厂方法创建不同的支付策略对象，使得策略的创建和使用更加灵活和解耦。

五、总结

工厂模式和策略模式是软件设计中非常常见的两种模式，它们分别关注对象的创建和行为的选择。在实际开发中，理解它们的意图和使用场景对于编写高质量的代码至关重要。

  • 工厂模式适用于需要对对象的创建过程进行封装的场景，通过提供统一的接口来创建对象，避免了客户端直接依赖具体类，从而提高了代码的灵活性和可扩展性。

  • 策略模式适用于需要在不同算法或行为之间进行切换的场景，通过将算法封装在不同的策略类中，使得客户端可以根据需求灵活选择和切换行为，提升了代码的可维护性和可扩展性。

通过合理地应用这两种模式，甚至将它们结合使用，可以大大提高代码的可维护性和可扩展性，使得系统能够更好地应对未来的变化和需求。理解和掌握这两种设计模式，将为您的开发工作带来更多的灵活性和效率。

希望这篇博客能够帮助您更好地理解工厂模式和策略模式的区别，以及如何在实际项目中应用它们。如果您有任何问题或建议，欢迎在评论区留言讨论！

相关推荐
GoppViper8 小时前
golang学习笔记28——golang中实现多态与面向对象
笔记·后端·学习·golang·多态·面向对象
Python私教9 小时前
Go语言现代web开发14 协程和管道
开发语言·前端·golang
楚钧艾克9 小时前
Windows系统通过部署wsl + Goland进行跨平台开发
linux·windows·后端·ubuntu·golang
__AtYou__9 小时前
Golang | Leetcode Golang题解之第413题等差数列划分
leetcode·golang·题解
编程点滴9 小时前
go单测报错 monkey undefined jmpToFunctionValue
开发语言·后端·golang
__AtYou__17 小时前
Golang | Leetcode Golang题解之第405题数字转换为十六进制数
leetcode·golang·题解
吃着火锅x唱着歌17 小时前
Go语言设计与实现 学习笔记 第七章 内存管理（1）
笔记·学习·golang
GoppViper1 天前
golang学习笔记24——golang微服务中配置管理问题的深度剖析
笔记·后端·学习·微服务·golang·配置管理
景天科技苑1 天前
【Go】Go语言中延迟函数、函数数据的类型、匿名函数、闭包等高阶函数用法与应用实战
后端·golang·回调函数·defer·匿名函数·闭包·go函数数据类型
蒙娜丽宁1 天前
Go语言错误处理详解
ios·golang·go·xcode·go1.19
热门推荐
01RAG 实践- Ollama+RagFlow 部署本地知识库02组基轨迹建模 GBTM的介绍与实现（Stata 或 R）032024年高教社杯数学建模国赛C题超详细解题思路分析04CANoe Trace窗口过滤栏消失的几种解决方法（附上最终解决方案）05苍穹外卖面试总结06【2024数模国赛赛题思路公开】国赛B题思路丨附可运行代码丨无偿自提07yolov8实战第五天——yolov8+ffmpg实时视频流检测并进行实时推流——（推流，保姆教学）08Coze扣子平台完整体验和实践（附国内和国际版对比）09【2024高教社杯全国大学生数学建模竞赛】B题 生产过程中的决策问题——解题思路 代码 论文10浏览器插件——ModHeader 的分享和学习