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

一、工厂模式简介

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

1.1 工厂模式的实现

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

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 策略模式的实现

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

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. 代码结构：

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

四、综合对比与选择

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

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

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 结合了工厂模式和策略模式，通过工厂方法创建不同的支付策略对象，使得策略的创建和使用更加灵活和解耦。

五、总结

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

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

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

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

---

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