【设计模式】简单工厂模式，工厂模式，抽象工厂模式，单例，代理，go案例区分总结

工厂模式三种类型：

一、简单工厂模式（Simple Factory）

定义： 用一个工厂类，根据传入的参数决定创建哪一种具体产品类实例。

面试说法： 由一个统一的工厂创建所有对象，增加新产品时需要修改工厂类，不符合OCP开闭原则。

OCP原则：
对扩展开放（Open for extension）：软件中的功能应该允许通过新增代码来进行扩展。
对修改关闭（Closed for modification）：原有代码不应该被修改，以减少引入 bug 的风险。

Go 实现：

type PayMethod interface {Pay(amount float64)
}type AliPay struct{}
func (a *AliPay) Pay(amount float64) {fmt.Println("使用支付宝支付", amount)
}type WeChatPay struct{}
func (w *WeChatPay) Pay(amount float64) {fmt.Println("使用微信支付", amount)
}func PayFactory(channel string) PayMethod {switch channel {case "alipay":return &AliPay{}case "wechat":return &WeChatPay{}default:return nil}
}

---

二、工厂方法模式（Factory Method）

定义： 把创建对象的逻辑下放到每个具体工厂类，遵循了开闭原则。

面试说法： 一个抽象工厂接口 + 多个具体工厂类，每种产品由对应工厂类负责创建。符合开闭原则，新增产品时不修改已有代码，只需新增工厂类。

Go 实现：

type PayMethod interface {Pay(amount float64)
}type PayFactory interface {CreatePayMethod() PayMethod
}type AliPay struct{}
func (a *AliPay) Pay(amount float64) {fmt.Println("使用支付宝支付", amount)
}type AliPayFactory struct{}
func (f *AliPayFactory) CreatePayMethod() PayMethod {return &AliPay{}
}type WeChatPay struct{}
func (w *WeChatPay) Pay(amount float64) {fmt.Println("使用微信支付", amount)
}type WeChatPayFactory struct{}
func (f *WeChatPayFactory) CreatePayMethod() PayMethod {return &WeChatPay{}
}

---

三、抽象工厂模式（Abstract Factory）

定义： 提供一系列产品创建的接口，每个具体工厂创建一整套产品。

面试说法： 用于创建一系列相关产品，适用于产品族的扩展。每个工厂可以返回多个产品实例，如 UI 工厂创建按钮、窗口、滚动条等。

Go 实现：

// 抽象产品
type Pay interface {Pay(amount float64)
}
type Refund interface {Refund(amount float64)
}// 抽象工厂
type PayFactory interface {CreatePay() PayCreateRefund() Refund
}// 支付宝产品实现
type AliPay struct{}
func (a *AliPay) Pay(amount float64) {fmt.Println("支付宝支付", amount)
}
type AliRefund struct{}
func (a *AliRefund) Refund(amount float64) {fmt.Println("支付宝退款", amount)
}// 支付宝工厂
type AliFactory struct{}
func (f *AliFactory) CreatePay() Pay {return &AliPay{}
}
func (f *AliFactory) CreateRefund() Refund {return &AliRefund{}
}

---

面试中该如何答工厂模式的区别？

1. 简单工厂模式

   • 优点：结构简单，适用于产品数量较少、需求变化不频繁的场景。
   • 缺点：不符合开闭原则，新增产品需要修改工厂代码。
   • 应用场景：支付渠道种类少的项目、快速原型开发。

2. 工厂方法模式

   • 优点：符合开闭原则，新增产品时只需新增具体工厂类，扩展性好。
   • 缺点：类的数量增加，结构相对复杂。
   • 应用场景：产品频繁扩展变化的系统，例如支持多个支付渠道，未来还会新增。

3. 抽象工厂模式

   • 优点：可以创建一整套相关联的产品（产品族），一致性强。
   • 缺点：不方便支持新增产品种类（每个工厂都要改），灵活性略低。
   • 应用场景：跨平台开发、UI 工具包、数据库驱动（同一工厂生产连接器和执行器等）。

---

“简单工厂是最基本的一种模式，用一个工厂创建所有对象，不符合开闭原则。工厂方法将创建逻辑分离到每个工厂类，支持扩展。抽象工厂则用于生产一组相关产品，产品族统一，适合跨平台系统。”

工厂模式：
✅ 通常只有一个抽象工厂接口和多个具体工厂实现类，每个工厂创建一种产品。
抽象工厂模式：
✅ 有一个抽象工厂接口，多个具体工厂实现类，每个工厂创建一个产品族。
✅ 强调产品之间的 “族” 关系（如 Windows 风格的按钮 + 复选框必须来自同一个工厂）。

// 抽象产品族
type Button interface { Click() }
type Checkbox interface { Check() }// 具体产品（按族分类）
type WindowsButton struct{}
type WindowsCheckbox struct{}
type MacButton struct{}
type MacCheckbox struct{}// 抽象工厂
type GUIFactory interface {CreateButton() ButtonCreateCheckbox() Checkbox
}// 具体工厂
type WindowsFactory struct{} // 创建Windows风格的Button和Checkbox
type MacFactory struct{}     // 创建Mac风格的Button和Checkbox

---

四、单例模式（Singleton Pattern）

定义：

确保一个类只有一个实例，并提供一个全局访问点。

使用场景：

• 配置管理类
• 数据库连接池
• 日志处理类
• 缓存管理器

特点：

• 全局唯一
• 延迟初始化（懒汉）
• 线程安全

Go 语言实现（懒汉 + 线程安全）：

package singletonimport ("sync"
)type Singleton struct {Name string
}var (instance *Singletononce     sync.Once
)func GetInstance() *Singleton {once.Do(func() {instance = &Singleton{Name: "唯一实例"}})return instance
}

单例模式确保某个类在整个系统中只有一个实例。常用 sync.Once 来实现线程安全的延迟初始化。在场景如日志记录器、配置加载器中很常见。它的关键是将构造函数私有化，通过提供一个全局访问方法来获取实例。

饿汉

package singletontype EagerSingleton struct {Name string
}var eagerInstance = &EagerSingleton{Name: "饿汉式单例"}func GetEagerInstance() *EagerSingleton {return eagerInstance
}

1. 懒汉式在第一次使用时才初始化，需要注意并发下的线程安全，Go 中推荐使用 sync.Once 来保证只初始化一次；
2. 饿汉式在程序启动时就创建实例，线程安全但资源利用不够高效。适合对资源敏感性不强的场景。
   实际开发中，推荐懒汉式 + sync.Once 方式来兼顾延迟加载和线程安全。

---

五、代理模式（Proxy Pattern）

定义：

为其他对象提供一个“代理”以控制对该对象的访问。

使用场景：

• 访问控制（权限校验）
• 延迟加载（虚拟代理）
• 远程代理（RPC Stub）
• 缓存代理（避免重复计算）

Go 语言实现（以下载器为例，带缓存功能的代理）：

package proxyimport "fmt"type Downloader interface {Download(url string)
}// 真实对象
type RealDownloader struct{}func (r *RealDownloader) Download(url string) {fmt.Println("正在下载：", url)
}// 代理对象
type ProxyDownloader struct {real     *RealDownloadercacheMap map[string]bool
}func NewProxyDownloader() *ProxyDownloader {return &ProxyDownloader{real:     &RealDownloader{},cacheMap: make(map[string]bool),}
}func (p *ProxyDownloader) Download(url string) {if p.cacheMap[url] {fmt.Println("缓存命中：", url)} else {p.real.Download(url)p.cacheMap[url] = true}
}

代理模式通过引入一个代理对象来控制对目标对象的访问。比如在缓存代理中，代理会先判断是否命中缓存，如果没有才真正访问目标对象。这样可以在不改动原有逻辑的情况下，增强对象的功能（控制、缓存、权限等）。

---

https://github.com/0voice